Konversi Daftar <DerivedClass> ke Daftar <BaseClass>

Meskipun kita dapat mewarisi dari kelas dasar / antarmuka, mengapa kita tidak dapat mendeklarasikan List<> menggunakan kelas / antarmuka yang sama?

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

Apakah ada jalan keluar?

Cara untuk membuat pekerjaan ini adalah untuk beralih ke daftar dan melemparkan elemen. Ini dapat dilakukan dengan menggunakan ConvertAll:

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

Anda juga bisa menggunakan Linq:

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

Pertama-tama, berhentilah menggunakan nama-nama kelas yang mustahil untuk dipahami seperti A, B, C. Gunakan Hewan, Mamalia, Jerapah, atau Makanan, Buah, Jeruk atau sesuatu di mana hubungannya jelas.

Pertanyaan Anda kemudian adalah "mengapa saya tidak bisa menetapkan daftar jerapah ke variabel daftar jenis hewan, karena saya bisa menetapkan jerapah ke variabel jenis hewan?"

Jawabannya adalah: seandainya Anda bisa. Lalu apa yang bisa salah?

Nah, Anda dapat menambahkan Macan ke daftar hewan. Misalkan kami mengizinkan Anda untuk meletakkan daftar jerapah dalam variabel yang menyimpan daftar hewan. Kemudian Anda mencoba menambahkan harimau ke daftar itu. Apa yang terjadi? Apakah Anda ingin daftar jerapah mengandung harimau? Apakah Anda ingin crash? atau apakah Anda ingin kompiler melindungi Anda dari crash dengan menjadikan tugas itu ilegal?

Kami memilih yang terakhir.

Konversi semacam ini disebut konversi "kovarian". Dalam C # 4 kami akan memungkinkan Anda untuk membuat konversi kovarian pada antarmuka dan delegasi ketika konversi diketahui selalu aman . Lihat artikel blog saya tentang kovarians dan contravariance untuk detailnya. (Akan ada yang baru pada topik ini pada hari Senin dan Kamis minggu ini.)

Mengutip penjelasan hebat Eric

Apa yang terjadi? Apakah Anda ingin daftar jerapah mengandung harimau? Apakah Anda ingin crash? atau apakah Anda ingin kompiler melindungi Anda dari crash dengan menjadikan tugas itu ilegal? Kami memilih yang terakhir.

Tetapi bagaimana jika Anda ingin memilih untuk crash runtime daripada kesalahan kompilasi? Anda biasanya menggunakan Cast <> atau ConvertAll <> tetapi kemudian Anda akan memiliki 2 masalah: Ini akan membuat salinan daftar. Jika Anda menambahkan atau menghapus sesuatu di daftar baru, ini tidak akan tercermin dalam daftar asli. Dan kedua, ada performa besar dan hukuman memori karena membuat daftar baru dengan objek yang ada.

Saya memiliki masalah yang sama dan karena itu saya membuat kelas pembungkus yang dapat membuat daftar generik tanpa membuat daftar yang sama sekali baru.

Dalam pertanyaan awal, Anda dapat menggunakan:

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

dan di sini kelas wrapper (+ metode extention CastList agar mudah digunakan)

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

Jika Anda menggunakan IEnumerablesebagai gantinya, itu akan berfungsi (setidaknya dalam C # 4.0, saya belum mencoba versi sebelumnya). Ini hanya pemain, tentu saja, itu masih akan menjadi daftar.

Dari pada -

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

Dalam kode asli pertanyaan, gunakan -

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

Sejauh mengapa itu tidak berhasil, mungkin akan membantu untuk memahami kovarians dan contravariance .

Hanya untuk menunjukkan mengapa ini tidak berhasil, berikut adalah perubahan pada kode yang Anda berikan:

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

     C FirstItem = DerivedList.First();
}

Haruskah ini berhasil? Item pertama dalam daftar adalah tipe "B", tetapi tipe item DerivedList adalah C.

Sekarang, asumsikan kita benar-benar hanya ingin membuat fungsi generik yang beroperasi pada daftar beberapa jenis yang mengimplementasikan A, tetapi kami tidak peduli apa jenisnya:

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

}

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

Anda hanya dapat memilih untuk membaca daftar saja. Sebagai contoh:

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

Dan Anda tidak dapat melakukannya untuk daftar yang mendukung elemen hemat. Alasannya adalah:

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

Apa sekarang? Ingat bahwa listObject dan listString sebenarnya adalah daftar yang sama, jadi listString sekarang memiliki elemen objek - seharusnya tidak mungkin dan tidak.

Saya pribadi suka membuat lib dengan ekstensi ke kelas

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

Karena C # tidak mengizinkan jenis itu warisankonversi saat ini .

Ini adalah perpanjangan dari jawaban brilian BigJim .

Dalam kasus saya, saya memiliki NodeBasekelas dengan Childrenkamus, dan saya membutuhkan cara untuk melakukan O (1) secara umum dari anak-anak. Saya mencoba untuk mengembalikan bidang kamus pribadi di pengambil Children, jadi jelas saya ingin menghindari penyalinan / iterasi yang mahal. Oleh karena itu saya menggunakan kode Bigjim untuk melemparkan Dictionary<whatever specific type>ke generik 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>();
    }
    ...
}

Ini bekerja dengan baik. Namun, saya akhirnya mengalami keterbatasan yang tidak terkait dan akhirnya menciptakan FindChild()metode abstrak di kelas dasar yang akan melakukan pencarian. Ternyata ini menghilangkan kebutuhan akan kamus yang sudah dicor. (Saya bisa menggantinya dengan yang sederhana IEnumerableuntuk tujuan saya.)

Jadi pertanyaan yang mungkin Anda tanyakan (terutama jika kinerja adalah masalah yang melarang Anda menggunakan .Cast<>atau .ConvertAll<>) adalah:

"Apakah saya benar-benar perlu membuang seluruh koleksi, atau bisakah saya menggunakan metode abstrak untuk menyimpan pengetahuan khusus yang diperlukan untuk melakukan tugas dan dengan demikian menghindari mengakses koleksi secara langsung?"

Terkadang solusi paling sederhana adalah yang terbaik.

Anda juga dapat menggunakan System.Runtime.CompilerServices.Unsafepaket NuGet untuk membuat referensi yang sama List:

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

Dengan contoh di atas, Anda dapat mengakses Hammerinstance yang ada dalam daftar menggunakan toolsvariabel. Menambahkan Toolinstance ke daftar melempar ArrayTypeMismatchExceptionpengecualian karena toolsreferensi variabel yang sama dengan hammers.

Saya telah membaca seluruh utas ini, dan saya hanya ingin menunjukkan apa yang tampak seperti inkonsistensi bagi saya.

Kompiler mencegah Anda dari melakukan tugas dengan Daftar:

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

Tetapi kompiler sangat baik dengan array:

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

Argumen tentang apakah tugas tersebut diketahui aman jatuh terpisah di sini. Tugas yang saya lakukan dengan array tidak aman . Untuk membuktikannya, jika saya tindak lanjuti dengan ini:

myAnimalsArray[1] = new Giraffe();

Saya mendapatkan pengecualian runtime "ArrayTypeMismatchException". Bagaimana seseorang menjelaskan hal ini? Jika kompiler benar-benar ingin mencegah saya melakukan sesuatu yang bodoh, itu seharusnya mencegah saya dari melakukan tugas array.