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

Article
07/13/2023

Applique la stratégie runtime à un type particulier, tel qu'une classe ou une structure.

Syntaxe

<Type Name="type_name"
      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.
`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. Contrôle la stratégie pour le marshaling des types de valeurs vers du code natif.

Name (attribut)

Valeur	Description
TYPE_NAME	Nom du type. Si cet `<Type>` élément est l’enfant d’un <élément Namespace> ou d’un autre `<Type>` élément, type_name pouvez inclure le nom du type sans son espace de noms. Dans le cas contraire, type_name doit inclure le nom de type complet.

Tous les autres attributs

Valeur	Description
policy_setting	Paramètre à appliquer à ce type de stratégie. 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
<AttributeImplies>	Si le type conteneur est un attribut, définit la stratégie runtime pour les éléments de code auxquels l'attribut est appliqué.
<É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.
<GenericParameter>	Applique la stratégie au type de paramètre d'un type générique.
<ImpliesType>	Applique la stratégie à un type, si cette stratégie a été appliquée au type représenté par l'élément conteneur `<Type>`.
<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.
<Sous-types>	Applique la stratégie runtime à toutes les classes héritées du type conteneur.
`<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.

É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. Si aucun n'est présent, l'élément <Type> sert de conteneur dont les types enfants définissent une stratégie pour des membres individuels.

Si un <Type> élément est l’enfant d’un <élément Assembly>, <Namespace>, <Type>ou <TypeInstantiation> , il remplace les paramètres de stratégie définis par l’élément parent.

Un élément <Type> d'un type générique applique sa stratégie à toutes les instanciations qui n'ont pas leur propre stratégie. La stratégie des types génériques construits est définie par l’élément <TypeInstantiation> .

Si le type est un type générique, son nom est décoré d’un symbole d’accent grave (') suivi de son nombre de paramètres génériques. Par exemple, l'attribut Name d'un élément <Type> pour la classe System.Collections.Generic.List<T> est Name="System.Collections.Generic.List`1".

Exemple 1

L'exemple suivant utilise la réflexion pour afficher des informations sur les champs, les propriétés et les méthodes de la classe System.Collections.Generic.List<T>. La variable b dans l’exemple est un TextBlock contrôle . Comme l'exemple récupère simplement les informations de type, la disponibilité des métadonnées est contrôlée par le paramètre de stratégie Browse.

public static void GetReflectionInfo()
{
   Type t = typeof(List<>);
   b.Text += String.Format("Type information for {0}\n", t);

   // Get fields.
   b.Text += "\nFields:\n";

   var fields = t.GetTypeInfo().DeclaredFields;
   int nFields = 0;
   foreach (var field in fields)
   {
      b.Text += String.Format("   {0} ({1})", field.Name, field.FieldType.Name);
      nFields++;
   }
   if (nFields == 0) b.Text += "   None\n";

   // Get properties.
   b.Text += "\nProperties:\n";
   var props = t.GetTypeInfo().DeclaredProperties;
   int nProps = 0;
   foreach (var prop in props)
   {
      b.Text += String.Format("   {0} ({1})\n", prop.Name, prop.PropertyType.Name);
      nProps++;
   }
   if (nProps == 0) b.Text += "   None\n";

   // Get methods.
   b.Text += "\nMethods:\n";
   var methods = t.GetTypeInfo().DeclaredMethods;
   int nMethods = 0;
   foreach (var method in methods)
   {
      if (method.IsSpecialName) continue;
      b.Text += String.Format("   {0}({1}) ({2})\n", method.Name,
                              GetSignature(method), method.ReturnType.Name);
      nMethods++;
   }
   if (nMethods == 0) b.Text += "   None\n";
}

private static string GetSignature(MethodInfo m)
{
   string signature = null;
   var parameters = m.GetParameters();
   for (int ctr = 0; ctr < parameters.Length; ctr++)
   {
      signature += String.Format("{0} {1}", parameters[ctr].ParameterType.Name,
                                  parameters[ctr].Name);
      if (ctr < parameters.Length - 1) signature += ", ";
   }
   return signature;
}

Étant donné que les métadonnées de la List<T> classe ne sont pas automatiquement incluses par la chaîne d’outils .NET Native, l’exemple ne parvient pas à afficher les informations de membre demandées au moment de l’exécution. Pour fournir les métadonnées nécessaires, ajoutez l'élément <Type> suivant au fichier de directives runtime. Notez que, étant donné que nous avons fourni un élément Namespace> parent<, nous n’avons pas besoin de fournir un nom de type complet dans l’élément<Type>.

<Directives xmlns="http://schemas.microsoft.com/netfx/2013/01/metadata">
   <Application>
      <Assembly Name="*Application*" Dynamic="Required All" />
      <Namespace Name ="System.Collections.Generic" >
        <Type Name="List`1" Browse="Required All" />
     </Namespace>
   </Application>
</Directives>

Exemple 2

L'exemple suivant utilise la réflexion pour récupérer un objet PropertyInfo qui représente la propriété String.Chars[]. Il utilise ensuite la méthode PropertyInfo.GetValue(Object, Object[]) pour récupérer la valeur du septième caractère d'une chaîne et afficher tous les caractères de la chaîne. La variable b dans l’exemple est un TextBlock contrôle .

public void Example()
{
  string test = "abcdefghijklmnopqrstuvwxyz";

  // Get a PropertyInfo object.
  TypeInfo ti = typeof(string).GetTypeInfo();
  PropertyInfo pinfo = ti.GetDeclaredProperty("Chars");

  // Show the seventh letter ('g')
  object[] indexArgs = { 6 };
  object value = pinfo.GetValue(test, indexArgs);
  b.Text += String.Format("Character at position {0}: {1}\n", indexArgs[0], value);

  // Show the complete string.
  b.Text += "\nThe complete string:\n";
  for (int x = 0; x < test.Length; x++)
  {
      b.Text += pinfo.GetValue(test, new Object[] {x}).ToString() + " ";
  }
}
// The example displays the following output:
//       Character at position 6: g
//
//       The complete string:
//       a b c d e f g h i j k l m n o p q r s t u v w x y z

Étant donné que les métadonnées de l’objet String ne sont pas disponibles, l’appel à la PropertyInfo.GetValue(Object, Object[]) méthode lève une NullReferenceException exception au moment de l’exécution lorsqu’il est compilé avec la chaîne d’outils .NET Native. Pour éliminer l'exception et fournir les métadonnées nécessaires, ajoutez l'élément <Type> suivant au fichier de directives runtime :

<Directives xmlns="http://schemas.microsoft.com/netfx/2013/01/metadata">
  <Application>
    <Assembly Name="*Application*" Dynamic="Required All" />
    <Type Name="System.String" Dynamic="Required Public"/> -->
  </Application>
</Directives>

Share via