Question

我有一个抽象类，我更多地使用它作为接口。我的部分代码接受抽象类，但我需要弄清楚哪个类继承了它，以便我可以使用该类填充List。

abstract class thingy
{
    //methods, variables, etc
}

class awsomeThing : thingy
{
    //Imagine there are more of these classes with different names...
}

我只能将抽象类（thingy）作为类型传递，但需要awsomeThing类型吗？我该怎么做呢？

修改

在答案中，使用awsomeThing的类有一个接近此的方法，以澄清我在寻找的内容：

void Start(thingy wantedType){

    List<thingy> collectionOfStuff = new List<thingy>( );

    for(int i = 0; i < 3; i++){
        //Here I want to add the type awsomeThing or one of the other classes
        //that derive from thingy but I don't know which one it is

        collectionOfStuff.Add(new ????); //what is wantedType in reality?
    }
}

Answer 1

您可以通过GetType方法获取对象类型。

您还可以向基类添加虚方法，返回一些枚举，以便您确定实际的对象类型。

另一个选择是在if语句中使用is作为条件，您需要确定对象类型。

Answer 2

我认为你混淆了一些关于OOP的概念。如果使用抽象类作为接口，则应使用接口（或更多接口）。它们不是同一个概念。您应该根据域的需要使用尽可能多的接口，而不是使用巨大的通用接口（或抽象）。它被称为接口隔离原则（https://en.wikipedia.org/wiki/Interface_segregation_principle）。

关于您的问题，您可以创建接口类型列表以及抽象类型。在您的情况下，如果您想使用基本抽象类型作为集合的类型，您应该记住“根据Liskov替换原则，继承基类的所有类应具有与将它们用作基类相同的行为”。

Answer 3

您无需担心使用

填充列表的类型

只需创建List<thingy>

类型的列表

var ls = new List<thingy>();

//Add any object that inherits from thingy
ls.Add(new myAwesomeThingy());

//Or add whatever other type of object that implements myThingy
ls.Add( new AnotherClassThatInheritsFromMyThingy());
ls.Add( new WhatThatGuySaid() );
ls.Add( new Ditto() );

//If you want to get only the items of type myAwesomeThingy do this
var nls = ls.OfType<myAwesomeThingy>().ToList();

//this will print one
Console.WriteLine(nls.Count);

//This will print out type name "myAwesomeThingy"
Console.WriteLine(nls[0].GetType());

基于您的修改

如果要根据传递的参数创建新实例，可以执行以下操作：

void Start<T>(T wantedType) where T : new(), thingy
{

    List<thingy> collectionOfStuff = new List<thingy>();

    for(int i = 0; i < 3; i++){
        //here I want to add the type awsomething or one of the other classes
        //that derive from thingy but I don't know which one it is

        collectionOfStuff.Add(new T()); //Will create based off the passed type of T
    }
}

Answer 4

为什么不定义一个抽象工厂方法并在每个继承的类中实现它以返回它自己的新实例，例如：

    class Thingy
    {
        abstract Thingy CreateInstance();
    }

    class AwesomeThingy : Thingy
    {
        override Thingy CreateInstance()
        {
             return new AwesomeThingy();
        }
    }

然后你可以在你的方法中使用它：

    void SomeMethodThatPopulatesAListOfThingy(Thingy t)
    {
        var list = new List<Thingy>(Enumerable.Range(0,5).Select(i=>t.CreateInstance()));
    }

Answer 5

static void Main(string[] args)
{
   BaseItem item = new Item();
   Console.WriteLine(GetBaseType<Item>().Name); // BaseItem
   Console.WriteLine(GetImplementerType(item).Name); // Item
}

static Type GetBaseType<T>()
{
   return typeof(T).BaseType;
}

static Type GetImplementerType(object obj)
{
   return obj.GetType();
}

Answer 6

如果你像接口一样使用抽象类，也许它应该是一个; - ）

以下是GetType()调用的替代方法：您可以通用方式实现此功能;代码执行比在运行时调用GetType()方法更快。

属性GetGenericType返回继承类的类型：

abstract class Thingy<T> where T : Thingy<T>
{
    //methods, variables, etc

    public Type GetGenericType => typeof(T);
}

class AwsomeThing : Thingy<AwsomeThing>
{
    //Imagine there are more of these classes with different names...
}

Answer 7

thingy t = new awsomeThing();
if (t is awsomeThing) Console.WriteLine("My type is awsomeThing");

输出是＆＃34;我的类型是awsomeThing＆＃34;

C＃从继承的类中获取类型

7 个答案: