将当前对象类型传递给基本构造函数调用

Question

如何获取继承类的Type 并将其传递给同样继承的类的基构造函数？请参阅下面的代码示例：

// VeryBaseClass is in an external assembly
public abstract class VeryBaseClass
{
    public VeryBaseClass(string className, MyObject myObject)
    {

    }
}

// BaseClass and InheritedClass are in my assembly
public abstract class BaseClass : VeryBaseClass
{
    public BaseClass(MyObject myObject) :
        base(this.GetType().Name, myObject) // can't reference "this" (Type expected)
    {

    }
}

public class InheritedClass : BaseClass
{
    public InheritedClass(MyObject myObject)
    {

    }
}

base(typeof(this).Name, myObject) 行不起作用，因为我还不能引用 this，因为对象尚未完成构造，因此不存在。

是否可以抓取当前构造对象的Type？

编辑：

将示例更正为orsogufo suggested，但仍然无法正常工作，因为this 未定义。

编辑 2：

澄清一下，我想最终将"InheritedClass" 传递给VeryBaseClass(string className, MyObject myObject) 构造函数。

Answer 1

GetType().Name 不起作用吗？

Answer 2

一个可能的解决方案：

class VeryBase {
    public VeryBase(string name) {
        Console.WriteLine(name);
    }
}

class Base<T> : VeryBase where T : Base<T> {
    protected Base()
        : base(typeof(T).Name) {
    }
}

class Derived : Base<Derived> {
    public Derived() {
    }
}

class Program {
    public static void Main(params string[] args) {
        Derived d = new Derived();
    }
}

Answer 3

我之前在Google Wave Robot .NET API 中遇到过完全相同的痛苦，我想让构造函数根据属性传递一些值。您可以在derived type 和base type 的代码中查看我的解决方案。基本上我将一个委托传递给基本构造函数，然后调用该委托将“this”传递给委托。因此，在您的情况下，您将拥有：

public VeryBaseClass(Func<VeryBaseClass, string> classNameProvider)
{
    this.name = classNameProvider(this);
}

和

public BaseClass() : base(FindClassName)
{
}

private static string FindClassName(VeryBaseClass @this)
{
    return @this.GetType().Name;
}

真的很丑，但是很管用。

编辑：此方法仅在您可以更改基类构造函数的情况下才有效，如图所示；如果你不能，我不确定它是否真的可行:(

Answer 4

还有一个选择……

// VeryBaseClass is in an external assembly
public abstract class VeryBaseClass
{
    public VeryBaseClass(string className)
    {
        Console.WriteLine(className);
    }
}

// BaseClass and InheritedClass are in my assembly
public abstract class BaseClass : VeryBaseClass
{
    public BaseClass(string className)
        :
        base(className)
    {

    }
}

public class InheritedClass : BaseClass
{
    public InheritedClass()
        : base(typeof(InheritedClass).Name)
    {
    }
}

Answer 5

如果在运行时确定继承类的类型比性能更重要，您可以查看 StackTrace 以了解从何处调用构造函数。在此示例中调用 GetInheritedClassName 时，您可能需要编写更多假设代码：

public abstract class BaseClass : VeryBaseClass
{
    private static string GetInheritedClassName
    {
        get
        {
            // Get the current Stack
            StackTrace currentStack = new StackTrace();
            MethodBase method = currentStack.GetFrame(1).GetMethod();

            // 1st frame should be the constructor calling
            if (method.Name != ".ctor")
                return null;

            method = currentStack.GetFrame(2).GetMethod();

            // 2nd frame should be the constructor of the inherited class
            if (method.Name != ".ctor")
                return null;

            // return the type of the inherited class
            return method.ReflectedType.Name;
        }
    }

    public BaseClass(MyObject myObject) :
        base(GetInheritedClassName, myObject)
    {

    }
}

我想不出一种在不影响性能的情况下动态获取继承类名称的好方法。我知道这是您想要避免的，但如果我需要调用具有这些要求的第 3 方程序集，我只需要每个类指定自己的类型：

public abstract class BaseClass : VeryBaseClass
{
    public BaseClass(string className, MyObject myObject) :
        base(className, myObject)
    {

    }
}

public class InheritedClass : BaseClass
{
    public InheritedClass(MyObject myObject) : base("InheritedClass", myObject)
    {

    }
}

Answer 6

啊哈！我找到了解决方案。您可以使用泛型来做到这一点：

public abstract class VeryBaseClass
{
    public VeryBaseClass(string className, MyObject myObject)
    {
        this.ClassName = className;
    }

    public string ClassName{ get; set; }
}
public abstract class BaseClass<T> : VeryBaseClass
{
    public BaseClass(MyObject myObject)
        : base(typeof(T).Name, myObject)
    {
    }
}

public class InheritedClass : BaseClass<InheritedClass>
{
    public InheritedClass(MyObject myObject) 
        : base(myObject)
    {

    }
}