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.

返回

如果满足下列任一条件,则为 truetrue 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.
  • 在以下示例中,当前实例是表示 Stream 类的 Type 对象。In the following example, the current instance is a Type object that represents the Stream class. GenericWithConstraint 是一种泛型类型,其泛型类型参数必须为 Stream 类型。GenericWithConstraint 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
    

    适用于