ReadOnlyCollection with read-only items

Question

I have a class which contains a Collection (Collection<MyItem> myItems). I want to be able to modify this Collection privately and return it as read-only through a public property (in O(1) if possible). I was thinking about using a ReadOnlyCollection, but the problem is the items (MyItem) are not read-only. So I created a read-only wrapper class (ReadOnlyMyItem). How can I make the ReadOnlyCollection return the wrapper class (ReadOnlyMyItem) through the square brackets operator without building the entire Collection again, I want everything to remain O(1).

I was thinking about creating a new class derived from ReadOnlyCollection (class ReadOnlyMyCollection : ReadOnlyCollection<MyItem> or class ReadOnlyMyCollection : ReadOnlyCollection<ReadOnlyMyItem>) which returns the read-only wrapper class (ReadOnlyMyItem) through the square brackets operator, but either the square brackets operator is not marked as virtual and the return type is not even the same or the constructor doesn't have an IList of the wrapper class (IList<ReadOnlyMyItem>) to use. Should I build the class (ReadOnlyMyCollection) from scratch?

The code looks something like this:

public class MyClass
{
    public ReadOnlyCollection<ReadOnlyMyItem> MyItems { get => GetMyItems(); }
    private List<MyItem> myItems;
    // ...

    private ReadOnlyCollection<ReadOnlyMyItem> GetMyItems()
    {
        throw new NotImplementedException();
    }
    // ...
}

public class MyItem
{
    // ...
}

public class ReadOnlyMyItem
{
    private readonly MyItem myItem;
    // ...

    public ReadOnlyMyItem(MyItem myItem) => this.myItem = myItem;
    // ...
}

You could derive `MyItem` from `ReadOnlyMyItem` putting all set accessors into the derived class. — Klaus Gütter, Jul 24 '20 at 07:23
@KlausGütter Thanks for the idea, but then I'd have to use a `List` in `MyClass` so I don't get an error when I return `new ReadOnlyCollection(myItems)` right? Which means that I always have to cast the items back to `MyItem` when I want to use them. Also the items can be casted into `MyItem` outside the class. — dCake, Jul 24 '20 at 08:02

Matthew Watson · Accepted Answer · 2020-07-24T10:22:38.403

Can you get away with using IReadOnlyList<T> rather than ReadOnlyCollection<T>?

IReadOnlyList<T> only provides the count and the indexing operator [index] (and IEnumerable<T>), but if that's all you need you can write something like this:

public interface IReadOnlyMyItem
{
    int SomeValue { get; }
}

public interface IWritableMyItem: IReadOnlyMyItem
{
    new int SomeValue { get;  set; } // Note use of `new`
}

public sealed class WriteableMyItem: IWritableMyItem
{
    public int SomeValue { get; set; }
}

public sealed class MyClass
{
    readonly List<WriteableMyItem> _items = new List<WriteableMyItem>();

    public IReadOnlyList<IReadOnlyMyItem> MyItems() => _items;
}

Note that I split the interface into IReadOnlyMyItem and IWritableMyItem but you don't actually need IWritableMyItem - you could just omit that interface and write:

public sealed class WriteableMyItem: IReadOnlyMyItem
{
    public int SomeValue { get; set; }
}

instead. I just included IWritableMyItem for completeness (because it shows how you introduce a set to an interface property that only has a get, by using new).

As per the comments below, you can prevent the possibility of downcasting by making IWriteableMyItem and WriteableMyItem private or internal. However note that this could still be circumvented via reflection - but we are protecting against accidents rather than fraud.

To avoid that a client gets a writable object by downcasting, `WritableMyItem` (and `IWritableMyItem` if used) could be made private or internal. — Klaus Gütter, Jul 24 '20 at 08:24
As long as `WritableMyItem` is made private, as @KlausGütter suggested, this solution seems to work great. The other problem I thought I would face is if the `IReadOnlyList` is casted into a `IList`, but since IList's type parameter is not covariant, I don't think this is possible. Thank you! — dCake, Jul 24 '20 at 09:35

ReadOnlyCollection with read-only items

1 Answers1