Custom attribute classes in C Sharp (C#) - Deep Dive

Overview - Custom attribute classes

What is it?

Custom attribute classes in C# let you add extra information to your code elements like classes, methods, or properties. This information is stored as metadata and can be read at runtime or compile time. You create a custom attribute by making a new class that inherits from System.Attribute. Then you can use this attribute to mark parts of your code with special tags.

Why it matters

Custom attributes solve the problem of attaching extra data to code without changing its behavior directly. Without them, you would have to write extra code or use external files to store metadata, which is harder to maintain and less flexible. They make your code more expressive and allow frameworks or tools to understand how to handle your code automatically.

Where it fits

Before learning custom attributes, you should understand classes, inheritance, and basic C# syntax. After this, you can explore reflection to read attributes at runtime and advanced topics like aspect-oriented programming or code generation that use attributes heavily.

Mental Model

Core Idea

Custom attribute classes are special tags you create to add hidden notes or instructions to your code elements that can be read later.

Think of it like...

It's like putting sticky notes on pages of a book to remind yourself or others about important details without changing the text itself.

Code Element ──► [Custom Attribute]
       │               │
       │               └─ Extra info stored as metadata
       └─ Normal code behavior remains unchanged

Build-Up - 7 Steps

1

Foundation

What are Attributes in C#

Concept: Attributes are metadata tags that you can add to code elements to provide extra information.

In C#, attributes are classes that inherit from System.Attribute. You use them by placing them in square brackets above classes, methods, or properties. Example: [Obsolete("Use NewMethod instead")] public void OldMethod() { } This marks OldMethod as obsolete with a message.

Result

The method OldMethod is now marked with metadata that tools or the compiler can detect.

Understanding that attributes are just classes lets you see how flexible and powerful they can be.

2

Foundation

Creating a Simple Custom Attribute

Concept: You can create your own attribute by making a class that inherits from System.Attribute.

Example: public class MyInfoAttribute : Attribute { public string Info { get; } public MyInfoAttribute(string info) { Info = info; } } You can now use [MyInfo("some info")] on code elements.

Result

You have a new attribute that stores a string and can be applied to code elements.

Knowing how to create custom attributes opens the door to adding your own metadata to code.

3

Intermediate

Applying Custom Attributes to Code Elements

Concept: Attributes can be applied to different code elements like classes, methods, or properties to tag them with metadata.

Example: [MyInfo("Class info")] public class MyClass { [MyInfo("Method info")] public void MyMethod() { } } This shows how you can tag multiple parts of your code with your custom attribute.

Result

Both the class and method have metadata attached that can be read later.

Seeing attributes applied at different levels helps understand their flexibility in marking code.

4

Intermediate

Using AttributeUsage to Control Attribute Behavior

🤔Before reading on: Do you think you can apply any attribute anywhere by default? Commit to yes or no.

Concept: AttributeUsage lets you specify where your custom attribute can be applied and if it can be used multiple times on the same element.

Example: [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = false)] public class MyInfoAttribute : Attribute { public string Info { get; } public MyInfoAttribute(string info) { Info = info; } } This restricts usage to classes and methods only, and only once per element.

Result

The compiler enforces where and how often your attribute can be used.

Knowing how to restrict attribute usage prevents mistakes and clarifies your attribute's purpose.

5

Intermediate

Reading Custom Attributes with Reflection

🤔Before reading on: Do you think attributes are automatically used by the program, or do you have to ask for them? Commit to your answer.

Concept: To use the metadata stored in attributes, you read them at runtime using reflection APIs.

Example: var type = typeof(MyClass); var attrs = type.GetCustomAttributes(typeof(MyInfoAttribute), false); foreach (MyInfoAttribute attr in attrs) { Console.WriteLine(attr.Info); } This code finds and prints the Info string from MyInfoAttribute on MyClass.

Result

You get the stored metadata and can use it to change program behavior or display info.

Understanding that attributes are passive until read explains why reflection is essential to use them.

6

Advanced

Attributes with Multiple Parameters and Properties

🤔Before reading on: Can custom attributes have more than one piece of data? Commit to yes or no.

Concept: Custom attributes can have multiple constructor parameters and public properties to store various data types.

Example: public class VersionAttribute : Attribute { public int Major { get; } public int Minor { get; } public string Description { get; set; } public VersionAttribute(int major, int minor) { Major = major; Minor = minor; } } Usage: [Version(1, 0, Description = "Initial release")] public class MyClass { } This shows how to pass required and optional data.

Result

Attributes can carry rich metadata with required and optional parts.

Knowing how to design attributes with flexible data makes them more useful in real projects.

7

Expert

How Attributes Affect Compilation and Runtime

🤔Before reading on: Do you think attributes change how your code runs by themselves? Commit to yes or no.

Concept: Attributes do not change code behavior by themselves; they add metadata stored in compiled assemblies, which can be inspected or used by tools or frameworks at runtime or compile time.

When you compile, attributes are saved in the assembly's metadata. The runtime or other tools can read this metadata using reflection or specialized APIs. Some frameworks use attributes to generate code, enforce rules, or modify behavior dynamically. Example: The [Serializable] attribute marks a class for serialization but does not serialize it by itself.

Result

Attributes act as signals or markers, not direct behavior changers.

Understanding that attributes are passive metadata clarifies their role and prevents expecting automatic behavior changes.

Under the Hood

When you define a custom attribute class, the compiler treats it as a special class derived from System.Attribute. When you apply this attribute in code, the compiler stores an instance of this attribute's data in the assembly's metadata tables. At runtime, the .NET reflection system can read these metadata tables to retrieve attribute instances and their data. This process does not affect the execution flow unless your code or a framework explicitly reads and acts on these attributes.

Why designed this way?

Attributes were designed to separate metadata from code logic, allowing developers and tools to add descriptive information without changing program behavior. This design keeps code clean and flexible. Alternatives like embedding metadata in comments or external files were less reliable and harder to maintain. The attribute system leverages .NET's metadata infrastructure for efficient storage and retrieval.

Source Code
   │
   ▼
[Custom Attribute Class]
   │
   ▼
Compiler
   │
   ├─ Stores attribute data in assembly metadata
   │
   ▼
Assembly (DLL/EXE)
   │
   ▼
Runtime Reflection
   │
   └─ Reads attribute data on demand
   │
   ▼
Program or Framework uses metadata

Myth Busters - 4 Common Misconceptions

Quick: Do attributes automatically change how your program runs? Commit to yes or no.

Common Belief: Attributes automatically modify the behavior of the code they decorate.

Reality: Attributes only add metadata; they do not change code behavior unless explicitly read and acted upon by code or frameworks.

Why it matters: Expecting automatic behavior changes leads to confusion and bugs when attributes seem to have no effect.

Quick: Can you apply the same attribute multiple times on one method by default? Commit to yes or no.

Common Belief: You can always apply an attribute multiple times on the same code element.

Reality: By default, attributes can only be applied once unless AttributeUsage allows multiple usage.

Why it matters: Misunderstanding this causes compilation errors or unexpected attribute behavior.

Quick: Are attributes only useful for marking classes? Commit to yes or no.

Common Belief: Attributes are only meant for classes and cannot be applied to methods or properties.

Reality: Attributes can be applied to many code elements like methods, properties, fields, assemblies, and more.

Why it matters: Limiting attribute use reduces their power and flexibility in real-world applications.

Quick: Do attribute constructor parameters have to be optional? Commit to yes or no.

Common Belief: All attribute data must be optional and set via properties.

Reality: Attributes can have required constructor parameters and optional properties for flexible data design.

Why it matters: Misunderstanding this limits how you design attributes and can lead to awkward or unclear metadata.

Expert Zone

1

Attributes can be inherited by derived classes if marked with Inherited = true in AttributeUsage, which affects how metadata is read in inheritance chains.

2

Custom attributes can be combined with code generation tools or source generators to automate repetitive coding tasks based on metadata.

3

Reflection to read attributes can impact performance if overused; caching attribute data is a common optimization in production systems.

When NOT to use

Avoid using custom attributes when the metadata changes frequently at runtime or when performance is critical and reflection overhead is unacceptable. Instead, use configuration files, dependency injection, or explicit code to handle dynamic behavior.

Production Patterns

In production, custom attributes are widely used for validation rules, serialization instructions, authorization policies, and mapping database columns. Frameworks like ASP.NET Core use attributes to define routing, filters, and model binding, making code declarative and easier to maintain.

Connections

Reflection

Builds-on

Understanding custom attributes deeply requires knowing reflection, as it is the mechanism to read attribute metadata at runtime.

Annotations in Java

Similar pattern

Custom attributes in C# are conceptually similar to Java annotations, showing how different languages solve metadata tagging with similar ideas.

Metadata in Library Science

Analogous concept

Just like metadata describes books or documents without changing their content, custom attributes describe code elements without changing their behavior.

Common Pitfalls

#1 Expecting attributes to execute code automatically.

Wrong approach:

[MyInfo("test")]
public void DoSomething() {
// Expect this attribute to run code automatically
}

Correct approach:

[MyInfo("test")]
public void DoSomething() {
// Use reflection elsewhere to read and act on this attribute
}

Root cause:

Misunderstanding that attributes are passive metadata, not active code.

#2 Applying an attribute multiple times without allowing it.

Wrong approach:

[MyInfo("first")]
[MyInfo("second")]
public class MyClass { }

Correct approach:

[AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
public class MyInfoAttribute : Attribute { ... }

[MyInfo("first")]
[MyInfo("second")]
public class MyClass { }

Root cause:

Not setting AllowMultiple = true in AttributeUsage when multiple instances are needed.

#3 Not specifying AttributeUsage, leading to unintended attribute application.

Wrong approach:

public class MyInfoAttribute : Attribute { ... }

[MyInfo("info")]
public int myField;

Correct approach:

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
public class MyInfoAttribute : Attribute { ... }

[MyInfo("info")]
public class MyClass { }

Root cause:

Forgetting to restrict attribute targets causes misuse and confusion.

Key Takeaways

Custom attribute classes let you add extra metadata to your code without changing its behavior.

You create custom attributes by inheriting from System.Attribute and can control where and how they are applied using AttributeUsage.

Attributes are passive; you must use reflection to read and act on their data at runtime.

Designing attributes with constructor parameters and properties allows flexible and clear metadata.

Understanding attributes' role as metadata helps avoid common mistakes and unlocks powerful programming patterns.