Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

Type.IsAssignableFrom méthode (Type)

 

Date de publication : novembre 2016

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

Espace de noms:   System
Assembly:  mscorlib (dans mscorlib.dll)

public virtual bool IsAssignableFrom(
	Type c
)

Paramètres

c
Type: System.Type

Type à comparer avec le type actuel.

Valeur de retour

Type: System.Boolean

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ée indirectement de l’instance actuelle si elle hérite d’une série d’une ou plusieurs classes qui héritent de l’instance actuelle.

  • L'instance actuelle est une interface implémentée par c.

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

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

    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 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.

Le IsAssignableFrom méthode peut être utilisée pour déterminer si une instance de c peuvent être attribués à 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 permet l’affectation conditionnelle, comme le montre l’exemple suivant.

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 qui garantit ainsi une ligne de code comme celui-ci s’exécute lors de l’exécution sans lever une InvalidCastException exception ou une exception semblable :

instanceOfT = instanceOfC;

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

System_CAPS_noteRemarque

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 construit fermé MyGenericList<int> (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 qui doit être créé. L’exemple de code suivant illustre cela : à l’aide d’un type construit nommé 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

L’exemple suivant illustre la IsAssignableFrom à l’aide de la méthode définie classes, tableaux d’entiers et des génériques.

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 depuis 1.1
Bibliothèque de classes portable
Pris en charge dans : plateformes .NET portables
Silverlight
Disponible depuis 2.0
Silverlight pour Windows Phone
Disponible depuis 7.0
Retour au début
Afficher: