Elemento <TypeInstantiation> (.NET Native)<TypeInstantiation> Element (.NET Native)

Applica i criteri di reflection di runtime a un tipo generico costruito.Applies runtime reflection policy to a constructed generic type.

SintassiSyntax

<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 elementiAttributes and Elements

Nelle sezioni seguenti vengono descritti gli attributi, gli elementi figlio e gli elementi padre.The following sections describe attributes, child elements, and parent elements.

AttributiAttributes

AttributoAttribute Tipo di attributoAttribute type DescrizioneDescription
Name GeneraleGeneral Attributo obbligatorio.Required attribute. Specifica il nome del tipo.Specifies the type name.
Arguments GeneraleGeneral Attributo obbligatorio.Required attribute. Specifica gli argomenti di tipo generico.Specifies the generic type arguments. Se sono presenti più argomenti, saranno separati da virgole.If multiple arguments are present, they are separated by commas.
Activate ReflectionReflection Attributo facoltativo.Optional attribute. Controlla l'accesso in fase di esecuzione ai costruttori per abilitare l'attivazione di istanze.Controls runtime access to constructors to enable activation of instances.
Browse ReflectionReflection Attributo facoltativo.Optional attribute. Controlla le query per le informazioni sugli elementi di programma, ma non abilita l'accesso in fase di esecuzione.Controls querying for information about program elements, but does not enable any runtime access.
Dynamic ReflectionReflection Attributo facoltativo.Optional attribute. 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.Controls runtime access to all type members, including constructors, methods, fields, properties, and events, to enable dynamic programming.
Serialize SerializzazioneSerialization Attributo facoltativo.Optional attribute. 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.Controls runtime access to constructors, fields, and properties, to enable type instances to be serialized and deserialized by libraries such as the Newtonsoft JSON serializer.
DataContractSerializer SerializzazioneSerialization Attributo facoltativo.Optional attribute. Controlla i criteri per la serializzazione che usano la classe System.Runtime.Serialization.DataContractSerializer.Controls policy for serialization that uses the System.Runtime.Serialization.DataContractSerializer class.
DataContractJsonSerializer SerializzazioneSerialization Attributo facoltativo.Optional attribute. Controlla i criteri per la serializzazione JSON che usano la classe System.Runtime.Serialization.Json.DataContractJsonSerializer.Controls policy for JSON serialization that uses the System.Runtime.Serialization.Json.DataContractJsonSerializer class.
XmlSerializer SerializzazioneSerialization Attributo facoltativo.Optional attribute. Controlla i criteri per la serializzazione XML che usano la classe System.Xml.Serialization.XmlSerializer.Controls policy for XML serialization that uses the System.Xml.Serialization.XmlSerializer class.
MarshalObject InteroperabilitàInterop Attributo facoltativo.Optional attribute. Controlla i criteri per effettuare il marshalling dei tipi di riferimento a Windows Runtime e COM.Controls policy for marshaling reference types to Windows Runtime and COM.
MarshalDelegate InteroperabilitàInterop Attributo facoltativo.Optional attribute. Controlla i criteri per effettuare il marshalling dei tipi delegati come puntatori a funzioni al codice nativo.Controls policy for marshaling delegate types as function pointers to native code.
MarshalStructure InteroperabilitàInterop Attributo facoltativo.Optional attribute. Controlla i criteri per il marshalling delle strutture al codice nativo.Controls policy for marshaling structures to native code.

Name (attributo)Name attribute

ValoreValue DescrizioneDescription
type_nametype_name Nome del tipo.The type name. Se questo elemento <TypeInstantiation> è figlio di un elemento <Namespace>, un elemento <Type> o di un altro elemento <TypeInstantiation>, type_name può specificare il nome del tipo senza il relativo spazio dei nomi.If this <TypeInstantiation> element is the child of a <Namespace> element, a <Type> element, or another <TypeInstantiation> element, type_name can specify the name of the type without its namespace. In caso contrario, type_name deve includere il nome completo del tipo.Otherwise, type_name must include the fully qualified type name. Il nome del tipo non è decorato.The type name isn't decorated. Ad esempio, per un oggetto System.Collections.Generic.List<T>, l'elemento <TypeInstantiation> può apparire come segue:For example, for a System.Collections.Generic.List<T> object, the <TypeInstantiation> element might appear as follows:

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

Attributo di argomentiArguments attribute

ValoreValue DescrizioneDescription
type_argumenttype_argument Specifica gli argomenti tipo generico.Specifies the generic type arguments. Se sono presenti più argomenti, saranno separati da virgole.If multiple arguments are present, they are separated by commas. Ogni argomento deve essere costituito dal nome completo del tipo.Each argument must consist of the fully qualified type name.

Tutti gli altri attributiAll other attributes

ValoreValue DescrizioneDescription
policy_settingpolicy_setting L'impostazione da applicare a questo tipo di criteri per il tipo generico costruito.The setting to apply to this policy type for the constructed generic type. I valori consentiti sono All, Auto, Excluded, Public, PublicAndInternal, Required Public, Required PublicAndInternal e Required All.Possible values are All, Auto, Excluded, Public, PublicAndInternal, Required Public, Required PublicAndInternal, and Required All. Per altre informazioni, vedere Runtime Directive Policy Settings (Impostazioni dei criteri delle direttive di runtime).For more information, see Runtime Directive Policy Settings.

Elementi figlioChild Elements

ElementoElement DescrizioneDescription
<Event><Event> Applica i criteri di reflection a un evento appartenente a questo tipo.Applies reflection policy to an event belonging to this type.
<Field><Field> Applica i criteri di reflection a un campo appartenente a questo tipo.Applies reflection policy to a field belonging to this type.
<ImpliesType><ImpliesType> Applica criteri a un tipo, se tale criterio è stato applicato al tipo rappresentato dall'oggetto contenente l'elemento <TypeInstantiation>.Applies policy to a type, if that policy has been applied to the type represented by the containing <TypeInstantiation> element.
<Method><Method> Applica i criteri di reflection a un metodo appartenente a questo tipo.Applies reflection policy to a method belonging to this type.
<MethodInstantiation><MethodInstantiation> Applica criteri di reflection a un metodo generico costruito, appartenente a questo tipo.Applies reflection policy to a constructed generic method belonging to this type.
<Property><Property> Applica i criteri di reflection a una proprietà appartenente a questo tipo.Applies reflection policy to a property belonging to this type.
<Type><Type> Applica criteri di reflection un tipo annidato.Applies reflection policy to a nested type.
<TypeInstantiation> Applica i criteri di reflection a un tipo generico costruito annidato.Applies reflection policy to a nested constructed generic type.

Elementi padreParent Elements

ElementoElement DescrizioneDescription
<Application><Application> 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.Serves as a container for application-wide types and type members whose metadata is available for reflection at run time.
<Assembly><Assembly> Applica i criteri di reflection a tutti i tipi in un determinato assembly.Applies reflection policy to all the types in a specified assembly.
<Library><Library> Definisce l'assembly che contiene i tipi e i membri dei tipi i cui metadati sono disponibili per la reflection al runtime.Defines the assembly that contains types and type members whose metadata is available for reflection at run time.
<Namespace><Namespace> Applica criteri di reflection a tutti i tipi in uno spazio dei nomi.Applies reflection policy to all the types in a namespace.
<Type><Type> Applica i criteri di reflection a un tipo e a tutti i membri.Applies reflection policy to a type and all its members.
<TypeInstantiation> Applica i criteri di reflection a un tipo generico costruito e a tutti i membri.Applies reflection policy to a constructed generic type and all its members.

NoteRemarks

La reflection, la serializzazione e gli attributi di interoperabilità sono facoltativi.The reflection, serialization, and interop attributes are all optional. ma è necessario usarne almeno uno.However, at least one must be present.

Se un elemento <TypeInstantiation> è figlio di un elemento <Assembly>, <Namespace> o <Type>, sottopone a override le impostazioni dei criteri definite dall'elemento padre.If a <TypeInstantiation> element is the child of an <Assembly>, <Namespace>, or <Type>, element, it overrides the policy settings defined by the parent element. 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.If a <Type> element defines a corresponding generic type definition, the <TypeInstantiation> element overrides runtime reflection policy only for instantiations of the specified constructed generic type.

EsempioExample

Nell'esempio seguente viene usata la reflection per recuperare la definizione di tipo generico da un oggetto Dictionary<TKey,TValue> costruito.The following example uses reflection to retrieve the generic type definition from a constructed Dictionary<TKey,TValue> object. Viene anche usata la reflection per visualizzare informazioni sugli oggetti Type che rappresentano tipi generici costruiti e definizioni di tipo generico.It also uses reflection to display information about Type objects that represent constructed generic types and generic type definitions. La variabile b nell'esempio è un controllo TextBlock.The variable b in the example is a TextBlock control.

   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.NET Native, l'esempio genera un'eccezione MissingMetadataException sulla riga che chiama il metodo Type.GetGenericTypeDefinition.After compilation with the .NET Native.NET Native tool chain, the example throws a MissingMetadataException exception on the line that calls the Type.GetGenericTypeDefinition method. È possibile eliminare l'eccezione e fornire i metadati necessari aggiungendo il seguente elemento <TypeInstantiation> al file di direttive di runtime:You can eliminate the exception and provide the necessary metadata by adding the following <TypeInstantiation> element to the runtime directives file:

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

Vedere ancheSee Also

Informazioni di riferimento sul file di configurazione delle direttive di runtime (rd.xml)Runtime Directives (rd.xml) Configuration File Reference
Elementi direttiva di runtimeRuntime Directive Elements
Impostazioni dei criteri delle direttive di runtimeRuntime Directive Policy Settings