Come fare downcasting dinamica in vb.net?

Question

Ho diversi classi, che tutto deriva da superclasse.

Quando si creano le classi, tutti sono messi in una lista (Of SuperClass). Quando vado attraverso la lista, vorrei downcast l'oggetto SuperClass alla sua BaseObject, e metterlo nella lista corretta. (Ho una lista creata per ciascuno dei sub tipi di SuperClass).

E 'possibile determin:

 If TypeOf SuperClass Is SubClass Then
      listOfSubClass.Add(DirectCast(SuperCLass, SubClass)
 End If

, ma questo è un sacco di lavoro, quando ci sono più classi.

Utilizzando

SuperClass.GetType.FullName

ho il tipo di sottoclasse.

La mia domanda è: E 'possibile utilizzare questo per lanciare in modo dinamico l'oggetto SuperClass? in psudoCode:

For each SuperClass
     Dim temp As SuperClass.GetType.FullName = _
                       DirectCast(SuperCLass, SuperClass.GetType.FullName 
     list.add(temp)
Next

Modifica: Speravo che potrei usare una variabile al posto del creare un caso per ogni sottoclasse e fare tutto in un loop.

Answer 1

Hai pensato di usare OfType metodo di estensione di LINQ? Avvolge una enumerable e filtra gli elementi in modo che vengano restituiti solo quelli del tipo specificato. Si potrebbe utilizzare in questo modo:

list.AddRange(superList.OfType(Of SubClass)())

o anche:

list = superList.OfType(Of SubClass)().ToList()

Scusate se la mia sintassi è spento, è stato un po 'che ho usato VB.NET

---

Modifica Esempio, come promesso:

namespace Demo.ListFilter
{
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Collections;

    class Program
    {
        private class SuperClass
        {
        }

        private class SubClassA :
            SuperClass
        {
        }

        private class SubClassB :
            SuperClass
        {
        }

        static void Main(string[] args)
        {
            var superList = new List<SuperClass>()
            {
                new SuperClass(),
                new SuperClass(),
                new SuperClass(),
                new SuperClass(),
                new SubClassA(),
                new SubClassA(),
                new SubClassA(),
                new SubClassB(),
                new SubClassB(),
                new SubClassB(),
                new SubClassB()
            };

            var listA = new List<SubClassA>();
            var listB = new List<SubClassB>();

            SplitList(superList, listA, listB);

            Console.WriteLine("List A: {0}", listA.Count);
            Console.WriteLine("List B: {0}", listB.Count);
            Console.WriteLine("Press any key to exit...");
            Console.ReadKey();
        }

        static void SplitList(IList superList, params IList[] subLists)
        {
            foreach(var subList in subLists)
            {
                var type = subList.GetType().GetGenericArguments()[0];
                FilterList(superList, subList, type);
            }
        }

        static void FilterList(IList superList, IList subList, Type type)
        {
            var ofTypeMethod = typeof(Enumerable).GetMethod("OfType");
            var genericMethod = ofTypeMethod.MakeGenericMethod(type);
            var enumerable = (IEnumerable)genericMethod.Invoke(null, new[] { superList });

            foreach(var item in enumerable)
            {
                subList.Add(item);
            }
        }
    }
}

---

Un altro Modifica: Si potrebbe anche combinare i metodi come questo:

    static void SplitList(IList superList, params IList[] subLists)
    {
        var ofTypeMethod = typeof(Enumerable).GetMethod("OfType");

        foreach(var subList in subLists)
        {
            var subListType = subList.GetType();
            var type = subListType.GetGenericArguments()[0];
            var genericOfTypeMethod = ofTypeMethod.MakeGenericMethod(type);
            var enumerable = genericOfTypeMethod.Invoke(null, new[] { superList });

            var addRangeMethod = subListType.GetMethod("AddRange");
            addRangeMethod.Invoke(subList, new[] { enumerable });
        }
    }

Non dimenticare di aggiungere la gestione degli errori!