返回IEnumerable <IMyInterface> 从清单 <MyInterfaceClass>

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. ie 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(...);

Answer 2

Other class must implement IOther interface and you don't need to cast.

When you declare _mOtherList, it's IEnumerable, so you can't use list methods. Declare it as a list.

public class Data : IData
{
   List<IOther> _mOtherList = new List<Other>();

   public IEnumberable<IOther> OtherList { get { return _mOtherList } }

   IOther AddOther()
   {
       return null;
   }
   void RemoveOtherData(IOther data){}
}

Your Other class:

class Other : IOther
{
   //some members
}

Answer 3

As IEnumerable is covariant this is fine:

    public interface IInterface{}

    public class ClassA : IInterface{}

    public class ClassB
    {
        private readonly List<ClassA> _classAs;

        public IEnumerable<IInterface> Data{ get { return _classAs; } }
    }