In C#, Attributes are a way to associate metadata with code elements. They provide additional information that can be queried through reflection at runtime and play a key role in metaprogramming. 1. Attributes are applied to target elements through square brackets, such as marking methods as obsolete; 2. Custom attributes can be created by inheriting System.Attribute, such as adding description information to the class; 3. Use reflection to read the attribute content dynamically, which is very useful for building systems such as serializers, ORMs or test runners; 4. Attributes are often used to mark members that need to be ignored, annotated unit test methods, and define Web API model verification rules; 5. In metaprogramming, attributes combined with reflection support plug-in automatic detection, dependency injection management, and routing and authorization of ASP.NET MVC; 6. Due to the low reflection performance, caching should be considered when operating frequently to improve efficiency. Therefore, despite the small properties themselves, they make modern C# development more flexible and easy to maintain.

In C#, attributes are a way to associate metadata with code elements like classes, methods, properties, or even assemblies. They provide additional information that can be queried at runtime using reflection, and they play a key role in metaprogramming—where code inspects and modify its own structure or behavior dynamically.

What Do Attributes Look Like in C#?

An attribute is applied using square brackets just before the target element. For example:

 [Obsolete("Use the new version instead.")]
public void OldMethod()
{
    // Method implementation
}

Here, Obsolete is an attribute built into the .NET framework that tells the compiler this method shouldn't be used anymore.

You can also create your own custom attributes by inheriting from System.Attribute . Here's a basic example:

 public class MyCustomAttribute : Attribute
{
    public string Description { get; }

    public MyCustomAttribute(string description)
    {
        Description = description;
    }
}

[MyCustom("This is a sample class")]
public class SampleClass
{
    // Class body
}

Now, SampleClass has some extra info attached to it via the MyCustom attribute.

How to Use Reflection to Access Attributes

Reflection lets you inspect types, methods, and other members at runtime. Combined with attributes, it becomes a powerful tool for dynamic behavior.

Let's say you want to read the MyCustom attribute from SampleClass . Here's how you might do that:

 var type = typeof(SampleClass);
var attr = (MyCustomAttribute)Attribute.GetCustomAttribute(
    type,
    typeof(MyCustomAttribute));

if (attr != null)
{
    Console.WriteLine(attr.Description); // Outputs: This is a sample class
}

This kind of pattern is useful when building systems like serializers, ORMs, or test runners that need to make decisions based on metadata rather than hardcoded logic.

Some common use cases include:

• Marking methods to be ignored during serialization
• Annotating test methods in unit testing frameworks
• Defining validation rules for models in web APIs

Using Attributes in Metaprogramming Scenarios

Metaprogramming referers to writing code that manipulates or generates other code. While C# isn't as flexible as languages ??like Ruby or Python in this area, attributes combined with reflection allows for a fair amount of dynamic behavior.

For instance, imagine you're building a plugin system where certain classes should be auto-detected and registered. You could define an attribute like [Plugin] , apply it to relevant classes, and then scan all loaded assemblies at startup for types marked with that attribute.

Another example is dependency injection containers that look for [Service] or [Scoped] attributes to determine how to manage object lifetimes.

Even tools like ASP.NET MVC use attributes heavily—for routing, authorization, model binding, etc.

One thing to keep in mind is performance. Reflection isn't blazing fast, so if you're scanning many types or doing it frequently, caching results can help avoid slowdowns.

Attributes Are Simple but Powerful Tools

They may seem small and unassuming, but attributes are a big part of what makes modern C# development flexible and maintainable. Whether you're using them out-of-the-box or creating your own, they let you add declarative information that drives behavior behind the scenes.

Used wisely, they reduce boilerplate and separate concerns—like keeping configuration close to the code it affects.

So next time you see something like [Authorize] or [JsonProperty] , remember: there's a good chance reflection and attributes working together under the hood.

That's basically it.

The above is the detailed content of What are attributes in C#, and how can they be used for reflection and metaprogramming?. For more information, please follow other related articles on the PHP Chinese website!