다음을 통해 공유

<TypeInstantiation > 요소(.NET 네이티브)

  • 아티클

생성된 제네릭 형식에 런타임 리플렉션 정책을 적용합니다.

구문

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

특성 및 요소

다음의 섹션은 특성, 자식 요소 및 부모 요소에 대해 설명합니다.

특성

특성 특성 형식 설명
Name 일반 필수 특성입니다. 형식 이름을 지정합니다.
Arguments 일반 필수 특성입니다. 제네릭 형식 인수를 지정합니다. 인수가 여러 개이면 쉼표로 구분합니다.
Activate 리플렉션 선택적 특성입니다. 인스턴스를 활성화할 수 있도록 생성자에 대한 런타임 액세스를 제어합니다.
Browse 리플렉션 선택적 특성입니다. 프로그램 요소에 대한 정보 쿼리를 제어하지만 런타임 액세스를 사용하도록 설정하지는 않습니다.
Dynamic 리플렉션 선택적 특성입니다. 생성자, 메서드, 필드, 속성 및 이벤트를 비롯한 모든 형식 멤버에 대한 런타임 액세스를 제어하여 동적 프로그래밍을 수행할 수 있도록 합니다.
Serialize 직렬화 선택적 특성입니다. Newtonsoft JSON 직렬 변환기 등의 라이브러리를 통해 형식 인스턴스를 직렬화 및 역직렬화할 수 있도록 생성자, 필드 및 속성에 대한 런타임 액세스를 제어합니다.
DataContractSerializer 직렬화 선택적 특성입니다. System.Runtime.Serialization.DataContractSerializer 클래스를 사용하는 직렬화에 대한 정책을 제어합니다.
DataContractJsonSerializer 직렬화 선택적 특성입니다. System.Runtime.Serialization.Json.DataContractJsonSerializer 클래스를 사용하는 JSON 직렬화에 대한 정책을 제어합니다.
XmlSerializer 직렬화 선택적 특성입니다. System.Xml.Serialization.XmlSerializer 클래스를 사용하는 XML 직렬화에 대한 정책을 제어합니다.
MarshalObject Interop 선택적 특성입니다. Windows 런타임 및 COM에 대한 참조 형식을 마샬링하는 정책을 제어합니다.
MarshalDelegate Interop 선택적 특성입니다. 네이티브 코드에 대한 함수 포인터로 대리자 형식을 마샬링하는 정책을 제어합니다.
MarshalStructure Interop 선택적 특성입니다. 구조체를 네이티브 코드로 마샬링하는 정책을 제어합니다.

이름 특성

값 설명
type_name 형식 이름입니다. 이 <TypeInstantiation>요소가 <Namespace> 요소, <Type> 요소 또는 다른 <TypeInstantiation> 요소의 자식인 경우 type_name은 네임스페이스가 없는 형식 이름을 지정할 수 있습니다. 그러지 않으면 type_name은 정규화된 형식 이름을 포함해야 합니다. 형식 이름은 데코레이팅되지 않습니다. 예를 들어 System.Collections.Generic.List<T> 개체의 <TypeInstantiation> 요소는 다음과 같이 표시될 수 있습니다.

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

인수 특성

값 설명
type_argument 제네릭 형식 인수를 지정합니다. 인수가 여러 개이면 쉼표로 구분합니다. 각 인수는 정규화된 형식 이름으로 구성되어야 합니다.

기타 모든 특성

값 설명
policy_setting 생성된 제네릭 형식에 대해 이 정책 형식에 적용할 설정입니다. 가능한 값은 All, Auto, Excluded, Public, PublicAndInternal, Required Public, Required PublicAndInternal 및 Required All입니다. 자세한 정보는 런타임 지시문 정책 설정을 참조하세요.

자식 요소

요소 설명
<이벤트> 이 형식에 속하는 이벤트에 리플렉션 정책을 적용합니다.
<필드> 이 형식에 속하는 필드에 리플렉션 정책을 적용합니다.
<ImpliesType> 포함 <TypeInstantiation> 요소가 나타내는 형식에 정책이 적용된 경우 형식에 해당 정책을 적용합니다.
<방법> 이 형식에 속하는 메서드에 리플렉션 정책을 적용합니다.
<MethodInstantiation> 이 형식에 속하는 생성된 제네릭 메서드에 리플렉션 정책을 적용합니다.
<속성> 이 형식에 속하는 속성에 리플렉션 정책을 적용합니다.
<Type> 중첩된 형식에 리플렉션 정책을 적용합니다.
<TypeInstantiation> 생성된 중첩 제네릭 형식에 리플렉션 정책을 적용합니다.

부모 요소

요소 설명
<애플리케이션> 런타임에 해당 메타데이터를 리플렉션에 사용할 수 있는 애플리케이션 수준 형식 및 형식 멤버에 대한 컨테이너로 사용됩니다.
<어셈블리> 지정된 어셈블리의 모든 형식에 리플렉션 정책을 적용합니다.
<라이브러리> 런타임에 해당 메타데이터를 리플렉션에 사용할 수 있는 형식 및 형식 멤버가 포함된 어셈블리를 정의합니다.
<네임스페이스> 네임스페이스의 모든 형식에 리플렉션 정책을 적용합니다.
<Type> 형식 및 모든 해당 멤버에 리플렉션 정책을 적용합니다.
<TypeInstantiation> 생성된 제네릭 형식 및 모든 해당 멤버에 리플렉션 정책을 적용합니다.

설명

리플렉션, serialization 및 interop 특성은 모두 선택 사항입니다. 그러나 이러한 특성이 하나 이상 있어야 합니다.

<TypeInstantiation> 요소가 <Assembly>, <Namespace> 또는 <Type> 요소의 자식인 경우 부모 요소가 정의하는 정책 설정을 재정의합니다. <Type> 요소가 해당 제네릭 형식 정의를 정의하는 경우 <TypeInstantiation> 요소는 지정한 생성된 제네릭 형식의 인스턴스화에 대해서만 런타임 리플렉션 정책을 재정의합니다.

예시

다음 예제에서는 리플렉션을 사용하여 생성된 Dictionary<TKey,TValue> 개체에서 제네릭 형식 정의를 검색합니다. 또한 리플렉션을 사용하여 생성된 제네릭 형식 및 제네릭 형식 정의를 나타내는 Type 개체에 대한 정보를 표시합니다. 예제에서 b 변수는 TextBlock 컨트롤입니다.

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

이 예제는 .NET 네이티브 도구 체인을 사용하여 컴파일하면 Type.GetGenericTypeDefinition 메서드를 호출하는 줄에서 MissingMetadataException 예외를 throw합니다. 다음 <TypeInstantiation> 요소를 런타임 지시문 파일에 추가하면 예외를 방지하고 필요한 메타데이터를 제공할 수 있습니다.

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

참고 항목