Lire en anglais

Partager via


Type.IsAssignableFrom(Type) Méthode

Définition

Détermine si une instance d’un type spécifié c peut être affectée à une variable du type actuel.

C#
public virtual bool IsAssignableFrom(Type? c);
C#
public virtual bool IsAssignableFrom(Type c);

Paramètres

c
Type

Type à comparer avec le type actuel.

Retours

true si l'une ou plusieurs des conditions suivantes sont remplies :

  • c et l’instance actuelle représentent le même type.

  • c est dérivé directement ou indirectement de l’instance actuelle. c est dérivé directement de l’instance actuelle s’il hérite de l’instance actuelle ; c est dérivé indirectement de l’instance actuelle s’il hérite d’une succession d’une ou plusieurs classes qui héritent de l’instance actuelle.

  • L’instance actuelle est une interface qui c implémente.

  • c est un paramètre de type générique et l’instance actuelle représente l’une des contraintes de c.

  • c représente un type valeur, et l’instance actuelle représente Nullable<c> (Nullable(Of c) en Visual Basic).

false si aucune de ces conditions n'a la valeur true, ou si c est null.

Implémente

Exemples

L’exemple suivant illustre la IsAssignableFrom méthode utilisant des classes définies, des tableaux d’entiers et des génériques.

C#
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:
//
// Defined 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

Dans l’exemple suivant, l’instance actuelle est un objet Type qui représente la classe Stream. GenericWithConstraint est un type générique dont le paramètre de type générique doit être de type Stream. Le passage de son paramètre de type générique à la IsAssignableFrom méthode indique qu’une instance du paramètre de type générique peut être affectée à un Stream objet .

C#
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
{}

Remarques

La IsAssignableFrom méthode peut être utilisée pour déterminer si une instance de c peut être affectée à une instance du type actuel. La méthode est particulièrement utile lorsque vous gérez des objets dont les types ne sont pas connus au moment du design et autorise l’affectation conditionnelle, comme le montre l’exemple suivant.

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

Cette méthode garantit ainsi qu’une ligne de code comme celle-ci s’exécute au moment de l’exécution sans lever d’exception InvalidCastException ou d’exception similaire :

C#
instanceOfT = instanceOfC;

Cette méthode peut être remplacée par une classe dérivée.

Notes

Une définition de type générique n’est pas assignable à partir d’un type construit fermé. Autrement dit, vous ne pouvez pas affecter le type MyGenericList<int> construit fermé (MyGenericList(Of Integer) en Visual Basic) à une variable de type MyGenericList<T>.

Si le c paramètre est de type TypeBuilder, le résultat est basé sur le type à générer. L’exemple de code suivant le montre à l’aide d’un type généré nommé B.

C#
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

S’applique à

Produit Versions
.NET Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9, 10
.NET Framework 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard 2.0, 2.1