.NET: Statik yönteminde "bu" sınıfın türünü belirleyin

Statik olmayan bir yöntemde kullanabilirdim this.GetType()ve Type. Aynı şeyi Typestatik bir yöntemde nasıl elde edebilirim ? Tabii ki, ben sadece yazamıyorum typeof(ThisTypeName)çünkü ThisTypeNamesadece çalışma zamanında bilinmektedir. Teşekkürler!

this.GetType()Statik yöntemlere eşdeğer 1 astar arıyorsanız , aşağıdakileri deneyin.

Type t = MethodBase.GetCurrentMethod().DeclaringType

Bu muhtemelen kullanmaktan çok daha pahalı olsa da typeof(TheTypeName).

Diğer yanıtların tam olarak açıklığa kavuşturmadığı bir şey var ve bu tür fikrinizin yalnızca uygulama sırasında mevcut olmasıyla ilgili.

Statik bir üye yürütmek için türetilmiş bir tür kullanırsanız , ikili dosyada gerçek tür adı atlanır. Örneğin, bu kodu derleyin:

UnicodeEncoding.GetEncoding(0);

Şimdi ildasm'ı kullanın ... aramanın şöyle yapıldığını göreceksiniz:

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

Derleyici çağrıyı çözdü Encoding.GetEncoding- UnicodeEncodingsol iz yok . Korkarım bu, "şu anki tip" fikrinizi anlamsız kılıyor.

Başka bir çözüm de kendi kendine başvuran bir tür kullanmaktır

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

Sonra onu devralan sınıfta, kendine referans veren bir tür yapıyorum:

public class Child: Parent<Child>
{
}

Şimdi, Parent içindeki typeof (TSelfReferenceType) çağrı türü, bir örneğe ihtiyaç duymadan arayanın Türünü alacak ve döndürecektir.

Child.GetType();

-Rob

thisStatik bir yöntemde kullanamazsınız , bu nedenle bu doğrudan mümkün değildir. Ancak, bir nesnenin türüne ihtiyacınız varsa GetType, onu çağırın ve thisörneği geçirmeniz gereken bir parametre yapın, örneğin:

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

Yine de bu kötü bir tasarım gibi görünüyor. Örneğin türünü gerçekten kendi statik yönteminin içine almanız gerektiğinden emin misiniz? Bu biraz tuhaf görünüyor. Neden sadece bir örnek yöntemi kullanmıyorsunuz?

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

Typeof (ThisTypeName) 'i neden kullanamadığınızı anlamıyorum. Bu genel olmayan bir türse, bu işe yaramalıdır:

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

Genel bir türse, o zaman:

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

Burada bariz bir şeyi mi kaçırıyorum?

Üyeniz statik olduğunda, çalışma zamanında hangi türün parçası olduğunu her zaman bilirsiniz. Bu durumda:

class A
{
  public static int GetInt(){}

}
class B : A {}

Çağrı yapamazsınız (düzenleme: görünüşe göre, aşağıdaki yorumu görebilirsiniz, ancak yine de A'yı arıyor olacaksınız):

B.GetInt();

üye statik olduğu için kalıtım senaryolarında rol oynamaz. Ergo, türünün A olduğunu her zaman bilirsin.

Amaçlarım için, @ T-moty'nin fikrini beğendim. Yıllardır "kendi kendine referans veren tip" bilgisini kullanmış olsam da, temel sınıfa atıfta bulunmak daha sonra daha zor.

Örneğin (yukarıdaki @Rob Leclerc örneğini kullanarak):

public class ChildA: Parent<ChildA>
{
}

public class ChildB: Parent<ChildB>
{
}

Bu modelle çalışmak zor olabilir, örneğin; temel sınıfı bir işlev çağrısından nasıl döndürürsünüz?

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

Veya tip döküm ne zaman?

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

Bu yüzden, elimden geldiğince kaçınmaya çalışıyorum ve gerektiğinde kullanıyorum. Gerekirse, şu kalıbı izlemenizi öneririm:

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

Artık (daha fazla) ile kolayca çalışabilirsiniz BaseClass. Bununla birlikte, benim mevcut durumum gibi, türetilmiş sınıfı temel sınıf içinden açığa çıkarmanın gerekli olmadığı ve @ M-moty'nin önerisini kullanmanın doğru yaklaşım olabileceği zamanlar vardır.

Ancak, @ M-moty'nin kodunu kullanmak, yalnızca temel sınıf çağrı yığınında herhangi bir örnek oluşturucu içermediği sürece çalışır. Maalesef benim temel sınıflarım örnek oluşturucuları kullanıyor.

Bu nedenle, temel sınıf 'örnek' oluşturucularını hesaba katan benim genişletme yöntemim:

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

DÜZENLE Bu yöntemler yalnızca PDB dosyalarını çalıştırılabilir / kitaplık ile dağıttığınızda, markmnl'nin bana işaret ettiği gibi çalışır .

Aksi takdirde tespit edilmesi gereken çok büyük bir sorun olacaktır: geliştirmede iyi çalışıyor, ancak üretimde olmayabilir.

Fayda yöntemi, ihtiyacınız olduğunda, kodunuzun her yerinden yöntemi çağırmanız yeterlidir:

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