如何在vb.net中进行动态下传？

我有几个类，都是从超类派生的

创建类时，它们都被放入（超类）列表中。 当我浏览这个列表时，我想将超类对象向下转换为它的baseObject，并将它放入正确的列表中。（我为超类的每个子类型创建了一个列表）

可以确定：

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

但这是一个很大的工作，当有几个类

利用

SuperClass.GetType.FullName

我得到了子类的类型

我的问题是：是否可以使用它来动态地强制转换超类对象？ 在psudoCode中：

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

编辑：

---

我希望我可以使用一个变量，而不是为每个子类创建一个案例，并在一个循环中完成所有工作。

您考虑过使用LINQ的扩展方法吗？它包装一个可枚举项并过滤元素，以便只返回指定类型的元素。您可以这样使用它：

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

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

甚至：

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

抱歉，如果我的语法是关闭的，我已经有一段时间没有使用VB.NET了

---

编辑：示例，如承诺的：

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

---

别忘了添加错误处理

问题是我必须对每个子类都这样做，这将是大量的工作。我希望我可以使用一个变量而不是“子类”，并在一个循环中完成所有操作。您可以创建一个方法，将

系统.Type

作为参数，并使用反射来建立对

类型的调用。如果你愿意的话，我可以给你看一个C#的例子，但如果我在VB中尝试的话，恐怕我会把它弄坏。这比我想象的要容易，希望它能有所帮助。