C# 集合列表具有多种类型的用户定义对象？

我有一个静态列表：

public static List<IMachines>mList =new List<IMachines>();

---

如果在将项添加到列表后，我想通过其name属性搜索特定的机器，然后在使用foreach循环进行遍历后，如果在列表中找到该项。。。我如何知道该项目是属于

AC

类型还是

Generator

类型？

您可以使用：

检查对象是否与给定类型兼容

例如：

if(item is AC)
{
  // it is AC
}

您可以使用：

检查对象是否与给定类型兼容

例如：

if(item is AC)
{
  // it is AC
}

---

您还可以使用OfType（）的

方法
仅返回指定类型的项：

IEnumerable<Generator> generators = mList.OfType<Generator>();

IEnumerable generators=mList.OfType（）；
您还可以使用OfType（）的
方法仅返回指定类型的项目：

IEnumerable<Generator> generators = mList.OfType<Generator>();

IEnumerable generators=mList.OfType（）；
接口车辆{
}
等级：IVehicle
{
}
自行车等级：IVehicle
{
}
静态void Main（字符串[]参数）
{
var v1=新车（）；
var v2=新自行车（）；
var list=新列表（）；
列表。添加（v1）；
列表。添加（v2）；
foreach（列表中的var v）
{
WriteLine（v.GetType（））；
}
}
接口车辆{
}
等级：IVehicle
{
}
自行车等级：IVehicle
{
}
静态void Main（字符串[]参数）
{
var v1=新车（）；
var v2=新自行车（）；
var list=新列表（）；
列表。添加（v1）；
列表。添加（v2）；
foreach（列表中的var v）
{
WriteLine（v.GetType（））；
}
}
使用“is”操作符

List<IMachines> list = new List<IMachines>();
list.Add(new AC());
list.Add(new Generator());
foreach(IMachines o in list)
{
  if (o is Ingredient)
  {
    //do sth
  }
  else if (o is Drink)
  {
    //do sth
  }
}

List List=新列表（）；
添加（新的AC（））；
添加（新生成器（））；
foreach（列表中的IMachines o）
{
如果（o是成分）
{
//做某事
}
否则，如果（o是饮料）
{
//做某事
}
}
使用“is”操作符

List<IMachines> list = new List<IMachines>();
list.Add(new AC());
list.Add(new Generator());
foreach(IMachines o in list)
{
  if (o is Ingredient)
  {
    //do sth
  }
  else if (o is Drink)
  {
    //do sth
  }
}

List List=新列表（）；
添加（新的AC（））；
添加（新生成器（））；
foreach（列表中的IMachines o）
{
如果（o是成分）
{
//做某事
}
否则，如果（o是饮料）
{
//做某事
}
}
使用
is
和
作为
运算符

        List<IMachines> mList =new List<IMachines>();
        IMachines machine = mList.Where(x => x.Name == "MachineName").FirstOrDefault();

        if (machine != null)
        {
            if (machine is Generator)
            {
                Generator generator = machine as Generator;
                //do something with generator
            }
            else if (machine is AC)
            {
                AC ac = machine as AC;
                //do something with ac
            }
            else
            {
                //do you other kinds? if no, this is never going to happen
                throw new Exception("Unsupported machine type!!!");
            }

        }

List mList=new List（）；
IMachines machine=mList.Where（x=>x.Name==“MachineName”）.FirstOrDefault（）；
如果（机器！=null）
{
如果（机器是发电机）
{
发电机=作为发电机的机器；
//用发电机做些什么
}
否则，如果（机器为交流）
{
AC=机器为AC；
//用空调做点什么
}
其他的
{
//你有其他种类的吗？如果没有，这永远不会发生
抛出新异常（“不支持的机器类型！！！”；
}
}
使用
is
和
作为
运算符

        List<IMachines> mList =new List<IMachines>();
        IMachines machine = mList.Where(x => x.Name == "MachineName").FirstOrDefault();

        if (machine != null)
        {
            if (machine is Generator)
            {
                Generator generator = machine as Generator;
                //do something with generator
            }
            else if (machine is AC)
            {
                AC ac = machine as AC;
                //do something with ac
            }
            else
            {
                //do you other kinds? if no, this is never going to happen
                throw new Exception("Unsupported machine type!!!");
            }

        }

List mList=new List（）；
IMachines machine=mList.Where（x=>x.Name==“MachineName”）.FirstOrDefault（）；
如果（机器！=null）
{
如果（机器是发电机）
{
发电机=作为发电机的机器；
//用发电机做些什么
}
否则，如果（机器为交流）
{
AC=机器为AC；
//用空调做点什么
}
其他的
{
//你有其他种类的吗？如果没有，这永远不会发生
抛出新异常（“不支持的机器类型！！！”；
}
}
如果要根据类型执行不同的操作，可以使用
GroupBy
type

通过这样做，您可以获得对应于每个派生类型的子列表

下面是代码片段

    void Main()
    {
        List<IMachines> mList = new List<IMachines>();

        mList.Add(new AC());
        mList.Add(new Generator());
        mList.Add(new AC());
        mList.Add(new Generator());
        mList.Add(new Generator());
        mList.Add(new Generator());

        var differentIMachines = mList.GroupBy(t=>t.GetType());
        foreach(var grouping in differentIMachines)
        {
                Console.WriteLine("Type - {0}, Count - {1}", grouping.Key, grouping.Count());

                foreach(var item in grouping)
                {
                //iterate each item for particular type here
                }
        }

    }

    interface IMachines {   }

    class AC : IMachines {}

    class Generator : IMachines {}

void Main（）
{
List mList=新列表（）；
mList.Add（新AC（））；
mList.Add（新生成器（））；
mList.Add（新AC（））；
mList.Add（新生成器（））；
mList.Add（新生成器（））；
mList.Add（新生成器（））；
var differentIMachines=mList.GroupBy（t=>t.GetType（））；
foreach（不同机器中的var分组）
{
WriteLine（“Type-{0}，Count-{1}”，grouping.Key，grouping.Count（））；
foreach（分组中的变量项）
{
//在此处迭代特定类型的每个项
}
}
}
接口IMachines{}
AC类：IMachines{}
类生成器：IMachines{}
如果要根据类型执行不同的操作，可以使用
GroupBy
type

通过这样做，您可以获得对应于每个派生类型的子列表

下面是代码片段

    void Main()
    {
        List<IMachines> mList = new List<IMachines>();

        mList.Add(new AC());
        mList.Add(new Generator());
        mList.Add(new AC());
        mList.Add(new Generator());
        mList.Add(new Generator());
        mList.Add(new Generator());

        var differentIMachines = mList.GroupBy(t=>t.GetType());
        foreach(var grouping in differentIMachines)
        {
                Console.WriteLine("Type - {0}, Count - {1}", grouping.Key, grouping.Count());

                foreach(var item in grouping)
                {
                //iterate each item for particular type here
                }
        }

    }

    interface IMachines {   }

    class AC : IMachines {}

    class Generator : IMachines {}

void Main（）
{
List mList=新列表（）；
mList.Add（新AC（））；
mList.Add（新生成器（））；
mList.Add（新AC（））；
mList.Add（新生成器（））；
mList.Add（新生成器（））；
mList.Add（新生成器（））；
var differentIMachines=mList.GroupBy（t=>t.GetType（））；
foreach（不同机器中的var分组）
{
WriteLine（“Type-{0}，Count-{1}”，grouping.Key，grouping.Count（））；
foreach（分组中的变量项）
{
//在此处迭代特定类型的每个项
}
}
}
接口IMachines{}
AC类：IMachines{}
类生成器：IMachines{}
“我怎么知道该物品是交流型还是发电机型？”你不是。通过
IMachines
接口引用对象，您的意思是只有该接口指定的东西才是您关心的。有很多方法可以解决这个问题，但正确的答案通常是解决需要你去做的设计问题。