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

Applica i criteri di runtime a un determinato tipo, ad esempio una classe o una struttura.Applies runtime policy to a particular type, such as a class or structure.

SintassiSyntax

<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 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.
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 dei tipi di valore al codice nativo.Controls policy for marshaling value types to native code.

Name (attributo)Name attribute

ValoreValue DescrizioneDescription
type_nametype_name Nome del tipo.The type name. 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.If this <Type> element is the child of either a <Namespace> element or another <Type> element, type_name can include 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.

Tutti gli altri attributiAll other attributes

ValoreValue DescrizioneDescription
policy_settingpolicy_setting L'impostazione da applicare a questo tipo di criteri.The setting to apply to this policy 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
<AttributeImplies><AttributeImplies> Se il tipo contenitore è un attributo, definisce i criteri di runtime per gli elementi del codice a cui è applicato l'attributo.If the containing type is an attribute, defines runtime policy for code elements to which the attribute is applied.
<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.
<GenericParameter><GenericParameter> Applica i criteri al tipo di parametro di un tipo generico.Applies policy to the parameter type of a generic type.
<ImpliesType><ImpliesType> Applica criteri a un tipo, se tale criterio è stato applicato al tipo rappresentato dall'oggetto contenente l'elemento <Type>.Applies policy to a type, if that policy has been applied to the type represented by the containing <Type> 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.
<Subtypes><Subtypes> Applica i criteri di runtime a tutte le classi ereditate per il tipo contenitore.Applies runtime policy to all classes inherited from the containing type.
<Type> Applica criteri di reflection un tipo annidato.Applies reflection policy to a nested type.
<TypeInstantiation><TypeInstantiation> Applica i criteri di reflection a un tipo generico costruito.Applies reflection policy to a 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> Applica i criteri di reflection a un tipo e a tutti i membri.Applies reflection policy to a type and all its members.
<TypeInstantiation><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. Se non è presente, l'elemento <Type> funge da contenitore i cui tipi figlio definiscono criteri per i singoli membri.If none are present, the <Type> element serves as a container whose child types define policy for individual members.

Se un elemento <Type> è figlio di un elemento <Assembly>, <Namespace>, <Type> o <TypeInstantiation>, sottopone a override le impostazioni dei criteri definite dall'elemento padre.If a <Type> element is the child of an <Assembly>, <Namespace>, <Type>, or <TypeInstantiation> element, it overrides the policy settings defined by the parent element.

Un elemento <Type> di un tipo generico applica i relativi criteri a tutte le istanze che non dispongono di propri criteri.A <Type> element of a generic type applies its policy to all instantiations that do not have their own policy. I criteri di tipi generici costruiti sono definiti dall'elemento <TypeInstantiation>.The policy of constructed generic types is defined by the <TypeInstantiation> element.

Se il tipo è un tipo generico, il nome è decorato da un simbolo di accento grave ( `) seguito dal relativo numero di parametri generici.If the type is a generic type, its name is decorated by a grave accent symbol (`) followed by its number of generic parameters. Ad esempio, l'attributo Name di un elemento <Type> per la classe System.Collections.Generic.List<T> viene visualizzato come Name="System.Collections.Generic.List1"`.For example, the Name attribute of a <Type> element for the System.Collections.Generic.List<T> class appears as Name="System.Collections.Generic.List1"`.

EsempioExample

Nell'esempio seguente viene usata la reflection per visualizzare le informazioni su campi, proprietà e metodi della classe System.Collections.Generic.List<T>.The following example uses reflection to display information about the fields, properties, and methods of the System.Collections.Generic.List<T> class. La variabile b nell'esempio è un controllo TextBlock.The variable b in the example is a TextBlock control. Poiché l'esempio recupera semplicemente le informazioni sul tipo, la disponibilità dei metadati è controllata dall'impostazione dei criteri Browse.Because the example simply retrieves type information, the availability of metadata is controlled by the Browse policy setting.

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 viene incluso automaticamente dalla catena di strumenti .NET Native.NET Native, l'esempio non riesce a visualizzare le informazioni sul membro richiesto in fase di esecuzione.Because metadata for the List<T> class isn't automatically included by the .NET Native.NET Native tool chain, the example fails to display the requested member information at run time. Per fornire i metadati necessari, aggiungere il seguente elemento <Type> al file di direttive di runtime.To provide the necessary metadata, add the following <Type> element to the runtime directives file. Da notare che dal momento che è stato fornito un elemento <Namespace> padre, non è necessario fornire un nome di tipo completo nell'elemento <Type>.Note that, because we've provided a parent <Namespace> element, we don't have to provide a fully qualified type name in the <Type> element.

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

EsempioExample

Nell'esempio seguente viene usata la reflection per recuperare un oggetto PropertyInfo che rappresenta la proprietà String.Chars[Int32].The following example uses reflection to retrieve a PropertyInfo object that represents the String.Chars[Int32] property. 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.It then uses the PropertyInfo.GetValue(Object, Object[]) method to retrieve the value of the seventh character in a string, and to display all the characters in the string. La variabile b nell'esempio è un controllo TextBlock.The variable b in the example is a TextBlock control.

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 .NET Native.NET Native.Because metadata for the String object isn't available, the call to the PropertyInfo.GetValue(Object, Object[]) method throws a NullReferenceException exception at run time when compiled with the .NET Native.NET Native tool chain. Per eliminare l'eccezione e fornire i metadati necessari, aggiungere il seguente elemento <Type> al file di direttive di runtime:To eliminate the exception and provide the necessary metadata, add the following <Type> element to the runtime directives file:

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

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