Type.IsAssignableFrom(Type) Type.IsAssignableFrom(Type) Type.IsAssignableFrom(Type) Type.IsAssignableFrom(Type) Method

定義

判斷所指定型別之執行個體是否可以指派給目前型別的變數。Determines whether an instance of a specified type can be assigned to a variable of the current type.

public:
 virtual bool IsAssignableFrom(Type ^ c);
public virtual bool IsAssignableFrom (Type c);
abstract member IsAssignableFrom : Type -> bool
override this.IsAssignableFrom : Type -> bool
Public Overridable Function IsAssignableFrom (c As Type) As Boolean

參數

c
Type Type Type Type

要與目前的類型比較的類型。The type to compare with the current type.

傳回

true (下列任何條件成立時):true if any of the following conditions is true:

  • c 與目前的執行個體代表相同的型別。
  • c and the current instance represent the same type.

  • c 直接或間接衍生自目前執行個體。
  • c is derived either directly or indirectly from the current instance.
  • c 會直接衍生自目前的執行個體 (如果它繼承自目前的執行個體),c 會間接衍生自目前的執行個體 (如果它繼承自目前的執行個體所繼承的一或多個一連串類別)。c is derived directly from the current instance if it inherits from the current instance; c is derived indirectly from the current instance if it inherits from a succession of one or more classes that inherit from the current instance.

    - 目前執行個體是 c 實作的介面。- The current instance is an interface that c implements.

    • c 是泛型類型參數,而且目前執行個體代表 c 的其中一個條件約束。
  • c is a generic type parameter, and the current instance represents one of the constraints of c.
  • 在下列範例中,目前的執行個體是 Type 物件,代表 Stream 類別。In the following example, the current instance is a Type object that represents the Stream class. GenericWithConstraint 泛型型別,其泛型型別參數必須是型別 StreamGenericWithConstraint is a generic type whose generic type parameter must be of type Stream. 傳遞其泛型型別參數至 IsAssignableFrom(Type) 表示泛型型別參數的執行個體可以指派給 Stream 物件。Passing its generic type parameter to the IsAssignableFrom(Type) indicates that an instance of the generic type parameter can be assigned to an Stream object.

    [!code-csharpSystem.Type.IsAssignableFrom#2] [!code-vbSystem.Type.IsAssignableFrom#2][!code-csharpSystem.Type.IsAssignableFrom#2] [!code-vbSystem.Type.IsAssignableFrom#2]

    • c 代表實值型別,而目前執行個體代表 Nullable<c> (在 Visual Basic 中為 Nullable(Of c))。
  • c represents a value type, and the current instance represents Nullable<c> (Nullable(Of c) in Visual Basic).
  • 如果以上條件都不成立,或者 cfalse,則為 nullfalse if none of these conditions are true, or if c is null.

    實作

    範例

    下列範例示範IsAssignableFrom類別、 整數陣列和泛型方法使用定義。The following example demonstrates the IsAssignableFrom method using defined classes, integer arrays, and generics.

    using namespace System;
    using namespace System::Collections::Generic;
    
    ref class Room
    {
    };
    
    ref class Kitchen : Room
    {
    };
    
    ref class Bedroom : Room
    {
    };
    
    ref class Guestroom : Bedroom
    {
    };
    
    ref class MasterBedroom : Bedroom
    {
    };
    
    ref class Program
    {
    public:
        static void Main()
        {
                // Demonstrate classes:
                Console::WriteLine("Defined Classes:");
                Room^ room1 = gcnew Room();
                Kitchen^ kitchen1 = gcnew Kitchen();
                Bedroom^ bedroom1 = gcnew Bedroom();
                Guestroom^ guestroom1 = gcnew Guestroom();
                MasterBedroom^ masterbedroom1 = gcnew MasterBedroom();
    
                Type^ room1Type = room1->GetType();
                Type^ kitchen1Type = kitchen1->GetType();
                Type^ bedroom1Type = bedroom1->GetType();
                Type^ guestroom1Type = guestroom1->GetType();
                Type^ masterbedroom1Type = masterbedroom1->GetType();
    
                Console::WriteLine("room assignable from kitchen: {0}", room1Type->IsAssignableFrom(kitchen1Type));
                Console::WriteLine("bedroom assignable from guestroom: {0}", bedroom1Type->IsAssignableFrom(guestroom1Type));
                Console::WriteLine("kitchen assignable from masterbedroom: {0}", kitchen1Type->IsAssignableFrom(masterbedroom1Type));
    
                // Demonstrate arrays:
                Console::WriteLine();
                Console::WriteLine("Integer arrays:");
                array<Int32>^ array2 = gcnew array<Int32>(2);
                array<Int32>^ array10 = gcnew array<Int32>(10);
                array<Int32, 2>^ array22 = gcnew array<Int32, 2>(2, 2);
                array<Int32, 2>^ array24 = gcnew array<Int32, 2>(2, 4);
    
                Type^ array2Type = array2->GetType();
                Type^ array10Type = array10->GetType();
                Type^ array22Type = array22->GetType();
                Type^ array24Type = array24->GetType();
    
                Console::WriteLine("Int32[2] assignable from Int32[10]: {0}", array2Type->IsAssignableFrom(array10Type));
                Console::WriteLine("Int32[2] assignable from Int32[2,4]: {0}", array2Type->IsAssignableFrom(array24Type));
                Console::WriteLine("Int32[2,4] assignable from Int32[2,2]: {0}", array24Type->IsAssignableFrom(array22Type));
    
                // Demonstrate generics:
                Console::WriteLine();
                Console::WriteLine("Generics:");
    
                // Note that "int?[]" is the same as "Nullable<int>[]"
                //int?[] arrayNull = new int?[10];
                array<Nullable^>^ arrayNull = gcnew array<Nullable^>(10);
                List<Int32>^ genIntList = gcnew List<Int32>();
                List<Type^>^ genTList = gcnew List<Type^>();
    
                Type^ arrayNullType = arrayNull->GetType();
                Type^ genIntListType = genIntList->GetType();
                Type^ genTListType = genTList->GetType();
    
                Console::WriteLine("Int32[10] assignable from Nullable[10]: {0}", array10Type->IsAssignableFrom(arrayNullType));
                Console::WriteLine("List<Int32> assignable from List<Type^>: {0}", genIntListType->IsAssignableFrom(genTListType));
                Console::WriteLine("List<Type^> assignable from List<Int32>: {0}", genTListType->IsAssignableFrom(genIntListType));
    
                Console::ReadLine();
        }
    };
    
    int main()
    {
        Program::Main();
    }
    
    //This code example produces the following output:
    //
    // Defned Classes:
    // room assignable from kitchen: True
    // bedroom assignable from guestroom: True
    //kitchen assignable from masterbedroom: False
    //
    // Integer arrays:
    // Int32[2] assignable from Int32[10]: True
    // Int32[2] assignable from Int32[2,4]: False
    // Int32[2,4] assignable from Int32[2,2]: True
    //
    // Generics:
    // Int32[10] assignable from Nullable[10]: False
    // List<Int32> assignable from List<Type^>: False
    // List<Type^> assignable from List<Int32>: False
    
    using System;
    using System.Collections.Generic;
    class Program
    {
        public static void Main()
        {
                // Demonstrate classes:
                Console.WriteLine("Defined Classes:");
                Room room1 = new Room();
                Kitchen kitchen1 = new Kitchen();
                Bedroom bedroom1 = new Bedroom();
                Guestroom guestroom1 = new Guestroom();
                MasterBedroom masterbedroom1 = new MasterBedroom();
    
                Type room1Type = room1.GetType();
                Type kitchen1Type = kitchen1.GetType();
                Type bedroom1Type = bedroom1.GetType();
                Type guestroom1Type = guestroom1.GetType();
                Type masterbedroom1Type = masterbedroom1.GetType();
    
                Console.WriteLine("room assignable from kitchen: {0}", room1Type.IsAssignableFrom(kitchen1Type));
                Console.WriteLine("bedroom assignable from guestroom: {0}", bedroom1Type.IsAssignableFrom(guestroom1Type));
                Console.WriteLine("kitchen assignable from masterbedroom: {0}", kitchen1Type.IsAssignableFrom(masterbedroom1Type));
    
                // Demonstrate arrays:
                Console.WriteLine();
                Console.WriteLine("Integer arrays:");
    
                int[] array2 = new int[2];
                int[] array10 = new int[10];
                int[,] array22 = new int[2, 2];
                int[,] array24 = new int[2, 4];
    
                Type array2Type = array2.GetType();
                Type array10Type = array10.GetType();
                Type array22Type = array22.GetType();
                Type array24Type = array24.GetType();
    
                Console.WriteLine("int[2] assignable from int[10]: {0}", array2Type.IsAssignableFrom(array10Type));
                Console.WriteLine("int[2] assignable from int[2,4]: {0}", array2Type.IsAssignableFrom(array24Type));
                Console.WriteLine("int[2,4] assignable from int[2,2]: {0}", array24Type.IsAssignableFrom(array22Type));
    
                // Demonstrate generics:
                Console.WriteLine();
                Console.WriteLine("Generics:");
    
                // Note that "int?[]" is the same as "Nullable<int>[]"
                int?[] arrayNull = new int?[10];
                List<int> genIntList = new List<int>();
                List<Type> genTList = new List<Type>();
    
                Type arrayNullType = arrayNull.GetType();
                Type genIntListType = genIntList.GetType();
                Type genTListType = genTList.GetType();
    
                Console.WriteLine("int[10] assignable from int?[10]: {0}", array10Type.IsAssignableFrom(arrayNullType));
                Console.WriteLine("List<int> assignable from List<Type>: {0}", genIntListType.IsAssignableFrom(genTListType));
                Console.WriteLine("List<Type> assignable from List<int>: {0}", genTListType.IsAssignableFrom(genIntListType));
    
                Console.ReadLine();
    
        }
    }
    class Room
    {
    }
    
    class Kitchen : Room
    {
    }
    
    class Bedroom : Room
    {
    }
    
    class Guestroom : Bedroom
    {
    }
    
    class MasterBedroom : Bedroom
    {
    }
    
    //This code example produces the following output:
    //
    // Defned Classes:
    // room assignable from kitchen: True
    // bedroom assignable from guestroom: True
    // kitchen assignable from masterbedroom: False
    //
    // Integer arrays:
    // int[2] assignable from int[10]: True
    // int[2] assignable from int[2,4]: False
    // int[2,4] assignable from int[2,2]: True
    //
    // Generics:
    // int[10] assignable from int?[10]: False
    // List<int> assignable from List<Type>: False
    // List<Type> assignable from List<int>: False
    
    Imports System.Collections.Generic
    
    Module Example
        Public Sub Main()
            Console.WriteLine("Defined Classes:")
            Dim room1 As New Room()
            Dim kitchen1 As New Kitchen()
            Dim bedroom1 As New Bedroom()
            Dim guestroom1 As New Guestroom()
            Dim masterbedroom1 As New MasterBedroom()
    
            Dim room1Type As Type = room1.GetType()
            Dim kitchen1Type As Type = kitchen1.GetType()
            Dim bedroom1Type As Type = bedroom1.GetType()
            Dim guestroom1Type As Type = guestroom1.GetType()
            Dim masterbedroom1Type As Type = masterbedroom1.GetType()
    
            Console.WriteLine("room assignable from kitchen: {0}", room1Type.IsAssignableFrom(kitchen1Type))
            Console.WriteLine("bedroom assignable from guestroom: {0}", bedroom1Type.IsAssignableFrom(guestroom1Type))
            Console.WriteLine("kitchen assignable from masterbedroom: {0}", kitchen1Type.IsAssignableFrom(masterbedroom1Type))
    
            ' Demonstrate arrays:
            Console.WriteLine()
            Console.WriteLine("Integer arrays:")
    
            Dim array10(10) As Integer
            Dim array2(2) As Integer
            Dim array22(2, 2) As Integer
            Dim array24(2, 4) As Integer
    
            Dim array10Type As Type = array10.GetType
            Dim array2Type As Type = array2.GetType
            Dim array22Type As Type = array22.GetType
            Dim array24Type As Type = array24.GetType
    
            Console.WriteLine("Integer(2) assignable from Integer(10): {0}", array2Type.IsAssignableFrom(array10Type))
            Console.WriteLine("Integer(2) assignable from Integer(2,4): {0}", array2Type.IsAssignableFrom(array24Type))
            Console.WriteLine("Integer(2,4) assignable from Integer(2,2): {0}", array24Type.IsAssignableFrom(array22Type))
    
            ' Demonstrate generics:
            Console.WriteLine()
            Console.WriteLine("Generics:")
    
            Dim arrayNull(10) As Nullable(Of Integer)
            Dim genIntList As New List(Of Integer)
            Dim genTList As New List(Of Type)
    
            Dim arrayNullType As Type = arrayNull.GetType
            Dim genIntListType As Type = genIntList.GetType
            Dim genTListType As Type = genTList.GetType
    
            Console.WriteLine("Integer(10) assignable from Nullable(Of Integer)(10): {0}", array10Type.IsAssignableFrom(arrayNullType))
            Console.WriteLine("List(Of Integer) assignable from List(Of Type): {0}", genIntListType.IsAssignableFrom(genTListType))
            Console.WriteLine("List(Of Type) assignable from List(Of Integer): {0}", genTListType.IsAssignableFrom(genIntListType))
            Console.ReadLine()
        End Sub
    End Module
    
    Class Room
    End Class
    
    Class Kitchen : Inherits Room
    End Class
    
    Class Bedroom : Inherits Room
    End Class
    
    Class Guestroom : Inherits Bedroom
    End Class
    
    Class MasterBedroom : Inherits Bedroom
    End Class
    ' The example displays the following output:
    '    Defined Classes:
    '    room assignable from kitchen: True
    '    bedroom assignable from guestroom: True
    '    kitchen assignable from masterbedroom: False
    '
    '    Integer arrays:
    '    Integer(2) assignable from Integer(10): True
    '    Integer(2) assignable from Integer(2,4): False
    '    Integer(2,4) assignable from Integer(2,2): True
    '
    '    Generics:
    '    Integer(10) assignable from Nullable(Of Integer)(10): False
    '    List(Of Integer) assignable from List(Of Type): False
    '    List(Of Type) assignable from List(Of Integer): False
    

    備註

    IsAssignableFrom方法可用來判斷執行個體c可被指派目前型別的執行個體,方法是最有用,當您處理要知道其類型,這是在設計階段的物件並允許條件式指派,如下列範例會顯示。The IsAssignableFrom method can be used to determine whether an instance of c can be assigned to an instance of the current type, The method is most useful when you are handling objects whose types are not known at design time and allows for conditional assignment, as the following example shows.

    using System;
    using System.Collections;
    
    public class Example
    {
       public static void Main()
       {
          Type t = typeof(IEnumerable);
          Type c = typeof(Array);
          
          IEnumerable instanceOfT;
          int[] instanceOfC = { 1, 2, 3, 4 };
          if (t.IsAssignableFrom(c))
             instanceOfT = instanceOfC;
      }
    }
    
    Imports System.Collections
    
    Module Example
       Public Sub Main()
          Dim t As Type = GetType(IEnumerable)
          Dim c As Type = GetType(Array)
          
          Dim instanceOfT As IEnumerable
          Dim instanceOfC As Integer() = { 1, 2, 3, 4 }
          If t.IsAssignableFrom(c) Then
             instanceOfT = instanceOfC
          End If  
       End Sub
    End Module
    

    這個方法因此可確保程式碼,例如下列時,會執行在執行階段上,而不擲回InvalidCastException例外狀況或類似的例外狀況:This method thus ensures that a line of code like the following will execute at runtime without throwing an InvalidCastException exception or a similar exception:

    instanceOfT = instanceOfC;
    
    instanceOfT = instanceOfC
    

    在衍生類別可以覆寫此方法。This method can be overridden by a derived class.

    注意

    無法從封閉式建構類型可指派的泛型類型定義。A generic type definition is not assignable from a closed constructed type. 也就是說,您無法將封閉式建構的類型的指派MyGenericList<int>(MyGenericList(Of Integer) Visual Basic 中) 至型別的變數MyGenericList<T>That is, you cannot assign the closed constructed type MyGenericList<int> (MyGenericList(Of Integer) in Visual Basic) to a variable of type MyGenericList<T>.

    如果c參數的類型是TypeBuilder,結果為基礎建置的型別。If the c parameter is of type TypeBuilder, the result is based on the type that is to be built. 下列程式碼範例示範此使用內建的類型,名為BThe following code example demonstrates this using a built type named B.

    using System;
    using System.Reflection;
    using System.Reflection.Emit;
    
    public class A
    {}
    
    public class Example
    {
       public static void Main()
       {
          AppDomain domain = AppDomain.CurrentDomain;
          AssemblyName assemName = new AssemblyName();
          assemName.Name = "TempAssembly";
    
          // Define a dynamic assembly in the current application domain.
          AssemblyBuilder assemBuilder = domain.DefineDynamicAssembly(assemName,
                                                AssemblyBuilderAccess.Run);
    
          // Define a dynamic module in this assembly.
          ModuleBuilder moduleBuilder = assemBuilder.DefineDynamicModule("TempModule");
    
          TypeBuilder b1 = moduleBuilder.DefineType("B", TypeAttributes.Public, typeof(A));
          Console.WriteLine(typeof(A).IsAssignableFrom(b1));
       }
    }
    // The example displays the following output:
    //        True
    
    Imports System.Reflection
    Imports System.Reflection.Emit
    
    Public Class A
    End Class
    
    Module Example
       Public Sub Main()
          Dim domain As AppDomain = AppDomain.CurrentDomain
          Dim assemName As New AssemblyName()
          assemName.Name = "TempAssembly"
    
          ' Define a dynamic assembly in the current application domain.
          Dim assemBuilder As AssemblyBuilder = domain.DefineDynamicAssembly(assemName,
                                                       AssemblyBuilderAccess.Run)
    
          ' Define a dynamic module in this assembly.
          Dim moduleBuilder As ModuleBuilder = assemBuilder.DefineDynamicModule("TempModule")
    
          Dim b1 As TypeBuilder = moduleBuilder.DefineType("B", TypeAttributes.Public, GetType(A))
          Console.WriteLine(GetType(A).IsAssignableFrom(b1))
       End Sub
    End Module
    ' The example displays the following output:
    '       True
    

    適用於