Question

我有一个Buildable抽象类，从该类继承了House and Road类。

我正在尝试对包含房屋和道路的Buildable对象数组进行分类。

我知道我可以检查对象是否为C:\Program Files (x86)\Microsoft\Edge Dev\Application\之类的道路，并且可以正常工作，但是出于可伸缩性的原因，我想要一个数组，其中包含从Buildable继承的类。我尝试了一些方法，但显然不起作用：f(myBuildables[i] is Road)

我也尝试过类型class[] inheritTypes = { House, Road }的数组，但是由于Types[] buildableTypes = { typeOf(Hosue), typeOf(Road) }总是返回Buildable类型，所以我无法比较类型。

Answer 1

is对实例进行检查但对类型的等效功能为Type.IsAssignableFrom（docs）。

在您的情况下：

if (typeof(House).IsAssignableFrom(obj.GetType()))
{
//obj is a house
}

因此，您可以将类型保留在数组中，然后根据该数组的内容动态地做出决定。

Answer 2

给予

public abstract class Buildable{}

class Road : Buildable{}
class House : Buildable{}

您可以执行以下操作

List<Buildable> buildables = new List<Buildable>();
buildables.Add(new House());
buildables.Add(new Road());
buildables.Add(new House());

foreach(var item in buildables)
{
    if(item is House)
    {
        Console.WriteLine("House");
    }
    if (item is Road)
    {
        Console.WriteLine("Road");
    }
}

或者在C＃8.0中，您可以执行以下高级模式匹配：

abstract class Buildable { 
    public bool Damage;
}

class Road : Buildable { }
class House : Buildable { }

与模式匹配：

List<Buildable> buildables = new List<Buildable>();
buildables.Add(new House());
buildables.Add(new Road());
buildables.Add(new House{  Damage = true });

foreach (var item in buildables)
{
    switch (item)
    {
        case House damageHouse when damageHouse.Damage:
            Console.WriteLine("House Damaged");
            break;
        case House house:
            Console.WriteLine("House");
            break;
        case Road road:
            Console.WriteLine("Road");
            break;
        case Buildable _:
            Console.WriteLine("Default");
            break;
    }

}

Answer 3

您应该使用object.GetType（）：

myBuildables [I] .GetType ();

这是示例代码：

 class Program
    {
        abstract class Buildable
        {
            public string Name { get; set; } = string.Empty;
        }

        class Home : Buildable{}

        class Roard: Buildable{}

        static void Main(string[] args)
        {
            List<Type> listTypes = new List<Type>()
            {
                typeof(Home),
            };

            List<Buildable> listBuildable = new List<Buildable>()
            {
                new Home(){Name = "home 1"},
                new Home(){Name = "home 2"},
                new Home(){Name = "home 3"},
                new Roard(){Name = "road 1"},
                new Roard(){Name = "road 2"},
                new Roard(){Name = "road 3"},
            };
            foreach(var item in listBuildable)
            {
                var itemType = item.GetType();
                Console.WriteLine("Buildable name = " + item.Name);
                Console.Write("item typeof" + itemType.ToString());

                if (listTypes.Find(o => o.Equals(itemType)) != null)
                    Console.WriteLine(" - Type isset in list");
                else
                    Console.WriteLine(" - Unknown type");

                Console.WriteLine();

            }
            Console.ReadLine();
        }
    }

结果：

可建造名称=房屋1   项目typeofConsoleApp1.Program + Home-类型在列表中设置

可建造名称=房屋2   项目typeofConsoleApp1.Program + Home-类型在列表中设置

可建造名称=房屋3   项目typeofConsoleApp1.Program + Home-类型在列表中设置

可建造名称=道路1   项目typeofConsoleApp1.Program + Roard-未知类型

可建造名称=道路2   项目typeofConsoleApp1.Program + Roard-未知类型

可建造名称=路3   项目typeofConsoleApp1.Program + Roard-未知类型

检查并比较两个对象

3 个答案: