Bir türün bir alt tür VEYA bir nesnenin türü olup olmadığını nasıl kontrol edebilirim?

Bir türün C # içinde başka bir türün alt sınıfı olup olmadığını kontrol etmek için kolaydır:

typeof (SubClass).IsSubclassOf(typeof (BaseClass)); // returns true

Ancak, bu başarısız olacaktır:

typeof (BaseClass).IsSubclassOf(typeof (BaseClass)); // returns false

Bir ORişleç kullanmadan veya bir uzantı yöntemi kullanmadan , bir türün temel sınıfın alt sınıfı VEYA olup olmadığını denetlemenin bir yolu var mı ?

Görünüşe göre, hayır.

Seçenekler şunlardır:

• Kullanım Type.IsSubclassOf
• Type.IsAssignableFrom kullanın
• is ve as

Type.IsSubclassOf

Daha önce de bildiğiniz gibi, iki tür aynı ise bu çalışmaz, işte size gösteren örnek bir LINQPad programı:

void Main()
{
    typeof(Derived).IsSubclassOf(typeof(Base)).Dump();
    typeof(Base).IsSubclassOf(typeof(Base)).Dump();
}

public class Base { }
public class Derived : Base { }

Çıktı:

True
False

Bu, bunun Derivedbir alt sınıfı olduğunu Base, ancak Base(tabii ki) kendi alt sınıfı olmadığını gösterir.

Type.IsAssignableFrom

Şimdi, bu sizin özel sorunuza cevap verecektir, ancak size yanlış pozitifler de verecektir. Eric Lippert'in yorumlarda belirttiği gibi, yöntem gerçekten de Trueyukarıdaki iki soru Trueiçin geri dönerken , muhtemelen istemediğiniz bunlar için de geri dönecektir :

void Main()
{
    typeof(Base).IsAssignableFrom(typeof(Derived)).Dump();
    typeof(Base).IsAssignableFrom(typeof(Base)).Dump();
    typeof(int[]).IsAssignableFrom(typeof(uint[])).Dump();
}

public class Base { }
public class Derived : Base { }

Burada aşağıdaki çıktıyı elde edersiniz:

True
True
True

Sonuncusu True, eğer yöntem sadece sorulan soruya cevap verdiyse , ondan uint[]miras kaldığını int[]veya aynı tipte olduklarını gösterir, ki bu açıkça değil.

Bu IsAssignableFromda tamamen doğru değil.

is ve as

"Sorun" isve assorunuzun bağlamında onlar nesneler üzerinde işlem ve doğrudan kodda türlerinden birini değil, eser yazmak için gerektirecektir olmasıdır Typenesneler.

Başka bir deyişle, bu derlenmeyecektir:

SubClass is BaseClass
^--+---^
   |
   +-- need object reference here

bu da olmayacak:

typeof(SubClass) is typeof(BaseClass)
                    ^-------+-------^
                            |
                            +-- need type name here, not Type object

bu da olmayacak:

typeof(SubClass) is BaseClass
^------+-------^
       |
       +-- this returns a Type object, And "System.Type" does not
           inherit from BaseClass

Sonuç

Yukarıdaki yöntemler ihtiyaçlarınızı karşılasa da, sorunuzun (doğru olarak gördüğüm) tek doğru cevabı, ekstra bir kontrole ihtiyacınız olacaktır:

typeof(Derived).IsSubclassOf(typeof(Base)) || typeof(Derived) == typeof(Base);

elbette bir yöntemde daha mantıklı:

public bool IsSameOrSubclass(Type potentialBase, Type potentialDescendant)
{
    return potentialDescendant.IsSubclassOf(potentialBase)
           || potentialDescendant == potentialBase;
}

typeof(BaseClass).IsAssignableFrom(unknownType);

Bunun yerine Type.IsAssignableFrom'u kullanmayı denemelisiniz .

Bir Xamarin Forms PCL projesinde yapmaya çalışıyorsanız, yukarıdaki çözümler IsAssignableFrombir hata verir:

Hata: 'Type', 'IsAssignableFrom' için bir tanım içermiyor ve 'Type' türünün ilk bağımsız değişkenini kabul eden 'IsAssignableFrom' için bir uzantı yöntemi bulunamadı (kullanma yönergesi veya bir montaj başvurusu eksik mi?)

çünkü IsAssignableFrombir TypeInfonesne ister . GetTypeInfo()Yöntemi şuradan kullanabilirsiniz System.Reflection:

typeof(BaseClass).GetTypeInfo().IsAssignableFrom(typeof(unknownType).GetTypeInfo())

Bu yanıtı, kötü bir fikir olup olmadığı ve neden benimle paylaştığı umuduyla gönderiyorum. Uygulamamda, Typeeof (A) veya typeof (B) olduğundan emin olmak için kontrol etmek istediğim bir özellik var, burada B A'dan türetilmiş herhangi bir sınıftır. Yani benim kodum:

public class A
{
}

public class B : A
{
}

public class MyClass
{
    private Type _helperType;
    public Type HelperType
    {
        get { return _helperType; }
        set 
        {
            var testInstance = (A)Activator.CreateInstance(value);
            if (testInstance==null)
                throw new InvalidCastException("HelperType must be derived from A");
            _helperType = value;
        }
    }
}

Burada biraz naif olabileceğimi hissediyorum, bu yüzden herhangi bir geri bildirim hoş geldiniz.