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 ?

Answer 1

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
    // ...
  }
} 

Answer 2

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
        // ...
    }
}

Answer 3

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());

Answer 4

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
      // ...
   }
 } 

Answer 5

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>;
      }
   } 
}