<Elemento> Type (.NET Native)

Articolo
03/28/2024

Applica i criteri di runtime a un determinato tipo, ad esempio una classe o una struttura.

Sintassi

<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" />

Attributi ed elementi

Nelle sezioni seguenti vengono descritti gli attributi, gli elementi figlio e gli elementi padre.

Attributi

Attributo	Tipo di attributo	Descrizione
`Name`	Generali	Attributo obbligatorio. Specifica il nome tipo.
`Activate`	Reflection	Attributo facoltativo. Controlla l'accesso in fase di esecuzione ai costruttori per abilitare l'attivazione di istanze.
`Browse`	Reflection	Attributo facoltativo. Controlla le query per le informazioni sugli elementi di programma, ma non abilita l'accesso in fase di esecuzione.
`Dynamic`	Reflection	Attributo facoltativo. Controlla l'accesso in fase di esecuzione a tutti i membri dei tipi, inclusi costruttori, metodi, campi, proprietà ed eventi, per abilitare la programmazione dinamica.
`Serialize`	Serializzazione	Attributo facoltativo. Controlla l'accesso in fase di esecuzione a costruttori, campi e proprietà per abilitare la serializzazione e la deserializzazione delle istanze del tipo da parte di librerie quali il serializzatore JSON di Newtonsoft.
`DataContractSerializer`	Serializzazione	Attributo facoltativo. Controlla i criteri per la serializzazione che usano la classe System.Runtime.Serialization.DataContractSerializer.
`DataContractJsonSerializer`	Serializzazione	Attributo facoltativo. Controlla i criteri per la serializzazione JSON che usano la classe System.Runtime.Serialization.Json.DataContractJsonSerializer.
`XmlSerializer`	Serializzazione	Attributo facoltativo. Controlla i criteri per la serializzazione XML che usano la classe System.Xml.Serialization.XmlSerializer.
`MarshalObject`	Interop	Attributo facoltativo. Controlla i criteri per effettuare il marshalling dei tipi di riferimento a Windows Runtime e COM.
`MarshalDelegate`	Interop	Attributo facoltativo. Controlla i criteri per effettuare il marshalling dei tipi delegati come puntatori a funzioni al codice nativo.
`MarshalStructure`	Interop	Attributo facoltativo. Controlla i criteri per il marshalling dei tipi di valore al codice nativo.

Name (attributo)

valore	Descrizione
type_name	Nome del tipo. Se questo elemento `<Type>` è figlio di un elemento <Namespace> o di un altro elemento `<Type>` , type_name può includere il nome del tipo senza il relativo spazio dei nomi. In caso contrario, type_name deve includere il nome completo del tipo.

Tutti gli altri attributi

valore	Descrizione
policy_setting	L'impostazione da applicare a questo tipo di criteri. I valori consentiti sono `All`, `Auto`, `Excluded`, `Public`, `PublicAndInternal`, `Required Public`, `Required PublicAndInternal` e `Required All`. Per altre informazioni, vedere Runtime Directive Policy Settings (Impostazioni dei criteri delle direttive di runtime).

Elementi figlio

Elemento	Descrizione
<AttributeImplies>	Se il tipo contenitore è un attributo, definisce i criteri di runtime per gli elementi del codice a cui è applicato l'attributo.
<Evento>	Applica i criteri di reflection a un evento appartenente a questo tipo.
<Campo>	Applica i criteri di reflection a un campo appartenente a questo tipo.
<GenericParameter>	Applica i criteri al tipo di parametro di un tipo generico.
<ImpliesType>	Applica criteri a un tipo, se tale criterio è stato applicato al tipo rappresentato dall'oggetto contenente l'elemento `<Type>`.
<Metodo>	Applica i criteri di reflection a un metodo appartenente a questo tipo.
<MethodInstantiation>	Applica criteri di reflection a un metodo generico costruito, appartenente a questo tipo.
<Proprietà>	Applica i criteri di reflection a una proprietà appartenente a questo tipo.
<Sottotipi>	Applica i criteri di runtime a tutte le classi ereditate per il tipo contenitore.
`<Type>`	Applica criteri di reflection un tipo annidato.
<TypeInstantiation>	Applica i criteri di reflection a un tipo generico costruito.

Elementi padre

Elemento	Descrizione
<Applicazione>	Viene usato come contenitore per i tipi e i membri dei tipi a livello di applicazione i cui metadati sono disponibili per la reflection al runtime.
<Assemblaggio>	Applica i criteri di reflection a tutti i tipi in un determinato assembly.
<Libreria>	Definisce l'assembly che contiene i tipi e i membri dei tipi i cui metadati sono disponibili per la reflection al runtime.
<Spazio dei nomi>	Applica criteri di reflection a tutti i tipi in uno spazio dei nomi.
`<Type>`	Applica i criteri di reflection a un tipo e a tutti i membri.
<TypeInstantiation>	Applica i criteri di reflection a un tipo generico costruito e a tutti i membri.

Osservazioni:

La reflection, la serializzazione e gli attributi di interoperabilità sono facoltativi. Se non è presente, l'elemento <Type> funge da contenitore i cui tipi figlio definiscono criteri per i singoli membri.

Se un elemento <Type> è figlio di un elemento <Assembly>, <Namespace>, <Type>, o <TypeInstantiation>, sottopone a override le impostazioni dei criteri definite dall'elemento padre.

Un elemento <Type> di un tipo generico applica i relativi criteri a tutte le istanze che non dispongono di propri criteri. I criteri di tipi generici costruiti sono definiti dall'elemento <TypeInstantiation> .

Se il tipo è un tipo generico, il nome è decorato da un simbolo di accento grave (`) seguito dal relativo numero di parametri generici. Ad esempio, l'attributo Name di un elemento <Type> per la classe System.Collections.Generic.List<T> viene visualizzato come Name="System.Collections.Generic.List`1".

Esempio 1

Nell'esempio seguente viene usata la reflection per visualizzare le informazioni su campi, proprietà e metodi della classe System.Collections.Generic.List<T>. La variabile b nell'esempio è un controllo TextBlock . Poiché l'esempio recupera semplicemente le informazioni sul tipo, la disponibilità dei metadati è controllata dall'impostazione dei criteri 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;
}

Poiché i metadati per la classe List<T> non sono inclusi automaticamente dalla catena di strumenti .NET Native, l'esempio non riesce a visualizzare le informazioni sul membro richiesto in fase di esecuzione. Per fornire i metadati necessari, aggiungere il seguente elemento <Type> al file di direttive di runtime. Da notare che dal momento che è stato fornito un elemento <Namespace> padre, non è necessario fornire un nome di tipo completo nell'elemento <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>

Esempio 2

Nell'esempio seguente viene usata la reflection per recuperare un oggetto PropertyInfo che rappresenta la proprietà String.Chars[]. Viene quindi usato il metodo PropertyInfo.GetValue(Object, Object[]) per recuperare il valore del settimo carattere in una stringa e visualizzare tutti i caratteri nella stringa. La variabile b nell'esempio è un controllo TextBlock .

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

Poiché i metadati relativi all'oggetto String non sono disponibili, la chiamata al metodo PropertyInfo.GetValue(Object, Object[]) genera un'eccezione NullReferenceException in fase di esecuzione quando compilato con la catena di strumenti. Per eliminare l'eccezione e fornire i metadati necessari, aggiungere il seguente elemento <Type> al file di direttive di 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>

Vedi anche

Informazioni di riferimento sul file di configurazione delle direttive di runtime (rd.xml)
Elementi direttiva di runtime
Runtime Directive Policy Settings (Impostazioni dei criteri delle direttive di runtime)

Condividi tramite