Convert List DerivedClass to List BaseClass

Question

While we can inherit from base class interface  why can t we declare a List lt  gt  using same class interface      interface A      class B   A      class C   B      class Test       static void Main string   args                A a   new C       OK         List lt A gt  listOfA   new List lt C gt        compiler Error           Is there a way around

User · Answer

Because C  doesn t allow that type of inheritance conversion at the moment

User · Answer

The way to make this work is to iterate over the list and cast the elements  This can be done using ConvertAll   List lt A gt  listOfA   new List lt C gt    ConvertAll x   gt   A x     You could also use Linq   List lt A gt  listOfA   new List lt C gt    Cast lt A gt    ToList

User · Answer

You can also use the System Runtime CompilerServices Unsafe NuGet package to create a reference to the same List   using System Runtime CompilerServices      class Tool     class Hammer   Tool         var hammers   new List lt Hammer gt         var tools   Unsafe As lt List lt Tool gt  gt  hammers     Given the sample above  you can access the existing Hammer instances in the list using the tools variable  Adding Tool instances to the list throws an ArrayTypeMismatchException exception because tools references the same variable as hammers

User · Answer

To quote the great explanation of Eric      What happens  Do you want the list of giraffes to contain a tiger  Do you want a crash  or do you want the compiler to protect you from the crash by making the assignment illegal in the first place    We choose the latter    But what if you want to choose for a runtime crash instead of a compile error  You would normally use Cast lt   or ConvertAll lt   but then you will have 2 problems  It will create a copy of the list  If you add or remove something in the new list  this won t be reflected in the original list  And secondly  there is a big performance and memory penalty since it creates a new list with the existing objects   I had the same problem and therefore I created a wrapper class that can cast a generic list without creating an entirely new list   In the original question you could then use   class Test       static void Main string   args                A a   new C       OK         IList lt A gt  listOfA   new List lt C gt    CastList lt C A gt        now ok            and here the wrapper class    an extention method CastList for easy use   public class CastedList lt TTo  TFrom gt    IList lt TTo gt        public IList lt TFrom gt  BaseList       public CastedList IList lt TFrom gt  baseList                BaseList   baseList                IEnumerable     IEnumerator IEnumerable GetEnumerator     return BaseList GetEnumerator              IEnumerable lt  gt      public IEnumerator lt TTo gt  GetEnumerator     return new CastedEnumerator lt TTo  TFrom gt  BaseList GetEnumerator               ICollection     public int Count   get   return BaseList Count          public bool IsReadOnly   get   return BaseList IsReadOnly          public void Add TTo item    BaseList Add  TFrom  object item         public void Clear     BaseList Clear          public bool Contains TTo item    return BaseList Contains  TFrom  object item         public void CopyTo TTo   array  int arrayIndex    BaseList CopyTo  TFrom    object array  arrayIndex         public bool Remove TTo item    return BaseList Remove  TFrom  object item             IList     public TTo this int index                get   return  TTo  object BaseList index             set   BaseList index     TFrom  object value               public int IndexOf TTo item    return BaseList IndexOf  TFrom  object item         public void Insert int index  TTo item    BaseList Insert index   TFrom  object item         public void RemoveAt int index    BaseList RemoveAt index        public class CastedEnumerator lt TTo  TFrom gt    IEnumerator lt TTo gt        public IEnumerator lt TFrom gt  BaseEnumerator       public CastedEnumerator IEnumerator lt TFrom gt  baseEnumerator                BaseEnumerator   baseEnumerator                IDisposable     public void Dispose     BaseEnumerator Dispose              IEnumerator     object IEnumerator Current   get   return BaseEnumerator Current          public bool MoveNext     return BaseEnumerator MoveNext          public void Reset     BaseEnumerator Reset              IEnumerator lt  gt      public TTo Current   get   return  TTo  object BaseEnumerator Current         public static class ListExtensions       public static IList lt TTo gt  CastList lt TFrom  TTo gt  this IList lt TFrom gt  list                return new CastedList lt TTo  TFrom gt  list

User · Answer

I ve read this whole thread  and I just want to point out what seems like an inconsistency to me     The compiler prevents you from doing the assignment with Lists   List lt Tiger gt  myTigersList   new List lt Tiger gt      new Tiger    new Tiger    new Tiger      List lt Animal gt  myAnimalsList   myTigersList        Compiler error   But the compiler is perfectly fine with arrays   Tiger   myTigersArray   new Tiger 3    new Tiger    new Tiger    new Tiger      Animal   myAnimalsArray   myTigersArray        No problem   The argument about whether the assignment is known to be safe falls apart here   The assignment I did with the array is not safe   To prove that  if I follow that up with this   myAnimalsArray 1    new Giraffe      I get a runtime exception  ArrayTypeMismatchException    How does one explain this   If the compiler really wants to prevent me from doing something stupid  it should have prevented me from doing the array assignment

User · Answer

If you use IEnumerable instead  it will work  at least in C  4 0  I have not tried previous versions   This is just a cast  of course  it will still be a list   Instead of -  List lt A gt  listOfA   new List lt C gt        compiler Error  In the original code of the question  use -  IEnumerable lt A gt  listOfA   new List lt C gt        compiler error - no more

User · Answer

You can only cast to readonly lists  For example   IEnumerable lt A gt  enumOfA   new List lt C gt      This works IReadOnlyCollection lt A gt  ro colOfA   new List lt C gt      This works IReadOnlyList lt A gt  ro listOfA   new List lt C gt      This works   And you cannot do it for lists that support saving elements  The reason why is   List lt string gt  listString new List lt string gt     List lt object gt  listObject  List lt object gt  listString   Assume that this is possible listObject Add new object       What now  Remember that listObject and listString are the same list actually  so listString now have object element - it shouldn t be possible and it s not

User · Answer

As far as why it doesn t work  it might be helpful to understand covariance and contravariance   Just to show why this shouldn t work  here is a change to the code you provided   void DoesThisWork          List lt C gt  DerivedList   new List lt C gt          List lt A gt  BaseList   DerivedList       BaseList Add new B           C FirstItem   DerivedList First        Should this work   The First item in the list is of Type  B   but the type of the DerivedList item is C     Now  assume that we really just want to make a generic function that operates on a list of some type which implements A  but we don t care what type that is   void ThisWorks lt T gt  List lt T gt  GenericList  where T A       void Test          ThisWorks new List lt B gt           ThisWorks new List lt C gt

User · Answer

First of all  stop using impossible-to-understand class names like A  B  C   Use Animal  Mammal  Giraffe  or Food  Fruit  Orange or something where the relationships are clear   Your question then is  why can I not assign a list of giraffes to a variable of type list of animal  since I can assign a giraffe to a variable of type animal    The answer is  suppose you could  What could then go wrong   Well  you can add a Tiger to a list of animals  Suppose we allow you to put a list of giraffes in a variable that holds a list of animals  Then you try to add a tiger to that list  What happens   Do you want the list of giraffes to contain a tiger  Do you want a crash  or do you want the compiler to protect you from the crash by making the assignment illegal in the first place   We choose the latter   This kind of conversion is called a  covariant  conversion  In C  4 we will allow you to make covariant conversions on interfaces and delegates when the conversion is known to be always safe   See my blog articles on covariance and contravariance for details   There will be a fresh one on this topic on both Monday and Thursday of this week

User · Answer

This is an extension to BigJim s brilliant answer   In my case I had a NodeBase class with a Children dictionary  and I needed a way to generically do O 1  lookups from the children   I was attempting to return a private dictionary field in the getter of Children  so obviously I wanted to avoid expensive copying iterating   Therefore I used Bigjim s code to cast the Dictionary lt whatever specific type gt  to a generic Dictionary lt NodeBase gt       Abstract parent class public abstract class NodeBase       public abstract IDictionary lt string  NodeBase gt  Children   get                  Implementing child class public class RealNode   NodeBase       private Dictionary lt string  RealNode gt  containedNodes       public override IDictionary lt string  NodeBase gt  Children                  Using a modification of Bigjim s code to cast the Dictionary          return new IDictionary lt string  NodeBase gt    CastDictionary lt string  RealNode  NodeBase gt                       This worked well   However  I eventually ran into unrelated limitations and ended up creating an abstract FindChild   method in the base class that would do the lookups instead   As it turned out this eliminated the need for the casted dictionary in the first place   I was able to replace it with a simple IEnumerable for my purposes    So the question you might ask  especially if performance is an issue prohibiting you from using  Cast lt  gt  or  ConvertAll lt  gt   is    Do I really need to cast the entire collection  or can I use an abstract method to hold the special knowledge needed to perform the task and thereby avoid directly accessing the collection     Sometimes the simplest solution is the best

User · Answer

I personally like to create libs with extensions to the classes  public static List lt TTo gt  Cast lt TFrom  TTo gt  List lt TFrom gt  fromlist    where TFrom   class    where TTo   class     return fromlist ConvertAll x   gt  x as TTo

[c#] Convert List<DerivedClass> to List<BaseClass>

Examples related to c#

Examples related to list

Examples related to inheritance

Examples related to collections

Examples related to covariance