---

C# Attribute 详解：是什么，如何用

在 C# 编程中，我们经常会遇到一种特殊的语法结构，它们被放置在方括号 [] 中，紧邻着类、方法、属性、字段等代码元素。这些就是 Attributes（特性）。Attributes 是 .NET 平台提供的一种强大的元数据（Metadata）机制，它们允许我们在代码中嵌入声明性的信息。本文将深入探讨 C# Attributes 的各个方面，从它们的定义、作用，到如何使用内置 Attribute 以及如何创建和使用自定义 Attribute，希望能帮助你全面理解这一重要的概念。

1. 什么是 Attribute？

简单来说，Attribute 是一种向代码中添加元数据的方式。元数据是描述代码本身的数据，而不是代码执行时处理的数据。例如，一个类名、方法参数类型、返回值类型等都是元数据。Attributes 则是一种声明性的元数据，你可以用它来描述程序集、模块、类型（类、结构体、枚举、接口、委托）、成员（方法、属性、字段、事件）、参数、返回值，甚至泛型类型参数等。

你可以将 Attribute 理解为一种标签（Tag）或者标记（Marker）。你将这些标签应用到你的代码元素上，这些标签本身并不直接改变代码的执行逻辑，但它们提供了额外的信息，这些信息可以在编译时被编译器使用，或者在运行时通过反射（Reflection）被读取和处理。

C# 中的所有 Attribute 都直接或间接继承自 System.Attribute 这个基类。这是 .NET 框架定义 Attribute 的约定。按照约定，Attribute 的类名通常以 “Attribute” 结尾，例如 SerializableAttribute。但在应用 Attribute 时，通常可以省略 Attribute 后缀，直接使用 [Serializable]。

为什么需要 Attributes？

在没有 Attributes 之前，开发者如果要向代码添加元数据，可能依赖于以下方式：

• 注释 (Comments): 只是给人看，编译器或运行时无法直接利用。
• 文档 (Documentation): 通过 XML 注释生成，主要用于生成文档，运行时同样无法直接利用这些结构化的信息。
• 配置文件 (Configuration Files): 将某些配置信息放到外部文件，运行时读取。这适用于全局或应用级别的配置，但不适合与特定的代码元素（如某个方法是否可序列化）紧密关联。
• 接口 (Interfaces): 定义了契约，但接口主要描述行为或结构，而不是描述属性或元数据。

Attributes 提供了一种标准化的、与代码元素紧密关联的、可被运行时读取和处理的元数据附加方式。这使得框架、工具和库能够根据你附加的 Attribute 来改变它们的行为，而不需要你写额外的代码来注册或配置这些行为。

2. Attributes 的作用和应用场景

Attributes 的核心作用是为代码元素提供额外的、可被程序读取的描述信息。基于这个核心作用，Attributes 有着广泛的应用场景：

1. 影响编译时行为： 某些 Attributes 会被编译器识别，并影响编译过程或结果。例如 [Obsolete] Attribute 会让编译器对使用过时代码的地方发出警告或错误。
2. 影响调试器行为： 某些 Attributes 可以控制调试器在调试时的行为。例如 [DebuggerStepThrough] Attribute 会告诉调试器在单步执行时跳过带有此 Attribute 的方法。
3. 提供运行时元数据供框架或库使用： 这是 Attributes 最常见的用途。框架或库可以在运行时通过反射检测代码元素上附加的 Attributes，并据此改变它们的行为。
   • 序列化： [Serializable], [DataContract], [DataMember], [JsonProperty] (来自 Json.NET/Newtonsoft.Json) 等 Attributes 控制对象如何被序列化和反序列化。
   • ORM (Object-Relational Mapping)： Entity Framework Core 使用 Attributes (如 [Table], [Column], [Key]) 来映射对象模型到数据库结构。
   • Web 开发框架： ASP.NET Core MVC 使用 Attributes (如 [Route], [ApiController], [HttpGet], [HttpPost]) 来定义路由、控制器行为等。
   • 依赖注入 (DI)： 某些 DI 框架使用 Attributes (如 [Inject]) 来标记需要注入的成员。
   • 单元测试框架： NUnit、xUnit、MSTest 都使用 Attributes (如 [Test], [Fact], [Theory]) 来标记测试方法和配置测试行为。
   • 验证 (Validation)： System.ComponentModel.DataAnnotations 命名空间下的 Attributes (如 [Required], [StringLength], [Range], [EmailAddress]) 用于模型验证，常用于 Web 或数据输入场景。
   • 互操作性 (Interop)： [DllImport] 用于标记从非托管 DLL 导入的函数，[MarshalAs] 用于控制数据封送。
4. 文档生成或代码分析工具： 虽然 XML 注释是主要的文档方式，但 Attributes 也可以为某些自动化工具提供结构化的信息。例如，自定义 Attribute 可以标记一个方法的作者、最后修改日期等。

Attributes 的引入极大地提高了代码的声明性，将一些原本需要在代码逻辑中硬编码的配置或元数据信息，以一种更清晰、更灵活的方式附加到代码结构上。

3. Attribute 的基本语法

Attributes 使用方括号 [] 来应用。它们可以应用于各种代码元素之前。

“`csharp
// 应用于程序集 (Assembly)
[assembly: SomeAssemblyAttribute]

// 应用于模块 (Module)
[module: SomeModuleAttribute]

// 应用于类 (Class)
[Serializable] // 常用的内置属性
[MyCustomClassAttribute(“SomeValue”, Version = “1.0”)] // 自定义属性带参数
public class MyClass
{
// 应用于属性 (Property)
[JsonPropertyName(“item_name”)] // 常用于 JSON 序列化
public string ItemName { get; set; }

// 应用于字段 (Field)
[NonSerialized] // 常用于控制序列化
private int _internalState;

// 应用于方法 (Method)
[Obsolete("This method is obsolete. Use NewMethod instead.", true)] // 警告并报错
[CustomMethodAttribute]
public void OldMethod()
{
    // ...
}

// 应用于方法参数 (Parameter)
public void ProcessData([CallerMemberName] string callerName = null) // 提供调用者信息
{
    // ...
}

// 应用于返回值 (Return Value) - 较少见，但语法支持
[CustomReturnAttribute]
public int CalculateResult()
{
    return 0;
}

// 应用于事件 (Event)
[CustomEventAttribute]
public event EventHandler MyEvent;

// 应用于结构体 (Struct)
[StructLayout(LayoutKind.Sequential)] // 控制内存布局
public struct MyStruct
{
    // ...
}

// 应用于枚举 (Enum)
public enum Status
{
    [Description("Active status")] // 常用于 UI 显示或序列化
    Active,
    [Description("Inactive status")]
    Inactive
}

// 应用于委托 (Delegate)
[CustomDelegateAttribute]
public delegate void MyDelegate();

}
“`

语法细节：

• 方括号 []： Attributes 必须放在方括号内。
• 位置： Attributes 通常放在它们所应用的声明之前。
• 多个 Attributes： 可以在同一个代码元素上应用多个 Attributes。可以放在同一对方括号内，用逗号分隔；也可以分别放在不同的方括号对内。
  csharp
[Serializable, CustomClassAttribute]
[AnotherAttribute]
public class AnotherClass { ... }
  这两种写法是等价的。
• Attribute 命名： 如果 Attribute 的类名以 Attribute 结尾（这是约定），则在应用时可以省略 Attribute 后缀。例如，System.SerializableAttribute 可以写作 [Serializable]。但如果 Attribute 类名不以 Attribute 结尾，则必须使用完整的类名。
• 指定目标： 对于程序集和模块级别的 Attribute，必须显式指定目标，使用 [assembly:] 或 [module:]。对于其他目标（类、方法、属性等），通常可以省略目标，编译器会根据 Attribute 的位置自动推断。但为了清晰起见或处理模糊情况（例如一个 Attribute 可以应用于方法或方法的返回值），也可以显式指定目标，例如 [method: Obsolete(...)] 或 [return: MarshalAs(...)]。可能的显式目标包括 assembly, module, class, struct, enum, constructor, method, property, field, event, interface, parameter, delegate, return, generic。
• Attribute 参数： Attributes 可以接受参数，这些参数用于初始化 Attribute 的状态。参数分为两种：
  • 位置参数 (Positional Parameters)： 通过 Attribute 的构造函数传递，必须按照构造函数定义的顺序和类型提供。
    csharp
[Obsolete("This is the message", true)] // "This is the message" 和 true 是位置参数
  • 命名参数 (Named Parameters)： 通过 Attribute 类的公共读写属性设置。使用 PropertyName = value 的语法。命名参数是可选的，并且顺序不重要。
    csharp
[CustomAttribute(PositionParam1, PositionParam2, NamedParam1 = value1, NamedParam2 = value2)]

4. 创建自定义 Attribute

虽然 .NET 提供了许多内置 Attribute，但在很多情况下，你需要创建自己的 Attribute 来满足特定的需求，例如标记某个类的作者信息，或者标记某个属性在自定义序列化中的顺序。

创建自定义 Attribute 非常简单：

1. 创建一个类，该类必须继承自 System.Attribute。
2. （可选）使用 [AttributeUsage] Attribute 来限制你的自定义 Attribute 可以应用于哪些代码元素以及是否允许重复应用或被继承。
3. （可选）定义构造函数来接收位置参数。
4. （可选）定义公共读写属性来接收命名参数。

“`csharp
using System;

// 2. 使用 [AttributeUsage] 控制 Attribute 的使用范围
[AttributeUsage(
AttributeTargets.Class | // 可以应用于类
AttributeTargets.Struct | // 可以应用于结构体
AttributeTargets.Method, // 可以应用于方法
AllowMultiple = false, // 不允许在同一个目标上多次应用此 Attribute
Inherited = true // 子类或重写方法会继承此 Attribute
)]
public class DeveloperInfoAttribute : Attribute
{
// 3. 定义构造函数接收位置参数
public string DeveloperName { get; } // 位置参数通常通过属性暴露

// 4. 定义公共读写属性接收命名参数
public string LastModified { get; set; }
public string Version { get; set; }

// 构造函数 (位置参数)
public DeveloperInfoAttribute(string developerName)
{
    if (string.IsNullOrWhiteSpace(developerName))
    {
        throw new ArgumentException("Developer name cannot be null or whitespace.", nameof(developerName));
    }
    DeveloperName = developerName;
}

// 注意：命名参数必须对应公共读写属性，不能通过构造函数直接设置

}

// 使用自定义 Attribute
[DeveloperInfo(“John Doe”, LastModified = “2023-10-27”, Version = “1.1”)]
public class MyFeature
{
[DeveloperInfo(“Jane Smith”)] // 也可以不使用命名参数
public void Process()
{
// …
}
}

[DeveloperInfo(“Alice Brown”, Version = “2.0”)] // 应用于结构体
public struct Settings
{
// …
}

// 由于 AllowMultiple = false, 以下会引起编译错误
// [DeveloperInfo(“User1”)]
// [DeveloperInfo(“User2”)]
// public class AnotherFeature { … }

// 由于 Inherited = true, ChildFeature 会继承 MyFeature 的 DeveloperInfoAttribute
public class ChildFeature : MyFeature
{
// …
}
“`

[AttributeUsage] 的参数说明：

• AttributeTargets validOn: 指定 Attribute 可以应用于哪些代码元素。这是一个枚举类型 AttributeTargets，可以使用位运算符 | 组合多个目标。
  • Assembly, Module
  • Class, Struct, Enum, Interface, Delegate
  • Constructor, Method, Property, Field, Event
  • Parameter, ReturnValue
  • GenericParameter
  • All: 可以应用于所有目标 (慎用)。
  • Class | Struct: 可以应用于类或结构体。
• bool AllowMultiple: 如果设置为 true，则允许在同一个目标上多次应用同一个 Attribute。例如 [DeveloperInfo("User1")][DeveloperInfo("User2")]。默认值为 false。
• bool Inherited: 如果设置为 true，则应用在基类上的 Attribute 会被继承的子类继承；应用在接口上的 Attribute 会被实现此接口的类继承；应用在虚方法或抽象方法上的 Attribute 会被派生类中的重写方法继承。默认值为 true。

创建了自定义 Attribute 后，就可以像使用内置 Attribute 一样，将其应用于你的代码元素上。但是，仅仅应用 Attribute 是不够的，你还需要在运行时读取这些 Attribute，并根据它们包含的信息来执行相应的逻辑。这就是反射的作用。

5. 通过反射读取和处理 Attribute

Attribute 本身只是一种声明性的元数据。它们的价值体现在能够被运行时检测到并根据其内容执行逻辑。这通常通过 反射 (Reflection) 来实现。反射是 .NET 提供的一组 API，允许程序在运行时检查自身结构（如类型、成员信息）并与它们进行交互。

System.Reflection 命名空间提供了获取类型信息、成员信息以及其附加 Attributes 的方法。

核心方法是 GetCustomAttributes() 和 IsDefined()，它们可以在各种 System.Reflection 类型的对象上调用，例如 Type, MethodInfo, PropertyInfo, FieldInfo, ParameterInfo 等。

“`csharp
using System;
using System.Reflection;
using System.Linq;

// 假设上面的 DeveloperInfoAttribute 和 MyFeature 类已定义

public class AttributeReader
{
public static void ReadAttributes()
{
// 1. 获取 Type 对象
Type myFeatureType = typeof(MyFeature);

    Console.WriteLine($"Reading attributes for type: {myFeatureType.Name}");

    // 2. 获取类级别上的 Attributes
    // GetCustomAttributes(bool inherit): 获取直接应用于此成员的 Attributes，并可选地包括继承的 Attributes
    // GetCustomAttributes(Type attributeType, bool inherit): 获取指定类型的 Attributes
    object[] typeAttributes = myFeatureType.GetCustomAttributes(false); // 只获取直接应用的 Attributes
    Console.WriteLine($"Found {typeAttributes.Length} attributes on {myFeatureType.Name}:");

    foreach (object attr in typeAttributes)
    {
        Console.WriteLine($"- {attr.GetType().Name}");

        // 尝试将 Attribute 转换为特定类型以访问其参数
        if (attr is DeveloperInfoAttribute devInfoAttr)
        {
            Console.WriteLine($"  Developer: {devInfoAttr.DeveloperName}");
            Console.WriteLine($"  Last Modified: {devInfoAttr.LastModified ?? "N/A"}"); // 使用 ?? 处理可能为 null 的命名参数
            Console.WriteLine($"  Version: {devInfoAttr.Version ?? "N/A"}");
        }
        // 可以检查其他类型的内置或自定义 Attribute
        if (attr is SerializableAttribute)
        {
            Console.WriteLine("  [Serializable] attribute is present.");
        }
    }

    Console.WriteLine("\n---");

    // 3. 获取方法级别上的 Attributes
    MethodInfo processMethod = myFeatureType.GetMethod("Process"); // 获取名为 "Process" 的公共方法
    if (processMethod != null)
    {
        Console.WriteLine($"Reading attributes for method: {processMethod.Name}");
        object[] methodAttributes = processMethod.GetCustomAttributes(false);
        Console.WriteLine($"Found {methodAttributes.Length} attributes on {processMethod.Name}:");

        foreach (object attr in methodAttributes)
        {
             Console.WriteLine($"- {attr.GetType().Name}");
             if (attr is DeveloperInfoAttribute devInfoAttr)
             {
                Console.WriteLine($"  Developer: {devInfoAttr.DeveloperName}");
                Console.WriteLine($"  Last Modified: {devInfoAttr.LastModified ?? "N/A"}");
                Console.WriteLine($"  Version: {devInfoAttr.Version ?? "N/A"}");
             }
        }
    }

    Console.WriteLine("\n---");

    // 4. 检查是否应用了某个特定的 Attribute
    Console.WriteLine($"Is {myFeatureType.Name} serializable? {myFeatureType.IsDefined(typeof(SerializableAttribute), false)}"); // 检查是否存在 [Serializable]
    Console.WriteLine($"Does {myFeatureType.Name} have DeveloperInfoAttribute? {myFeatureType.IsDefined(typeof(DeveloperInfoAttribute), false)}");

    Console.WriteLine("\n---");

    // 5. 获取继承的 Attributes (如果 Inherited = true)
    Type childFeatureType = typeof(ChildFeature);
    Console.WriteLine($"Reading attributes for inherited type: {childFeatureType.Name}");
    // 获取 DeveloperInfoAttribute，并包括继承的 Attributes
    DeveloperInfoAttribute[] inheritedDevInfoAttrs = (DeveloperInfoAttribute[])childFeatureType.GetCustomAttributes(typeof(DeveloperInfoAttribute), true);

    Console.WriteLine($"Found {inheritedDevInfoAttrs.Length} DeveloperInfoAttribute(s) on {childFeatureType.Name} (including inherited):");
     foreach (var attr in inheritedDevInfoAttrs)
    {
        Console.WriteLine($"- Developer: {attr.DeveloperName}, Version: {attr.Version ?? "N/A"}");
    }

     // 6. Linq 过滤和查询 Attributes
     var developerAttributesViaLinq = myFeatureType.GetCustomAttributes(false)
                                                   .OfType<DeveloperInfoAttribute>() // 使用 OfType<T> 过滤并转换为指定类型
                                                   .ToList();

     Console.WriteLine($"\nFound {developerAttributesViaLinq.Count} DeveloperInfoAttribute(s) on {myFeatureType.Name} (via Linq):");
     foreach (var attr in developerAttributesViaLinq)
     {
         Console.WriteLine($"- Developer: {attr.DeveloperName}");
     }
}

}

// 调用示例
// AttributeReader.ReadAttributes();
“`

通过反射使用 Attribute 的步骤：

1. 获取目标对象的 System.Type： 使用 typeof(MyClass) 或对象的 GetType() 方法。
2. 获取成员信息对象： 从 Type 对象获取 MethodInfo, PropertyInfo, FieldInfo 等对象。
3. 调用 GetCustomAttributes() 或 IsDefined()：
   • GetCustomAttributes(bool inherit): 返回一个 object[] 数组，包含应用于目标的所有 Attributes。
   • GetCustomAttributes(Type attributeType, bool inherit): 返回一个 object[] 数组，只包含指定类型的 Attributes。
   • IsDefined(Type attributeType, bool inherit): 返回 bool，指示目标是否应用了指定类型的 Attribute。
   • inherit 参数控制是否包括从基类、接口或重写成员继承的 Attributes。
4. 处理返回的 Attributes： 遍历 object[] 数组，使用 is 运算符或强制转换将每个 Attribute 对象转换为你期望的 Attribute 类型，然后就可以访问其公共属性（命名参数）和通过构造函数初始化的值（位置参数）。

框架和库正是通过这种方式在运行时检查你的代码，读取你附加的 Attribute，并根据 Attribute 的信息来配置或调整它们的行为。例如，一个序列化库会检查类和属性上的序列化相关的 Attribute，决定哪些字段需要序列化，序列化时的名称是什么等等。

6. 常见的内置 Attributes 示例

.NET 框架提供了大量的内置 Attributes 用于各种目的。下面列举一些最常用和重要的例子：

• [System.Obsolete]： 标记某个类型或成员已过时，不应再使用。
  “`csharp
  [Obsolete(“This method is outdated. Use NewCalculate.”)]
  public static int OldCalculate(int a, int b) => a + b;

  [Obsolete(“This class is no longer supported.”, true)] // true 表示将警告变为错误
  public class LegacyClass { }
  * **`[System.Diagnostics.Conditional]`：** 应用于方法或 Attribute 类，指示仅在定义了指定的编译符号时才调用方法或应用 Attribute。csharp
  [Conditional(“DEBUG”)] // 只在定义了 DEBUG 符号时才编译和调用 LogMessage 方法
  public static void LogMessage(string message)
  {
  Console.WriteLine($”DEBUG: {message}”);
  }

  // 应用于自定义 Attribute (较少见)
  [Conditional(“ENABLE_FEATURE_X”)]
  public class FeatureXAttribute : Attribute { }
  * **`[System.Runtime.InteropServices.DllImport]`：** 应用于方法，指示被标记的方法是通过 P/Invoke (Platform Invoke) 从非托管 DLL 导入的。csharp
  using System.Runtime.InteropServices;

  public static class NativeMethods
  {
  [DllImport(“user32.dll”, CharSet = CharSet.Unicode)]
  public static extern int MessageBox(IntPtr hWnd, string lpText, string lpCaption, uint uType);
  }
  * **`[System.Serializable]` 和 `[System.NonSerialized]`：** 控制 .NET 的默认二进制或 SOAP 序列化器如何处理类型和字段。csharp
  [Serializable] // 标记类可序列化
  public class UserSettings
  {
  public string Username { get; set; } // 会被序列化
  public string Email { get; set; } // 会被序列化

  [NonSerialized] // 标记此字段不应被序列化
  private string _sessionToken;
  

  }
  * **`[System.ComponentModel.DataAnnotations]` Attributes (Validation Attributes)：** 用于模型验证。csharp
  using System.ComponentModel.DataAnnotations;

  public class Product
  {
  [Required(ErrorMessage = “Product name is required.”)]
  [StringLength(100, MinimumLength = 3, ErrorMessage = “Product name must be between 3 and 100 characters.”)]
  public string Name { get; set; }

  [Range(0.01, 1000.00, ErrorMessage = "Price must be between 0.01 and 1000.00.")]
  public decimal Price { get; set; }
  
  [EmailAddress(ErrorMessage = "Invalid email format.")]
  public string ContactEmail { get; set; }
  

  }
  * **`[System.Runtime.CompilerServices.CallerMemberName]`, `[CallerFilePath]`, `[CallerLineNumber]`：** 应用于可选方法参数，当调用者没有为该参数提供显式值时，编译器会自动填充调用者的成员名、源文件路径或行号。常用于日志记录或诊断。csharp
  using System.Runtime.CompilerServices;

  public static void Log(string message,
  [CallerMemberName] string memberName = “”,
  [CallerFilePath] string filePath = “”,
  [CallerLineNumber] int lineNumber = 0)
  {
  Console.WriteLine($”[{memberName} in {filePath}:{lineNumber}] {message}”);
  }

  // 调用 Log(“Something happened.”); 会自动捕获调用位置信息
  * **`[System.Diagnostics.DebuggerStepThrough]` 和 `[System.Diagnostics.DebuggerHidden]`：** 控制调试器行为。`[DebuggerStepThrough]` 在单步调试时会跳过带此 Attribute 的方法；`[DebuggerHidden]` 会完全隐藏带此 Attribute 的方法（你甚至看不到它在调用堆栈中）。
* **`[System.Reflection.DefaultMember]`：** 应用于类、结构体或接口，指定其默认成员（通常是索引器）。允许你像访问数组一样访问对象，例如 `myObject[index]`。csharp
  [DefaultMember(“Items”)] // 标记 Items 属性为默认成员
  public class MyCollection
  {
  private List _items = new List();

  public T this[int index] // 索引器
  {
      get => _items[index];
      set => _items[index] = value;
  }
  
  // ... 其他方法
  

  }
  “`

这只是冰山一角，.NET 中还有很多其他用途的 Attributes，比如用于 COM 互操作、线程模型、UI 设计等。

7. Attributes 的局限性与注意事项

尽管 Attributes 非常强大，但在使用时也需要注意一些方面：

• 参数类型限制： Attribute 的位置参数和命名参数的类型是有限制的。它们必须是以下类型之一：
  • bool, byte, char, double, float, int, long, sbyte, short, string, uint, ulong, ushort (即基元类型)
  • object
  • System.Type
  • enum 类型
  • 上述类型的一维数组
  • 不能使用复杂的对象实例、集合类型（除了一维数组）、nullabl 值类型（除非作为 object 类型）。
• 无法直接包含逻辑： Attribute 类本身是数据载体，不应该包含复杂的业务逻辑。读取和处理 Attribute 的逻辑应该在其他地方（通常是框架或自定义的处理代码）通过反射来完成。
• 反射开销： 虽然读取 Attribute 的反射操作通常很快，尤其是在现代 .NET 版本中，但频繁地大量使用反射可能会带来一定的性能开销。不过对于大多数典型的 Attribute 使用场景（如在应用程序启动时扫描一次或在请求处理的开始阶段），这种开销通常可以忽略不计。
• 编译时 vs. 运行时： Attributes 本身是元数据，它们的存在是编译时就确定的。但大多数 Attributes 的处理发生在运行时，通过反射。少数 Attributes (如 [Conditional], [Obsolete]) 会影响编译时行为。
• 设计考虑： 设计自定义 Attribute 时，要确保其目的清晰，参数尽可能精简且类型合适。避免创建过于通用的 Attribute，它们可能难以理解和维护。

8. Attributes 与其他元数据或配置方式的比较

• Attributes vs. Configuration Files (e.g., JSON, XML):
  • Attributes: 元数据与代码元素紧密耦合，信息分散在代码中。适用于描述特定代码元素的行为、属性或约束。易于通过反射获取。不适合在运行时动态修改。
  • Configuration Files: 配置信息集中管理，与代码分离。适用于全局设置、连接字符串、外部服务地址等。易于在不重新编译代码的情况下修改。读取需要额外的配置解析逻辑。
  • 选择： 如果信息描述的是代码结构的某个方面，并且这种信息通常在开发时确定，Attributes 是一个好选择。如果信息需要频繁变动，或者与应用程序环境/部署强相关，配置文件更合适。很多框架会结合使用：Attributes 标记某个属性需要配置，然后从配置文件中读取实际的配置值。
• Attributes vs. Interfaces:
  • Attributes: 提供声明性的信息，不强制实现任何方法或属性。关注“是什么”或“有什么特性”。
  • Interfaces: 定义了契约，强制实现特定的方法、属性或事件。关注“能做什么”。
  • 选择： 如果你只需要标记某个类或成员具有某种“属性”或“元数据”，并且不需要强制它实现特定行为，使用 Attributes。如果你需要定义一个可被实现的契约，并依赖多态来处理不同实现，使用接口。
• Attributes vs. XML Comments:
  • Attributes: 结构化的元数据，可被程序读取和处理。主要用于影响程序行为或被工具使用。
  • XML Comments: 主要用于生成 API 文档，给人阅读。程序运行时通常不处理这些注释。
  • 选择： Attributes 是机器可读的元数据，XML Comments 是给人读的文档。它们目的不同，可以并存。

9. 总结

C# Attributes 是 .NET 平台中一项非常重要的元数据机制。它们允许开发者以一种声明性的方式向代码中嵌入附加信息，这些信息可以被编译器、调试器、各种框架、工具或开发者自己编写的代码在运行时通过反射读取和处理。

本文详细介绍了：

• Attribute 的基本概念：它是一种声明性元数据，继承自 System.Attribute。
• Attribute 的作用和应用场景：影响编译、调试、框架行为，支持序列化、ORM、Web 开发、测试、验证等。
• Attribute 的语法：使用 [] 应用，支持位置参数和命名参数，可以指定目标，可以应用多个。
• 如何创建自定义 Attribute：继承 System.Attribute，使用 [AttributeUsage] 控制用法，定义构造函数和属性。
• 如何通过反射读取和处理 Attribute：使用 GetCustomAttributes() 和 IsDefined() 方法，并转换 Attribute 类型以访问其数据。
• 常见的内置 Attributes 示例：[Obsolete], [Conditional], [DllImport], [Serializable], Validation Attributes 等。
• Attributes 的局限性和注意事项：参数类型限制、不包含逻辑、反射开销等。
• Attributes 与其他机制的比较。

掌握 Attributes 的概念和用法，对于深入理解和有效利用许多 .NET 框架和库至关重要，同时也能让你设计出更具声明性和灵活性的自定义解决方案。希望本文能够帮助你全面掌握 C# Attributes 的奥秘。

---