Übergeben aktuellen Objekttyp in Basis Konstruktor Anruf

Question

Wie greife ich die Type der geerbten Klasse und übergeben Sie es in den Basiskonstruktor der Klasse auch geerbt? Sehen Sie sich das folgende Codebeispiel:

// 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) 
    { 

    } 
} 

Die Linie base(typeof(this).Name, myObject) funktioniert nicht, weil ich nicht this noch verweisen kann, da das Objekt nicht beendet hat, Konstruktion und deshalb nicht existiert.

Ist es möglich, die Type des gerade konstruierenden Objekts zu greifen?

EDIT:

die Probe als orsogufo suggested, wird korrigiert, aber immer noch nicht funktioniert, wie this nicht definiert ist.

EDIT 2:

Nur um zu klären, möchte ich mit "InheritedClass" am Ende wird in den Konstruktor VeryBaseClass(string className, MyObject myObject) geben.

Answer 1

Ah Hah! Ich habe eine Lösung gefunden. Sie können es mit Generika machen:

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) 
    { 

    } 
} 

Answer 2

Funktioniert GetType(). Name nicht?

Answer 3

Eine mögliche Lösung:

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 4

ich genau vor jetzt die gleichen Schmerzen gehabt haben in der Google Wave Robot .NET API, wo ich auf Attribute den Konstruktor in einigen Werten basierend machen wollte. Sie können sich meine Lösung im Code für die derived type und die base type ansehen. Im Grunde übergebe ich einen Delegaten an den Basiskonstruktor und rufe dann diesen Delegaten auf, der "this" an den Delegaten übergibt. Also in Ihrem Fall müssten Sie:

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

und

public BaseClass() : base(FindClassName) 
{ 
} 

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

Es ist wirklich hässlich, aber es funktioniert.

EDIT: Dieser Ansatz funktioniert nur, wenn Sie Ihren Basisklassenkonstruktor wie gezeigt ändern können; wenn Sie kann nicht, ich bin nicht sicher, es tatsächlich machbar ist bei :(alle

Answer 5

noch eine weitere Option ...

// 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 6

Wenn die Fähigkeit, die geerbte Klasse Typ zur Laufzeit zu bestimmen, ist wichtiger als Leistung Sie können an der Stacktrace einen Blick darauf werfen, um zu sehen, wo der Konstruktor aus aufgerufen wird, Sie müssen unter Umständen mehr Annahmen codieren, wenn GetInheritedClassName in diesem Beispiel nennen:.

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) 
    { 

    } 
} 

ich kann nicht eine gute Möglichkeit zu denken, dynamisch Erhalte den Namen der geerbten Klasse ohne Auswirkungen auf die Leistung. Ich weiß, ist, was man vermeiden wollte, aber wenn ich mit diesen Anforderungen eine 3rd-Party-Versammlung zu rufen brauchte ich würde nur jede Klasse benötigen, um ihre eigene Art angeben:

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) 
    { 

    } 
}