.NET: determina il tipo di classe "this" nel suo metodo statico

In un metodo non statico potrei usare this.GetType()e restituirebbe il file Type. Come posso ottenere lo stesso Typein un metodo statico? Ovviamente non posso scrivere solo typeof(ThisTypeName)perché ThisTypeNameè noto solo in runtime. Grazie!

Se stai cercando un 1 liner equivalente ai this.GetType()metodi statici, prova quanto segue.

Type t = MethodBase.GetCurrentMethod().DeclaringType

Sebbene questo sia probabilmente molto più costoso del semplice utilizzo typeof(TheTypeName).

C'è qualcosa che le altre risposte non hanno del tutto chiarito e che è rilevante per la tua idea del tipo disponibile solo al momento dell'esecuzione.

Se si utilizza un tipo derivato per eseguire un membro statico, il nome del tipo reale viene omesso nel file binario. Quindi, ad esempio, compila questo codice:

UnicodeEncoding.GetEncoding(0);

Ora usa ildasm su di esso ... vedrai che la chiamata viene emessa in questo modo:

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

Il compilatore ha risolto la chiamata a Encoding.GetEncoding- non c'è traccia di UnicodeEncodingsinistra. Ciò rende la tua idea di "tipo attuale" priva di senso, temo.

Un'altra soluzione consiste nell'usare un tipo autoriferito

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

Quindi nella classe che lo eredita, creo un tipo autoreferenziale:

public class Child: Parent<Child>
{
}

Ora il tipo di chiamata typeof (TSelfReferenceType) all'interno di Parent otterrà e restituirà il tipo del chiamante senza la necessità di un'istanza.

Child.GetType();

-Rapinare

Non puoi usarlo thisin un metodo statico, quindi non è possibile direttamente. Tuttavia, se hai bisogno del tipo di un oggetto, chiamalo GetTypee rendi l' thisistanza un parametro che devi passare, ad esempio:

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

Questo sembra un design scadente, però. Sei sicuro di aver davvero bisogno di ottenere il tipo di istanza stessa all'interno del proprio metodo statico? Sembra un po 'bizzarro. Perché non utilizzare semplicemente un metodo di istanza?

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

Non capisco perché non puoi usare typeof (ThisTypeName). Se questo è un tipo non generico, dovrebbe funzionare:

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

Se è un tipo generico, allora:

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

Mi manca qualcosa di ovvio qui?

Quando il tuo membro è statico, saprai sempre di che tipo fa parte in fase di esecuzione. In questo caso:

class A
{
  public static int GetInt(){}

}
class B : A {}

Non puoi chiamare (modifica: a quanto pare, puoi, vedi il commento qui sotto, ma staresti comunque chiamando A):

B.GetInt();

poiché il membro è statico, non svolge alcun ruolo negli scenari di ereditarietà. Ergo, sai sempre che il tipo è A.

Per i miei scopi, mi piace l'idea di @T-moty. Anche se ho usato per anni informazioni di "tipo autoreferenziale", fare riferimento alla classe base è più difficile da fare in seguito.

Ad esempio (usando l'esempio di @Rob Leclerc dall'alto):

public class ChildA: Parent<ChildA>
{
}

public class ChildB: Parent<ChildB>
{
}

Lavorare con questo modello può essere impegnativo, per esempio; come si restituisce la classe base da una chiamata di funzione?

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

O quando digiti il ​​casting?

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

Quindi, cerco di evitarlo quando posso e di usarlo quando devo. Se devi, ti suggerisco di seguire questo schema:

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

Ora puoi (più) facilmente lavorare con BaseClass. Tuttavia, ci sono momenti, come la mia situazione attuale, in cui non è necessario esporre la classe derivata, dall'interno della classe base, e usare il suggerimento di @ M-moty potrebbe essere l'approccio giusto.

Tuttavia, l'utilizzo del codice di @ M-moty funziona solo fintanto che la classe base non contiene alcun costruttore di istanza nello stack di chiamate. Purtroppo le mie classi base utilizzano costruttori di istanze.

Pertanto, ecco il mio metodo di estensione che tiene conto dei costruttori di "istanza" della classe base:

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

EDIT Questo metodo funziona solo quando distribuisci file PDB con l'eseguibile / libreria, come mi ha fatto notare markmnl .

Altrimenti sarà un grosso problema da rilevare: funziona bene nello sviluppo, ma forse non nella produzione.

Metodo di utilità, chiama semplicemente il metodo quando ne hai bisogno, da ogni punto del tuo codice:

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