Kann C# 4.0-Varianz mir helfen, einen Basisklassenkonstruktor mit einem Upcast aufzurufen?

Question

Ich habe ein wenig über generische Varianz gelesen und ich habe noch kein volles Verständnis davon, aber ich würde gerne wissen, ob es so etwas wie das Folgende möglich macht?

class A<T> { } 

class B { } 

class C : B { } 

class My1 { 
    public My1(A<B> lessDerivedTemplateParameter) 
    { 
    } 
} 

class My2 : My1 { 
    public My2(A<C> moreDerivedTemplateParameter) 
     : base(moreDerivedTemplateParameter) // <-- compile error here, cannot convert 
    { 
    } 
} 

Answer 1

Nein, denn während C erbt von B, A<C> von A<B> nicht erben wird.

Um zu verstehen, warum dies der Fall ist, vorstellen, wenn A<T> statt List<T> sind:

class B { } 

class C : B { } 

class D : B { } 

class My1 { 
    public My1(List<B> lessDerivedTemplateParameter) 
    { 
     // This is totally legal 
     lessDerivedTemplateParameter.Add(new D()); 
    } 
} 

class My2 : My1 { 
    public My2(List<C> moreDerivedTemplateParameter) 
     // if this were allowed, then My1 could add a D to a list of Bs 
     : base(moreDerivedTemplateParameter) 
    { 
    } 
} 

nun auf der anderen Seite, das ist legal:

interface IA<out T> { 
    public T GetSome(); 
} 

class B { } 

class C : B { } 

class D : B { } 

class My1 { 
    public My1(IA<B> lessDerivedTemplateParameter) 
    { 
     // This is totally legal 
     var someB = lessDerivedTemplateParameter.GetSome(); 
    } 
} 

class My2 : My1 { 
    public My2(IA<C> moreDerivedTemplateParameter) 
     // This is allowed, because an A<C> only *produces* C's (which are also B's) 
     // so the base class (which consumes B's, and doesnt care if they are C's) 
     // can use an IA<C> 
     : base(moreDerivedTemplateParameter) 
    { 
    } 
} 

Answer 2

Sie A als Schnittstelle deklarieren mit einem kontravarianten Typ Parameter und es wird kompilieren:

internal interface A<out T> 
    { 
    } 

    internal class B 
    { 
    } 

    internal class C : B 
    { 
    } 

    internal class My1 
    { 
    public My1(A<B> lessDerivedTemplateParameter) 
    { 
    } 
} 

internal class My2 : My1 
{ 
    public My2(A<C> moreDerivedTemplateParameter) 
     : base(moreDerivedTemplateParameter) 
    { 
    } 

}