Type.IsAssignableFrom(Type) 메서드

정의

지정한 형식의 인스턴스를 현재 형식의 변수에 할당할 수 있는지 여부를 결정합니다.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

현재 형식과 비교할 형식입니다.The type to compare with the current type.

반환

다음 조건 중 하나 이상이 true일 경우 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.
  • 다음 예제에서 현재 인스턴스는 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이면 null입니다.false 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
    

    이 메서드 따라서를 사용 하면 다음이 런타임에 throw 하지 않고 실행 됩니다와 같은 코드 줄을 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. 다음 코드 예제에서는이 라는 기본 제공된 형식을 사용 하 여 B입니다.The 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
    

    적용 대상