C# 访问不同类型阵列的统一方法

假设我有以下课程：

class Master {
  int x;
  int y;

  public int X { get { return x; } set { x = value; } }
  public int Y { get { return y; } set { y = value; } }
}

class Sub1:Master {
  int z;

  public int Z { get { return z; } set { z = value; } }
}

class Sub2:Master {
  int w;

  public int W { get { return w; } set { w = value; } }
}
class Sub3:Master {
  int t;

  public int T { get { return t; } set { t = value; } }
}

然后我定义了三个不同的数组，每个数组对应于

Sub*

类型：

List<Sub1> array1;
List<Sub2> array2;
List<Sub3> array3;

列表数组1；
列表2；
列表阵列3；

最后，我需要一种以统一方式访问所有实例的方法。这个想法是使用一个新的数组

List[]array4=new[]{array1，array2，array3}

并使用

int

作为索引，因此我不必为属性

X

和

Y

编写三次常见操作

---

但是，我不能这样做，因为这三个数组的类型不同。我可以使用什么？

它们共享一个基本类型，因此您可以创建一个

列表来保存所有三种类型的实例

最终，所有对象共享相同的基本类型
对象
，因此始终可以有一个
列表
，但在这种情况下，它们共享层次结构中较高的基本类型，因此您可以使用
主控

要为所有实例创建列表，可以执行以下操作：

var all = new List<Master>(array1.Count + array2.Count + array3.Count);

all.AddRange(array1);
all.AddRange(array2);
all.AddRange(array3);

var all=新列表（array1.Count+array2.Count+array3.Count）；
all.AddRange（数组1）；
all.AddRange（array2）；
全部。添加范围（数组3）；

首先，创建一个新列表，因为您已经知道预期容量应该是多少，所以使用接受
int capacity
的构造函数重载。这样，在添加其他集合时，不必调整列表的大小，从而提高代码的效率

作为旁注，我知道这可能只是示例代码，但是您应该根据变量所表示的内容来命名变量，因此像
array*
这样的命名应该保留给它们真正表示数组的时候。
列表实现了非通用接口
ICollection
，
IEnumerable
和
IList
，因此您可以创建
IList[]array4={array1，array2，array3}的新数组

或者，在列表中添加元素时，您可以将它们（也）添加到另一个Master类型列表中，如下所示

List<Sub1> array1 = new List<Sub1>();
List<Sub2> array2 = new List<Sub2>();
List<Sub3> array3 = new List<Sub3>();
List<Master> array4 = new List<Master>();

...

public void AddSub1(Sub1 sub)
{
    array1.Add(sub);
    array4.Add(sub);
}

public void AddSub2(Sub2 sub)
{
    array2.Add(sub);
    array4.Add(sub);
}

public void AddSub3(Sub3 sub)
{
    array3.Add(sub);
    array4.Add(sub);
}

实际上，您可以通过将
IEnumerable
声明为
IEnumerable
，并针对
IEnumerable
实现的
IList
的运行时类型进行优化来实现这一点。这让您可以这样做：

var x = new IEnumerable<Master>[] {array1, array2, array3};
x[0].ElementAt(4);

var x=new IEnumerable[]{array1，array2，array3}；
x[0]。元素AT（4）；

同时仍然可以对列表中的各个元素进行固定时间访问。感觉有点笨重，但应该还能用

如果它适合所做的工作，我认为更好的选择是创建一个泛型方法，并在每个列表上调用泛型方法：

private void MainMethod()
{
    List<Sub1> array1 = new List<Sub1>();
    List<Sub2> array2 = new List<Sub2>();
    List<Sub3> array3 = new List<Sub3>();
    DoOperation(array1);
    DoOperation(array2);
    DoOperation(array3);
}

private void DoOperation<T>(List<T> list) where T: Master
{
    // do work here
    list[0].X = 0;
}

private void main方法（）
{
列表数组1=新列表（）；
List array2=新列表（）；
列表数组3=新列表（）；
操作（阵列1）；
操作（阵列2）；
操作（阵列3）；
}
私有无效操作（列表），其中T:Master
{
//你在这里工作吗
列表[0].X=0；
}
您是否尝试过List[]masterList=新列表[]{array1，array2，array3}；
private void MainMethod()
{
    List<Sub1> array1 = new List<Sub1>();
    List<Sub2> array2 = new List<Sub2>();
    List<Sub3> array3 = new List<Sub3>();
    DoOperation(array1);
    DoOperation(array2);
    DoOperation(array3);
}

private void DoOperation<T>(List<T> list) where T: Master
{
    // do work here
    list[0].X = 0;
}