C# Attributes — The Reflection Caching Gap Killing Your RPS

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;

// 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;

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

[SensitiveData] // on class is valid
public class UserCredentials
{
    [SensitiveData] // on property is valid
    public string Password { get; set; } = string.Empty;

    // Compile error: Attribute 'SensitiveDataAttribute' is not valid on this declaration type.
    // [SensitiveData]
    // public void Encrypt() { }

    // This would work if we added AttributeTargets.Method above.
}

using System;
using System.Diagnostics;
using System.Reflection;

public class DebugOnlyAttribute : Attribute
{
    public string Reason { get; }
    public DebugOnlyAttribute(string reason) => Reason = reason;
}

public class RequestHandler
{
    // This attribute only exists in DEBUG builds.
    // In RELEASE, the compiler sees nothing above this method.
#if DEBUG
    [DebugOnly("Tracing all requests for debugging")]
#endif
    public void HandleRequest()
    {
        Console.WriteLine("Request handled.");
    }
}

class Program
{
    static void Main()
    {
        var method = typeof(RequestHandler).GetMethod(nameof(RequestHandler.HandleRequest))!;
        var attr = method.GetCustomAttribute<DebugOnlyAttribute>();

        if (attr != null)
        {
            Console.WriteLine($"Debug attribute found: {attr.Reason}");
        }
        else
        {
            Console.WriteLine("No DebugOnly attribute — we're in RELEASE mode.");
        }
    }
}

using System;
using System.Collections.Concurrent;
using System.Reflection;

/// <summary>
/// Thread-safe cache for attribute lookups.
/// Uses Lazy<T> to ensure attribute is instantiated at most once per key,
/// even under concurrent requests.
/// </summary>
public static class AttributeCache<TAttribute> where TAttribute : Attribute
{
    private static readonly ConcurrentDictionary<MemberInfo, Lazy<TAttribute?>> _cache = new();

    public static TAttribute? Get(MemberInfo member)
    {
        // GetOrAdd is thread-safe: the factory is executed at most once per key.
        return _cache.GetOrAdd(member, mi =>
            new Lazy<TAttribute?>(() => mi.GetCustomAttribute<TAttribute>())
        ).Value;
    }

    /// <summary>
    /// For assemblies that can be unloaded (AssemblyLoadContext),
    /// call this method when the assembly is unloaded to release cached references.
    /// </summary>
    public static void Clear()
    {
        _cache.Clear();
    }
}

// Usage in a middleware or service:
public class RateLimitMiddleware
{
    private static readonly ConcurrentDictionary<MethodInfo, RateLimitAttribute?> _rateLimitCache = new();

    public void ProcessRequest(string endpoint)
    {
        MethodInfo method = GetControllerMethod(endpoint); // hypothetical

        // Using the generic cache:
        var attr = AttributeCache<RateLimitAttribute>.Get(method);
        if (attr != null)
        {
            // Apply rate limiting logic using attr.MaxRequests etc.
        }

        // Alternative direct ConcurrentDictionary (faster for single attribute type):
        var attr2 = _rateLimitCache.GetOrAdd(method, m => m.GetCustomAttribute<RateLimitAttribute>());
    }

    private MethodInfo GetControllerMethod(string endpoint) => typeof(object).GetMethod("ToString")!; // placeholder
}

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);
    }
}