Konvertieren Sie List <DerivedClass> in List <BaseClass>

Während wir von der Basisklasse / Schnittstelle erben können, warum können wir nicht deklarieren List<> , dass dieselbe Klasse / Schnittstelle verwendet wird?

interface A
{ }

class B : A
{ }

class C : B
{ }

class Test
{
    static void Main(string[] args)
    {
        A a = new C(); // OK
        List<A> listOfA = new List<C>(); // compiler Error
    }
}

Gibt es einen Weg herum?

Um dies zu erreichen, müssen Sie die Liste durchlaufen und die Elemente umwandeln. Dies kann mit ConvertAll erfolgen:

List<A> listOfA = new List<C>().ConvertAll(x => (A)x);

Sie können auch Linq verwenden:

List<A> listOfA = new List<C>().Cast<A>().ToList();

Verwenden Sie zunächst keine unverständlichen Klassennamen wie A, B, C. Verwenden Sie Tier, Säugetier, Giraffe oder Nahrung, Obst, Orange oder etwas, bei dem die Beziehungen klar sind.

Ihre Frage lautet dann: "Warum kann ich einer Variablen vom Typ Tierliste keine Liste von Giraffen zuweisen, da ich einer Variablen vom Typ Tier eine Giraffe zuweisen kann?"

Die Antwort lautet: Angenommen, Sie könnten. Was könnte dann schief gehen?

Nun, Sie können einen Tiger zu einer Liste von Tieren hinzufügen. Angenommen, Sie können eine Liste von Giraffen in eine Variable einfügen, die eine Liste von Tieren enthält. Dann versuchen Sie, dieser Liste einen Tiger hinzuzufügen. Was geschieht? Möchten Sie, dass die Liste der Giraffen einen Tiger enthält? Willst du einen Absturz? oder möchten Sie, dass der Compiler Sie vor dem Absturz schützt, indem er die Zuweisung überhaupt illegal macht?

Wir wählen letzteres.

Diese Art der Umwandlung wird als "kovariante" Umwandlung bezeichnet. In C # 4 können Sie kovariante Konvertierungen für Schnittstellen und Delegaten durchführen, wenn bekannt ist, dass die Konvertierung immer sicher ist . Weitere Informationen finden Sie in meinen Blog-Artikeln zu Kovarianz und Kontravarianz. (Am Montag und Donnerstag dieser Woche wird es ein neues zu diesem Thema geben.)

Um die großartige Erklärung von Eric zu zitieren

Was geschieht? Möchten Sie, dass die Liste der Giraffen einen Tiger enthält? Willst du einen Absturz? oder möchten Sie, dass der Compiler Sie vor dem Absturz schützt, indem er die Zuweisung überhaupt illegal macht? Wir wählen letzteres.

Aber was ist, wenn Sie sich für einen Laufzeitabsturz anstelle eines Kompilierungsfehlers entscheiden möchten? Normalerweise verwenden Sie Cast <> oder ConvertAll <>, aber dann treten zwei Probleme auf: Es wird eine Kopie der Liste erstellt. Wenn Sie der neuen Liste etwas hinzufügen oder daraus entfernen, wird dies nicht in der ursprünglichen Liste angezeigt. Und zweitens gibt es einen großen Leistungs- und Speicherverlust, da eine neue Liste mit den vorhandenen Objekten erstellt wird.

Ich hatte das gleiche Problem und habe daher eine Wrapper-Klasse erstellt, die eine generische Liste umwandeln kann, ohne eine völlig neue Liste zu erstellen.

In der ursprünglichen Frage könnten Sie dann verwenden:

class Test
{
    static void Main(string[] args)
    {
        A a = new C(); // OK
        IList<A> listOfA = new List<C>().CastList<C,A>(); // now ok!
    }
}

und hier die Wrapper-Klasse (+ eine Erweiterungsmethode CastList zur einfachen Verwendung)

public class CastedList<TTo, TFrom> : IList<TTo>
{
    public IList<TFrom> BaseList;

    public CastedList(IList<TFrom> baseList)
    {
        BaseList = baseList;
    }

    // IEnumerable
    IEnumerator IEnumerable.GetEnumerator() { return BaseList.GetEnumerator(); }

    // IEnumerable<>
    public IEnumerator<TTo> GetEnumerator() { return new CastedEnumerator<TTo, TFrom>(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<TTo, TFrom> : IEnumerator<TTo>
{
    public IEnumerator<TFrom> BaseEnumerator;

    public CastedEnumerator(IEnumerator<TFrom> 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<>
    public TTo Current { get { return (TTo)(object)BaseEnumerator.Current; } }
}

public static class ListExtensions
{
    public static IList<TTo> CastList<TFrom, TTo>(this IList<TFrom> list)
    {
        return new CastedList<TTo, TFrom>(list);
    }
}

Wenn Sie IEnumerablestattdessen verwenden, wird es funktionieren (zumindest in C # 4.0 habe ich frühere Versionen nicht ausprobiert). Dies ist nur eine Besetzung, natürlich wird es immer noch eine Liste sein.

Anstatt -

List<A> listOfA = new List<C>(); // compiler Error

Verwenden Sie im Originalcode der Frage -

IEnumerable<A> listOfA = new List<C>(); // compiler error - no more! :)

Was den Grund betrifft, warum es nicht funktioniert, kann es hilfreich sein, Kovarianz und Kontravarianz zu verstehen .

Um zu zeigen, warum dies nicht funktionieren sollte, wurde der von Ihnen angegebene Code geändert:

void DoesThisWork()
{
     List<C> DerivedList = new List<C>();
     List<A> BaseList = DerivedList;
     BaseList.Add(new B());

     C FirstItem = DerivedList.First();
}

Sollte das funktionieren? Das erste Element in der Liste ist vom Typ "B", der Typ des DerivedList-Elements ist jedoch C.

Nehmen wir nun an, wir möchten wirklich nur eine generische Funktion erstellen, die mit einer Liste eines Typs arbeitet, der A implementiert, aber es ist uns egal, um welchen Typ es sich handelt:

void ThisWorks<T>(List<T> GenericList) where T:A
{

}

void Test()
{
     ThisWorks(new List<B>());
     ThisWorks(new List<C>());
}

Sie können nur in schreibgeschützte Listen umwandeln. Beispielsweise:

IEnumerable<A> enumOfA = new List<C>();//This works
IReadOnlyCollection<A> ro_colOfA = new List<C>();//This works
IReadOnlyList<A> ro_listOfA = new List<C>();//This works

Und Sie können dies nicht für Listen tun, die das Speichern von Elementen unterstützen. Der Grund dafür ist:

List<string> listString=new List<string>();
List<object> listObject=(List<object>)listString;//Assume that this is possible
listObject.Add(new object());

Was jetzt? Denken Sie daran, dass listObject und listString tatsächlich dieselbe Liste sind, sodass listString jetzt ein Objektelement hat - es sollte nicht möglich sein und es ist nicht möglich.

Ich persönlich mag es, Bibliotheken mit Erweiterungen der Klassen zu erstellen

public static List<TTo> Cast<TFrom, TTo>(List<TFrom> fromlist)
  where TFrom : class 
  where TTo : class
{
  return fromlist.ConvertAll(x => x as TTo);
}

Weil C # diese Art von nicht zulässt ErbeUmwandlung im Moment .

Dies ist eine Erweiterung von BigJims brillanter Antwort .

In meinem Fall hatte ich eine NodeBaseKlasse mit einem ChildrenWörterbuch, und ich brauchte eine Möglichkeit, generisch O (1) -Suchen von den Kindern durchzuführen. Ich habe versucht, ein privates Wörterbuchfeld im Getter von zurückzugeben Children, daher wollte ich natürlich teures Kopieren / Iterieren vermeiden. Deshalb habe ich Bigjims Code verwendet, um das Dictionary<whatever specific type>in ein generisches umzuwandeln Dictionary<NodeBase>:

// Abstract parent class
public abstract class NodeBase
{
    public abstract IDictionary<string, NodeBase> Children { get; }
    ...
}

// Implementing child class
public class RealNode : NodeBase
{
    private Dictionary<string, RealNode> containedNodes;

    public override IDictionary<string, NodeBase> Children
    {
        // Using a modification of Bigjim's code to cast the Dictionary:
        return new IDictionary<string, NodeBase>().CastDictionary<string, RealNode, NodeBase>();
    }
    ...
}

Das hat gut funktioniert. Schließlich stieß ich jedoch auf nicht verwandte Einschränkungen und erstellte schließlich eine abstrakte FindChild()Methode in der Basisklasse, die stattdessen die Suche durchführen würde. Wie sich herausstellte, war das gegossene Wörterbuch damit überhaupt nicht mehr erforderlich. (Ich konnte es IEnumerablefür meine Zwecke durch ein einfaches ersetzen .)

Die Frage, die Sie möglicherweise stellen (insbesondere wenn die Leistung ein Problem darstellt, das Ihnen die Verwendung von .Cast<>oder verbietet .ConvertAll<>), lautet:

"Muss ich wirklich die gesamte Sammlung besetzen oder kann ich eine abstrakte Methode verwenden, um das für die Ausführung der Aufgabe erforderliche Spezialwissen zu speichern und so den direkten Zugriff auf die Sammlung zu vermeiden?"

Manchmal ist die einfachste Lösung die beste.

Sie können auch das System.Runtime.CompilerServices.UnsafeNuGet-Paket verwenden, um einen Verweis auf dasselbe zu erstellen List:

using System.Runtime.CompilerServices;
...
class Tool { }
class Hammer : Tool { }
...
var hammers = new List<Hammer>();
...
var tools = Unsafe.As<List<Tool>>(hammers);

HammerAnhand des obigen Beispiels können Sie mit der toolsVariablen auf die vorhandenen Instanzen in der Liste zugreifen . Das Hinzufügen von ToolInstanzen zur Liste löst eine ArrayTypeMismatchExceptionAusnahme aus, da toolsauf dieselbe Variable wie verwiesen wird hammers.

Ich habe diesen ganzen Thread gelesen und möchte nur darauf hinweisen, was mir als Inkonsistenz erscheint.

Der Compiler verhindert, dass Sie die Zuweisung mit Listen ausführen:

List<Tiger> myTigersList = new List<Tiger>() { new Tiger(), new Tiger(), new Tiger() };
List<Animal> myAnimalsList = myTigersList;    // Compiler error

Aber der Compiler ist mit Arrays vollkommen in Ordnung:

Tiger[] myTigersArray = new Tiger[3] { new Tiger(), new Tiger(), new Tiger() };
Animal[] myAnimalsArray = myTigersArray;    // No problem

Das Argument, ob die Zuordnung als sicher bekannt ist, fällt hier auseinander. Die Zuordnung, die ich mit dem Array vorgenommen habe, ist nicht sicher . Um das zu beweisen, wenn ich dem folge:

myAnimalsArray[1] = new Giraffe();

Ich erhalte eine Laufzeitausnahme "ArrayTypeMismatchException". Wie erklärt man das? Wenn der Compiler mich wirklich daran hindern möchte, etwas Dummes zu tun, hätte er mich daran hindern sollen, die Array-Zuweisung vorzunehmen.