Question

EDIT: This question would be invalid in .NET 4 since it actually works as desired.

I have a Data class that must implement an interface like this:

public interface IData
{
   IEnumberable<IOther> OtherList { get; }
   IOther AddOther();
   void RemoveOtherData(IOther data);
}

But I am stuck with declaring the actual member in Data

public class Data : IData
{
   // desired, always return the same reference
   public IEnumberable<IOther> OtherList { get { return _mOtherList } }
   // Non persistent reference not desirable.
   public IEnumerable<IOther> OtherList { get { return _mOtherList.Select(x => x as IOther); } }        
   List<IOther> _mOtherList = new List<Other>(); // error, type mismatch
   List<Other> _mOtherList = new List<Other>(); // error, property return type mismatch
   IEnumerable<IOther> _mOtherList = new List<Other>(); // ok, but cannot use List methods without casting.
}

What would be the best solution in this case?

Answer 1

public class Data : IData
{
   public IEnumerable<IOther> OtherList { get; private set; }        
   List<Other> _mOtherList = new List<Other>();

   public Data()
   {
     OtherList=mOtherList.Cast<IOther>();
   }
}

On .net 4 IEnumerable<out T> is co-variant. i.e. a class that implements IEnumerable<Other> automatically implements IEnumerable<IOther> too. So could also simply write:

public class Data : IData
{
   public IEnumerable<IOther> OtherList { get{return mOtherList;} }        
   List<Other> _mOtherList = new List<Other>();
}

But I’d avoid that, since it breaks encapsulation and allows outsiders to modify your list.

((List<Other>)MyData.OtherList).Add(...);