Question

Here is my problem: there is a class that contains a inner collection (or list, or array, or something like this) of some some class and It must expose a public read-only collection of items, which are properties (or fields) of relative items in inner collection. For example:

//Inner collection consists of items of this class
class SomeClass
{
  public int _age;

  //This property is needed for exposing
  public string Age { get { return this._age.ToString(); } }
}

//Keeps inner collection and expose outer read-only collection
class AnotherClass
{
  private List<SomeClass> _innerList = new List<SomeClass> ();

  public ReadOnlyCollection<string> Ages 
  {
     get 
     {
       //How to implement what i need?
     }
  }
}

I know a simple way to do this by the use of a pair of inner lists, where the second keeps values of needed properties of first. Something like this:

//Inner collection consists of items of this class
class SomeClass
{
  public int _age;

  //This property is needed for exposing
  public string Age { get { return this._age.ToString(); } }
}

//Keeps inner collection and expose outer read-only collection
class AnotherClass
{
  private List<SomeClass> _innerList = new List<SomeClass> ();
  private List<string> _innerAgesList = new List<string> ();

  public ReadOnlyCollection<string> Ages 
  {
     get 
     {
       return this._innerAgesList.AsreadOnly();
     }
  }
}

But I dislike this overhead. May be there is some way to do what I want with exposing interfaces. Help me, please!

Hurra!
It seems that the best solution has been found. Due to the post of Groo

this problem found its almost universal answer. Here is It (we need to add two entity):

public interface IIndexable<T> : IEnumerable<T>
{
    T this[int index] { get; }
    int Count { get; }
}

class Indexer <Tsource, Ttarget> : IIndexable<Ttarget>
{
    private IList<Tsource> _source = null;
    private Func<Tsource, Ttarget> _func = null;

    public Indexer(IList<Tsource> list, Func<Tsource, Ttarget> projection)
    {
        this._source = list;
        this._func = projection;
    }

    public Ttarget this[int index] { get { return this._func(this._source[index]); } }

    public int Count { get { return _source.Count; } }

    IEnumerator IEnumerable.GetEnumerator() { return GetEnumerator(); }

    public IEnumerator<Ttarget> GetEnumerator()
    { foreach (Tsource src in this._source) yield return this._func(src); }     
}

With them, our implementation looks like this:

//Inner collection consists of items of this class
class SomeClass
{
  public int _age;

  //This property is needed for exposing
  public string Age { get { return this._age.ToString(); } }
}

//Keeps inner collection and expose outer read-only collection
class AnotherClass
{
  private List<SomeClass> _innerList = new List<SomeClass> ();
  private Indexer<SomeClass, string> _indexer = null;

  public AnotherClass () 
  { this._indexer = new Indexer<SomeClass, string > (this._innerList, s => s.Age); }

  public IIndexable<string> Ages { get { return this._indexer; } }
}

Thank Groo and the rest who answered. Hope, this helps someone else.

Answer 1

The overhead is not so significant if you consider that ReadOnlyCollection is a wrapper around the list (i.e. it doesn’t create a copy of all the items).

In other words, if your class looked like this:

class AnotherClass
{
    private ReadOnlyCollection<string> _readonlyList;
    public ReadOnlyCollection<string> ReadonlyList
    {
        get { return _readonlyList; }
    }

    private List<string> _list;
    public List<string> List
    {
        get { return _list; }
    }

    public AnotherClass()
    {
        _list = new List<string>();
        _readonlyList = new ReadOnlyCollection<string>(_list);
    }
}

Then any change to the List property is reflected in the ReadOnlyList property:

class Program
{
    static void Main(string[] args)
    {
        AnotherClass c = new AnotherClass();

        c.List.Add("aaa");
        Console.WriteLine(c.ReadonlyList[0]); // prints "aaa"

        c.List.Add("bbb");
        Console.WriteLine(c.ReadonlyList[1]); // prints "bbb"

        Console.Read();
    }
}

You may have issues with thread safety, but exposing IEnumerable is even worse for that matter.

Personally, I use a custom IIndexable<T> interface with several handy wrapper classes and extension method that I use all over my code for immutable lists. It allows random access to list elements, and does not expose any methods for modification:

public interface IIndexable<T> : IEnumerable<T>
{
    T this[int index] { get; }
    int Length { get; }
}

It also allows neat LINQ-like extension methods like Skip, Take and similar, which have better performance compared to LINQ due to the indexing capability.

In that case, you can implement a projection like this:

public class ProjectionIndexable<Tsrc, Ttarget> : IIndexable<Ttarget>
{
    public ProjectionIndexable
         (IIndexable<Tsrc> src, Func<Tsrc, Ttarget> projection)
    {
        _src = src;
        _projection = projection;
    }

    #region IIndexable<Ttarget> Members

    public Ttarget this[int index]
    {
        get { return _projection(_src[index]); }
    }

    public int Length
    {
        get { return _src.Length; }
    }

    #endregion

    #region IEnumerable<Ttarget> Members

    // create your own enumerator here

    #endregion
}

And use it like this:

class AnotherClass
{
    private IIndexable<string> _readonlyList;
    public IIndexable<string> ReadonlyList
    {
        get { return _readonlyList; }
    }

    private List<SomeClass> _list;
    public List<SomeClass> List
    {
        get { return _list; }
    }

    public AnotherClass()
    {
        _list = new List<SomeClass>();
        _readonlyList = new ProjectionIndexable<SomeClass, string>
             (_list.AsIndexable(), c => c.Age);
    }
}

[Edit]

In the meantime, I posted an article describing such a collection on CodeProject. I saw you’ve implemented it yourself already, but you can check it out nevertheless and reuse parts of the code where you see fit.