Freigeben über

<TypeInstantiation-Element (.NET Native)>

  • Artikel

Wendet eine Laufzeitreflektionsrichtlinie auf einen konstruierten generischen Typ an.

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

Attribute und Elemente

In den folgenden Abschnitten werden Attribute sowie untergeordnete und übergeordnete Elemente beschrieben.

Attribute

Attribut Attributtyp Beschreibung
Name Allgemein Erforderliches Attribut. Gibt den Namen des Typs an
Arguments Allgemein Erforderliches Attribut. Gibt die generischen Typargumente an. Wenn mehrere Argumente vorhanden sind, werden sie durch Kommas getrennt.
Activate Reflexion Optionales Attribut. Steuert den Laufzeitzugriff auf Konstruktoren, um die Aktivierung von Instanzen zu ermöglichen.
Browse Reflexion Optionales Attribut. Steuert das Abfragen von Informationen über Programmelemente, ermöglicht jedoch keinen Laufzeitzugriff.
Dynamic Reflexion Optionales Attribut. Steuert den Laufzeitzugriff auf alle Typmember, einschließlich Konstruktoren, Methoden, Felder, Eigenschaften und Ereignisse, um die dynamische Programmierung zu ermöglichen.
Serialize Serialisierung Optionales Attribut. Steuert den Laufzeitzugriff auf Konstruktoren, Felder und Eigenschaften, um Serialisierung und Deserialisierung von Typinstanzen durch Bibliotheken wie das Newtonsoft JSON-Serialisierungsprogramm zu ermöglichen.
DataContractSerializer Serialisierung Optionales Attribut. Steuert die Richtlinie für die Serialisierung, die die System.Runtime.Serialization.DataContractSerializer-Klasse verwendet.
DataContractJsonSerializer Serialisierung Optionales Attribut. Steuert die Richtlinie für die JSON-Serialisierung, die die System.Runtime.Serialization.Json.DataContractJsonSerializer-Klasse verwendet.
XmlSerializer Serialisierung Optionales Attribut. Steuert die Richtlinie für die XML-Serialisierung, die die System.Xml.Serialization.XmlSerializer-Klasse verwendet.
MarshalObject Interop Optionales Attribut. Steuert die Richtlinie für das Marshalling von Verweistypen zu Windows-Runtime und COM.
MarshalDelegate Interop Optionales Attribut. Steuert die Richtlinie für das Marshalling von Delegattypen als Funktionszeiger zu systemeigenem Code.
MarshalStructure Interop Optionales Attribut. Steuert die Richtlinie für das Marshalling von Strukturen zu nativem Code.

Namensattribut

Wert Beschreibung
type_name Der Typname. Wenn dieses <TypeInstantiation> Element das untergeordnete Element eines <Namespace-Elements> , eines <Type-Elements> oder eines anderen <TypeInstantiation> Elements ist, kann type_name den Namen des Typs ohne den Namespace angeben. Andernfalls muss type_name den vollqualifizierten Typnamen enthalten. Der Typname wird nicht ergänzt. Für ein System.Collections.Generic.List<T>-Objekt könnte das <TypeInstantiation>-Element z. B. wie folgt aussehen:

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

Arguments-Attribut

Wert Beschreibung
type_argument Gibt die generischen Typargumente an. Wenn mehrere Argumente vorhanden sind, werden sie durch Kommas getrennt. Jedes Argument muss aus dem vollqualifizierten Typnamen bestehen.

Alle anderen Attribute

Wert Beschreibung
policy_setting Die Einstellung, die auf diesen Richtlinientyp für den konstruierten generischen Typ anzuwenden ist. Mögliche Werte sind All, Auto, Excluded, Public, PublicAndInternal, Required Public, Required PublicAndInternal und Required All. Weitere Informationen finden Sie unter Richtlinieneinstellungen für die Laufzeitanweisungen.

Untergeordnete Elemente

Element Beschreibung
<Ereignis> Wendet die Reflektionsrichtlinie auf ein Ereignis dieses Typs an.
<Feld> Wendet die Reflektionsrichtlinie auf ein Feld dieses Typs an.
<ImpliesType> Wendet eine Richtlinie auf einen Typ an, wenn diese Richtlinie an den Typ angewendet wurde, der vom enthaltenden <TypeInstantiation>-Element dargestellt wird.
<Methode> Wendet die Reflektionsrichtlinie auf eine Methode dieses Typs an.
<MethodInstantiation> Wendet die Reflektionsrichtlinie auf eine konstruierte generische Methode dieses Typs an.
<Eigenschaft> Wendet die Reflektionsrichtlinie auf eine Eigenschaft dieses Typs an.
<Typ> Wendet die Reflektionsrichtlinie auf einen geschachtelten Typ an.
<TypeInstantiation> Wendet die Reflektionsrichtlinie auf einen geschachtelten konstruierten generischen Typ an.

Übergeordnete Elemente

Element Beschreibung
<Anwendung> Dient als Container für anwendungsweite Typen und Typmember, deren Metadaten zur Laufzeit für die Reflektion verfügbar sind.
<Assembly> Wendet die Reflektionsrichtlinie auf alle Typen in einer angegebenen Assembly an.
<Bibliothek> Definiert die Assembly, die Typen und Typmember enthält, deren Metadaten zur Laufzeit für die Reflektion verfügbar sind.
<Namespace> Wendet die Reflektionsrichtlinie auf alle Typen in einem Namespace an.
<Typ> Wendet die Reflektionsrichtlinie auf einen Typ und alle seine Member an.
<TypeInstantiation> Wendet die Reflektionsrichtlinie auf einen konstruierten generischen Typ und alle seine Member an.

Hinweise

Die Reflektions-, Serialisierungs- und Interop-Attribute sind optional. Allerdings muss mindestens eines vorhanden sein.

Wenn ein <TypeInstantiation> Element das untergeordnete Element einer< Assembly>, <Namespace> oder< Eines Typs> ist, überschreibt es die vom übergeordneten Element definierten Richtlinieneinstellungen. Wenn ein <Type-Element> eine entsprechende generische Typdefinition definiert, überschreibt das <TypeInstantiation> Element die Laufzeitreflektionsrichtlinie nur für Instanziierungen des angegebenen konstruierten generischen Typs.

Beispiel

Im folgenden Beispiel wird Reflektion zum Abrufen der generischen Typdefinition von einem konstruierten Dictionary<TKey,TValue>-Objekt verwendet. Außerdem wird Reflektion zum Anzeigen von Informationen über Type-Objekte verwendet, die konstruierte generische Typen und generische Typdefinitionen darstellen. Die Variable b im Beispiel ist ein TextBlock Steuerelement.

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

Nach der Kompilierung mit der .NET Native-Toolkette löst das Beispiel eine MissingMetadataException-Ausnahme in der Zeile aus, die die Type.GetGenericTypeDefinition Methode aufruft. Sie können die Ausnahme eliminieren und die erforderlichen Metadaten bereitstellen, indem Sie folgendes <TypeInstantiation>-Element in der Laufzeitanweisungsdatei hinzufügen:

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

Weitere Informationen