Konvertieren Liste<DerivedClass> Liste<BaseClass>

Den Weg zu machen diese Arbeit ist die Iteration über die Liste und die Besetzung der Elemente. Dies kann mit ConvertAll:

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

Du könntest auch Linq:

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

InformationsquelleAutor Mark Byers

Zitieren, der die große Erklärung von Eric

Was passiert? Wollen Sie die Liste der Giraffen zu enthalten, ein tiger? Wollen Sie einen crash? oder wollen Sie den compiler, um Sie zu schützen vor dem Absturz von der Abtretung in Erster Linie illegal?
Wir wählen den letzteren.

Aber was ist, wenn Sie sich für eine Laufzeit crash statt einen compile-Fehler? Sie normalerweise verwenden würden, Cast<> oder ConvertAll<> aber dann wirst du 2 Probleme haben: Es wird eine Kopie der Liste. Wenn Sie hinzufügen oder entfernen von etwas, das in der neuen Liste, ist dieses nicht auch in der ursprünglichen Liste. Und zweitens, es ist eine große Leistung und Speicher Strafe seit es erstellt eine neue Liste mit den vorhandenen Objekten.

Ich hatte das gleiche problem und deshalb erstellte ich eine wrapper-Klasse casten kann eine generische Liste, ohne eine komplett neue Liste.

In der ursprünglichen Frage, dann könnten Sie 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 Erweiterung Methode CastList für die einfache Nutzung)

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);
    }
}

InformationsquelleAutor Bigjim

Wenn Sie IEnumerable statt, es wird funktionieren (zumindest in C# 4.0, ich habe nicht versucht, frühere Versionen). Dies ist nur ein cast, natürlich, es wird noch eine Liste.

Statt -

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

Im original-code von der Frage,

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

InformationsquelleAutor PhistucK

Ich persönlich gerne erstellen libs mit Erweiterungen der Klassen

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

InformationsquelleAutor vikingfabian

Dies ist eine Erweiterung des BigJim ist genial Antwort.

In meinem Fall hatte ich eine NodeBase Klasse mit einem Children Wörterbuch, und ich brauchte einen Weg, um generisch O(1) - lookups von den Kindern. Ich war versucht, zurück ein eigenes dictionary-Feld in der getter von Children, so offensichtlich wollte ich vermeiden teuer kopieren/verändern. Deshalb habe ich Bigjim code zum cast der Dictionary<whatever specific type> zu einem generischen 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 funktionierte gut. Jedoch ich schließlich lief in beziehungslose Grenzen und am Ende die Schaffung eines abstrakten FindChild() Methode in der Basisklasse, die tun würde, die lookups statt. Es stellte sich heraus, dies eliminiert die Notwendigkeit für die gegossenen Wörterbuch in den ersten Platz. (Ich war in der Lage, Sie zu ersetzen mit einem einfachen IEnumerable für meine Zwecke.)

Also die Frage, die Sie stellen könnten (vor allem wenn die Leistung ein Problem, verbieten Sie von der Nutzung .Cast<> oder .ConvertAll<>):

"Muss ich wirklich brauchen, um zu werfen die gesamte Kollektion, oder kann ich eine abstrakte Methode zu halten, die Besondere Kenntnisse erforderlich, um die Aufgabe zu erfüllen und dabei vermeiden, direkt auf die Sammlung?"

Manchmal ist die einfachste Lösung die beste ist.

InformationsquelleAutor Zach