Riferimento a file di configurazione di direttive di runtime (rd.xml)Runtime Directives (rd.xml) Configuration File Reference

Un file di direttive di runtime (rd.xml) è un file di configurazione XML che specifica se gli elementi del programma designato sono disponibili per la reflection.A runtime directives (.rd.xml) file is an XML configuration file that specifies whether designated program elements are available for reflection. Ecco un esempio di un file di direttive di runtime:Here’s an example of a runtime directives file:

<Directives xmlns="http://schemas.microsoft.com/netfx/2013/01/metadata">  
<Application>  
  <Namespace Name="Contoso.Cloud.AppServices" Serialize="Required Public" />  
  <Namespace Name="ContosoClient.ViewModels" Serialize="Required Public" />  
  <Namespace Name="ContosoClient.DataModel" Serialize="Required Public" />  
  <Namespace Name="Contoso.Reader.UtilityLib" Serialize="Required Public" />  

  <Namespace Name="System.Collections.ObjectModel" >  
    <TypeInstantiation Name="ObservableCollection"   
          Arguments="ContosoClient.DataModel.ProductItem" Serialize="Public" />  
    <TypeInstantiation Name="ReadOnlyObservableCollection"   
          Arguments="ContosoClient.DataModel.ProductGroup" Serialize="Public" />  
  </Namespace>  
</Application>  
</Directives>  

La struttura di un file di direttive di runtimeThe structure of a runtime directives file

Il file di direttive di runtime usa lo spazio dei nomi http://schemas.microsoft.com/netfx/2013/01/metadata.The runtime directives file uses the http://schemas.microsoft.com/netfx/2013/01/metadata namespace.

L'elemento radice è l'elemento Directives.The root element is the Directives element. Può contenere zero o più elementi Library e zero o un elemento Application, come illustrato nella struttura seguente.It can contain zero or more Library elements, and zero or one Application element, as shown in the following structure. Gli attributi dell'elemento Application possono definire criteri di reflection di runtime a livello di applicazione oppure possono fungere da contenitore per gli elementi figlio.The attributes of the Application element can define application-wide runtime reflection policy, or it can serve as a container for child elements. L'elemento Library, invece, è semplicemente un contenitore.The Library element, on the other hand, is simply a container. Gli elementi figlio degli elementi Application e Library definiscono i tipi, i metodi, i campi, le proprietà e gli eventi disponibili per la reflection.The children of the Application and Library elements define the types, methods, fields, properties, and events that are available for reflection.

Per le informazioni di riferimento, scegliere gli elementi dalla struttura seguente o vedere Elementi direttiva di runtime.For reference information, choose elements from the following structure or see Runtime Directive Elements. Nella seguente gerarchia, i puntini di sospensione contrassegnano una struttura ricorsiva.In the following hierarchy, the ellipsis marks a recursive structure. Le informazioni tra parentesi quadre indicano se tale elemento è facoltativo oppure obbligatorio e, se viene usato, il numero di istanze consentito (una o molte).The information in brackets indicates whether that element is optional or required, and if it is used, how many instances (one or many) are allowed.

Directives [1:1]Directives [1:1]
Application [0:1]Application [0:1]
Assembly [0:M]Assembly [0:M]
Namespace [0:M]Namespace [0:M]
.. .. ..
Type [0:M]Type [0:M]
.. .. ..
TypeInstantiation (tipo generico costruito) [0:M]TypeInstantiation (constructed generic type) [0:M]
.. .. ..
Namespace [0:M]Namespace [0:M]
Namespace [0:M]Namespace [0:M]
.. .. ..
Type [0:M]Type [0:M]
.. .. ..
TypeInstantiation (tipo generico costruito) [0:M]TypeInstantiation (constructed generic type) [0:M]
.. .. ..
Type [0:M]Type [0:M]
Subtypes (sottoclassi del tipo contenitore) [O:1]Subtypes (subclasses of the containing type) [O:1]
Type [0:M]Type [0:M]
.. .. ..
TypeInstantiation (tipo generico costruito) [0:M]TypeInstantiation (constructed generic type) [0:M]
.. .. ..
AttributeImplies (il tipo contenitore è un attributo) [O:1]AttributeImplies (containing type is an attribute) [O:1]
GenericParameter [0:M]GenericParameter [0:M]
Method [0:M]Method [0:M]
Parameter [0:M]Parameter [0:M]
TypeParameter [0:M]TypeParameter [0:M]
GenericParameter [0:M]GenericParameter [0:M]
MethodInstantiation (metodo generico costruito) [0:M]MethodInstantiation (constructed generic method) [0:M]
Property [0:M]Property [0:M]
Field [0:M]Field [0:M]
Event [0:M]Event [0:M]
TypeInstantiation (tipo generico costruito) [0:M]TypeInstantiation (constructed generic type) [0:M]
Type [0:M]Type [0:M]
.. .. ..
TypeInstantiation (tipo generico costruito) [0:M]TypeInstantiation (constructed generic type) [0:M]
.. .. ..
Method [0:M]Method [0:M]
Parameter [0:M]Parameter [0:M]
TypeParameter [0:M]TypeParameter [0:M]
GenericParameter [0:M]GenericParameter [0:M]
MethodInstantiation (metodo generico costruito) [0:M]MethodInstantiation (constructed generic method) [0:M]
Property [0:M]Property [0:M]
Field [0:M]Field [0:M]
Event [0:M]Event [0:M]
Library [0:M]Library [0:M]
Assembly [0:M]Assembly [0:M]
Namespace [0:M]Namespace [0:M]
.. .. ..
Type [0:M]Type [0:M]
.. .. ..
TypeInstantiation (tipo generico costruito) [0:M]TypeInstantiation (constructed generic type) [0:M]
.. .. ..
Namespace [0:M]Namespace [0:M]
Namespace [0:M]Namespace [0:M]
.. .. ..
Type [0:M]Type [0:M]
.. .. ..
TypeInstantiation (tipo generico costruito) [0:M]TypeInstantiation (constructed generic type) [0:M]
.. .. ..
Type [0:M]Type [0:M]
Subtypes (sottoclassi del tipo contenitore) [O:1]Subtypes (subclasses of the containing type) [O:1]
Type [0:M]Type [0:M]
.. .. ..
TypeInstantiation (tipo generico costruito) [0:M]TypeInstantiation (constructed generic type) [0:M]
.. .. ..
AttributeImplies (il tipo contenitore è un attributo) [O:1]AttributeImplies (containing type is an attribute) [O:1]
GenericParameter [0:M]GenericParameter [0:M]
Method [0:M]Method [0:M]
MethodInstantiation (metodo generico costruito) [0:M]MethodInstantiation (constructed generic method) [0:M]
Property [0:M]Property [0:M]
Field [0:M]Field [0:M]
Event [0:M]Event [0:M]
TypeInstantiation (tipo generico costruito) [0:M]TypeInstantiation (constructed generic type) [0:M]
Type [0:M]Type [0:M]
.. .. ..
TypeInstantiation (tipo generico costruito) [0:M]TypeInstantiation (constructed generic type) [0:M]
.. .. ..
Method [0:M]Method [0:M]
MethodInstantiation (metodo generico costruito) [0:M]MethodInstantiation (constructed generic method) [0:M]
Property [0:M]Property [0:M]
Field [0:M]Field [0:M]
Event [0:M]Event [0:M]

L'elemento Application può non avere attributi oppure può avere gli attributi dei criteri descritti nella sezione Direttive e criteri di runtime.The Application element can have no attributes, or it can have the policy attributes discussed in the Runtime directive and policy section.

Un elemento Library ha un solo attributo, Name, che specifica il nome di una libreria o di un assembly, senza l'estensione del file.A Library element has a single attribute, Name, that specifies the name of a library or assembly, without its file extension. Ad esempio, l'elemento Library seguente si applica a un assembly denominato Extensions.dll.For example, the following Library element applies to an assembly named Extensions.dll.

<Directives xmlns="http://schemas.microsoft.com/netfx/2013/01/metadata">  
  <Application>  
     <!-- Child elements go here -->    
  </Application>  
  <Library Name="Extensions">  
     <!-- Child elements go here -->    
  </Library>  
</Directives>  

Direttive e criteri di runtimeRuntime directives and policy

L'elemento Application stesso e gli elementi figlio degli elementi Library e Application esprimono criteri, ovvero definiscono il modo in cui un'app può applicare la reflection a un elemento del programma.The Application element itself and the child elements of the Library and Application elements express policy; that is, they define the way in which an app can apply reflection to a program element. Il tipo di criterio è definito da un attributo dell'elemento (ad esempio, Serialize).The policy type is defined by an attribute of the element (for example, Serialize). Il valore di criterio è definito dal valore dell'attributo (ad esempio, Serialize="Required").The policy value is defined by the attribute’s value (for example, Serialize="Required").

Qualsiasi criterio specificato da un attributo di un elemento si applica a tutti gli elementi figlio che non specificano un valore per tale criterio.Any policy specified by an attribute of an element applies to all child elements that don’t specify a value for that policy. Ad esempio, se vengono specificati criteri da un elemento Type, tali criteri si applicano a tutti i tipi e membri contenuti per i quali non sono stati esplicitamente specificati i criteri.For example, if a policy is specified by a Type element, that policy applies to all contained types and members for which a policy is not explicitly specified.

I criteri che possono essere espressi dagli elementi Application, Assembly, AttributeImplies, Namespace, Subtypes e Type differiscono da quelli che possono essere espressi per i singoli membri (dagli elementi Method, Property, Field ed Event).The policy that can be expressed by the Application, Assembly, AttributeImplies, Namespace, Subtypes, and Type elements differs from the policy that can be expressed for individual members (by the Method, Property, Field, and Event elements).

Specifica di criteri per assembly, spazi dei nomi e tipiSpecifying policy for assemblies, namespaces, and types

Gli elementi Application, Assembly, AttributeImplies, Namespace, Subtypes e Type supportano i tipi di criteri seguenti:The Application, Assembly, AttributeImplies, Namespace, Subtypes, and Type elements support the following policy types:

  • Activate.Activate. 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.Browse. 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.Dynamic. 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.Serialize. Controlla l'accesso in fase di esecuzione ai costruttori, ai campi e alle proprietà per abilitare la serializzazione e la deserializzazione delle istanze del tipo da parte di librerie di terze parti, ad esempio il serializzatore JSON di Newtonsoft.Controls runtime access to constructors, fields, and properties, to enable type instances to be serialized and serialized by third-party libraries such as the Newtonsoft JSON serializer.

  • DataContractSerializer.DataContractSerializer. 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.DataContractJsonSerializer. Controlla i criteri per la serializzazione JSON che usano la classe System.Runtime.Serialization.DataContractSerializer.Controls policy for JSON serialization that uses the System.Runtime.Serialization.DataContractSerializer class.

  • XmlSerializer.XmlSerializer. 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.MarshalObject. Criteri di controlli per effettuare il marshalling dei tipi di riferimento per WinRT e COM.Controls policy for marshaling reference types to WinRT and COM.

  • MarshalDelegate.MarshalDelegate. 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 .MarshalStructure . Controlla i criteri per il marshalling delle strutture al codice nativo.Controls policy for marshaling structures to native code.

Le impostazioni associate a questi tipi di criteri sono:The settings associated with these policy types are:

  • All.All. Attivare il criterio per tutti i tipi e membri che la catena di strumenti non riesce a rimuovere.Enable the policy for all types and members that the tool chain does not remove.

  • Auto.Auto. Usare il comportamento predefinitoUse the default behavior. (non specificare un criterio è equivalente a impostare tale criterio su Auto a meno che tale criterio sia sottoposto a override, ad esempio da un elemento padre).(Not specifying a policy is equivalent to setting that policy to Auto unless that policy is overridden, for example by a parent element.)

  • Excluded.Excluded. Disattivare il criterio per l'elemento di programma.Disable the policy for the program element.

  • Public.Public. Attivare i criteri per i tipi o i membri pubblici, a meno che la catena di strumenti non determini che il tipo o il membro non è necessario e lo rimuovaEnable the policy for public types or members unless the tool chain determines that the member is unnecessary and therefore removes it. (in quest'ultimo caso, è necessario usare Required Public per garantire che il membro venga mantenuto e abbia funzionalità di reflection.)(In the latter case, you must use Required Public to ensure that the member is kept and has reflection capabilities.)

  • PublicAndInternal.PublicAndInternal. Attivare il criterio per i tipi o membri pubblici e interni se la catena di strumenti non li rimuove.Enable the policy for public and internal types or members if the tool chain doesn't remove them.

  • Required Public.Required Public. Richiedere che la catena di strumenti mantenga i tipi e i membri pubblici, indipendentemente dal fatto che vengano usati o no, e attivare i relativi criteri.Require the tool chain to keep public types and members whether or not they are used, and enable the policy for them.

  • Required PublicAndInternal.Required PublicAndInternal. Richiedere che la catena di strumenti mantenga i tipi e i membri pubblici e interni, indipendentemente dal fatto che vengano usati o no, e attivare i relativi criteri.Require the tool chain to keep both public and internal types and members whether or not they are used, and enable the policy for them.

  • Required All.Required All. Richiedere che la catena di strumenti mantenga tutti i tipi e i membri, indipendentemente dal fatto che vengano usati o no, e attivare i relativi criteri.Require the tool chain to keep all types and members whether or not they are used, and enable the policy for them.

Il seguente file di direttive di runtime, ad esempio, definisce i criteri per tutti i tipi e membri nell'assembly DataClasses.dll.For example, the following runtime directives file defines policy for all types and members in the assembly DataClasses.dll. Consente la reflection per la serializzazione di tutte le proprietà pubbliche, consente di cercare tutti i tipi e membri del tipo, consente l'attivazione per tutti i tipi (a causa dell'attributo Dynamic) e abilita la reflection per tutti i tipi e membri pubblici.It enables reflection for serialization of all public properties, enables browsing for all types and type members, enables activation for all types (because of the Dynamic attribute), and enables reflection for all public types and members.

<Directives xmlns="http://schemas.microsoft.com/netfx/2013/01/metadata">  
   <Application>  
      <Assembly Name="DataClasses" Serialize="Required Public"   
                Browse="All" Activate="PublicAndInternal"   
                Dynamic="Public"  />  
   </Application>  
   <Library Name="UtilityLibrary">  
     <!-- Child elements go here -->    
   </Library>  
</Directives>  

Specifica di criteri per i membriSpecifying policy for members

Gli elementi Property e Field supportano i tipi di criteri seguenti:The Property and Field elements support the following policy types:

  • Browse: controlla le query per le informazioni su questo membro, ma non abilita l'accesso in fase di esecuzione.Browse - Controls querying for information about this member but does not enable any runtime access.

  • Dynamic: 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.Dynamic - Controls runtime access to all type members, including constructors, methods, fields, properties, and events, to enable dynamic programming. Controlla anche la ricerca di informazioni sul tipo contenitore.Also controls querying for information about the containing type.

  • Serialize: controlla l'accesso in fase di esecuzione al membro per abilitare istanze di tipi da serializzare e deserializzare da parte di librerie quali il serializzatore JSON di Newtonsoft.Serialize - Controls runtime access to the member to enable type instances to be serialized and deserialized by libraries such as the Newtonsoft JSON serializer. Questi criteri possono essere applicati a costruttori, campi e proprietà.This policy can be applied to constructors, fields, and properties.

Gli elementi Method ed Event supportano i tipi di criteri seguenti:The Method and Event elements support the following policy types:

  • Browse: controlla le query per le informazioni su questo membro, ma non abilita l'accesso in fase di esecuzione.Browse - Controls querying for information about this member but doesn’t enable any runtime access.

  • Dynamic: 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.Dynamic - Controls runtime access to all type members, including constructors, methods, fields, properties, and events, to enable dynamic programming. Controlla anche la ricerca di informazioni sul tipo contenitore.Also controls querying for information about the containing type.

Le impostazioni associate a questi tipi di criteri sono:The settings associated with these policy types are:

  • Auto: usare il comportamento predefinitoAuto - Use the default behavior. (non specificare un criterio equivale a impostare tale criterio su Auto a meno che un elemento esegua l'override).(Not specifying a policy is equivalent to setting that policy to Auto unless something overrides it.)

  • Excluded: non includere mai i metadati per il membro.Excluded - Never include metadata for the member.

  • Included: abilitare il criterio se il tipo padre è presente nell'output.Included - Enable the policy if the parent type is present in the output.

  • Required: richiedere che la catena di strumenti conservi questo membro anche se sembra non essere in uso e abilitare i relativi criteri.Required - Require the tool chain to keep this member even if appears to be unused, and enable policy for it.

Semantica dei file di runtime direttiveRuntime directives file semantics

È possibile definire criteri contemporaneamente per gli elementi di livello più alto e più basso.Policy can be defined simultaneously for both higher-level and lower-level elements. Ad esempio, è possibile definire dei criteri per un assembly e per alcuni dei tipi di contenuti in tale assembly.For example, policy can be defined for an assembly, and for some of the types contained in that assembly. Se non è rappresentato un particolare elemento di livello inferiore, esso eredita i criteri del padre.If a particular lower-level element is not represented, it inherits the policy of its parent. Ad esempio, se è presente un elemento Assembly, ma gli elementi Type sono assenti, il criterio specificato nell'elemento Assembly viene applicato a ciascun tipo nell'assembly.For example, if an Assembly element is present but Type elements are not, the policy specified in the Assembly element applies to each type in the assembly. Più elementi possono anche applicare criteri allo stesso elemento di programma.Multiple elements can also apply policy to the same program element. Ad esempio, elementi Assembly separati potrebbero definire lo stesso elemento di criteri per lo stesso assembly in modo diverso.For example, separate Assembly elements might define the same policy element for the same assembly differently. Le sezioni seguenti spiegano come risolvere il criterio per un determinato tipo in questi casi.The following sections explain how the policy for a particular type is resolved in those cases.

Un elemento Type o Method di un tipo o un metodo generico applica i relativi criteri a tutte le istanze che non hanno criteri propri.A Type or Method element of a generic type or method applies its policy to all instantiations that do not have their own policy. Ad esempio, un elemento Type che specifica i criteri per List<T> si applica a tutte le istanze costruite di tale tipo generico, a meno che non venga eseguito l'override per un particolare tipo generico costruito (come List<Int32>) da un elemento TypeInstantiation.For example, a Type element that specifies policy for List<T> applies to all constructed instances of that generic type, unless it's overridden for a particular constructed generic type (such as a List<Int32>) by a TypeInstantiation element. In caso contrario, gli elementi definiscono i criteri per l'elemento di programma denominato.Otherwise, elements define policy for the program element named.

Quando un elemento è ambiguo, il motore ricerca corrispondenze e, se ne trova di esatte, le usa.When an element is ambiguous, the engine looks for matches, and if it finds an exact match, it will use it. Se trova più corrispondenze, si riceverà un avviso o un errore.If it finds multiple matches, there will be a warning or error.

Se due direttive applicano criteri allo stesso elemento di programmaIf two directives apply policy to the same program element

Se due elementi in diversi file di direttive di runtime provano a impostare lo stesso tipo di criteri per lo stesso elemento di programma (ad esempio un tipo o assembly) su valori diversi, il conflitto viene risolto come segue:If two elements in different runtime directives files try to set the same policy type for the same program element (such as an assembly or type) to different values, the conflict is resolved as follows:

  1. Se l'elemento Excluded è presente, ha la precedenza.If the Excluded element is present, it has precedence.

  2. Required ha la precedenza su non Required.Required has precedence over not Required.

  3. All ha la precedenza su PublicAndInternal, che a sua volta ha la precedenza su Public.All has precedence over PublicAndInternal, which has precedence over Public.

  4. Qualsiasi impostazione esplicita ha la precedenza su Auto.Any explicit setting has precedence over Auto.

Ad esempio, se un singolo progetto include i due file di direttive di runtime seguenti, i criteri di serializzazione per DataClasses.dll vengono impostati su Required Public e All.For example, if a single project includes the following two runtime directives files, the serialization policy for DataClasses.dll is set to both Required Public and All. In questo caso, il criterio di serializzazione sarebbe risolto come Required All.In this case, the serialization policy would be resolved as Required All.

<Directives xmlns="http://schemas.microsoft.com/netfx/2013/01/metadata">  
   <Application>  
      <Assembly Name="DataClasses" Serialize="Required Public"/>  
   </Application>  
   <Library Name="DataClasses">  
      <!-- any other elements -->  
   </Library>  
</Directives>  
<Directives xmlns="http://schemas.microsoft.com/netfx/2013/01/metadata">  
   <Application>  
      <Assembly Name="DataClasses" Serialize="All" />  
   </Application>  
   <Library Name="DataClasses">  
      <!-- any other elements -->  
   </Library>  
</Directives>  

Tuttavia, se due direttive in un unico file di direttive di runtime prova a impostare lo stesso tipo di criteri per l'elemento del programma stesso, lo strumento di definizione di schema XML visualizza un messaggio di errore.However, if two directives in a single runtime directives file try to set the same policy type for the same program element, the XML Scheme Definition tool displays an error message.

Se gli elementi figlio e padre applicano lo stesso tipo di criteriIf child and parent elements apply the same policy type

Gli elementi figlio eseguono l'override dei relativi elementi padre, inclusa l'impostazione Excluded.Child elements override their parent elements, including the Excluded setting. L'override è il motivo principale per cui è preferibile specificare Auto.Overriding is the main reason you would want to specify Auto.

Nell'esempio seguente, l'impostazione dei criteri di serializzazione per tutto quanto presente in DataClasses ma assente in DataClasses.ViewModels corrisponderebbe a Required Public, e tutto quanto presente sia in DataClasses sia in DataClasses.ViewModels corrisponderebbe a All.In the following example, the serialization policy setting for everything in DataClasses that’s not in DataClasses.ViewModels would be Required Public, and everything that's in both DataClasses and DataClasses.ViewModels would be All.

<Directives xmlns="http://schemas.microsoft.com/netfx/2013/01/metadata">  
   <Application>  
      <Assembly Name="DataClasses" Serialize="Required Public" >  
         <Namespace Name="DataClasses.ViewModels" Seralize="All" />  
      </Assembly>  
   </Appliction>  
   <Library Name="DataClasses">  
      <!-- any other elements -->  
   </Library>  
</Directives>  

Se i generics aperti e gli elementi di un'istanza applicano lo stesso tipo di criteriIf open generics and instantiated elements apply the same policy type

Nell'esempio seguente, a Dictionary<int,int> viene assegnato il criterio Browse solo se il motore ha un motivo differente per assegnare il criterio Browse (che altrimenti sarebbe il comportamento predefinito). Per qualsiasi altra istanza di Dictionary<TKey,TValue> sarà possibile esplorare tutti i membri.In the following example, Dictionary<int,int> is assigned the Browse policy only if the engine has another reason to give it the Browse policy (which would otherwise be the default behavior); every other instantiation of Dictionary<TKey,TValue> will have all of its members browsable.

<Directives xmlns="http://schemas.microsoft.com/netfx/2013/01/metadata">  
   <Application>  
      <Assembly Name="DataClasses" Serialize="Required Public" >  
         <Namespace Name="DataClasses.ViewModels" Seralize="All" />  
      </Assembly>  
      <Namespace Name="DataClasses.Generics" />  
      <Type Name="Dictionary" Browse="All" />  
      <TypeInstantiation Name="Dictionary"   
                         Arguments="System.Int32,System.Int32" Browse="Auto" />  
   </Application>  
   <Library Name="DataClasses">  
      <!-- any other elements -->  
   </Library>  
</Directives>  

Come vengono dedotti i criteriHow policy is inferred

Ogni tipo di criteri ha un diverso insieme di regole che determinano in che modo la presenza di tale tipo di criterio ha effetto su altri costrutti.Each policy type has a different set of rules that determine how the presence of that policy type affects other constructs.

Effetto del criterio BrowseThe effect of Browse policy

L'applicazione del criterio Browse a un tipo implica le seguenti modifiche:Applying the Browse policy to a type involves the following policy changes:

  • Il tipo di base del tipo viene contrassegnato con il criterio Browse.The base type of the type is marked with the Browse policy.

  • Se il tipo è un generico istanziato, la versione priva di istanze del tipo è contrassegnata con il criterio Browse.If the type is an instantiated generic, the uninstantiated version of the type is marked with the Browse policy.

  • Se il tipo è un delegato, il metodo Invoke del tipo è contrassegnato con il criterio Dynamic.If the type is a delegate, the Invoke method on the type is marked with the Dynamic policy.

  • Ciascuna interfaccia del tipo viene contrassegnata con il criterio Browse.Each interface of the type is marked with the Browse policy.

  • Il tipo di ciascun attributo applicato al tipo è contrassegnato con il criterio Browse.The type of each attribute applied to the type is marked with the Browse policy.

  • Se il tipo è generico, ogni tipo di vincolo è contrassegnato con il criterio Browse.If the type is generic, each constraint type is marked with the Browse policy.

  • Se il tipo è generico, i tipi su cui viene creata un'istanza del tipo sono contrassegnati con il criterio Browse.If the type is generic, the types over which the type is instantiated are marked with the Browse policy.

L'applicazione del criterio Browse a un metodo implica le seguenti modifiche:Applying the Browse policy to a method involves the following policy changes:

  • Ogni tipo di parametro del metodo è contrassegnato con il criterio Browse.Each parameter type of the method is marked with the Browse policy.

  • Il tipo restituito del metodo è contrassegnato con il criterio Browse.The return type of the method is marked with the Browse policy.

  • Il tipo contenitore del metodo è contrassegnato con il criterio Browse.The containing type of the method is marked with the Browse policy.

  • Se il metodo è un metodo generico istanziato, il metodo generico privo di istanze è contrassegnato con il criterio Browse.If the method is an instantiated generic method, the uninstantiated generic method is marked with the Browse policy.

  • Il tipo di ciascun attributo applicato al metodo è contrassegnato con il criterio Browse.The type of each attribute applied to the method is marked with the Browse policy.

  • Se il metodo è generico, ogni tipo di vincolo è contrassegnato con il criterio Browse.If the method is generic, each constraint type is marked with the Browse policy.

  • Se il metodo è generico, i tipi su cui viene creata un'istanza del metodo sono contrassegnati con il criterio Browse.If the method is generic, the types over which the method is instantiated are marked with the Browse policy.

L'applicazione del criterio Browse a un campo implica le seguenti modifiche:Applying the Browse policy to a field involves the following policy changes:

  • Il tipo di ciascun attributo applicato al campo è contrassegnato con il criterio Browse.The type of each attribute applied to the field is marked with the Browse policy.

  • Il tipo del campo viene contrassegnato con il criterio Browse.The type of the field is marked with the Browse policy.

  • Il tipo al quale appartiene il campo viene contrassegnato con il criterio Browse.The type to which the field belongs is marked with the Browse policy.

Effetto dei criteri DynamicThe effect of Dynamic policy

L'applicazione del criterio Dynamic a un tipo implica le seguenti modifiche:Applying the Dynamic policy to a type involves the following policy changes:

  • Il tipo di base del tipo viene contrassegnato con il criterio Dynamic.The base type of the type is marked with the Dynamic policy.

  • Se il tipo è un generico istanziato, la versione priva di istanze del tipo è contrassegnata con il criterio Dynamic.If the type is an instantiated generic, the uninstantiated version of the type is marked with the Dynamic policy.

  • Se il tipo è un delegato, il metodo Invoke del tipo è contrassegnato con il criterio Dynamic.If the type is a delegate type, the Invoke method on the type is marked with the Dynamic policy.

  • Ciascuna interfaccia del tipo viene contrassegnata con il criterio Browse.Each interface of the type is marked with the Browse policy.

  • Il tipo di ciascun attributo applicato al tipo è contrassegnato con il criterio Browse.The type of each attribute applied to the type is marked with the Browse policy.

  • Se il tipo è generico, ogni tipo di vincolo è contrassegnato con il criterio Browse.If the type is generic, each constraint type is marked with the Browse policy.

  • Se il tipo è generico, i tipi su cui viene creata un'istanza del tipo sono contrassegnati con il criterio Browse.If the type is generic, the types over which the type is instantiated are marked with the Browse policy.

L'applicazione del criterio Dynamic a un metodo implica le seguenti modifiche:Applying the Dynamic policy to a method involves the following policy changes:

  • Ogni tipo di parametro del metodo è contrassegnato con il criterio Browse.Each parameter type of the method is marked with the Browse policy.

  • Il tipo restituito del metodo è contrassegnato con il criterio Dynamic.The return type of the method is marked with the Dynamic policy.

  • Il tipo contenitore del metodo è contrassegnato con il criterio Dynamic.The containing type of the method is marked with the Dynamic policy.

  • Se il metodo è un metodo generico istanziato, il metodo generico privo di istanze è contrassegnato con il criterio Browse.If the method is an instantiated generic method, the uninstantiated generic method is marked with the Browse policy.

  • Il tipo di ciascun attributo applicato al metodo è contrassegnato con il criterio Browse.The type of each attribute applied to the method is marked with the Browse policy.

  • Se il metodo è generico, ogni tipo di vincolo è contrassegnato con il criterio Browse.If the method is generic, each constraint type is marked with the Browse policy.

  • Se il metodo è generico, i tipi su cui viene creata un'istanza del metodo sono contrassegnati con il criterio Browse.If the method is generic, the types over which the method is instantiated are marked with the Browse policy.

  • Il metodo può essere richiamato da MethodInfo.Invoke e la creazione del delegato è resa possibile da MethodInfo.CreateDelegate.The method can be invoked by MethodInfo.Invoke, and delegate creation becomes possible by MethodInfo.CreateDelegate.

L'applicazione del criterio Dynamic a un campo implica le seguenti modifiche:Applying the Dynamic policy to a field involves the following policy changes:

  • Il tipo di ciascun attributo applicato al campo è contrassegnato con il criterio Browse.The type of each attribute applied to the field is marked with the Browse policy.

  • Il tipo del campo viene contrassegnato con il criterio Dynamic.The type of the field is marked with the Dynamic policy.

  • Il tipo al quale appartiene il campo viene contrassegnato con il criterio Dynamic.The type to which the field belongs is marked with the Dynamic policy.

Effetto del criterio ActivationThe effect of Activation policy

L'applicazione del criterio Activation a un tipo implica le seguenti modifiche:Applying the Activation policy to a type involves the following policy changes:

  • Se il tipo è un generico istanziato, la versione priva di istanze del tipo è contrassegnata con il criterio Browse.If the type is an instantiated generic, the uninstantiated version of the type is marked with the Browse policy.

  • Se il tipo è un delegato, il metodo Invoke del tipo è contrassegnato con il criterio Dynamic.If the type is a delegate type, the Invoke method on the type is marked with the Dynamic policy.

  • I costruttori del tipo vengono contrassegnati con il criterio Activation.Constructors of the type are marked with the Activation policy.

L'applicazione del criterio Activation a un metodo implica le seguenti modifiche:Applying the Activation policy to a method involves the following policy change:

L'applicazione del criterio Activation a un campo non ha alcun effetto.Applying the Activation policy to a field has no effect.

Effetto del criterio SerializeThe effect of Serialize policy

Il criterio Serialize consente l'utilizzo dei serializzatori basati su reflection più comuni.The Serialize policy enables the use of common reflection-based serializers. Tuttavia, poiché gli schemi di accesso alla reflection esatti dei serializzatori non Microsoft non sono noti a Microsoft, questo criterio potrebbe non essere completamente efficace.However, because the exact reflection access patterns of non-Microsoft serializers are not known to Microsoft, this policy may not be entirely effective.

L'applicazione del criterio Serialize a un tipo implica le seguenti modifiche:Applying the Serialize policy to a type involves the following policy changes:

  • Il tipo di base del tipo viene contrassegnato con il criterio Serialize.The base type of the type is marked with the Serialize policy.

  • Se il tipo è un generico istanziato, la versione priva di istanze del tipo è contrassegnata con il criterio Browse.If the type is an instantiated generic, the uninstantiated version of the type is marked with the Browse policy.

  • Se il tipo è un delegato, il metodo Invoke del tipo è contrassegnato con il criterio Dynamic.If the type is a delegate type, the Invoke method on the type is marked with the Dynamic policy.

  • Se il tipo è un'enumerazione, una matrice del tipo è contrassegnata con il criterio Serialize.If the type is an enumeration, an array of the type is marked with the Serialize policy.

  • Se il tipo implementa IEnumerable<T>, T viene contrassegnato con il criterio Serialize.If the type implements IEnumerable<T>, T is marked with the Serialize policy.

  • Se il tipo è IEnumerable<T>, IList<T>, ICollection<T>, IReadOnlyCollection<T> o IReadOnlyList<T>, T[] e List<T> vengono contrassegnati con il criterio Serialize, ma nessuno membro del tipo di interfaccia viene contrassegnato con il criterio Serialize.If the type is IEnumerable<T>, IList<T>, ICollection<T>, IReadOnlyCollection<T>, or IReadOnlyList<T>, then T[] and List<T> marked with the Serialize policy., but no members of the interface type are marked with the Serialize policy.

  • Se il tipo è List<T>, nessun membro del tipo viene contrassegnato con il criterio Serialize.If the type is List<T>, no members of the type are marked with the Serialize policy.

  • Se il tipo è IDictionary<TKey,TValue>, Dictionary<TKey,TValue> viene contrassegnato con il criterio Serialize,If the type is IDictionary<TKey,TValue>, Dictionary<TKey,TValue> is marked with the Serialize policy. ma nessun membro del tipo viene contrassegnato con il criterio Serialize.but no members of the type are marked with the Serialize policy.

  • Se il tipo è Dictionary<TKey,TValue>, nessun membro del tipo viene contrassegnato con il criterio Serialize.If the type is Dictionary<TKey,TValue>, no members of the type are marked with the Serialize policy.

  • Se il tipo implementa IDictionary<TKey,TValue>, TKey e TValue vengono contrassegnati con il criterio Serialize.If the type implements IDictionary<TKey,TValue>, TKey and TValue are marked with the Serialize policy.

  • Ogni costruttore, ogni funzione di accesso della proprietà e ogni campo è contrassegnato con il criterio Serialize.Each constructor, each property accessor, and each field is marked with the Serialize policy.

L'applicazione del criterio Serialize a un metodo implica le seguenti modifiche:Applying the Serialize policy to a method involves the following policy changes:

  • Il tipo contenitore è contrassegnato con il criterio Serialize.The containing type is marked with the Serialize policy.

  • Il tipo restituito del metodo è contrassegnato con il criterio Serialize.The return type of the method is marked with the Serialize policy.

L'applicazione del criterio Serialize a un campo implica le seguenti modifiche:Applying the Serialize policy to a field involves the following policy changes:

  • Il tipo contenitore è contrassegnato con il criterio Serialize.The containing type is marked with the Serialize policy.

  • Il tipo del campo viene contrassegnato con il criterio Serialize.The type of the field is marked with the Serialize policy.

Effetto dei criteri XmlSerializer, DataContractSerializer e DataContractJsonSerialierThe effect of XmlSerializer, DataContractSerializer, and DataContractJsonSerialier policies

A differenza del criterio Serialize, destinato ai serializzatori basati sulla reflection, i criteri XmlSerializer, DataContractSerializer e DataContractJsonSerializer sono usati per abilitare un set di serializzatori noti alla catena di strumenti .NET Native.NET Native.Unlike the Serialize policy, which is intended for reflection-based serializers, the XmlSerializer, DataContractSerializer, and DataContractJsonSerializer policies are used to enable a set of serializers that are known to the .NET Native.NET Native tool chain. Questi serializzatori non vengono implementati tramite reflection, ma l'insieme di tipi che possono essere serializzati in fase di esecuzione è determinato in modo simile come tipi soggetti a reflection.These serializers are not implemented by using reflection, but the set of types that can be serialized at run time is determined in a similar manner as types that are reflectable.

L'applicazione di uno di questi criteri a un tipo consente di serializzare il tipo con il serializzatore corrispondente.Applying one of these policies to a type enables the type to be serialized with the matching serializer. Inoltre, eventuali tipi che il motore di serializzazione determina come serializzabili saranno indicati come tali.Also, any types that the serialization engine can statically determine as needing serialization will also be serializable.

Questi criteri non hanno alcun effetto sui metodi o campi.These policies have no effect on methods or fields.

Per altre informazioni, vedere la sezione relativa alle differenze nei serializzatori in Migrating Your Windows Store App to .NET Native (Migrazione dell'app di Windows Store a .NET Native).For more information, see the "Differences in Serializers" section in Migrating Your Windows Store App to .NET Native.

Vedere ancheSee Also

Elementi direttiva di runtimeRuntime Directive Elements
Reflection e .NET NativeReflection and .NET Native