영어로 읽기

다음을 통해 공유


CustomAttributeTypedArgument 구조체

정의

리플렉션 전용 컨텍스트에서 사용자 지정 특성의 인수 또는 배열 인수의 요소를 나타냅니다.

public struct CustomAttributeTypedArgument
public readonly struct CustomAttributeTypedArgument
public readonly struct CustomAttributeTypedArgument : IEquatable<System.Reflection.CustomAttributeTypedArgument>
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public struct CustomAttributeTypedArgument
상속
CustomAttributeTypedArgument
특성
구현

예제

다음 예제에서는 4개의 생성자와 네 개의 속성을 사용하여 사용자 지정 특성을 정의합니다. 두 속성은 읽기 전용이며 생성자의 위치 매개 변수를 사용하여 설정됩니다. 다른 두 속성은 읽기/쓰기이며 명명된 인수를 사용해야만 설정할 수 있습니다. 한 위치 속성은 문자열 배열이고, 하나의 명명된 속성은 정수 배열입니다.

어셈블리, 어셈블리에 선언된 형식, 형식의 메서드 및 메서드의 매개 변수에 특성이 적용됩니다. 이러한 경우 다른 생성자가 사용됩니다. 실행하면 어셈블리가 리플렉션 전용 컨텍스트에 자신을 로드하고 사용자 지정 특성을 표시합니다.

형식에 적용되는 특성은 위치 인수와 명명된 인수를 모두 포함하는 배열 속성을 보여 줍니다.

using System;
using System.Reflection;
using System.Collections.Generic;
using System.Collections.ObjectModel;

// The example attribute is applied to the assembly.
[assembly:Example(ExampleKind.ThirdKind, Note="This is a note on the assembly.")]

// An enumeration used by the ExampleAttribute class.
public enum ExampleKind
{
    FirstKind,
    SecondKind,
    ThirdKind,
    FourthKind
};

// An example attribute. The attribute can be applied to all
// targets, from assemblies to parameters.
//
[AttributeUsage(AttributeTargets.All)]
public class ExampleAttribute : Attribute
{
    // Data for properties.
    private ExampleKind kindValue;
    private string noteValue;
    private string[] arrayStrings;
    private int[] arrayNumbers;

    // Constructors. The parameterless constructor (.ctor) calls
    // the constructor that specifies ExampleKind and an array of
    // strings, and supplies the default values.
    //
    public ExampleAttribute(ExampleKind initKind, string[] initStrings)
    {
        kindValue = initKind;
        arrayStrings = initStrings;
    }
    public ExampleAttribute(ExampleKind initKind) : this(initKind, null) {}
    public ExampleAttribute() : this(ExampleKind.FirstKind, null) {}

    // Properties. The Note and Numbers properties must be read/write, so they
    // can be used as named parameters.
    //
    public ExampleKind Kind { get { return kindValue; }}
    public string[] Strings { get { return arrayStrings; }}
    public string Note
    {
        get { return noteValue; }
        set { noteValue = value; }
    }
    public int[] Numbers
    {
        get { return arrayNumbers; }
        set { arrayNumbers = value; }
    }
}

// The example attribute is applied to the test class.
//
[Example(ExampleKind.SecondKind,
         new string[] { "String array argument, line 1",
                        "String array argument, line 2",
                        "String array argument, line 3" },
         Note="This is a note on the class.",
         Numbers = new int[] { 53, 57, 59 })]
public class Test
{
    // The example attribute is applied to a method, using the
    // parameterless constructor and supplying a named argument.
    // The attribute is also applied to the method parameter.
    //
    [Example(Note="This is a note on a method.")]
    public void TestMethod([Example] object arg) { }

    // Main() gets objects representing the assembly, the test
    // type, the test method, and the method parameter. Custom
    // attribute data is displayed for each of these.
    //
    public static void Main()
    {
        Assembly asm = Assembly.ReflectionOnlyLoad("Source");
        Type t = asm.GetType("Test");
        MethodInfo m = t.GetMethod("TestMethod");
        ParameterInfo[] p = m.GetParameters();

        Console.WriteLine("\r\nAttributes for assembly: '{0}'", asm);
        ShowAttributeData(CustomAttributeData.GetCustomAttributes(asm));
        Console.WriteLine("\r\nAttributes for type: '{0}'", t);
        ShowAttributeData(CustomAttributeData.GetCustomAttributes(t));
        Console.WriteLine("\r\nAttributes for member: '{0}'", m);
        ShowAttributeData(CustomAttributeData.GetCustomAttributes(m));
        Console.WriteLine("\r\nAttributes for parameter: '{0}'", p);
        ShowAttributeData(CustomAttributeData.GetCustomAttributes(p[0]));
    }

    private static void ShowAttributeData(
        IList<CustomAttributeData> attributes)
    {
        foreach( CustomAttributeData cad in attributes )
        {
            Console.WriteLine("   {0}", cad);
            Console.WriteLine("      Constructor: '{0}'", cad.Constructor);

            Console.WriteLine("      Constructor arguments:");
            foreach( CustomAttributeTypedArgument cata
                in cad.ConstructorArguments )
            {
                ShowValueOrArray(cata);
            }

            Console.WriteLine("      Named arguments:");
            foreach( CustomAttributeNamedArgument cana
                in cad.NamedArguments )
            {
                Console.WriteLine("         MemberInfo: '{0}'",
                    cana.MemberInfo);
                ShowValueOrArray(cana.TypedValue);
            }
        }
    }

    private static void ShowValueOrArray(CustomAttributeTypedArgument cata)
    {
        if (cata.Value.GetType() == typeof(ReadOnlyCollection<CustomAttributeTypedArgument>))
        {
            Console.WriteLine("         Array of '{0}':", cata.ArgumentType);

            foreach (CustomAttributeTypedArgument cataElement in
                (ReadOnlyCollection<CustomAttributeTypedArgument>) cata.Value)
            {
                Console.WriteLine("             Type: '{0}'  Value: '{1}'",
                    cataElement.ArgumentType, cataElement.Value);
            }
        }
        else
        {
            Console.WriteLine("         Type: '{0}'  Value: '{1}'",
                cata.ArgumentType, cata.Value);
        }
    }
}

/* This code example produces output similar to the following:

Attributes for assembly: 'source, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null'
   [System.Runtime.CompilerServices.CompilationRelaxationsAttribute((Int32)8)]
      Constructor: 'Void .ctor(Int32)'
      Constructor arguments:
         Type: 'System.Int32'  Value: '8'
      Named arguments:
   [System.Runtime.CompilerServices.RuntimeCompatibilityAttribute(WrapNonExceptionThrows = True)]
      Constructor: 'Void .ctor()'
      Constructor arguments:
      Named arguments:
         MemberInfo: 'Boolean WrapNonExceptionThrows'
         Type: 'System.Boolean'  Value: 'True'
   [ExampleAttribute((ExampleKind)2, Note = "This is a note on the assembly.")]
      Constructor: 'Void .ctor(ExampleKind)'
      Constructor arguments:
         Type: 'ExampleKind'  Value: '2'
      Named arguments:
         MemberInfo: 'System.String Note'
         Type: 'System.String'  Value: 'This is a note on the assembly.'

Attributes for type: 'Test'
   [ExampleAttribute((ExampleKind)1, new String[3] { "String array argument, line 1", "String array argument, line 2", "String array argument, line 3" }, Note = "This is a note on the class.", Numbers = new Int32[3] { 53, 57, 59 })]
      Constructor: 'Void .ctor(ExampleKind, System.String[])'
      Constructor arguments:
         Type: 'ExampleKind'  Value: '1'
         Array of 'System.String[]':
             Type: 'System.String'  Value: 'String array argument, line 1'
             Type: 'System.String'  Value: 'String array argument, line 2'
             Type: 'System.String'  Value: 'String array argument, line 3'
      Named arguments:
         MemberInfo: 'System.String Note'
         Type: 'System.String'  Value: 'This is a note on the class.'
         MemberInfo: 'Int32[] Numbers'
         Array of 'System.Int32[]':
             Type: 'System.Int32'  Value: '53'
             Type: 'System.Int32'  Value: '57'
             Type: 'System.Int32'  Value: '59'

Attributes for member: 'Void TestMethod(System.Object)'
   [ExampleAttribute(Note = "This is a note on a method.")]
      Constructor: 'Void .ctor()'
      Constructor arguments:
      Named arguments:
         MemberInfo: 'System.String Note'
         Type: 'System.String'  Value: 'This is a note on a method.'

Attributes for parameter: 'System.Object arg'
   [ExampleAttribute()]
      Constructor: 'Void .ctor()'
      Constructor arguments:
      Named arguments:
*/

설명

리플렉션 전용 컨텍스트에서 검사되는 코드는 실행할 수 없으므로 인스턴스를 만든 다음 해당 속성을 검사하고 Attribute.GetCustomAttributes, MemberInfo.GetCustomAttributes등의 메서드를 사용하여 사용자 지정 특성을 검사할 수 있는 것은 아닙니다. 특성 형식 자체에 대한 코드가 리플렉션 전용 컨텍스트로 로드되면 실행할 수 없습니다.

CustomAttributeNamedArgument 구조체는 특성 생성자를 실행하지 않고 사용자 지정 특성 인스턴스에 지정된 위치 인수의 형식 및 값에 대한 액세스를 제공하기 위해 CustomAttributeData 클래스에서 사용됩니다. 또한 사용자 지정 특성 형식의 해당 속성 코드를 실행하지 않고 명명된 인수의 형식 및 값에 액세스할 수 있습니다.

특성 인스턴스의 모든 위치 및 명명된 인수의 형식 및 값은 CustomAttributeTypedArgument 구조체에서 제공됩니다. CustomAttributeData.ConstructorArguments 속성에서 반환된 위치 특성은 CustomAttributeTypedArgument 구조체로 직접 표현되지만 CustomAttributeData.NamedArguments 속성에서 반환된 명명된 인수는 CustomAttributeNamedArgument 구조체로 표시됩니다. 명명된 인수의 CustomAttributeTypedArgument 구조를 얻으려면 CustomAttributeNamedArgument.TypedValue 속성을 사용합니다.

인수가 값 배열인 경우 인수를 나타내는 CustomAttributeTypedArgumentValue 속성은 CustomAttributeTypedArgument 개체의 제네릭 ReadOnlyCollection<T> 반환합니다. 컬렉션의 각 CustomAttributeTypedArgument 개체는 배열의 해당 요소를 나타냅니다.

CustomAttributeData 클래스의 인스턴스를 만들려면 staticGetCustomAttributes 팩터리 메서드를 사용합니다.

생성자

CustomAttributeTypedArgument(Object)

지정된 값을 사용하여 CustomAttributeTypedArgument 클래스의 새 인스턴스를 초기화합니다.

CustomAttributeTypedArgument(Type, Object)

지정된 형식과 값을 사용하여 CustomAttributeTypedArgument 클래스의 새 인스턴스를 초기화합니다.

속성

ArgumentType

인수 또는 배열 인수 요소의 형식을 가져옵니다.

Value

단순 인수 또는 배열 인수의 요소에 대한 인수 값을 가져옵니다. 배열 인수에 대한 값 컬렉션을 가져옵니다.

메서드

Equals(CustomAttributeTypedArgument)

현재 인스턴스가 동일한 형식의 다른 인스턴스와 같은지 여부를 나타냅니다.

Equals(Object)

이 인스턴스와 지정된 개체가 같은지 여부를 나타냅니다.

GetHashCode()

이 인스턴스의 해시 코드를 반환합니다.

ToString()

인수 이름, 등호 및 인수 값의 문자열 표현으로 구성된 문자열을 반환합니다.

연산자

적용 대상

제품 버전
.NET Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9
.NET Framework 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1
UWP 10.0

추가 정보