Type.IsAssignableFrom(Type) 方法

參考

定義

命名空間:: System

組件:: System.Runtime.dll

組件:: netstandard.dll

組件:: mscorlib.dll

重要

部分資訊涉及發行前產品，在發行之前可能會有大幅修改。 Microsoft 對此處提供的資訊，不做任何明確或隱含的瑕疵擔保。

判斷所指定型別 c的執行個體是否可以指派給目前型別的變數。

public:
 virtual bool IsAssignableFrom(Type ^ c);

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

要與目前的類型比較的類型。

傳回

Boolean

true (下列任何條件成立時)：

c 與目前的執行個體代表相同的型別。
c 直接或間接衍生自目前執行個體。 c 會直接衍生自目前的執行個體 (如果它繼承自目前的執行個體)，c 會間接衍生自目前的執行個體 (如果它繼承自目前的執行個體所繼承的一或多個一連串類別)。
目前執行個體是 c 實作的介面。
c 是泛型類型參數，而且目前執行個體代表 c 的其中一個條件約束。
c代表實值型別，而目前的實例代表 Visual Basic) 中的可為 null < c > (的 c) 可為 null 的 ( 。

如果以上條件都不成立，或者 c 為 false，則為 null。

實作

IsAssignableFrom(Type)

範例

下列範例示範 IsAssignableFrom 使用已定義的類別、整數陣列和泛型的方法。

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

在下列範例中，目前的執行個體是 Type 物件，代表 Stream 類別。 GenericWithConstraint 是泛型型別參數必須是型別的泛型型別 Stream 。將其泛型型別參數傳遞給 IsAssignableFrom 方法，表示泛型型別參數的實例可以指派給 Stream 物件。

using System;
using System.IO;

public class Example
{
   public static void Main()
   {
      Type t = typeof(Stream);
      Type genericT = typeof(GenericWithConstraint<>);
      Type genericParam = genericT.GetGenericArguments()[0];
      Console.WriteLine(t.IsAssignableFrom(genericParam));  
      // Displays True.
   }
}

public class GenericWithConstraint<T> where T : Stream
{}

Imports System.IO

Module Example
   Public Sub Main()
      Dim t As Type = GetType(Stream)
      Dim genericT As Type = GetType(GenericWithConstraint(Of ))
      Dim genericParam As Type = genericT.GetGenericArguments()(0)
      Console.WriteLine(t.IsAssignableFrom(genericParam))  
      ' Displays True.
   End Sub
End Module

Public Class GenericWithConstraint(Of T As Stream)
End Class

備註

IsAssignableFrom方法可以用來判斷的實例是否 c 可以指派給目前型別的實例，當您處理在設計階段不知道其型別且允許進行條件式指派的物件時，此方法最有用，如下列範例所示。

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 例外狀況或類似的例外狀況：

instanceOfT = instanceOfC;

instanceOfT = instanceOfC

衍生類別可以覆寫這個方法。

注意

泛型型別定義無法從封閉的結構類型指派。也就是說，您無法將 Visual Basic) 中的封閉型結構 MyGenericList<int> (指派 MyGenericList(Of Integer) 給類型的變數 MyGenericList<T> 。

如果 c 參數的類型為 TypeBuilder ，則結果是以要建立的型別為基礎。下列程式碼範例會使用名為的內建類型來示範此程式碼 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

適用於

共用方式為

Type.IsAssignableFrom(Type) 方法

定義

參數

傳回

實作

範例

備註

適用於

其他資源