Type.IsAssignableFrom-Methode

Bestimmt, ob der aktuellen Type-Instanz eine Instanz vom angegebenen Type zugewiesen werden kann.

Namespace: System
Assembly: mscorlib (in mscorlib.dll)

Syntax

'Declaration
Public Overridable Function IsAssignableFrom ( _
    c As Type _
) As Boolean
'Usage
Dim instance As Type
Dim c As Type
Dim returnValue As Boolean

returnValue = instance.IsAssignableFrom(c)

public virtual bool IsAssignableFrom (
    Type c
)

public:
virtual bool IsAssignableFrom (
    Type^ c
)

public boolean IsAssignableFrom (
    Type c
)

public function IsAssignableFrom (
    c : Type
) : boolean

Parameter

• c
  Der Type, der mit dem aktuellen Type verglichen werden soll.

Rückgabewert

true unter den folgenden Bedingungen: c und der aktuelle Type stellen denselben Typ dar; der aktuelle Type befindet sich in der Vererbungshierarchie von c; der aktuelle Type ist eine Schnittstelle, die von c implementiert wird; c ist ein generischer Typparameter, und der aktuelle Type stellt eine der Einschränkungen von c dar. false, wenn keine dieser Bedingungen zutrifft oder cNULL (Nothing in Visual Basic) ist.

Hinweise

Diese Methode kann von einer abgeleiteten Klasse überschrieben werden.

Bestimmen Sie die Elementtypen eines Type mit GetElementType.

Beispiel

Im folgenden Beispiel wird die Verwendung der IsAssignableFrom-Methode mit Arrays veranschaulicht.

Imports System

Class ArrayTypeTest

    Public Shared Sub Main()
        Dim i As Integer = 1
        Dim array10(10) As Integer
        Dim array2(2) As Integer
        Dim array22(2, 2) As Integer
        Dim array24(2, 4) As Integer
        Dim array333(3, 3, 3) 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()
        Dim array333Type As Type = array333.GetType()

        ' If X and Y are not both arrays, then return false.
        Console.WriteLine("Is int[2] assignable from int? {0}.", array2Type.IsAssignableFrom(i.GetType()))
        ' If X and Y have same type and rank, then return true.
        Console.WriteLine("Is int[2] assignable from int[10]? {0}.", array2Type.IsAssignableFrom(array10Type))
        Console.WriteLine("Is int[2,2] assignable from int[2,4]? {0}.", array22Type.IsAssignableFrom(array24Type))
        Console.WriteLine("Is int[2,4] assignable from int[2,2]? {0}.", array24Type.IsAssignableFrom(array22Type))
        ' If X and Y do not have the same rank, then return false.
        Console.WriteLine("Is int[2,2] assignable from int[10]? {0}.", array22Type.IsAssignableFrom(array10Type))
        Console.WriteLine("Is int[2,2] assignable from int[3,3,3]? {0}.", array22Type.IsAssignableFrom(array333Type))
        Console.WriteLine("Is int[3,3,3] is assignable from int[2,2]? {0}.", array333Type.IsAssignableFrom(array22Type))
    End Sub 'Main
End Class 'ArrayTypeTest

using System;
class ArrayTypeTest 
{
    public static void Main() 
    {
        int i = 1;
        int [] array10 = new int [10];
        int [] array2 = new int[2];
        int [,]array22 = new int[2,2];
        int [,]array24 = new int[2,4];
        int [,,]array333 = new int[3,3,3];
        Type array10Type = array10.GetType();
        Type array2Type = array2.GetType();
        Type array22Type = array22.GetType();
        Type array24Type = array24.GetType();
        Type array333Type = array333.GetType();

        // If X and Y are not both arrays, then return false.
        Console.WriteLine("Is int[2] assignable from int? {0}.", array2Type.IsAssignableFrom(i.GetType()));
        // If X and Y have same type and rank, then return true.
        Console.WriteLine("Is int[2] assignable from int[10]? {0}.", array2Type.IsAssignableFrom(array10Type));
        Console.WriteLine("Is int[2,2] assignable from int[2,4]? {0}.", array22Type.IsAssignableFrom(array24Type));
        Console.WriteLine("Is int[2,4] assignable from int[2,2]? {0}.", array24Type.IsAssignableFrom(array22Type));
        // If X and Y do not have the same rank, then return false.
        Console.WriteLine("Is int[2,2] assignable from int[10]? {0}.", array22Type.IsAssignableFrom(array10Type));
        Console.WriteLine("Is int[2,2] assignable from int[3,3,3]? {0}.", array22Type.IsAssignableFrom(array333Type));
        Console.WriteLine("Is int[3,3,3] assignable from int[2,2]? {0}.", array333Type.IsAssignableFrom(array22Type));
    }
}

using namespace System;
int main()
{
   Int32 i = 1;
   array<Int32>^array10 = gcnew array<Int32>(10);
   array<Int32>^array2 = gcnew array<Int32>(2);
   array<Int32, 2>^array22 = gcnew array<Int32,2>(2,2);
   array<Int32, 2>^array24 = gcnew array<Int32,2>(2,4);
   array<Int32, 3>^array333 = gcnew array<Int32,3>(3,3,3);
   Type^ array10Type = array10->GetType();
   Type^ array2Type = array2->GetType();
   Type^ array22Type = array22->GetType();
   Type^ array24Type = array24->GetType();
   Type^ array333Type = array333->GetType();
   
   // If X and Y are not both arrays, then return false.
   Console::WriteLine( "Is Int32[2] assignable from Int32? {0}.", array2Type->IsAssignableFrom( i.GetType() ).ToString() );
   
   // If X and Y have same type and rank, then return true.
   Console::WriteLine( "Is Int32[2] assignable from Int32[10]? {0}.", array2Type->IsAssignableFrom( array10Type ).ToString() );
   Console::WriteLine( "Is Int32[2,2] assignable from Int32[2,4]? {0}.", array22Type->IsAssignableFrom( array24Type ).ToString() );
   Console::WriteLine( "Is Int32[2,4] assignable from Int32[2,2]? {0}.", array24Type->IsAssignableFrom( array22Type ).ToString() );
   
   // If X and Y do not have the same rank, then return false.
   Console::WriteLine( "Is Int32[2,2] assignable from Int32[10]? {0}.", array22Type->IsAssignableFrom( array10Type ).ToString() );
   Console::WriteLine( "Is Int32[2,2] assignable from Int32[3,3,3]? {0}.", array22Type->IsAssignableFrom( array333Type ).ToString() );
   Console::WriteLine( "Is Int32[3,3,3] assignable from int[2,2]? {0}.", array333Type->IsAssignableFrom( array22Type ).ToString() );
}

import System.*;

class ArrayTypeTest
{
    public static void main(String[] args)
    {
        int i = 1;
        int array10[] = new int[10];
        int array2[] = new int[2];
        int array22[,] = new int[2, 2];
        int array24[,] = new int[2, 4];
        int array333[, ,] = new int[3, 3, 3];
        Type array10Type = array10.GetType();
        Type array2Type = array2.GetType();
        Type array22Type = array22.GetType();
        Type array24Type = array24.GetType();
        Type array333Type = array333.GetType();

        // If X and Y are not both arrays, then return false.
        Console.WriteLine("Is int[2] assignable from int? {0}.",
            System.Convert.ToString(array2Type.IsAssignableFrom(
            ((Int32)i).GetType())));

        // If X and Y have same type and rank, then return true.
        Console.WriteLine("Is int[2] assignable from int[10]? {0}.", 
            System.Convert.ToString(array2Type.IsAssignableFrom(array10Type)));
        Console.WriteLine("Is int[2,2] assignable from int[2,4]? {0}.",
            System.Convert.ToString(array22Type.IsAssignableFrom(
            array24Type)));
        Console.WriteLine("Is int[2,4] assignable from int[2,2]? {0}.",
            System.Convert.ToString(array24Type.IsAssignableFrom(
            array22Type)));

        // If X and Y do not have the same rank, then return false.
        Console.WriteLine("Is int[2,2] assignable from int[10]? {0}.",
            System.Convert.ToString(array22Type.IsAssignableFrom(
            array10Type)));
        Console.WriteLine("Is int[2,2] assignable from int[3,3,3]? {0}.",
            System.Convert.ToString(array22Type.IsAssignableFrom(
            array333Type)));
        Console.WriteLine("Is int[3,3,3] assignable from int[2,2]? {0}.",
            System.Convert.ToString(array333Type.IsAssignableFrom(
            array22Type)));
    } //main
} //ArrayTypeTest

Dieser Code erzeugt die folgende Ausgabe:

int[2] is assignable from int? False
     int[2] is assignable from int[10]? True
     int[2,2] is assignable from int[2,4]? True
     int[2,4] is assignable from int[2,2]? True
     int[2,2] is assignable from int[10]? False
     int[2,2] is assignable from int[3,3,3]? False
    int[3,3,3] is assignable from int[2,2]? False

Plattformen

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile für Pocket PC, Windows Mobile für Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

Versionsinformationen

.NET Framework

Unterstützt in: 2.0, 1.1, 1.0

.NET Compact Framework

Unterstützt in: 2.0, 1.0

Siehe auch

Referenz

Type-Klasse
Type-Member
System-Namespace