Pass aktuellen Objekttyp in Basis-Konstruktor aufrufen

Wie kann ich schnappe mir den Type von der geerbten Klasse, und übergeben Sie es in die Basis-Konstruktor von der Klasse geerbt? Siehe das code-Beispiel unten:

//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, da kann ich nicht Referenz this doch, da das Objekt noch nicht fertig konstruieren und daher nicht vorhanden ist.

Ist es möglich zu greifen, die Type von der aktuell Bau-Objekt?

EDIT:

Korrigiert die Stichprobe orsogufo vorgeschlagen, aber funktioniert immer noch nicht, wie this ist nicht definiert.

EDIT 2:

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

  • Warum wollen Sie dies tun? Ein Konstruktor sollte nicht egal, ob es aufgerufen wird, ist die Instanzierung der eigenen Klasse oder einer abgeleiteten Klasse.
  • Ich denke, Sie sind fehlt den Punkt. Die externe assembly, definiert die Basis-Klasse des Frameworks, die ich verwenden, benötigt die string-Darstellung der Klasse selbst übergeben werden dem Konstruktor übergeben. Bisher habe ich es immer aufgeschoben, als man erwarten würde (als string), aber ich würde es vorziehen, wenn es funktionieren würde, es zur Laufzeit für geistige Gesundheit Willen.
  • Oh ich sehe, es ist nicht deine Klasse. Ich denke immer noch, es ist eine schlechte Sache, die es interessiert 🙂
InformationsquelleAutor Codesleuth | 2010-02-18
  1. 18

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

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

    }
}
    • Oh mein Gott, Genie! Ich werde es testen, wenn ich fertig bin, Schlachten meine TFS Source Control layout 🙂
    • Ausgezeichnet, es funktioniert! Obwohl es bedeutet, dass ich haben eine Menge Arbeit zu tun, um meine bestehenden Klassen, aber es wird es Wert sein am Ende. Danke 🙂
    • Plötzlich, das CRTP (aka Neugierig Recurring Template Pattern) erscheint! 🙂 (siehe en.wikipedia.org/wiki/Curiously_recurring_template_pattern)
    • mit dem obigen code, Sie können eine Klasse wie dieses, wo Sie gehen in etwas anderes als die erweiterte Klasse.. public class InheritedClass : BaseClass<int> { .. } so zu erzwingen, dass nur die erweiterte Klasse " Typ übergeben wird, möchten Sie vielleicht, um eine where-Klausel hinzufügen. public abstract class BaseClass<T> : VeryBaseClass, wo T:BaseClass<T> { ... }
    • Billiant! Mit dieser 9 Jahre später...
    InformationsquelleAutor Thomas
  2. 6

    Ich habe genau die gleichen Schmerzen, bevor Sie nun in die Google Wave-Roboter .NET-API, wo ich wollte, um den Konstruktor übergeben, einige Werte basierend auf den Attributen. Sie können einen Blick auf meine Lösung in den code für die abgeleiteten Typ und die base Typ. Im Grunde gebe ich eine Stellvertretung an der Basis-Konstruktor, und rufen Sie dann das delegate übergeben, die in "dieser" die Stellvertretung. Also in deinem Fall müsstest du:

    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;
}

    Ist es wirklich hässlich, aber es funktioniert.

    EDIT: Dieser Ansatz funktioniert nur, wenn Sie ändern, können Sie Ihre Basis-Klasse-Konstruktor wie gezeigt; wenn Sie nicht können, ich bin mir nicht sicher, es ist eigentlich machbar an alle 🙁

    • Ich habe noch nie gesehen @this vor, und scheint zu verwirren Google. Tut es nur erlauben, eine Methode, die ohne Parameter aufgerufen und automatisch auf das aktuelle Objekt? (das ist, wie ich es sehe)
    • Nein, das @ vor ihm ist nur zu sagen, dass der compiler prüfen, "dies" als einen Bezeichner (zur Unterscheidung vom keyword). Überprüfen Sie dies: msdn.microsoft.com/en-us/library/aa664670%28VS.71%29.aspx. Sie ersetzen könnte '@' dieses ' mit einer beliebigen parameter-name.
    • Argument '1': cannot convert from 'method group' to 'string' Ich glaube, ich sollte hier erwähnen, dass, obwohl mein Beispiel zeigt nur die parameter verwendet, die von der Basisklasse, meine eigentliche Implementierung verwendet ein paar mehr. Ich werde zu aktualisieren, die Frage zu reflektieren.
    • Habt Ihr die VeryBaseClass Konstruktor wie gezeigt? Wenn dem so ist, sollte es nicht zu erwarten, dass ein string mehr...
    • Ah, ich habe gerade gesehen, dass Sie keine Kontrolle über die base-Klasse. In diesem Fall ist diese Lösung nicht für Sie arbeiten - ich werde mein edit beantworten, um zu zeigen, dass.
    • Awww, du warst so nah! Ich kann sicherlich nicht die erste person, die dieses problem hatte, muss es eine Auflösung (oder Erläuterung, warum gibt es nicht) irgendwo.
    • Pflege zu kommentieren?

    InformationsquelleAutor Jon Skeet
  3. 3

    Tut GetType().Namen nicht funktioniert?

    • Nein, weil die implizit verwendet, "diese", die Sie nicht verwenden können, zu bewerten Konstruktor-Verkettung der Argumente.
    • Sorry, ich wollte nicht in einen Konstruktor-Kette, ich meinte, dass der Konstruktor von VeryBaseClass verwenden könnte, GetType().Namen statt zu erwarten, dass es übergeben werden.
    • Das setzt Voraus, dass VeryBaseClass will immer den Namen der aktuellen Art; während das kann eine vernünftige Planung in einigen Fällen ist es nicht immer. Ich bin bei dieser Suche als eine umfassendere Frage von "was tun Sie, wenn Sie verwenden möchten this im Konstruktor chain-argument" - da kann man nicht immer schieben die Funktionalität bis der vererbungsstruktur.
    • Leider, die VeryBaseClass nicht zu diesem Zeitpunkt geändert werden. Ich kann nur ändern, die anderen zwei Klassen 🙁
    • Ok, ich sehe Ihren Punkt. Ich war versucht zu lösen, die der Fragesteller das problem. Ich würde vorschlagen, dass, wenn Sie verwenden möchten 'diese' in einem Konstruktor chain-argument, sollte man sich wahrscheinlich denken intensiv über eine Neugestaltung.
    • ok, das wäre ein problem. Ich denke, dass Sie wahrscheinlich zu bleiben, mit strings :(. Und haben ein Wort mit den Menschen, die zur Verfügung gestellt VeryBaseClass
    • Ich habe beschwert, um Sie vor, aber ohne Erfolg. Sie verließ die Firma, mit einer Anwendung gebaut, die auf der Oberseite des Rahmens. Typisch!
    • Ich fühle deinen Schmerz, wirklich ich tun

    InformationsquelleAutor pdr
  4. 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();
    }
}
    • Sorry, du hast Recht. diese.GetType sollte mein Beispiel. Ach, this ist nicht definiert.
    • Ah, ok... gut, ich habe meinen Beitrag aktualisiert mit einer möglichen (wenn auch nicht sehr einfach zu bedienende) Lösung...
    • Das wird schwieriger, wenn Sie möchten, fügen Sie eine weitere Schicht von Vererbung, und es ist die Logik der Verwendung von Typ.Name in die Basisklasse anstelle der abgeleiteten Klasse. (In der Frage, dass die Logik wird in die mittlere Schicht der drei.)
    • danke für die Anmerkung, ich habe den extra-Schicht. Übrigens, ich denke, deine Lösung ist besser, das war nur eine Idee 🙂
    • Okay, jetzt, wie Sie die weitere Ableitung von Abgeleitet? Man müsste machen, dass das Generikum auch... Das ist ein problem mit generics im Allgemeine 🙁
    InformationsquelleAutor Paolo Tedesco
  5. 3

    Wenn die Fähigkeit zur Ermittlung der geerbten Klasse Typ zur Laufzeit wichtiger ist als die Leistung, die Sie ergreifen können, einen Blick auf den StackTrace zu sehen, wo der Konstruktor aufgerufen wird, aus. Möglicherweise müssen Sie code in weitere Annahmen, die beim aufrufen GetInheritedClassName in diesem Beispiel:

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

    }
}

    Kann ich nicht denken, eine großartige Möglichkeit, um dynamisch den Namen der geerbten Klasse ohne Auswirkungen auf die Leistung. Ich begreife ist, was Sie vermeiden wollte, aber wenn ich brauchte, um Anruf ein 3rd-party-Versammlung mit diesen Anforderungen würde ich nur verlangen, dass jeder Klasse geben seine eigene Art:

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

    }
}
    • Ich mag den Einfallsreichtum, die in diese Antwort, aber du hast Recht, es wird Leistung intensive. Nach der überprüfung meines Codes kann ich sehen, dass ich nicht konstruieren viele dieser Objekte auf einmal an irgendeiner Stelle in meinem code, so ist dies auf jeden Fall realisierbar. Definitiv ein +1 Antwort 🙂
    InformationsquelleAutor sirchristian
  6. 0

    Noch eine andere 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)
    {
    }
}
    • Das wäre genau das gleiche wie die Eingabe der name der Klasse als string. Ich wollte vermeiden, dass passieren, was ich nicht haben, um in die BaseClass Konstruktor von der InheritedClass.
    InformationsquelleAutor Paolo
Schreibe einen Kommentar