Elemento <TypeInstantiation> (.NET Native)

Articolo
07/05/2024

Applica i criteri di reflection di runtime a un tipo generico costruito.

Sintassi

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

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.
`Arguments`	Generali	Attributo obbligatorio. Specifica gli argomenti tipo generico. Se sono presenti più argomenti, saranno separati da virgole.
`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 effettuare il marshalling delle strutture al codice nativo.

Name (attributo)

valore Descrizione

type_name Nome del tipo. Se questo elemento <TypeInstantiation> è figlio di un elemento <Namespace>, un elemento <Type> o un altro elemento<TypeInstantiation>, type_name può specificare il nome del tipo senza il relativo spazio dei nomi. In caso contrario, type_name deve includere il nome completo del tipo. Il nome del tipo non è decorato. Ad esempio, per un oggetto System.Collections.Generic.List<T>, l'elemento <TypeInstantiation> può apparire come segue:

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

valore	Descrizione
type_name	Nome del tipo. Se questo elemento `<TypeInstantiation>` è figlio di un elemento <Namespace>, un elemento <Type> o un altro elemento`<TypeInstantiation>`, type_name può specificare il nome del tipo senza il relativo spazio dei nomi. In caso contrario, type_name deve includere il nome completo del tipo. Il nome del tipo non è decorato. Ad esempio, per un oggetto System.Collections.Generic.List<T>, l'elemento `<TypeInstantiation>` può apparire come segue: `\<TypeInstantiation Name=System.Collections.Generic.List Dynamic="Required Public" />`

Attributo di argomenti

valore	Descrizione
type_argument	Specifica gli argomenti tipo generico. Se sono presenti più argomenti, saranno separati da virgole. Ogni argomento deve essere costituito dal nome completo del tipo.

Tutti gli altri attributi

valore	Descrizione
policy_setting	L'impostazione da applicare a questo tipo di criteri per il tipo generico costruito. 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
<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.
<ImpliesType>	Applica criteri a un tipo, se tale criterio è stato applicato al tipo rappresentato dall'oggetto contenente l'elemento `<TypeInstantiation>`.
<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.
<Type>	Applica criteri di reflection un tipo annidato.
`<TypeInstantiation>`	Applica i criteri di reflection a un tipo generico costruito annidato.

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. ma è necessario usarne almeno uno.

Se un elemento <TypeInstantiation> è figlio di un elemento <Assembly>, <Namespace> o <Type>, sottopone a override le impostazioni dei criteri definite dall'elemento padre. Se un elemento <Type> definisce una corrispondente definizione di tipo generico, l'elemento <TypeInstantiation> esegue l'override dei criteri di reflection di runtime solo per le istanze del tipo generico costruito specificato.

Esempio

Nell'esempio seguente viene usata la reflection per recuperare la definizione di tipo generico da un oggetto Dictionary<TKey,TValue> costruito. Viene anche usata la reflection per visualizzare informazioni sugli oggetti Type che rappresentano tipi generici costruiti e definizioni di tipo generico. La variabile b nell'esempio è un controllo TextBlock.

   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()
   { }
}

Dopo aver eseguito la compilazione con la catena di strumenti .NET Native, l'esempio genera un'eccezione MissingMetadataException sulla riga che chiama il metodo Type.GetGenericTypeDefinition. È possibile eliminare l'eccezione e fornire i metadati necessari aggiungendo il seguente elemento <TypeInstantiation> al file di direttive di 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>

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