C#，迭代泛型子类的公共父类

我该如何设置以下类，以便有一个方法可以接受公共父类/接口，并允许我在不指定泛型类型的情况下迭代任何子类

public abstract class BaseClass
{ ??? }

public class ChildClass<T> : BaseClass 
{
    public List<T> SomeList;
            ???
}

ChildClass<int> childA = new ChildClass<int> ();
ChildClass<string> childB = new ChildClass<string> ();

public void IterateOverChild (BaseClass someChildClass)
{
    foreach (var element in someChildClass.SomeList)    
    {
        Console.WriteLine (element);
    }

}

公共抽象类基类
{ ??? }
公共类子类：基类
{
公共列表；
???
}
ChildClass childA=新的ChildClass（）；
ChildClass childB=新的ChildClass（）；
public void IterateOverChild（基类someChildClass）
{
foreach（someChildClass.SomeList中的var元素）
{
Console.WriteLine（元素）；
}
}

除非

基类

知道

，否则它不能具有

T

类型的任何属性或方法。但是，您可以提供至少公开属性的非泛型形式的基本实现。您将丢失类型信息，但保留可枚举性

public abstract class BaseClass
{
    public IList SomeList { get; set; }
}

public class ChildClass<T> : BaseClass 
{
    public new List<T> SomeList
    {
        get { return (List<T>) base.SomeList; }
        set { base.SomeList = value; }
    }
}

公共抽象类基类
{
公共IList SomeList{get；set；}
}
公共类子类：基类
{
公共新列表
{
获取{return（List）base.SomeList；}
set{base.SomeList=value；}
}
}

除非

基类

知道

，否则它不能具有

T

类型的任何属性或方法。但是，您可以提供至少公开属性的非泛型形式的基本实现。您将丢失类型信息，但保留可枚举性

public abstract class BaseClass
{
    public IList SomeList { get; set; }
}

public class ChildClass<T> : BaseClass 
{
    public new List<T> SomeList
    {
        get { return (List<T>) base.SomeList; }
        set { base.SomeList = value; }
    }
}

公共抽象类基类
{
公共IList SomeList{get；set；}
}
公共类子类：基类
{
公共新列表
{
获取{return（List）base.SomeList；}
set{base.SomeList=value；}
}
}

让抽象类公开一些访问子类之间通用数据的方法，在这种情况下，每个对象可以是任何类型的数据序列：

public abstract class BaseClass
{
    public abstract IEnumerable Data { get; }
}

public class ChildClass<T> : BaseClass
{
    public List<T> SomeList { get; set; }
    public override IEnumerable Data { get { return SomeList; } }
}

公共抽象类基类
{
公共抽象IEnumerable数据{get；}
}
公共类子类：基类
{
公共列表SomeList{get；set；}
公共重写IEnumerable数据{get{return SomeList；}}
}

让抽象类公开一些访问子类之间通用数据的方法，在这种情况下，每个对象可以是任何类型的数据序列：

public abstract class BaseClass
{
    public abstract IEnumerable Data { get; }
}

public class ChildClass<T> : BaseClass
{
    public List<T> SomeList { get; set; }
    public override IEnumerable Data { get { return SomeList; } }
}

公共抽象类基类
{
公共抽象IEnumerable数据{get；}
}
公共类子类：基类
{
公共列表SomeList{get；set；}
公共重写IEnumerable数据{get{return SomeList；}}
}

使用

公共抽象类基类
{
公共列表SomeList{get；set；}
}
公共类子类：基类
{
}
public void IterateOverChild（基类someChildClass）
{
foreach（someChildClass.SomeList中的var元素）
{
控制台写入线（元素）；
}
}

使用

公共抽象类基类
{
公共列表SomeList{get；set；}
}
公共类子类：基类
{
}
public void IterateOverChild（基类someChildClass）
{
foreach（someChildClass.SomeList中的var元素）
{
控制台写入线（元素）；
}
}

您不能使用普通方式。BaseClass不知道ChildClass上存在的任何属性。为什么不让基类通用？换言之，看起来您可以更好地抽象您想要做的事情。泛型基类的问题在于，没有泛型基类，您无法在代码中引用它。例如，您必须使用

void IterateOverChild（BaseClass someChildClass）

。在许多情况下，您需要非泛型基类，因为泛型类型不可用。您不能使用普通方式。BaseClass不知道ChildClass上存在的任何属性。为什么不让基类通用？换言之，看起来您可以更好地抽象您想要做的事情。泛型基类的问题在于，没有泛型基类，您无法在代码中引用它。例如，您必须使用

void IterateOverChild（BaseClass someChildClass）

。在很多情况下，您需要非泛型基类，因为泛型类型不可用。与其将范围狭窄的数据结构存储在易于出错的广义定义变量中，最好将广义定义的成员作为作用域更窄的存储位置的视图。与其将作用域更窄的数据结构存储在易于出错的广义定义变量中，不如将广义定义的成员作为作用域更窄的存储位置的视图。这不一定是一个选项。例如，假设他想要一个

列表

，其中每个基类都是不同的泛型类型。如果基类必须是非泛型的，那么您的答案会更好。这不一定是一个选项。例如，假设他想要一个

列表

，其中每个基类都是不同的泛型类型。如果基类必须是非泛型的，那么您的答案会更好