Custom Attributes is a mechanism in C# used to attach metadata to code elements. Its core function is to inherit the System.Attribute class and read through reflection at runtime to implement functions such as logging, permission control, etc. Specifically, it includes: 1. Custom Attributes is declarative information, which exists in the form of feature classes and is often used to mark classes, methods, etc.; 2. When creating, you need to define a class inherited from Attribute, and use AttributeUsage to specify the application target; 3. After application, you can obtain feature information through reflection, such as using Attribute.GetCustomAttribute(); 4. Commonly used in logging, permission verification, testing frameworks and other scenarios; 5. Abuse should be avoided during use, and pay attention to performance, naming specifications and scope of application.

In C#, Custom Attributes is a very practical tool that can be used to add metadata to elements in a program (such as classes, methods, attributes, etc.). This information can be read by reflection at runtime, enabling flexible functional expansion. Below are some common usage scenarios and specific operation methods.

What are Custom Attributes?

Custom Attributes is a mechanism for attaching declarative information to code elements. They are essentially classes inherited from System.Attribute . You can apply them to classes, methods, properties, parameters, etc., and then obtain this information through reflection at runtime.

For example, you can tag [Obsolete] on a method to indicate that this method is no longer recommended, or customize a [Log] attribute to identify the method that needs to be logged.

How to create custom features

Creating custom features is actually very simple. You only need to define a class inherited from System.Attribute . Constructors and public properties can be added as needed.

 [AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
public class LogAttribute : Attribute
{
    public string Message { get; set; }

    public LogAttribute()
    {
        Message = "This method is being logged.";
    }

    public LogAttribute(string message)
    {
        Message = message;
    }
}

In this example:

• AttributeUsage specifies the targets on which this feature can be applied (here is the method).
• AllowMultiple = false means that the same feature cannot be applied repeatedly.
• The constructor supports parameterless and message-free initialization.

How to apply and read features

After defining the feature, you can use it in specific methods or classes. For example:

 public class ExampleClass
{
    [Log("User login method")]
    public void Login()
    {
        Console.WriteLine("User logged in.");
    }
}

This feature can then be read by reflection:

 var methodInfo = typeof(ExampleClass).GetMethod("Login");
var attribute = (LogAttribute)Attribute.GetCustomAttribute(
    methodInfo,
    typeof(LogAttribute));

if (attribute != null)
{
    Console.WriteLine(attribute.Message); // Output: User login method
}

Key points:

• Use typeof() to get type information.
• Attribute.GetCustomAttribute() can get specific types of features.
• If the feature does not exist, the return value will be null , so it must be judged by conditions.

Common application scenarios

Custom features are often used in the following situations:

• Logging : A method to mark a log that needs to be recorded.
• Permission control : For example, [Authorize] marks a method that requires access to a specific role.
• Serialization control : Specifies whether the field participates in serialization.
• Test framework : such as [TestMethod] or [Fact] tag test method.

For example, in ASP.NET Core, controller methods often use [HttpGet] or [HttpPost] to define the type of HTTP method, which is also a feature-based mechanism behind it.

Notes and best practices

• Avoid abuse : Not all places are suitable for use with features, and overuse can make the code difficult to maintain.
• Performance considerations : Reflection operations are relatively time-consuming, and frequent calls require caching.
• Naming specification : It is recommended that feature class names end with Attribute , but can be omitted when used.
• Set AttributeTargets reasonably : clearly specify whether your attributes are suitable for classes, methods, or other elements.

Basically that's it. Custom features are a powerful feature, and using them well can improve the readability and maintainability of the code.

The above is the detailed content of Creating and Applying Custom Attributes in C#. For more information, please follow other related articles on the PHP Chinese website!