Partilhar via

<Elemento TypeInstantiation> (.NET Native)

  • Artigo

Aplica a política de reflexão de runtime a um tipo genérico construído.

Syntax

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

Atributos e elementos

As seções a seguir descrevem atributos, elementos filho e elementos pai.

Atributos

Atributo Tipo de atributo Descrição
Name Geral Atributo obrigatório. Especifica o nome do tipo.
Arguments Geral Atributo obrigatório. Especifica os argumentos de tipo genérico. Se houver vários parâmetros, eles são separados por vírgulas.
Activate Reflexão Atributo opcional. Controla o acesso de runtime a construtores para habilitar a ativação de instâncias.
Browse Reflexão Atributo opcional. Controla a consulta para obter informações sobre elementos do programa, mas não permite qualquer acesso de runtime.
Dynamic Reflexão Atributo opcional. Controla o acesso a todos os tipos de membro ao runtime, incluindo construtores, métodos, campos, propriedades e eventos, habilitando a programação dinâmica.
Serialize Serialização Atributo opcional. Controla o acesso ao runtime para construtores, campos e propriedades para habilitar a serialização e desserialização das instâncias por bibliotecas como o serializador Newtonsoft JSON.
DataContractSerializer Serialização Atributo opcional. Controla a política de serialização que usa a classe System.Runtime.Serialization.DataContractSerializer.
DataContractJsonSerializer Serialização Atributo opcional. Controla a política de serialização JSON que usa a classe System.Runtime.Serialization.Json.DataContractJsonSerializer.
XmlSerializer Serialização Atributo opcional. Controla a política de serialização XML que usa a classe System.Xml.Serialization.XmlSerializer.
MarshalObject Interoperabilidade Atributo opcional. Política de controles de marshaling de tipos de referência para o Windows Runtime e COM.
MarshalDelegate Interoperabilidade Atributo opcional. Controla a diretiva de marshaling de tipos delegados como ponteiros de função para código nativo.
MarshalStructure Interoperabilidade Atributo opcional. Controla a política de estruturas de marshaling para código nativo.

Atributo de nome

Valor Descrição
type_name O nome do tipo. Se esse <TypeInstantiation> elemento for o filho de um <elemento Namespace> , um <elemento Type> ou outro <TypeInstantiation> elemento, type_name poderá especificar o nome do tipo sem seu namespace. Caso contrário, o type_name deverá incluir o nome do tipo totalmente qualificado. O nome do tipo não decorado. Por exemplo, para um objeto System.Collections.Generic.List<T>, o elemento <TypeInstantiation> poderá aparecer da seguinte maneira:

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

Atributo de argumentos

Valor Descrição
type_argument Especifica os argumentos de tipo genérico. Se houver vários parâmetros, eles são separados por vírgulas. Cada argumento deve conter o nome do tipo totalmente qualificado.

Todos os outros atributos

Valor Descrição
policy_setting A configuração a ser aplicada a este tipo de política para o tipo genérico construído. Os valores possíveis são All, Auto, Excluded, Public, PublicAndInternal, Required Public, Required PublicAndInternal e Required All. Para obter mais informações, consulte Configurações da política da diretiva de runtime.

Elementos filho

Elemento Descrição
<Evento> Aplica a política de reflexão a um evento pertencente a esse tipo.
<Campo> Aplica a política de reflexão a um campo pertencente a esse tipo.
<ImpliesType> Aplica a política a um tipo, se esta política tiver sido aplicada ao tipo representado pelo elemento <TypeInstantiation> recipiente.
<Método> Aplica a política de reflexão a um método pertencente a esse tipo.
<MethodInstantiation> Aplica a política de reflexão a um método construído genérico pertencente a esse tipo.
<Propriedade> Aplica a política de reflexão a uma propriedade pertencente a esse tipo.
<Type> Aplica a política de reflexão a um tipo aninhado.
<TypeInstantiation> Aplica a política de reflexão a um tipo genérico construído aninhado.

Elementos pai

Elemento Descrição
<Aplicativo> Serve como um contêiner para os tipos amplos de aplicativos cujos metadados estão disponíveis para reflexão no tempo de execução.
<Assembly> Aplica a política de reflexão para todos os tipos em um assembly especificado.
<Biblioteca> Define o assembly que contém tipos e membros de tipo cujos metadados estão disponíveis para reflexão em tempo de execução.
<Namespace> Aplica a política de reflexão a todos os tipos em um namespace.
<Type> Aplica a política de reflexão a um tipo e todos os seus membros.
<TypeInstantiation> Aplica a política de reflexão a um tipo genérico construído e todos os seus membros.

Comentários

Os atributos de reflexão, serialização e interoperabilidade são todos opcionais. No entanto, pelo menos um deve estar presente.

Se um <TypeInstantiation> elemento for filho de um <elemento Assembly>, <Namespace> ou <Type>, ele substituirá as configurações de política definidas pelo elemento pai. Se um <elemento Type> definir uma definição de tipo genérico correspondente, o elemento substituirá a <TypeInstantiation> política de reflexão de runtime somente para instanciações do tipo genérico construído especificado.

Exemplo

O exemplo a seguir usa uma reflexão para recuperar a definição de tipo genérico de um objeto Dictionary<TKey,TValue> construído. Ele também usa reflexão para exibir informações sobre objetos Type que representam tipos genéricos construídos e definições de tipo genérico. A variável b no exemplo é um TextBlock controle .

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

Após a compilação com a cadeia de ferramentas .NET Native, o exemplo gera uma exceção MissingMetadataException na linha que chama o Type.GetGenericTypeDefinition método . Para eliminar a exceção e fornecer os metadados necessários, adicione o seguinte elemento <TypeInstantiation> ao arquivo de diretivas de 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>

Confira também