<TypeInstantiation>, élément (.NET Native)

Article
07/13/2023

Applique la stratégie de réflexion runtime à un type générique construit.

Syntaxe

<TypeInstantiation Name="type_name"
                   Arguments="type_arguments"
                   Activate="policy_type"
                   Browse="policy_type"
                   Dynamic="policy_type"
                   Serialize="policy_type"
                   DataContractSerializer="policy_setting"
                   DataContractJsonSerializer="policy_setting"
                   XmlSerializer="policy_setting"
                   MarshalObject="policy_setting"
                   MarshalDelegate="policy_setting"
                   MarshalStructure="policy_setting" />

Attributs et éléments

Les sections suivantes décrivent des attributs, des éléments enfants et des éléments parents.

Attributs

Attribut	Type d'attribut	Description
`Name`	Général	Attribut requis. Spécifie le nom du type.
`Arguments`	Général	Attribut requis. Spécifie les arguments de type générique. Si plusieurs arguments sont présents, ils sont séparés par des virgules.
`Activate`	Réflexion	Attribut facultatif. Contrôle l'accès aux constructeurs pour permettre l'activation d'instances au moment de l'exécution.
`Browse`	Réflexion	Attribut facultatif. Contrôle la demande d'informations sur les éléments de programme, mais ne permet pas l'accès au moment de l'exécution.
`Dynamic`	Réflexion	Attribut facultatif. Contrôle l'accès à l'exécution à tous les membres de types, y compris les constructeurs, les méthodes, les champs, les propriétés et les événements, pour permettre la programmation dynamique.
`Serialize`	Sérialisation	Attribut facultatif. Contrôle l'accès au moment de l'exécution aux constructeurs, champs et propriétés, pour permettre la sérialisation et la désérialisation des instances de types par des bibliothèques comme le sérialiseur JSON Newtonsoft.
`DataContractSerializer`	Sérialisation	Attribut facultatif. Contrôle la stratégie pour la sérialisation qui utilise la classe System.Runtime.Serialization.DataContractSerializer.
`DataContractJsonSerializer`	Sérialisation	Attribut facultatif. Contrôle la stratégie pour la sérialisation JSON qui utilise la classe System.Runtime.Serialization.Json.DataContractJsonSerializer.
`XmlSerializer`	Sérialisation	Attribut facultatif. Contrôle la stratégie pour la sérialisation XML qui utilise la classe System.Xml.Serialization.XmlSerializer.
`MarshalObject`	Interop	Attribut facultatif. Contrôle la stratégie pour le marshaling des types de références vers Windows Runtime et COM.
`MarshalDelegate`	Interop	Attribut facultatif. Contrôle la stratégie pour le marshaling des types de délégués comme pointeurs de fonction vers du code natif.
`MarshalStructure`	Interop	Attribut facultatif. Stratégie de contrôles pour le marshaling de structures en code natif.

Name (attribut)

Valeur Description

TYPE_NAME Nom du type. Si cet <TypeInstantiation> élément est l’enfant d’un <élément Namespace> , d’un <élément Type> ou d’un autre <TypeInstantiation> élément, type_name pouvez spécifier le nom du type sans son espace de noms. Dans le cas contraire, type_name doit inclure le nom de type complet. Le nom du type n'est pas décoré. Par exemple, pour un objet System.Collections.Generic.List<T>, l'élément <TypeInstantiation> peut apparaître comme suit :

\<TypeInstantiation Name=System.Collections.Generic.List Dynamic="Required Public" />

Valeur	Description
TYPE_NAME	Nom du type. Si cet `<TypeInstantiation>` élément est l’enfant d’un <élément Namespace> , d’un <élément Type> ou d’un autre `<TypeInstantiation>` élément, type_name pouvez spécifier le nom du type sans son espace de noms. Dans le cas contraire, type_name doit inclure le nom de type complet. Le nom du type n'est pas décoré. Par exemple, pour un objet System.Collections.Generic.List<T>, l'élément `<TypeInstantiation>` peut apparaître comme suit : `\<TypeInstantiation Name=System.Collections.Generic.List Dynamic="Required Public" />`

Attribut Arguments

Valeur	Description
type_argument	Spécifie les arguments de type générique. Si plusieurs arguments sont présents, ils sont séparés par des virgules. Chaque argument doit être composé du nom de type qualifié complet.

Tous les autres attributs

Valeur	Description
policy_setting	Paramètre à appliquer à ce type de stratégie pour le type générique construit. Les valeurs possibles sont `All`, `Auto`, `Excluded`, `Public`, `PublicAndInternal`, `Required Public`, `Required PublicAndInternal` et `Required All`. Pour plus d’informations, consultez Paramètres de stratégie de directive runtime.

Éléments enfants

Élément	Description
<Événement>	Applique la stratégie de réflexion à un événement appartenant à ce type.
<Champ>	Applique la stratégie de réflexion à un champ appartenant à ce type.
<ImpliesType>	Applique la stratégie à un type, si cette stratégie a été appliquée au type représenté par l'élément conteneur `<TypeInstantiation>`.
<Méthode>	Applique la stratégie de réflexion à une méthode appartenant à ce type.
<MethodInstantiation>	Applique la stratégie de réflexion à une méthode générique construite appartenant à ce type.
<Propriété>	Applique la stratégie de réflexion à une propriété appartenant à ce type.
<Type>	Applique la stratégie de réflexion à un type imbriqué.
`<TypeInstantiation>`	Applique la stratégie de réflexion à un type générique construit imbriqué.

Éléments parents

Élément	Description
<Application>	Sert de conteneur pour des types à l'échelle de l'application et pour des membres de types dont les métadonnées sont disponibles pour la réflexion au moment de l'exécution.
<Assembly>	Applique la stratégie de réflexion à tous les types d'un assembly spécifié.
<Bibliothèque>	Définit l'assembly qui contient des types et des membres de types dont les métadonnées sont disponibles pour la réflexion au moment de l'exécution.
<Noms>	Applique la stratégie de réflexion à tous les types d'un espace de noms.
<Type>	Applique la stratégie de réflexion à un type et à tous ses membres.
`<TypeInstantiation>`	Applique la stratégie de réflexion à un type générique construit et à tous ses membres.

Remarques

Les attributs de réflexion, de sérialisation et d'interopérabilité sont tous facultatifs. Toutefois, au moins un doit être présent.

Si un <TypeInstantiation> élément est l’enfant d’un <élément Assembly>, <Namespace> ou <Type>, il remplace les paramètres de stratégie définis par l’élément parent. Si un <élément Type> définit une définition de type générique correspondante, l’élément remplace la <TypeInstantiation> stratégie de réflexion du runtime uniquement pour les instanciations du type générique construit spécifié.

Exemple

L'exemple suivant utilise la réflexion pour récupérer la définition de type générique construit d'un objet Dictionary<TKey,TValue>. Il utilise également la réflexion pour afficher des informations sur les objets Type qui représentent des types génériques construits et des définitions de type générique. La variable b dans l’exemple est un TextBlock contrôle .

   public static void GetGenericInfo()
   {
      // Get the type that represents the generic type definition and
      // display information about it.
      Type generic1 = typeof(Dictionary<,>);
      DisplayGenericType(generic1);

      // Get the type that represents a constructed generic type and its
      // generic type definition.
      Dictionary<string, Example> d1 = new Dictionary<string, Example>();
      Type constructed1 = d1.GetType();
      Type generic2 = constructed1.GetGenericTypeDefinition();

      // Display information for the generic type definition, and
      // for the constructed type Dictionary<String, Example>.
      DisplayGenericType(constructed1);
      DisplayGenericType(generic2);

      // Construct an array of type arguments.
      Type[] typeArgs = { typeof(string), typeof(Example) };
      // Construct the type Dictionary<String, Example>.
      Type constructed2 = generic1.MakeGenericType(typeArgs);

      DisplayGenericType(constructed2);

      object o = Activator.CreateInstance(constructed2);

      b.Text += "\r\nCompare types obtained by different methods:\n";
      b.Text += String.Format("   Are the constructed types equal? {0}\n",
                              (d1.GetType() == constructed2));
      b.Text += String.Format("   Are the generic definitions equal? {0}\n",
                              (generic1 == constructed2.GetGenericTypeDefinition()));

      // Demonstrate the DisplayGenericType and
      // DisplayGenericParameter methods with the Test class
      // defined above. This shows base, interface, and special
      // constraints.
      DisplayGenericType(typeof(TestGeneric<>));
   }

   // Display information about a generic type.
   private static void DisplayGenericType(Type t)
   {
      b.Text += String.Format("\n{0}\n", t);
      b.Text += String.Format("   Generic type? {0}\n",
                              t.GetTypeInfo().GenericTypeParameters.Length !=
                              t.GenericTypeArguments.Length);
      b.Text += String.Format("   Generic type definition? {0}\n",
                              ! t.IsConstructedGenericType);

      // Get the generic type parameters.
      Type[] typeParameters = t.GetTypeInfo().GenericTypeParameters;
      if (typeParameters.Length > 0)
      {
         b.Text += String.Format("   {0} type parameters:\n",
                                 typeParameters.Length);
         foreach (Type tParam in typeParameters)
            b.Text += String.Format("      Type parameter: {0} position {1}\n",
                     tParam.Name, tParam.GenericParameterPosition);
      }
      else
      {
         Type[] typeArgs = t.GenericTypeArguments;
         b.Text += String.Format("   {0} type arguments:\n",
                                 typeArgs.Length);
         foreach (var tArg in typeArgs)
               b.Text += String.Format("      Type argument: {0}\n",
                                       tArg);
      }
      b.Text += "\n-------------------------------\n";
   }
}

public interface ITestInterface { }

public class TestBase { }

public class TestGeneric<T> where T : TestBase, ITestInterface, new() { }

public class TestArgument : TestBase, ITestInterface
{
   public TestArgument()
   { }
}

Après la compilation avec la chaîne d’outils .NET Native, l’exemple lève une exception MissingMetadataException sur la ligne qui appelle la Type.GetGenericTypeDefinition méthode. Vous pouvez éliminer l'exception et fournir les métadonnées nécessaires en ajoutant l'élément <TypeInstantiation> suivant au fichier de directives runtime :

<Directives xmlns="http://schemas.microsoft.com/netfx/2013/01/metadata">
  <Application>
    <Assembly Name="*Application*" Dynamic="Required All" />
     <TypeInstantiation Name="System.Collections.Generic.Dictionary"
                        Arguments="System.String,GenericType.Example"
                        Dynamic="Required Public" />
  </Application>
</Directives>

Share via