C# Attributes

Attributes in C# provide a powerful way to add metadata to your code elements such as classes, methods, properties, and more. This metadata can be used for various purposes, including enforcing behaviors, controlling serialization, enabling interop with other systems, and enhancing code analysis. Understanding how to effectively use attributes is essential for writing robust and maintainable C# applications.

Table of Contents

1. Introduction to Attributes
- What Are Attributes?
- Benefits of Using Attributes

2. Built-in Attributes
- Commonly Used Built-in Attributes
- Example: Using Built-in Attributes

3. Creating Custom Attributes
- Defining a Custom Attribute
- Attribute Targets and Usage
- Example: Creating and Applying a Custom Attribute

4. Attribute Parameters
- Positional vs. Named Parameters
- Example: Attribute with Parameters

5. Retrieving Attributes via Reflection
- Using Reflection to Access Attributes
- Example: Accessing Attributes at Runtime

6. Advanced Topics
- Attribute Inheritance
- Conditional Attributes
- Multi-use Attributes

7. Best Practices for Using Attributes
8. Common Mistakes with Attributes
9. Real-World Example
10. Summary

1. Introduction to Attributes

What Are Attributes?

Benefits of Using Attributes

2. Built-in Attributes

Commonly Used Built-in Attributes

Example: Using Built-in Attributes

using System;
using System.Runtime.InteropServices;

[Serializable]
public class Person
{
    public string Name { get; set; }
    
    [Obsolete("Age property is deprecated. Use BirthDate instead.", false)]
    public int Age { get; set; }

    public DateTime BirthDate { get; set; }
}

class Program
{
    static void Main()
    {
        Person p = new Person
        {
            Name = "Alice",
            Age = 30, // This will generate a compile-time warning
            BirthDate = new DateTime(1993, 5, 23)
        };

        Console.WriteLine($"Name: {p.Name}, Age: {p.Age}, BirthDate: {p.BirthDate.ToShortDateString()}");
    }
}

Sample Output:
Name: Alice, Age: 30, BirthDate: 5/23/1993

3. Creating Custom Attributes

Defining a Custom Attribute

using System;

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = false, AllowMultiple = true)]
public sealed class MyCustomAttribute : Attribute
{
    // Positional parameter
    public string Description { get; }

    // Named parameter
    public int Version { get; set; }

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

Attribute Targets and Usage

using System;

// Define the custom attribute
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = false, AllowMultiple = true)]
public sealed class DocumentationAttribute : Attribute
{
    public string Author { get; }
    public string Description { get; }
    public int Version { get; set; }

    public DocumentationAttribute(string author, string description)
    {
        Author = author;
        Description = description;
    }
}

// Apply the custom attribute to a class and a method
[Documentation("Alice", "This class handles user operations.", Version = 1)]
public class UserService
{
    [Documentation("Bob", "Creates a new user.", Version = 1)]
    public void CreateUser(string username)
    {
        // Method implementation
    }

    [Documentation("Charlie", "Deletes an existing user.", Version = 2)]
    public void DeleteUser(string username)
    {
        // Method implementation
    }
}

class Program
{
    static void Main()
    {
        // No output is produced here; attributes are metadata.
    }
}

Sample Output:
(No output; attributes are metadata used at compile-time or runtime via reflection.)

4. Attribute Parameters

Positional vs. Named Parameters

using System;

[AttributeUsage(AttributeTargets.Class, Inherited = false)]
public sealed class InfoAttribute : Attribute
{
    // Positional parameter
    public string Title { get; }

    // Named parameter
    public string Description { get; set; }
    public int Priority { get; set; }

    public InfoAttribute(string title)
    {
        Title = title;
    }
}

[Info("User Management", Description = "Handles all user-related operations.", Priority = 1)]
public class UserService
{
    // Class implementation
}

class Program
{
    static void Main()
    {
        // No output; attributes are metadata.
    }
}

Sample Output:
(No output; attributes are metadata used at compile-time or runtime via reflection.)

5. Retrieving Attributes via Reflection

Using Reflection to Access Attributes

using System;
using System.Reflection;

// Define the custom attribute
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = false, AllowMultiple = true)]
public sealed class DocumentationAttribute : Attribute
{
    public string Author { get; }
    public string Description { get; }
    public int Version { get; set; }

    public DocumentationAttribute(string author, string description)
    {
        Author = author;
        Description = description;
    }
}

// Apply the custom attribute to a class and a method
[Documentation("Alice", "This class handles user operations.", Version = 1)]
public class UserService
{
    [Documentation("Bob", "Creates a new user.", Version = 1)]
    public void CreateUser(string username)
    {
        // Method implementation
    }

    [Documentation("Charlie", "Deletes an existing user.", Version = 2)]
    public void DeleteUser(string username)
    {
        // Method implementation
    }
}

class Program
{
    static void Main()
    {
        Type type = typeof(UserService);
        object[] classAttributes = type.GetCustomAttributes(typeof(DocumentationAttribute), false);

        Console.WriteLine($"Class: {type.Name}");
        foreach (DocumentationAttribute attr in classAttributes)
        {
            Console.WriteLine($" Author: {attr.Author}");
            Console.WriteLine($" Description: {attr.Description}");
            Console.WriteLine($" Version: {attr.Version}");
        }

        MethodInfo method = type.GetMethod("CreateUser");
        object[] methodAttributes = method.GetCustomAttributes(typeof(DocumentationAttribute), false);

        Console.WriteLine($"\nMethod: {method.Name}");
        foreach (DocumentationAttribute attr in methodAttributes)
        {
            Console.WriteLine($" Author: {attr.Author}");
            Console.WriteLine($" Description: {attr.Description}");
            Console.WriteLine($" Version: {attr.Version}");
        }
    }
}

Sample Output:
Class: UserService
Author: Alice
Description: This class handles user operations.
Version: 1
Method: CreateUser
Author: Bob
Description: Creates a new user.
Version: 1

6. Advanced Topics

6.1 Attribute Inheritance

using System;

// Define an attribute with Inherited = true
[AttributeUsage(AttributeTargets.Class, Inherited = true)]
public sealed class InheritableAttribute : Attribute
{
    public string Info { get; }

    public InheritableAttribute(string info)
    {
        Info = info;
    }
}

// Define an attribute with Inherited = false
[AttributeUsage(AttributeTargets.Class, Inherited = false)]
public sealed class NonInheritableAttribute : Attribute
{
    public string Info { get; }

    public NonInheritableAttribute(string info)
    {
        Info = info;
    }
}

[Inheritable("Base Class Info")]
[NonInheritable("Base Class Non-Inheritable Info")]
public class BaseClass
{
}

public class DerivedClass : BaseClass
{
}

class Program
{
    static void Main()
    {
        Type type = typeof(DerivedClass);
        object[] inheritableAttrs = type.GetCustomAttributes(typeof(InheritableAttribute), false);
        object[] nonInheritableAttrs = type.GetCustomAttributes(typeof(NonInheritableAttribute), false);

        Console.WriteLine("Inheritable Attributes on DerivedClass:");
        foreach (InheritableAttribute attr in inheritableAttrs)
        {
            Console.WriteLine($" Info: {attr.Info}");
        }

        Console.WriteLine("\nNon-Inheritable Attributes on DerivedClass:");
        foreach (NonInheritableAttribute attr in nonInheritableAttrs)
        {
            Console.WriteLine($" Info: {attr.Info}");
        }
    }
}

Sample Output:
Inheritable Attributes on DerivedClass:
Info: Base Class Info
Non-Inheritable Attributes on DerivedClass:

6.2 Conditional Attributes

using System;
using System.Diagnostics;

// Define a conditional attribute
[Conditional("DEBUG")]
public sealed class DebugOnlyAttribute : Attribute
{
    public string Message { get; }

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

public class Logger
{
    [DebugOnly("This method is for debugging purposes only.")]
    public void DebugLog(string message)
    {
        Console.WriteLine($"DEBUG: {message}");
    }
}

class Program
{
    static void Main()
    {
        Logger logger = new Logger();
        logger.DebugLog("Starting application."); // This will only execute in DEBUG mode
    }
}

Sample Output (DEBUG mode):
DEBUG: Starting application.

Sample Output (RELEASE mode):
(No output; the `DebugLog` method call is omitted)

6.3 Multi-use Attributes

using System;

[AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
public sealed class TagAttribute : Attribute
{
    public string Name { get; }

    public TagAttribute(string name)
    {
        Name = name;
    }
}

[Tag("Data")]
[Tag("Service")]
public class DataService
{
}

class Program
{
    static void Main()
    {
        Type type = typeof(DataService);
        object[] tags = type.GetCustomAttributes(typeof(TagAttribute), false);

        Console.WriteLine($"Tags for {type.Name}:");
        foreach (TagAttribute tag in tags)
        {
            Console.WriteLine($" - {tag.Name}");
        }
    }
}

Sample Output:
Tags for DataService:
- Data
- Service

7. Best Practices for Using Attributes

8. Common Mistakes with Attributes

public class MyCustom : Attribute
{
  // Implementation
}

[MyCustom] // Correct usage
public class Sample { }

// Trying to use [MyCustomAttribute] will not work unless defined

[AttributeUsage(AttributeTargets.Method)]
public sealed class ClassAttribute : Attribute
{
  // Intended for classes but restricted to methods
}

public sealed class MutableAttribute : Attribute
{
  public string Name { get; set; } // Mutable property
}

[MyAttribute(1)]
public struct MyStruct { }

public class MyAttribute : Attribute
{
  public int Value { get; }

  public MyAttribute(int value)
  {
      Value = value;
  }
}

[Tag("Data")]
[Tag("Service")]
public class DataService { }

// Accessing only the first attribute
var tag = (TagAttribute)typeof(DataService).GetCustomAttribute(typeof(TagAttribute));
Console.WriteLine(tag.Name); // Outputs: Data (ignores Service)

9. Real-World Example: Serialization Control with Attributes

Example: Using Attributes with JSON Serialization

using System;
using System.Text.Json;
using System.Text.Json.Serialization;

// Define a custom attribute to ignore a property
[AttributeUsage(AttributeTargets.Property)]
public sealed class IgnorePropertyAttribute : Attribute
{
}

// Define a class with serialization attributes
public class Employee
{
    public int Id { get; set; }

    [JsonPropertyName("full_name")]
    public string Name { get; set; }

    [IgnoreProperty]
    public string Password { get; set; }

    [JsonIgnore]
    public string InternalCode { get; set; }

    public override string ToString()
    {
        return $"Id: {Id}, Name: {Name}, Password: {Password}, InternalCode: {InternalCode}";
    }
}

// Custom converter to handle IgnorePropertyAttribute
public class IgnorePropertyConverter<T> : JsonConverter<T> where T : class, new()
{
    public override T Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
        // Implement deserialization if needed
        return JsonSerializer.Deserialize<T>(ref reader, options);
    }

    public override void Write(Utf8JsonWriter writer, T value, JsonSerializerOptions options)
    {
        var type = typeof(T);
        writer.WriteStartObject();
        foreach (var prop in type.GetProperties())
        {
            if (Attribute.IsDefined(prop, typeof(IgnorePropertyAttribute)) || Attribute.IsDefined(prop, typeof(JsonIgnoreAttribute)))
                continue;

            var propValue = prop.GetValue(value);
            var propName = prop.GetCustomAttribute< JsonPropertyNameAttribute>()?.Name ?? prop.Name;
            JsonSerializer.Serialize(writer, propValue, prop.PropertyType, options);
            writer.WritePropertyName(propName);
            JsonSerializer.Serialize(writer, propValue, prop.PropertyType, options);
        }
        writer.WriteEndObject();
    }
}

class Program
{
    static void Main()
    {
        Employee emp = new Employee
        {
            Id = 1,
            Name = "John Doe",
            Password = "Secret123",
            InternalCode = "XYZ-789"
        };

        var options = new JsonSerializerOptions
        {
            Converters = { new IgnorePropertyConverter<Employee>() },
            WriteIndented = true
        };

        string json = JsonSerializer.Serialize(emp, options);
        Console.WriteLine("Serialized JSON:");
        Console.WriteLine(json);

        Employee deserializedEmp = JsonSerializer.Deserialize<Employee>(json, options);
        Console.WriteLine("\nDeserialized Employee:");
        Console.WriteLine(deserializedEmp);
    }
}

Sample Output:
Serialized JSON:
{ "Id": 1, "full_name": "John Doe" } Deserialized Employee:
Id: 1, Name: John Doe, Password: , InternalCode:

10. Summary