C# Attributes Explained — Custom Metadata, Reflection and Real-World Patterns

using System;
using System.Reflection;

// A plain old class decorated with a built-in attribute.
// [Serializable] tells the runtime this class can be converted
// to bytes (e.g., for file storage or network transfer).
[Serializable]
public class CustomerOrder
{
    public int OrderId { get; set; }

    // [Obsolete] is a compiler-level attribute.
    // The string is the message shown in IDE warnings and build output.
    [Obsolete("Use CalculateTotalWithTax() instead. This method ignores VAT.")]
    public decimal CalculateTotal()
    {
        return 99.99m;
    }

    public decimal CalculateTotalWithTax(decimal vatRate)
    {
        return 99.99m * (1 + vatRate);
    }
}

class Program
{
    static void Main()
    {
        var order = new CustomerOrder { OrderId = 42 };

        // Reflect on the CustomerOrder TYPE (not an instance).
        // GetType() returns a Type object — the runtime's description
        // of what CustomerOrder looks like.
        Type orderType = order.GetType();

        // Check whether [Serializable] is present on this class.
        // IsDefined() is the fast path — it doesn't instantiate the attribute,
        // just checks if the metadata token exists.
        bool isSerializable = orderType.IsDefined(typeof(SerializableAttribute), inherit: false);
        Console.WriteLine($"Is CustomerOrder serializable? {isSerializable}");

        // Now look at a specific method and read its ObsoleteAttribute.
        MethodInfo oldMethod = orderType.GetMethod("CalculateTotal")!;

        // GetCustomAttribute<T>() DOES instantiate the attribute object.
        // This is the moment the attribute's constructor runs.
        ObsoleteAttribute? obsoleteInfo =
            oldMethod.GetCustomAttribute<ObsoleteAttribute>();

        if (obsoleteInfo != null)
        {
            // The Message property is set in the attribute's constructor.
            Console.WriteLine($"Warning — method is obsolete: {obsoleteInfo.Message}");
        }
    }
}

using System;
using System.Reflection;

// Step 1: Define AttributeUsage.
// AttributeTargets.Method means you can ONLY put this attribute on methods.
// AllowMultiple = false means you can't stack two [RequiresAuditLog] on one method.
// Inherited = true means if a subclass overrides the method, it inherits the attribute.
[AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
public sealed class RequiresAuditLogAttribute : Attribute
{
    // The reason for auditing — stored as metadata.
    public string Reason { get; }

    // AuditLevel lets callers declare how important this audit is.
    public AuditLevel Level { get; set; } = AuditLevel.Standard;

    // The constructor takes mandatory data — you must always provide a reason.
    public RequiresAuditLogAttribute(string reason)
    {
        Reason = reason;
    }
}

public enum AuditLevel { Standard, Critical }

// Step 2: Use the attribute on real service methods.
public class PaymentService
{
    [RequiresAuditLog("Financial transaction initiated", Level = AuditLevel.Critical)]
    public void ProcessPayment(decimal amount, string customerId)
    {
        // Real payment logic would go here.
        Console.WriteLine($"Processing £{amount} for customer {customerId}");
    }

    // No attribute — this method does NOT need auditing.
    public decimal GetAccountBalance(string customerId)
    {
        return 1500.00m;
    }
}

// Step 3: An "interceptor" that reads the attribute before invoking a method.
// In production this would live in middleware or a proxy, not Main().
public static class AuditInterceptor
{
    public static void Invoke(object serviceInstance, string methodName, object[] args)
    {
        Type serviceType = serviceInstance.GetType();
        MethodInfo? method = serviceType.GetMethod(methodName);

        if (method == null)
            throw new InvalidOperationException($"Method '{methodName}' not found.");

        // Read the attribute — returns null if not present.
        RequiresAuditLogAttribute? auditAttr =
            method.GetCustomAttribute<RequiresAuditLogAttribute>();

        if (auditAttr != null)
        {
            // Write the audit entry BEFORE the method runs.
            Console.WriteLine(
                $"[AUDIT | {auditAttr.Level.ToString().ToUpper()}] " +
                $"Method: {methodName} | Reason: {auditAttr.Reason} | " +
                $"Time: {DateTime.UtcNow:HH:mm:ss}"
            );
        }

        // Now actually call the method.
        method.Invoke(serviceInstance, args);
    }
}

class Program
{
    static void Main()
    {
        var paymentService = new PaymentService();

        // Call through the interceptor instead of directly.
        // In a real app, a DI container or proxy would do this automatically.
        AuditInterceptor.Invoke(
            paymentService,
            nameof(PaymentService.ProcessPayment),
            new object[] { 250.00m, "CUST-8821" }
        );

        Console.WriteLine();

        // This method has no audit attribute — no log entry is written.
        AuditInterceptor.Invoke(
            paymentService,
            nameof(PaymentService.GetAccountBalance),
            new object[] { "CUST-8821" }
        );
    }
}

using System;
using System.Reflection;

// This attribute can go on a class OR a method — not a property or field.
// AllowMultiple = true so we can attach multiple tags to one method.
// Inherited = false — subclasses don't silently inherit ownership tags.
[AttributeUsage(
    AttributeTargets.Class | AttributeTargets.Method,
    AllowMultiple = true,
    Inherited = false
)]
public sealed class OwnedByTeamAttribute : Attribute
{
    public string TeamName { get; }
    public string SlackChannel { get; set; } = "#engineering";

    public OwnedByTeamAttribute(string teamName)
    {
        TeamName = teamName;
    }
}

// Two attributes on the same class — allowed because AllowMultiple = true.
[OwnedByTeam("Payments", SlackChannel = "#payments-team")]
[OwnedByTeam("Platform", SlackChannel = "#platform-infra")]
public class RefundProcessor
{
    // A single attribute on a method.
    [OwnedByTeam("Payments")]
    public void IssueRefund(string orderId, decimal amount)
    {
        Console.WriteLine($"Refund of £{amount} issued for order {orderId}");
    }

    public void LogRefundAttempt(string orderId)
    {
        Console.WriteLine($"Logging refund attempt for {orderId}");
    }
}

// Subclass — does NOT inherit the [OwnedByTeam] attributes
// because Inherited = false on the attribute definition.
public class PartialRefundProcessor : RefundProcessor { }

class Program
{
    static void Main()
    {
        Type processorType = typeof(RefundProcessor);

        // GetCustomAttributes returns ALL instances when AllowMultiple = true.
        OwnedByTeamAttribute[] classOwners =
            (OwnedByTeamAttribute[])processorType
                .GetCustomAttributes(typeof(OwnedByTeamAttribute), inherit: false);

        Console.WriteLine("=== RefundProcessor owners ===");
        foreach (var owner in classOwners)
        {
            Console.WriteLine($"  Team: {owner.TeamName} | Channel: {owner.SlackChannel}");
        }

        // Now check the subclass — should have ZERO owners because Inherited = false.
        Type subType = typeof(PartialRefundProcessor);
        OwnedByTeamAttribute[] subOwners =
            (OwnedByTeamAttribute[])subType
                .GetCustomAttributes(typeof(OwnedByTeamAttribute), inherit: false);

        Console.WriteLine($"\n=== PartialRefundProcessor owners (expect 0): {subOwners.Length} ===");

        // Check the method — one attribute, attached at method level.
        MethodInfo issueRefundMethod = processorType.GetMethod("IssueRefund")!;
        OwnedByTeamAttribute[] methodOwners =
            (OwnedByTeamAttribute[])issueRefundMethod
                .GetCustomAttributes(typeof(OwnedByTeamAttribute), inherit: false);

        Console.WriteLine("\n=== IssueRefund method owners ===");
        foreach (var owner in methodOwners)
        {
            Console.WriteLine($"  Team: {owner.TeamName}");
        }
    }
}

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Reflection;
using System.Text.Json;
using System.Text.Json.Serialization;

// A model that uses Data Annotations for validation
// and System.Text.Json attributes for serialization shape.
public class CreateOrderRequest
{
    // [Required] — model binding will reject this if missing.
    // [StringLength] — EF Core will set VARCHAR(50) in the database.
    [Required(ErrorMessage = "Customer ID is mandatory.")]
    [StringLength(50, ErrorMessage = "Customer ID cannot exceed 50 characters.")]
    [JsonPropertyName("customer_id")] // JSON key uses snake_case
    public string CustomerId { get; set; } = string.Empty;

    [Range(1, 10000, ErrorMessage = "Order amount must be between £1 and £10,000.")]
    [JsonPropertyName("amount_gbp")]
    public decimal AmountGbp { get; set; }

    // [JsonIgnore] — this field is set server-side and must NEVER
    // appear in the outbound JSON response.
    [JsonIgnore]
    public string InternalTrackingCode { get; set; } = Guid.NewGuid().ToString();
}

// A simple validator that manually reads Data Annotation attributes.
// ASP.NET Core does this for you automatically — this shows you what's under the hood.
public static class ManualValidator
{
    public static List<string> Validate(object model)
    {
        var errors = new List<string>();
        Type modelType = model.GetType();

        foreach (PropertyInfo property in modelType.GetProperties())
        {
            // Get the actual value of this property on our model instance.
            object? value = property.GetValue(model);

            // Read ALL validation attributes from this property.
            IEnumerable<ValidationAttribute> validationAttrs =
                property.GetCustomAttributes<ValidationAttribute>();

            foreach (ValidationAttribute validator in validationAttrs)
            {
                // IsValid() is defined on ValidationAttribute base class.
                // Each subclass ([Required], [Range], etc.) overrides it.
                if (!validator.IsValid(value))
                {
                    // FormatErrorMessage fills in placeholders like {0} with the property name.
                    errors.Add($"{property.Name}: {validator.FormatErrorMessage(property.Name)}");
                }
            }
        }

        return errors;
    }
}

class Program
{
    static void Main()
    {
        // === Scenario 1: Invalid request — missing CustomerId, amount out of range ===
        var badRequest = new CreateOrderRequest
        {
            CustomerId = "",         // Fails [Required]
            AmountGbp = 99999m,      // Fails [Range]
            InternalTrackingCode = "TRK-001"
        };

        List<string> validationErrors = ManualValidator.Validate(badRequest);
        Console.WriteLine("=== Validation Errors ===");
        foreach (string error in validationErrors)
            Console.WriteLine($"  ✗ {error}");

        // === Scenario 2: Valid request — serialize to JSON ===
        var goodRequest = new CreateOrderRequest
        {
            CustomerId = "CUST-4421",
            AmountGbp = 149.99m,
            InternalTrackingCode = "TRK-SECRET-002" // This will NOT appear in JSON output
        };

        string json = JsonSerializer.Serialize(
            goodRequest,
            new JsonSerializerOptions { WriteIndented = true }
        );

        Console.WriteLine("\n=== Serialized JSON (note: no InternalTrackingCode) ===");
        Console.WriteLine(json);
    }
}