covariance

class Base {} abstract class A { abstract public List<Base> Items { get; set; } } class Derived : Base {} class B : A { private List<Derived> items; public override List<Derived> Items { get { return items; } set { items = value; } } } The compiler says that B.Items must be List of Base elements "to match overridden member" A.Items. How can i make that work? Eugene Podskal What you've tried to accomplish initially is impossible - .NET does not support co(contra)variance for method overload . The same goes for properties, because properties are just the pair of methods . But you can make your

After I read the subtyping chapter of the Nomicon , I couldn't wrap my head around covariance of a type parameter. Especially for the Box<T> type, which is described as: T is covariant . However, if I write this code: trait A {} trait B: A {} struct C; impl A for C {} impl B for C {} fn foo(v: Box<A>) {} fn main() { let c = C; let b: Box<B> = Box::new(c); foo(b); } ( Playground ) error[E0308]: mismatched types --> src/main.rs:13:9 | 13 | foo(b); | ^ expected trait `A`, found trait `B` | = note: expected type `std::boxed::Box<(dyn A + 'static)>` found type `std::boxed::Box<dyn B>` B is clearly

abstract class Animal { } class Mammal : Animal { } class Dog : Mammal { } class Reptile : Animal { } class AnimalWrapper<T> where T : Animal { public ISet<AnimalWrapper<T>> Children { get; set; } } class Program { public static void Main(string[] args) { var foo = new AnimalWrapper<Mammal>(); foo.Children = new HashSet<AnimalWrapper<Mammal>>(); var child = new AnimalWrapper<Dog>(); foo.Children.Add(child); } } This obviously doesn't compile because of foo.Children.Add(child); I'm not sure if the above code is the most clear way to demonstrate what I want to do, so I will try to explain in

How can I make the following code work? I don't think I quite understand C# generics. Perhaps, someone can point me in the right direction. public abstract class A { } public class B : A { } public class C : A { } public static List<C> GetCList() { return new List<C>(); } static void Main(string[] args) { List<A> listA = new List<A>(); listA.Add(new B()); listA.Add(new C()); // Compiler cannot implicitly convert List<A> listB = new List<B>(); // Compiler cannot implicitly convert List<A> listC = GetCList(); // However, copying each element is fine // It has something to do with generics (I

In .net, it's possible to use generics so that a function can accept arguments which support one or more interfaces and derive from a base type, even if there does not exist any single type from which all valid argument types derive. For example, one could say: Sub Foo(Of T As {IInterface1, IInterface2, SomeBaseType})(Param as T) and be allowed to pass any derivative of SomeBaseType which implements both IInterface1 and IInterface2. This will work even if SomeBaseType does not support Interface1 and Interface2, and classes which do implement those interfaces don't share any common ancestor