Question

One example of the general case:

public class Validator
{
   // ...
   public ReadOnlyCollection<InvalidContainer> ContainersUnderMinimum
   {
      get { return _containersUnderMinimum.AsReadOnly(); }
   }
}

public class InvalidContainer
{
   // ...
   public int LowestVolume { get; set; }
}

The Validator class above takes a collection of other items in its constructor, then adds invalid items to the internal List. Each container has many sub-containers (think a rack of test tubes), and the class wants to find the lowest volume. The constructor is adding to the list when an item (tube) is not found, and updating the existing list object when an item is found.

The problem is that the Validator wants to return a read-only collection of immutable objects, but the objects (InvalidContainers) must be mutable post-construction so that values can be (essentially) accumulated.

Refactoring to use an interface (IInvalidContainer) causes headaches, as generic collections cannot be cast to collections of a base type.

What are some good patterns or practices to solve this issue?

EDIT: To clarify, the intention is to have the property value (the collection) be immutable. I understand that ReadOnlyCollection only enforces immutability of the collection, not of the collection items. Normally I would make the items immutable, but I can’t in this (and similar) cases. However, I only want the items mutated at the time the Validator class is being constructed. Preventing callers from doing unwise casting is not a design goal; the goal is to avoid tempting callers with a settable public property.

EDIT: Changed the title for clarity.

EDIT: Here’s the refactored version (based on suggestions from LBushkin and recursive):

public IEnumerable<IInvalidContainer> ContainersUnderMinimum
{
   get
   {
      return _containersUnderMinimum.Cast<IInvalidContainer>();
   }
}

Answer 1

If I understand your problem correctly, you want to return a collection of immutable types, but internally retain a mutable collection. The typical way of doing so, is to create a base type (or interface) for your type that is immutable and return that.

You can either cast items to that type (a weak form of immutability control), or you can create wrapper objects and return those (a strong type of control). Wrapper objects can be more expensive to create – but they prevent external code from simply being able to perform a type-cast to get around immutability. This is, by the way, the mechanism that ReadOnlyCollection<T> uses to return immutable collections.

To overcome that fact that collection types have limited casting support, you can use LINQ to return a immutable copy of the immutable type:

_containersUnderMinimum.Cast<IInvalidContainer>().ToList().AsReadOnly()

This creates a copy of the collection – but it may be good enough – if you don’t need to the collection to reflect changes at runtime.

Also, be aware that ReadOnlyCollection does not require (or enforce) immutability of the elements of the collection. Rather, it prevents the receiver from being able to add or remove elements – changing existing elements in the collection is still possible.