Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Método Type.IsAssignableFrom (Type)

 

Publicado: octubre de 2016

Determina si una instancia de un tipo especificado se puede asignar a una instancia del tipo actual.

Espacio de nombres:   System
Ensamblado:  mscorlib (en mscorlib.dll)

public virtual bool IsAssignableFrom(
	Type c
)

Parámetros

c
Type: System.Type

Tipo que se va a comparar con el tipo actual.

Valor devuelto

Type: System.Boolean

true si alguna de las condiciones siguientes es "true":

  • c y la instancia actual representan el mismo tipo.

  • c se deriva de forma directa o indirecta de la instancia actual. c se deriva directamente de la instancia actual, si se hereda de la instancia actual; c se deriva indirectamente la instancia actual si se hereda de una sucesión de una o más clases que heredan de la instancia actual.

  • La instancia actual es una interfaz que c implementa.

  • c es un parámetro de tipo genérico y la instancia actual representa una de las restricciones de c.

    En el ejemplo siguiente, la instancia actual es un Type objeto que representa la Stream clase. GenericWithConstraint es un tipo genérico cuyo parámetro de tipo genérico debe ser de tipo Stream. Pasar su parámetro de tipo genérico para el IsAssignableFrom indica que una instancia de parámetro de tipo genérico puede asignarse a un Stream objeto.

    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
    {}
    
  • c representa un tipo de valor y la instancia actual representa Nullable<c> (Nullable(Of c) en Visual Basic).

Es false si ninguna de estas condiciones son "true" o si c es null.

El IsAssignableFrom método puede utilizarse para determinar si una instancia de c se puede asignar a una instancia del tipo actual, el método es muy útil cuando el control de objetos cuyos tipos no se conocen en tiempo de diseño y permite la asignación condicional, como se muestra en el ejemplo siguiente.

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;
  }
}

Este método garantiza que por lo tanto, una línea de código como el siguiente se ejecutará en tiempo de ejecución sin producir una InvalidCastException excepción o una excepción similar:

instanceOfT = instanceOfC;

Este método puede invalidarse mediante una clase derivada.

System_CAPS_noteNota

Una definición de tipo genérico no es asignable desde un tipo construido cerrado. Es decir, no se puede asignar el tipo construido cerrado MyGenericList<int> (MyGenericList(Of Integer) en Visual Basic) a una variable de tipo MyGenericList<T>.

Si el c parámetro es de tipo TypeBuilder, el resultado se basa en el tipo que se construye. El ejemplo de código siguiente muestra esto utilizando un tipo integrado denominado 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

En el ejemplo siguiente se muestra el IsAssignableFrom utilizando el método define clases, matrices de enteros y genéricos.

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

.NET Framework
Disponible desde 1.1
Biblioteca de clases portable
Se admite en: plataformas portátiles de .NET
Silverlight
Disponible desde 2.0
Windows Phone Silverlight
Disponible desde 7.0
Volver al principio
Mostrar: