.NET: Bestimmen Sie den Typ dieser Klasse in ihrer statischen Methode

In einer nicht statischen Methode könnte ich verwenden this.GetType()und es würde die zurückgeben Type. Wie kann ich dasselbe Typemit einer statischen Methode erreichen? Natürlich kann ich nicht einfach schreiben, typeof(ThisTypeName)weil ThisTypeNamees nur zur Laufzeit bekannt ist. Vielen Dank!

Wenn Sie nach einem 1-Liner suchen, der this.GetType()statischen Methoden entspricht, versuchen Sie Folgendes.

Type t = MethodBase.GetCurrentMethod().DeclaringType

Obwohl dies wahrscheinlich viel teurer ist als nur zu verwenden typeof(TheTypeName).

Es gibt etwas, das in den anderen Antworten nicht ganz geklärt ist und das für Ihre Vorstellung relevant ist, dass der Typ nur zur Ausführungszeit verfügbar ist.

Wenn Sie einen abgeleiteten Typ verwenden, um ein statisches Element auszuführen, wird der Name des realen Typs in der Binärdatei weggelassen. Kompilieren Sie beispielsweise diesen Code:

UnicodeEncoding.GetEncoding(0);

Verwenden Sie jetzt ildasm darauf ... Sie werden sehen, dass der Anruf wie folgt ausgegeben wird:

IL_0002:  call       class [mscorlib]System.Text.Encoding 
[mscorlib]System.Text.Encoding::GetEncoding(int32)

Der Compiler hat den Aufruf von aufgelöst Encoding.GetEncoding- es ist keine Spur UnicodeEncodingmehr vorhanden. Das macht Ihre Vorstellung von "dem aktuellen Typ" leider unsinnig.

Eine andere Lösung besteht darin, einen selbstreferenzierenden Typ zu verwenden

//My base class
//I add a type to my base class use that in the static method to check the type of the caller.
public class Parent<TSelfReferenceType>
{
    public static Type GetType()
    {
        return typeof(TSelfReferenceType);
    }
}

Dann mache ich in der Klasse, die es erbt, einen selbstreferenzierenden Typ:

public class Child: Parent<Child>
{
}

Jetzt ruft der Anruftyp typeof (TSelfReferenceType) in Parent den Typ des Anrufers ab und gibt ihn zurück, ohne dass eine Instanz erforderlich ist.

Child.GetType();

-Rauben

Sie können nicht thisin einer statischen Methode verwenden, daher ist dies nicht direkt möglich. Wenn Sie jedoch den Typ eines Objekts benötigen, rufen Sie GetTypees einfach auf und machen Sie die thisInstanz zu einem Parameter, den Sie übergeben müssen, z.

public class Car {
  public static void Drive(Car c) {
    Console.WriteLine("Driving a {0}", c.GetType());
  }
}

Dies scheint jedoch ein schlechtes Design zu sein. Sind Sie sicher, dass Sie den Typ der Instanz selbst wirklich in eine eigene statische Methode integrieren müssen? Das scheint ein bisschen bizarr. Warum nicht einfach eine Instanzmethode verwenden?

public class Car {
  public void Drive() { // Remove parameter; doesn't need to be static.
    Console.WriteLine("Driving a {0}", this.GetType());
  }
}

Ich verstehe nicht, warum Sie typeof (ThisTypeName) nicht verwenden können. Wenn dies ein nicht generischer Typ ist, sollte dies funktionieren:

class Foo {
   static void Method1 () {
      Type t = typeof (Foo); // Can just hard code this
   }
}

Wenn es sich um einen generischen Typ handelt, dann:

class Foo<T> {
    static void Method1 () {
       Type t = typeof (Foo<T>);
    }
}

Vermisse ich hier etwas Offensichtliches?

Wenn Ihr Mitglied statisch ist, wissen Sie zur Laufzeit immer, zu welchem ​​Typ es gehört. In diesem Fall:

class A
{
  public static int GetInt(){}

}
class B : A {}

Sie können nicht anrufen (bearbeiten: anscheinend können Sie, siehe Kommentar unten, aber Sie würden immer noch in A anrufen):

B.GetInt();

Da das Mitglied statisch ist, spielt es in Vererbungsszenarien keine Rolle. Ergo wissen Sie immer, dass der Typ A ist.

Für meine Zwecke mag ich die Idee von @ T-moty. Obwohl ich seit Jahren Informationen zum Typ "Selbstreferenzierend" verwende, ist es später schwieriger, auf die Basisklasse zu verweisen.

Zum Beispiel (am Beispiel von @Rob Leclerc von oben):

public class ChildA: Parent<ChildA>
{
}

public class ChildB: Parent<ChildB>
{
}

Das Arbeiten mit diesem Muster kann beispielsweise eine Herausforderung sein. Wie gibt man die Basisklasse von einem Funktionsaufruf zurück?

public Parent<???> GetParent() {}

Oder beim Typguss?

var c = (Parent<???>) GetSomeParent();

Also versuche ich es zu vermeiden, wenn ich kann, und benutze es, wenn ich muss. Wenn Sie müssen, würde ich vorschlagen, dass Sie diesem Muster folgen:

class BaseClass
{
    // All non-derived class methods goes here...

    // For example:
    public int Id { get; private set; }
    public string Name { get; private set; }
    public void Run() {}
}

class BaseClass<TSelfReferenceType> : BaseClass
{
    // All derived class methods goes here...

    // For example:
    public TSelfReferenceType Foo() {}
    public void Bar(TSelfRefenceType obj) {}
}

Jetzt können Sie (einfacher) mit dem arbeiten BaseClass. Es gibt jedoch Zeiten wie in meiner aktuellen Situation, in denen es nicht erforderlich ist, die abgeleitete Klasse innerhalb der Basisklasse verfügbar zu machen, und die Verwendung des Vorschlags von @ M-moty möglicherweise der richtige Ansatz ist.

Die Verwendung des Codes von @ M-moty funktioniert jedoch nur, solange die Basisklasse keine Instanzkonstruktoren im Aufrufstapel enthält. Leider verwenden meine Basisklassen Instanzkonstruktoren.

Daher hier meine Erweiterungsmethode, die Instanzkonstruktoren der Basisklasse berücksichtigt:

public static class TypeExtensions
{
    public static Type GetDrivedType(this Type type, int maxSearchDepth = 10)
    {
        if (maxSearchDepth < 0)
            throw new ArgumentOutOfRangeException(nameof(maxSearchDepth), "Must be greater than 0.");

        const int skipFrames = 2;  // Skip the call to self, skip the call to the static Ctor.
        var stack = new StackTrace();
        var maxCount = Math.Min(maxSearchDepth + skipFrames + 1, stack.FrameCount);
        var frame = skipFrames;

        // Skip all the base class 'instance' ctor calls. 
        //
        while (frame < maxCount)
        {
            var method = stack.GetFrame(frame).GetMethod();
            var declaringType = method.DeclaringType;

            if (type.IsAssignableFrom(declaringType))
                return declaringType;

            frame++;
        }

        return null;
    }
}

BEARBEITEN Diese Methode funktioniert nur, wenn Sie PDB-Dateien mit der ausführbaren Datei / Bibliothek bereitstellen , wie mir markmnl gezeigt hat.

Andernfalls wird ein großes Problem festgestellt: Funktioniert gut in der Entwicklung, aber möglicherweise nicht in der Produktion.

Utility-Methode: Rufen Sie die Methode bei Bedarf einfach an jeder Stelle Ihres Codes auf:

public static Type GetType()
{
    var stack = new System.Diagnostics.StackTrace();

    if (stack.FrameCount < 2)
        return null;

    return (stack.GetFrame(1).GetMethod() as System.Reflection.MethodInfo).DeclaringType;
}