How to avoid public access to private fields?

Question

For example let's declare:

private readonly List<string> _strings = new List<string>(); public IEnumerable<string> Strings {     get     {         return _strings;     } } 

And now we can do the following:

((List<string>) obj.Strings).Add("Hacked"); 

So we're really not hiding the List from usage but only hide it behind interface. How to hide the list in such example without copying _strings in the new collection to restrict modification of the list?

Answer 1

Plenty of ways.

The most naive approach would be to always copy the private field:

return _strings.ToList(); 

But that's not generally necessary. It would make sense, though, if:

1. You happen to know that calling code will generally want a List<T> anyway, so you might as well give one back (without exposing the original).
2. It's important for the exposed object to hold the original values even if the original collection is subsequently changed.

Alternately, you could just expose a read-only wrapper:

return _strings.AsReadOnly(); 

This is more efficient than the first option but will expose changes made to the underlying collection.

These strategies could also be combined. If you need a copy of the original collection (so changes to the original have no effect) but also don't want the object returned to be mutable*, you could go with:

 // copy AND wrap return _strings.ToList().AsReadOnly(); 

You could also use yield:

foreach (string s in _strings) {     yield return s; } 

This is similar in efficiency and trade-offs to the first option, but with deferred execution.

Clearly, the key thing to consider here is how your method is actually going to be used and what functionality, exactly, you mean to be providing with this property.

_{* Though to be honest, I'm not sure why you'd care.}