Public List without Add

Question

public class RegistrationManager
{
  public List<object> RegisteredObjects;

  public bool TryRegisterObject(object o) 
  {
    // ...
    // Add or not to Registered
    // ...
  }
}

I want that RegisterObjects be accessible from outside of the class, but also that the only way to populate the RegisterObjects list is through TryRegisterObject(object o).

Is this possible ?

Artiom · Accepted Answer · 2015-08-19T06:27:08.590

5

I would hide it under ReadonlyCollection. In this case client won't be able to add elements via casting to IList for example. It totaly depends on how secure you want to be (in simplest scenario exposing IEnumerable will be pretty enough).

public class RegistrationManager
{
  private List<object> _registeredObjects;
  ReadOnlyCollection<object> _readOnlyRegisteredObjects;

  public RegistrationManager()
  {
      _registeredObjects=new List<object>();
      _readOnlyRegisteredObjects=new ReadOnlyCollection<object>(_registeredObjects);
  }

  public IEnumerable<object> RegisteredObjects
  {
     get { return _readOnlyRegisteredObjects; }
  }


  public bool TryRegisterObject(object o) 
  {
    // ...
    // Add or not to Registered
    // ...
  }
}

edited Aug 19 '15 at 06:27

answered Aug 14 '15 at 13:52

Artiom

7,694
3
38
45

More "secure" than Dmitry solution, and don't involve that much additional code. Love it ! – Nicolas Voron Aug 14 '15 at 14:34
What if you wanted to modify properties from these readonly objects? – toughQuestions Apr 15 '20 at 10:28
1

@toughQuestions ReadOnlyCollection doesn't make these objects read-only. You can get an object and update it. But you cannot modify this collection of course. – Artiom Apr 15 '20 at 17:29

Backs · Answer 2 · 2015-08-14T13:52:25.080

Hide it under IEnumerable. You'll get "readonly" collection outise the class and work with List inside:

public class RegistrationManager
{
  public IEnumerable<object> RegisteredObjects
  {
    get
    {
      return _registeredObjects;
    }
  }
  private List<object> _registeredObjects;

  public bool TryRegisterObject(object o) 
  {
    // ...
    // Add or not to Registered
    // ...
  }
}

More protected variant with IReadOnlyColection:

public class RegistrationManager
{
    public IReadOnlyCollection<object> RegisteredObjects
    {
        get { return new ReadOnlyCollection<object>(_registeredObjects); }
    }
    private List<object> _registeredObjects;

    public bool TryRegisterObject(object o)
    {
        // ...
        // Add or not to Registered
        // ...
    }
}

Note that that doesn't prevent anyone from casting the result back to `List — Jon Skeet, Aug 14 '15 at 13:51

Dmitry Bychenko · Answer 3 · 2015-08-14T14:09:14.863

Something like that (I guess you have to have read-only access which means that Add, RemoveAt, Clear etc. are not allowed):

public class RegistrationManager
{
  // change RegisteredObjects to be private
  //TODO: do you really want List<object> instead of, say, List<RegisteredItem>?
  private List<object> RegisteredObjects = new List<object>();

  // let RegisteredObjects be visible as read-only
  public IReadOnlyList<object> Items { 
    get {
      return RegisteredObjects;
    }
  }

  // your TryRegisterObject
  public bool TryRegisterObject(object o) 
  {
    // ...
    // Add or not to Registered
    // ...
  }
}

downside of the solution is that, technically, it's possible to cast back, e.g.

  RegistrationManager manager = ...

  // you can't do this
  // manager.Items.Add(new Object()); // <- compile time error
  // but can do this
  ((List<Object>) (manager.Items)).Add(new Object());

Yeah, just put `object` to simplify ;) I'm aware about the downside, i just want a warning-type solution, since this is for internal use. Since this application isn't critical, i don't need a bullet-proof solution (unless it's easy as your code above !) — Nicolas Voron, Aug 14 '15 at 14:08

score 1 · Answer 4 · answered Aug 14 '15 at 13:50

return it as IReadOnlyList

public class RegistrationManager
{
   private List<object> _registeredObjects;
   public IReadOnlyList<object> RegisteredObjects
   {
       get{  return _registeredObjects; }
   }
   public bool TryRegisterObject(object o) 
   {
      // ...
      // Add or not to Registered
      // ...
   }
 }

score 0 · Answer 5 · answered Aug 14 '15 at 13:50

Yes you can expose a property of type IReadOnlyCollection(T).

List(T) implements IReadonlyCollection(T)

public class RegistrationManager
{
   private List<object> _registeredObjects; 
   public IReadOnlyCollection<object> RegisteredObjects
   {
      get
      {
         return _registeredObjects as IReadOnlyCollection<object>;
      }
   } 
}

Public List without Add

5 Answers5