.NET: Tentukan jenis kelas "ini" dalam metode statisnya

Dalam metode non-statis saya dapat menggunakan this.GetType()dan itu akan mengembalikan Type. Bagaimana saya bisa mendapatkan yang sama Typedalam metode statis? Tentu saja, saya tidak bisa hanya menulis typeof(ThisTypeName)karena ThisTypeNamehanya diketahui dalam runtime. Terima kasih!

Jika Anda mencari 1 liner yang setara dengan this.GetType()metode statis, coba yang berikut ini.

Type t = MethodBase.GetCurrentMethod().DeclaringType

Meskipun ini sepertinya jauh lebih mahal daripada hanya menggunakan typeof(TheTypeName).

Ada sesuatu yang jawaban lain belum cukup klarifikasi, dan yang relevan dengan ide Anda tentang jenis yang hanya tersedia pada waktu eksekusi.

Jika Anda menggunakan tipe turunan untuk mengeksekusi anggota statis, nama tipe sebenarnya dihilangkan dalam biner. Jadi misalnya, kompilasi kode ini:

UnicodeEncoding.GetEncoding(0);

Sekarang gunakan ildasm di atasnya ... Anda akan melihat bahwa panggilan dibunyikan seperti ini:

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

Kompilator telah menyelesaikan panggilan ke Encoding.GetEncoding- tidak ada jejak UnicodeEncodingkiri. Itu membuat gagasan Anda tentang "tipe saat ini" tidak masuk akal, saya khawatir.

Solusi lain adalah dengan menggunakan jenis referensi sendiri

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

Kemudian di kelas yang mewarisinya, saya membuat tipe referensi mandiri:

public class Child: Parent<Child>
{
}

Sekarang jenis panggilan typeof (TSelfReferenceType) di dalam Parent akan mendapatkan dan mengembalikan Jenis pemanggil tanpa memerlukan instance.

Child.GetType();

-Rampok

Anda tidak dapat menggunakan thismetode statis, jadi itu tidak mungkin dilakukan secara langsung. Namun, jika Anda memerlukan tipe dari beberapa objek, panggil saja objek GetTypetersebut dan jadikan thisinstance sebagai parameter yang harus Anda teruskan, misalnya:

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

Ini sepertinya desain yang buruk. Apakah Anda yakin bahwa Anda benar-benar perlu mendapatkan jenis instance itu sendiri di dalam metode statisnya sendiri? Sepertinya itu agak aneh. Mengapa tidak menggunakan metode contoh saja?

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

Saya tidak mengerti mengapa Anda tidak dapat menggunakan typeof (ThisTypeName). Jika ini adalah tipe non-generik, maka ini akan bekerja:

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

Jika itu adalah tipe generik, maka:

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

Apakah saya melewatkan sesuatu yang jelas di sini?

Ketika anggota Anda statis, Anda akan selalu tahu jenisnya bagian dari saat runtime. Pada kasus ini:

class A
{
  public static int GetInt(){}

}
class B : A {}

Anda tidak dapat memanggil (edit: ternyata, Anda bisa, lihat komentar di bawah, tetapi Anda masih akan memanggil ke A):

B.GetInt();

karena anggotanya statis, ia tidak berperan dalam skenario warisan. Ergo, Anda selalu tahu bahwa tipenya adalah A.

Untuk tujuan saya, saya suka ide @ T-moty. Meskipun saya telah menggunakan informasi "tipe referensi sendiri" selama bertahun-tahun, merujuk kelas dasar lebih sulit dilakukan nanti.

Misalnya (menggunakan contoh @Rob Leclerc dari atas):

public class ChildA: Parent<ChildA>
{
}

public class ChildB: Parent<ChildB>
{
}

Bekerja dengan pola ini dapat menjadi tantangan, misalnya; bagaimana Anda mengembalikan kelas dasar dari pemanggilan fungsi?

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

Atau saat mengetik casting?

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

Jadi, saya mencoba menghindarinya saat saya bisa, dan menggunakannya saat harus. Jika Anda harus, saya sarankan Anda mengikuti pola ini:

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

Sekarang Anda dapat (lebih) mudah bekerja dengan file BaseClass. Namun, ada kalanya, seperti situasi saya saat ini, di mana mengekspos kelas turunan, dari dalam kelas dasar, tidak diperlukan dan menggunakan saran @ M-moty mungkin merupakan pendekatan yang tepat.

Namun, penggunaan kode @ M-moty hanya berfungsi selama kelas dasar tidak berisi konstruktor instance apa pun dalam tumpukan panggilan. Sayangnya kelas dasar saya memang menggunakan konstruktor instance.

Oleh karena itu, inilah metode ekstensi saya yang memperhitungkan konstruktor 'instance' kelas dasar:

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 Metode ini hanya akan berfungsi ketika Anda menyebarkan file PDB dengan executable / library, sebagai markmnl ditunjukkan kepada saya.

Jika tidak, akan menjadi masalah besar untuk dideteksi: bekerja dengan baik dalam pengembangan, tapi mungkin tidak dalam produksi.

Metode utilitas, cukup panggil metode saat Anda membutuhkannya, dari setiap tempat kode Anda:

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