ฉันจะตรวจสอบว่าประเภทเป็นประเภทย่อยหรือชนิดของวัตถุได้อย่างไร

ในการตรวจสอบว่าประเภทเป็นประเภทย่อยเป็นประเภทอื่นใน C # หรือไม่เป็นเรื่องง่าย:

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

อย่างไรก็ตามสิ่งนี้จะล้มเหลว:

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

มีวิธีใดที่จะตรวจสอบว่าประเภทเป็นคลาสย่อยหรือคลาสพื้นฐานเองโดยไม่ต้องใช้ORโอเปอเรเตอร์หรือใช้วิธีการขยายหรือไม่

เห็นได้ชัดว่าไม่มี

นี่คือตัวเลือก:

• ใช้Type.IsSubclassOf
• ใช้Type.IsAssignableFrom
• is และ as

Type.IsSubclassOf

ตามที่คุณค้นพบแล้วสิ่งนี้จะไม่ทำงานหากทั้งสองประเภทเหมือนกันนี่คือตัวอย่างโปรแกรมLINQPadที่สาธิต:

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

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

เอาท์พุท:

True
False

ซึ่งบ่งชี้ว่าDerivedเป็นคลาสย่อยของBaseแต่นั่นBaseคือ (แน่นอน) ไม่ใช่คลาสย่อยของตัวเอง

Type.IsAssignableFrom

ตอนนี้จะตอบคำถามของคุณโดยเฉพาะ แต่จะให้ผลบวกที่ผิด ตามที่ Eric Lippert ได้ชี้ให้เห็นในความคิดเห็นในขณะที่วิธีการจะตอบกลับTrueสำหรับคำถามทั้งสองข้างต้นอย่างแน่นอนแต่ก็จะส่งคืนTrueสิ่งเหล่านี้ซึ่งคุณอาจไม่ต้องการ:

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

ที่นี่คุณจะได้รับผลลัพธ์ต่อไปนี้:

True
True
True

สุดท้ายTrueก็จะบ่งบอกถ้าวิธีการเพียงตอบคำถามที่ถามว่าuint[]สืบทอดมาจากint[]หรือว่าพวกเขากำลังชนิดเดียวกันที่ชัดเจนไม่ได้เป็นกรณี

ดังนั้นIsAssignableFromไม่ถูกต้องทั้งหมดเช่นกัน

is และ as

"ปัญหา" ที่มีisและasในบริบทของคำถามของคุณคือพวกเขาจะต้องการให้คุณดำเนินการกับวัตถุและเขียนหนึ่งในประเภทโดยตรงในรหัสและไม่ทำงานกับTypeวัตถุ

กล่าวอีกนัยหนึ่งสิ่งนี้จะไม่รวบรวม:

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

และสิ่งนี้จะไม่:

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

และสิ่งนี้จะไม่:

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

ข้อสรุป

ในขณะที่วิธีการข้างต้นอาจตรงกับความต้องการของคุณคำตอบที่ถูกต้องสำหรับคำถามของคุณ (ตามที่ฉันเห็น) คือคุณจะต้องตรวจสอบเพิ่มเติม:

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

ซึ่งแน่นอนมากขึ้นในวิธีการ:

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

typeof(BaseClass).IsAssignableFrom(unknownType);

คุณควรลองใช้Type.IsAssignableFromแทน

หากคุณกำลังพยายามที่จะทำในโครงการ Xamarin Forms PCL การแก้ปัญหาข้างต้นโดยใช้IsAssignableFromจะให้ข้อผิดพลาด:

ข้อผิดพลาด: 'Type' ไม่มีคำจำกัดความสำหรับ 'IsAssignableFrom' และไม่มีวิธีการขยาย 'IsAssignableFrom' ที่ยอมรับอาร์กิวเมนต์แรกของชนิด 'Type' (คุณกำลังใช้คำสั่งหรือการอ้างอิงชุดประกอบ)

เพราะIsAssignableFromถามหาTypeInfoวัตถุ คุณสามารถใช้GetTypeInfo()วิธีการจากSystem.Reflection:

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

ฉันโพสต์คำตอบนี้ด้วยความหวังว่าใครบางคนจะแบ่งปันกับฉันถ้าและทำไมมันจะเป็นความคิดที่ไม่ดี ในใบสมัครของฉันฉันมีคุณสมบัติประเภทที่ฉันต้องการตรวจสอบเพื่อให้แน่ใจว่ามันเป็น typeof (A) หรือ typeof (B) โดยที่ B คือคลาสใด ๆ ที่ได้มาจาก A. ดังนั้นรหัสของฉัน:

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

ฉันรู้สึกว่าฉันอาจจะไร้เดียงสาเล็กน้อยที่นี่เพื่อรับข้อเสนอแนะใด ๆ