拥有私人访问者的公共领域是否有意义？

Question

I have a class called GestorePersonale which holds a list of instances of another class:

public List<Dipendente> Dipendenti
{
    get;
    private set;
}

I want to keep this list modifiable only from the methods the class exposes, and not directly. I noticed that with the code above, one could just do

var gp = new GestorePersonale();
gp.Dipendenti.Add( new Dipendente( ... ) );

and be able to perform any other kind of action on the List<Dipendente> itself.

I considered converting the first code snippet to

\nprivate List dipendenti;  

but I could find a few downsides to that:

• This would break the personal rule of mine to try to always use the public fields over the private ones from inside the class's methods whenever possible (even though I'm not sure if it is good practice to do so, so any clarification would be welcome);
• This would impair any external entities' ability to access the contents of the list for reading purposes only, like, say, to execute a LINQ query over the contents of the list.

What would be the best way to solve this situation?

Answer 1

You can wrap the list in a ReadOnlyCollection<T> and expose that:

private List<Dipendente> dipendenti;
private ReadOnlyCollection<Dipendente> readOnlyDipendenti;

public GestorePersonale()
{
    dipendenti = new List<Dipendente>();
    readOnlyDipendenti = new ReadOnlyCollection<Dipendente>(dipendenti);
}

public ReadOnlyCollection<Dipendente> Dipendenti
{
    get { return readOnlyDipendenti; }
}

Internally, you have access to dipendenti and can add/remove items. External entities have access only to the ReadOnlyCollection<T> that wraps the list, so they can only read, but not add/remove items.

Answer 2

I would agree with dtb that ReadOnlyCollections is the way to go. However, you can return it from the property getter (using AsReadOnly) and drop the method.

    private List<Dipendente> dipendenti = new List<Dipendente>();

    public ReadOnlyCollection<Dipendente> ReadOnlyDipendenti
    {
        get
        {
            return dipendenti.AsReadOnly(); 
        }
    }

Answer 3

there are a couple of things you can do:

you use ReadOnlyCollection

you can return an IEnumerable<_type>

you can wrap the list in another class

you can roll your own collection class, implementing the appropriate interface

the method you use depends on the functionality you need and what you want/need to expose to the user of your class

Answer 4

What you have is a public property with a private accessor. It is very useful. It allows an instance to expose a value that is controlled (set) by the instance itself, eg a state.

For example, take a collection with a Count property. It makes no sense for it have a public accessor. An implementation could be to update the property (internally) when the collection is changed (to avoid having to count it each time).

Answer 5

Do a setter method or wrap the field in another class. This is a classic collection set and collection.add problem.