List <DerivedClass>をList <BaseClass>に変換します

基本クラス/インターフェースから継承できますが、List<> 同じクラス/インターフェースを使用して宣言できないのはなぜですか？

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

回避策はありますか？

これを機能させる方法は、リストを反復処理して要素をキャストすることです。これはConvertAllを使用して実行できます。

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

Linqを使用することもできます。

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

まず、A、B、Cなどの理解できないクラス名の使用をやめます。動物、哺乳類、キリン、または食品、果物、オレンジなど、関係が明確なものを使用します。

あなたの質問は、「キリンのリストを動物のタイプリストの変数に割り当てることができないのはなぜですか？キリンを動物のタイプの変数に割り当てることができるからですか？」

答えは次のとおりです。次に何がうまくいかないのでしょうか？

まあ、あなたは動物のリストにタイガーを追加することができます。動物のリストを保持する変数にキリンのリストを入れることができると仮定します。次に、そのリストに虎を追加しようとします。何が起こるのですか？キリンのリストに虎が含まれるようにしますか？クラッシュしたいですか？または、コンパイラーに割り当てを最初から違法にすることでクラッシュから保護しますか？

後者を選択します。

この種の変換は、「共変」変換と呼ばれます。C＃4では、変換が常に安全であることがわかっている場合に、インターフェイスとデリゲートで共変変換を行うことができます。詳細については、共分散と反変に関する私のブログ記事を参照してください。（今週の月曜日と木曜日の両方で、このトピックに関する最新のトピックがあります。）

エリックのすばらしい説明を引用する

何が起こるのですか？キリンのリストに虎が含まれるようにしますか？クラッシュしたいですか？または、コンパイラーに割り当てを最初から違法にすることでクラッシュから保護しますか？後者を選択します。

しかし、コンパイルエラーの代わりにランタイムクラッシュを選択する場合はどうでしょうか。通常はCast <>またはConvertAll <>を使用しますが、2つの問題が発生します。リストのコピーが作成されます。新しいリストで何かを追加または削除しても、元のリストには反映されません。次に、既存のオブジェクトを使用して新しいリストを作成するため、パフォーマンスとメモリが大幅に低下します。

同じ問題が発生したため、まったく新しいリストを作成せずにジェネリックリストをキャストできるラッパークラスを作成しました。

元の質問では、次のように使用できます。

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

そしてここにラッパークラス（+使いやすい拡張メソッドCastList）

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

IEnumerable代わりに使用する場合は、機能します（少なくともC＃4.0では、以前のバージョンは試していません）。これは単なるキャストです。もちろん、リストのままです。

の代わりに -

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

質問の元のコードでは、次を使用します-

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

それが機能しない理由に関しては、共分散と反分散を理解することが役立つ場合があります。

なぜこれが機能しないのかを示すために、ここにあなたが提供したコードへの変更があります：

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

     C FirstItem = DerivedList.First();
}

これでうまくいくでしょうか？リストの最初の項目はタイプ「B」ですが、DerivedList項目のタイプはCです。

ここで、Aを実装するいくつかの型のリストで動作するジェネリック関数を作成したいだけであると仮定しますが、それがどの型であるかは関係ありません。

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

}

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

キャストできるのは読み取り専用リストのみです。例えば：

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

また、要素の保存をサポートするリストに対してはできません。理由は次のとおりです。

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

今何？listObjectとlistStringは実際には同じリストであることを思い出してください。そのため、listStringにはオブジェクト要素があります。これは不可能であり、不可能です。

個人的には、クラスの拡張機能を備えたライブラリを作成したい

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

C＃はそのタイプを許可しないため 継承現時点での変換。

これはBigJimの素晴らしい答えの拡張版です。

私の場合NodeBase、Children辞書を持つクラスがあり、子からO（1）ルックアップを一般的に行う方法が必要でした。私はのゲッターでプライベートディクショナリフィールドを返そうとしていたChildrenので、明らかに、高価なコピー/反復を避けたかったのです。したがって、Bigjimのコードを使用しDictionary<whatever specific type>て、ジェネリックにキャストしました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>();
    }
    ...
}

これはうまくいきました。しかし、結局、無関係な制限に遭遇しFindChild()、代わりに検索を行う基本クラスで抽象メソッドを作成することになりました。結局、これによりキャストされた辞書の必要性が最初からなくなりました。（IEnumerable目的に合わせてシンプルに置き換えることができました。）

したがって、あなたが尋ねることがある質問（特に、パフォーマンスが.Cast<>orの使用を禁止する問題である場合.ConvertAll<>）は次のとおりです。

「本当にコレクション全体をキャストする必要がありますか、それとも抽象メソッドを使用して、タスクを実行するために必要な特別な知識を保持して、コレクションに直接アクセスしないようにできますか？」

時には、最も簡単な解決策が最善です。

System.Runtime.CompilerServices.UnsafeNuGetパッケージを使用して、同じものへの参照を作成することもできますList。

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

上記のサンプルHammerでは、tools変数を使用してリスト内の既存のインスタンスにアクセスできます。Toolリストにインスタンスを追加すると、と同じ変数を参照するArrayTypeMismatchExceptionため、例外がスローさtoolsれhammersます。

このスレッド全体を読んだので、矛盾しているように見えるものを指摘したいだけです。

コンパイラーは、リストを使用した割り当てを防止します。

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

しかし、コンパイラは配列で完全にうまくいきます：

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

割り当てが安全であると知られているかどうかについての議論はここで崩れます。配列で行った割り当ては安全ではありません。それを証明するために、私がこれをフォローアップした場合：

myAnimalsArray[1] = new Giraffe();

私が得るランタイム例外「ArrayTypeMismatchExceptionを」。これをどのように説明しますか？コンパイラが本当に私が愚かなことをするのを防ぎたいなら、それは私が配列の割り当てをすることを防ぐべきでした。