CustomAttributeNamedArgument 結構

定義

命名空間:

System.Reflection

組件:

netstandard.dll, System.Runtime.dll

來源:

CustomAttributeNamedArgument.cs

表示僅限反映內容中自定義屬性的具名自變數。

C#

public readonly struct CustomAttributeNamedArgument : IEquatable<System.Reflection.CustomAttributeNamedArgument>

繼承

Object

ValueType

CustomAttributeNamedArgument

實作

IEquatable<CustomAttributeNamedArgument>

範例

下列範例會定義具有四個建構函式和四個屬性的自定義屬性。 其中兩個屬性是唯讀的，並使用建構函式的位置參數來設定。 其他兩個屬性是讀取/寫入，而且只能使用具名自變數來設定。 一個位置屬性是字串數位，而一個具名屬性是整數陣列。

屬性會套用至元件、元件中宣告的類型、型別的方法，以及方法的參數。 這些案例使用不同的建構函式。 執行時，元件會自行載入僅限反映的內容，並顯示已套用至其所包含之類型和成員之自定義屬性的相關信息。

套用至 型別的屬性會示範數位屬性，同時具有位置自變數和具名自變數。

C#

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 類別用來提供自定義屬性實例指定之具名自變數的存取權，而不需執行自定義屬性類型的對應屬性程序代碼。 TypedValue 屬性會傳回 CustomAttributeTypedArgument 結構，其中包含具名自變數的類型和值。

重要

不論自變數是具名還是位置，您都必須使用 CustomAttributeTypedArgument 結構來存取其類型和值。

若要建立 CustomAttributeData 類別的實例，請使用 staticGetCustomAttributes Factory 方法。

建構函式

CustomAttributeNamedArgument(MemberInfo, CustomAttributeTypedArgument)	初始化 CustomAttributeNamedArgument 類別的新實例，這個實例代表自定義屬性的指定欄位或屬性，並指定描述欄位或屬性型別和值的 CustomAttributeTypedArgument 物件。
CustomAttributeNamedArgument(MemberInfo, Object)	初始化 CustomAttributeNamedArgument 類別的新實例，這個實例表示自定義屬性的指定欄位或屬性，並指定欄位或屬性的值。

屬性

IsField	取得值，指出具名自變數是否為欄位。
MemberInfo	取得將用來設定具名自變數的屬性成員。
MemberName	取得將用來設定具名自變數的屬性成員名稱。
TypedValue	取得 CustomAttributeTypedArgument 結構，可用來取得目前具名自變數的類型和值。

方法

Equals(CustomAttributeNamedArgument)	指出目前的實例是否等於相同類型的另一個實例。
Equals(Object)	傳回值，這個值表示這個實例是否等於指定的物件。
GetHashCode()	傳回這個實例的哈希碼。
ToString()	傳回包含自變數名稱、等號和自變數值的字串表示的字串。

運算子

Equality(CustomAttributeNamedArgument, CustomAttributeNamedArgument)	測試兩個 CustomAttributeNamedArgument 結構是否相等。
Inequality(CustomAttributeNamedArgument, CustomAttributeNamedArgument)	測試兩個 CustomAttributeNamedArgument 結構是否不同。

適用於

另請參閱

• CustomAttributeData
• CustomAttributeTypedArgument
• ReflectionOnlyLoad