C# Reflection — 50x Throughput Drop from Invoke() Boxing

using System;
using System.Reflection;
using System.Linq;

// A realistic domain class we'll inspect at runtime
public class OrderProcessor
{
    private readonly string _regionCode;

    public int ProcessedCount { get; private set; }

    public OrderProcessor(string regionCode)
    {
        _regionCode = regionCode;
    }

    public decimal CalculateTotal(decimal subtotal, decimal taxRate)
    {
        ProcessedCount++;
        return subtotal + (subtotal * taxRate);
    }

    private void ResetCounters() => ProcessedCount = 0;
}

class ReflectionMetadataExplorer
{
    static void Main()
    {
        // GetType() on a live instance is the fastest path — no string lookup
        Type orderProcessorType = typeof(OrderProcessor);

        Console.WriteLine($"Full name   : {orderProcessorType.FullName}");
        Console.WriteLine($"Assembly    : {orderProcessorType.Assembly.GetName().Name}");
        Console.WriteLine($"Is abstract : {orderProcessorType.IsAbstract}");
        Console.WriteLine($"Base type   : {orderProcessorType.BaseType?.Name}");
        Console.WriteLine();

        // GetMembers with BindingFlags to include private and instance members
        // Without these flags you only get public instance members — a common trap
        BindingFlags allMembers = BindingFlags.Public | BindingFlags.NonPublic
                                | BindingFlags.Instance | BindingFlags.Static;

        Console.WriteLine("=== ALL MEMBERS ===");
        foreach (MemberInfo member in orderProcessorType.GetMembers(allMembers)
                                                         .OrderBy(m => m.MemberType.ToString()))
        {
            // MemberType tells you Constructor / Field / Method / Property / Event
            Console.WriteLine($"  [{member.MemberType,-12}] {member.Name}");
        }

        Console.WriteLine();
        Console.WriteLine("=== METHOD SIGNATURES ===");

        // GetMethods returns MethodInfo[], each carrying full parameter metadata
        foreach (MethodInfo method in orderProcessorType.GetMethods(allMembers)
                                                         .Where(m => !m.IsSpecialName)) // skip get_/set_ accessors
        {
            string parameters = string.Join(", ",
                method.GetParameters()
                      .Select(p => $"{p.ParameterType.Name} {p.Name}"));

            string visibility = method.IsPublic ? "public" : "private";
            Console.WriteLine($"  {visibility} {method.ReturnType.Name} {method.Name}({parameters})");
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;

// ── Custom attribute that marks a class as a command handler ──────────────────
[AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
public sealed class CommandHandlerAttribute : Attribute
{
    public string CommandName { get; }
    public CommandHandlerAttribute(string commandName) => CommandName = commandName;
}

// ── Handler contract ──────────────────────────────────────────────────────────
public interface ICommandHandler
{
    string Execute(string payload);
}

// ── Two handlers discovered purely via reflection — no registration code ──────
[CommandHandler("greet")]
public class GreetHandler : ICommandHandler
{
    public string Execute(string payload) => $"Hello, {payload}!";
}

[CommandHandler("shout")]
public class ShoutHandler : ICommandHandler
{
    public string Execute(string payload) => payload.ToUpperInvariant() + "!!";
}

// ── The dispatcher — built once, invoked thousands of times ───────────────────
public class CommandDispatcher
{
    // Stores pre-compiled factory delegates: () => ICommandHandler
    // Using Func<ICommandHandler> means we get a fresh handler instance per call
    // (swap for a singleton if your handlers are stateless and thread-safe)
    private readonly Dictionary<string, Func<ICommandHandler>> _handlerFactories
        = new(StringComparer.OrdinalIgnoreCase);

    public CommandDispatcher(Assembly searchAssembly)
    {
        // ── STARTUP COST: do all reflection here, once ────────────────────────
        foreach (Type candidateType in searchAssembly.GetTypes())
        {
            // IsDefined is cheaper than GetCustomAttribute when you only need presence
            if (!candidateType.IsClass || candidateType.IsAbstract)
                continue;

            CommandHandlerAttribute? attr =
                candidateType.GetCustomAttribute<CommandHandlerAttribute>();

            if (attr is null) continue;

            // Verify the type actually implements ICommandHandler at startup
            // Fail fast here rather than at dispatch time
            if (!typeof(ICommandHandler).IsAssignableFrom(candidateType))
                throw new InvalidOperationException(
                    $"{candidateType.Name} has [CommandHandler] but doesn't implement ICommandHandler");

            // ── Build a compiled factory: Expression<Func<ICommandHandler>> ──
            // This is the key performance trick. We use Expression trees to emit
            // a delegate that calls `new GreetHandler()` directly — no Activator,
            // no boxing, no reflection at invocation time.
            ConstructorInfo ctor = candidateType.GetConstructor(Type.EmptyTypes)
                ?? throw new InvalidOperationException(
                    $"{candidateType.Name} needs a parameterless constructor");

            // NewExpression represents `new T()` in the expression tree
            NewExpression newExpression = Expression.New(ctor);

            // Cast to ICommandHandler so the delegate type is uniform
            UnaryExpression castExpression =
                Expression.Convert(newExpression, typeof(ICommandHandler));

            // Compile into an actual delegate — this is the one-time JIT cost
            Func<ICommandHandler> factory =
                Expression.Lambda<Func<ICommandHandler>>(castExpression).Compile();

            _handlerFactories[attr.CommandName] = factory;

            Console.WriteLine($"[Startup] Registered '{attr.CommandName}' → {candidateType.Name}");
        }
    }

    public string Dispatch(string commandName, string payload)
    {
        if (!_handlerFactories.TryGetValue(commandName, out Func<ICommandHandler>? factory))
            return $"Unknown command: {commandName}";

        // This is now essentially a direct constructor call + interface dispatch
        // Zero reflection overhead here — just a compiled delegate invocation
        ICommandHandler handler = factory();
        return handler.Execute(payload);
    }
}

class Program
{
    static void Main()
    {
        // All reflection happens here — one time, at startup
        var dispatcher = new CommandDispatcher(Assembly.GetExecutingAssembly());

        Console.WriteLine();
        Console.WriteLine("=== DISPATCHING COMMANDS ===");

        // These calls have no reflection overhead — just compiled delegate + vtable dispatch
        Console.WriteLine(dispatcher.Dispatch("greet", "World"));
        Console.WriteLine(dispatcher.Dispatch("shout", "this works"));
        Console.WriteLine(dispatcher.Dispatch("unknown", "anything"));
    }
}

// Requires: dotnet add package BenchmarkDotNet
// Run with: dotnet run -c Release

using System;
using System.Linq.Expressions;
using System.Reflection;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

public class PriceCalculator
{
    public decimal ApplyDiscount(decimal price, decimal discountRate)
        => price * (1m - discountRate);
}

[MemoryDiagnoser]   // shows allocations per operation
[RankColumn]        // adds a rank column so differences are obvious
public class InvocationBenchmarks
{
    private readonly PriceCalculator _calculator = new();

    // ── Pre-fetched and cached — this is what good code does ─────────────────
    private readonly MethodInfo _cachedMethodInfo;
    private readonly Func<PriceCalculator, decimal, decimal, decimal> _compiledDelegate;

    public InvocationBenchmarks()
    {
        // Cache MethodInfo once — reuse thousands of times
        _cachedMethodInfo = typeof(PriceCalculator)
            .GetMethod(nameof(PriceCalculator.ApplyDiscount))!;

        // Build and compile an Expression tree delegate once
        // Signature: (PriceCalculator instance, decimal price, decimal discountRate) => decimal
        ParameterExpression instanceParam   = Expression.Parameter(typeof(PriceCalculator), "instance");
        ParameterExpression priceParam      = Expression.Parameter(typeof(decimal), "price");
        ParameterExpression discountParam   = Expression.Parameter(typeof(decimal), "discountRate");

        MethodCallExpression callExpression = Expression.Call(
            instanceParam, _cachedMethodInfo, priceParam, discountParam);

        _compiledDelegate = Expression
            .Lambda<Func<PriceCalculator, decimal, decimal, decimal>>(
                callExpression, instanceParam, priceParam, discountParam)
            .Compile();
    }

    [Benchmark(Baseline = true)]
    public decimal DirectCall()
        // This is the gold standard — what we compare everything else to
        => _calculator.ApplyDiscount(100m, 0.1m);

    [Benchmark]
    public decimal CachedMethodInfoInvoke()
        // Uses pre-fetched MethodInfo — avoids lookup overhead, still pays boxing cost
        // decimal args get boxed into object[] here — that's the main remaining cost
        => (decimal)_cachedMethodInfo.Invoke(_calculator, new object[] { 100m, 0.1m })!;

    [Benchmark]
    public decimal UncachedMethodInfoInvoke()
        // Worst case: reflects AND invokes on every call — never do this in a loop
        => (decimal)typeof(PriceCalculator)
            .GetMethod(nameof(PriceCalculator.ApplyDiscount))!
            .Invoke(_calculator, new object[] { 100m, 0.1m })!;

    [Benchmark]
    public decimal CompiledExpressionDelegate()
        // Best of both worlds: discovered via reflection once, executes like a direct call
        // No boxing, no late-bind overhead — the JIT sees this as a regular delegate call
        => _compiledDelegate(_calculator, 100m, 0.1m);
}

class Program
{
    static void Main() => BenchmarkRunner.Run<InvocationBenchmarks>();
}

using System;
using System.Reflection;
using System.Reflection.Emit;

// A simple interceptor that logs every method call
public class LoggingProxyBuilder
{
    public static T CreateProxy<T>(T target, Action<string> logAction)
        where T : class
    {
        Type targetType = typeof(T);
        
        AssemblyName assemblyName = new AssemblyName("DynamicProxyAssembly");
        AssemblyBuilder assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(
            assemblyName, AssemblyBuilderAccess.Run);
        ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule("MainModule");
        TypeBuilder typeBuilder = moduleBuilder.DefineType(
            $"{targetType.Name}_Proxy",
            TypeAttributes.Public | TypeAttributes.Class,
            targetType);
        
        // Store target and logAction in fields
        FieldBuilder targetField = typeBuilder.DefineField(
            "_target", targetType, FieldAttributes.Private);
        FieldBuilder logField = typeBuilder.DefineField(
            "_log", typeof(Action<string>), FieldAttributes.Private);
        
        // Constructor that takes target and logAction
        ConstructorBuilder ctorBuilder = typeBuilder.DefineConstructor(
            MethodAttributes.Public,
            CallingConventions.Standard,
            new[] { targetType, typeof(Action<string>) });
        ILGenerator ctorIl = ctorBuilder.GetILGenerator();
        ctorIl.Emit(OpCodes.Ldarg_0);
        ctorIl.Emit(OpCodes.Call, typeof(object).GetConstructor(Type.EmptyTypes));
        ctorIl.Emit(OpCodes.Ldarg_0);
        ctorIl.Emit(OpCodes.Ldarg_1);
        ctorIl.Emit(OpCodes.Stfld, targetField);
        ctorIl.Emit(OpCodes.Ldarg_0);
        ctorIl.Emit(OpCodes.Ldarg_2);
        ctorIl.Emit(OpCodes.Stfld, logField);
        ctorIl.Emit(OpCodes.Ret);
        
        // Override every public virtual method
        foreach (MethodInfo method in targetType.GetMethods(
            BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly))
        {
            if (!method.IsVirtual || method.IsFinal) continue;
            
            ParameterInfo[] parameters = method.GetParameters();
            Type[] paramTypes = Array.ConvertAll(parameters, p => p.ParameterType);
            MethodBuilder methodBuilder = typeBuilder.DefineMethod(
                method.Name,
                MethodAttributes.Public | MethodAttributes.Virtual,
                method.ReturnType,
                paramTypes);
            ILGenerator il = methodBuilder.GetILGenerator();
            
            // Log method call
            il.Emit(OpCodes.Ldarg_0);
            il.Emit(OpCodes.Ldfld, logField);
            il.Emit(OpCodes.Ldstr, $"{method.Name} called");
            il.Emit(OpCodes.Callvirt, typeof(Action<string>).GetMethod("Invoke"));
            
            // Call target method
            il.Emit(OpCodes.Ldarg_0);
            il.Emit(OpCodes.Ldfld, targetField);
            for (int i = 1; i <= parameters.Length; i++)
                il.Emit(OpCodes.Ldarg, i);
            il.Emit(OpCodes.Callvirt, method);
            il.Emit(OpCodes.Ret);
        }
        
        Type proxyType = typeBuilder.CreateType();
        return (T)Activator.CreateInstance(proxyType, target, logAction);
    }
}

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Reflection;
using System.Diagnostics.CodeAnalysis;

// ── Pattern 1: Thread-safe lazy discovery cache ───────────────────────────────
public static class TypeMetadataCache
{
    // ConcurrentDictionary is safe for concurrent reads AND writes
    // Regular Dictionary with concurrent writes causes data corruption — not just exceptions
    private static readonly ConcurrentDictionary<Type, PropertyInfo[]> _propertyCache = new();

    // GetOrAdd is atomic: if two threads race, only one factory runs, one result is stored
    public static PropertyInfo[] GetPublicProperties(Type targetType)
        => _propertyCache.GetOrAdd(targetType,
            t => t.GetProperties(BindingFlags.Public | BindingFlags.Instance));
}

// ── Pattern 2: AOT-safe reflection with [DynamicallyAccessedMembers] ──────────
public static class SafeActivator
{
    // The [DynamicallyAccessedMembers] attribute tells the IL trimmer:
    // "keep the parameterless constructor for whatever type T resolves to"
    // Without this, NativeAOT / Blazor WASM AOT may trim the constructor away
    public static T CreateInstance<
        [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] T>()
        where T : new()
    {
        return new T(); // Activator.CreateInstance<T>() would also work here
    }
}

// ── Pattern 3: Generic type construction at runtime ───────────────────────────
public static class GenericTypeBuilder
{
    public static object CreateGenericList(Type elementType)
    {
        // typeof(List<>) is the open generic definition — List with no type args
        Type openListType = typeof(List<>);

        // MakeGenericType closes the generic: List<> + string → List<string>
        Type closedListType = openListType.MakeGenericType(elementType);

        // Now we can construct it — Activator is fine here since it's a one-time setup
        return Activator.CreateInstance(closedListType)
               ?? throw new InvalidOperationException("Could not create list instance");
    }

    public static void AddItemToList(object list, object item)
    {
        // list is a List<T> for some T — we need to find Add(T item)
        // GetMethod("Add") would throw AmbiguousMatchException for types with overloads
        // Safe approach: filter by name AND parameter count
        Type listType = list.GetType();

        MethodInfo addMethod = Array.Find(
            listType.GetMethods(),
            m => m.Name == "Add" && m.GetParameters().Length == 1)
            ?? throw new InvalidOperationException("No Add(T) method found");

        addMethod.Invoke(list, new[] { item });
    }
}

// ── Pattern 4: Reflecting over generic method definitions ─────────────────────
public class DataConverter
{
    public T Convert<T>(string input) where T : IParsable<T>
        => T.Parse(input, null);

    public static void DemonstrateGenericMethodReflection()
    {
        Type converterType = typeof(DataConverter);

        // GetMethod with just the name works here because there's only one overload
        // But if overloads existed, we'd use GetMethods().Where(m => m.IsGenericMethodDefinition)
        MethodInfo openGenericMethod = converterType.GetMethod("Convert")
            ?? throw new MissingMethodException("Convert method not found");

        Console.WriteLine($"Is generic method def: {openGenericMethod.IsGenericMethodDefinition}");

        // Close the generic by specifying the type argument: Convert<int>
        MethodInfo closedMethod = openGenericMethod.MakeGenericMethod(typeof(int));

        DataConverter instance = new DataConverter();
        object result = closedMethod.Invoke(instance, new object[] { "42" })!;
        Console.WriteLine($"Converted result: {result} (type: {result.GetType().Name})");
    }
}

class Program
{
    static void Main()
    {
        // Thread-safe cache demo
        PropertyInfo[] props1 = TypeMetadataCache.GetPublicProperties(typeof(DateTime));
        PropertyInfo[] props2 = TypeMetadataCache.GetPublicProperties(typeof(DateTime)); // cache hit
        Console.WriteLine($"DateTime properties found: {props1.Length} (both calls same array: {ReferenceEquals(props1, props2)})");

        // Generic type construction
        object stringList = GenericTypeBuilder.CreateGenericList(typeof(string));
        GenericTypeBuilder.AddItemToList(stringList, "hello");
        GenericTypeBuilder.AddItemToList(stringList, "world");
        Console.WriteLine($"List type: {stringList.GetType().Name}, contents: {string.Join(", ", (List<string>)stringList)}");

        // Generic method reflection
        DataConverter.DemonstrateGenericMethodReflection();
    }
}

// io.thecodeforge
public static class AssemblyLoader
{
    public static Assembly SafeLoadFromPath(string path)
    {
        byte[] raw = File.ReadAllBytes(path);
        return Assembly.Load(raw); // unique identity, no context pollution
    }

    public static IEnumerable<Type> GetLoadableTypes(this Assembly assembly)
    {
        try { return assembly.GetTypes(); }
        catch (ReflectionTypeLoadException ex)
        {
            // Production: log ex.LoaderExceptions[0].Message
            return ex.Types.Where(t => t != null)!;
        }
    }
}

// io.thecodeforge
public static class AttributeCache<TAttribute> where TAttribute : Attribute
{
    private static readonly ConcurrentDictionary<Type, TAttribute?> _cache = new();

    public static TAttribute? GetOrAdd(Type type, bool inherit = true)
    {
        return _cache.GetOrAdd(type, t =>
        {
            var attr = t.GetCustomAttribute<TAttribute>(inherit);
            return attr;
        });
    }

    // For hot-path checks: 0 allocations
    public static bool IsDefinedOn(Type type, bool inherit = true)
        => Attribute.IsDefined(type, typeof(TAttribute), inherit);
}

// Source generator attribute
[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
public class GenerateMethodInvokerAttribute : Attribute
{
    public Type TargetType { get; }
    public string MethodName { get; }
    public GenerateMethodInvokerAttribute(Type targetType, string methodName)
    {
        TargetType = targetType;
        MethodName = methodName;
    }
}

// Partial method declaration (generated code)
public static partial class MethodInvokers
{
    [GenerateMethodInvoker(typeof(MyClass), "MyMethod")]
    public static partial void InvokeMyMethod(MyClass instance, int arg1, string arg2);
}

// Usage
MyClass obj = new MyClass();
MethodInvokers.InvokeMyMethod(obj, 42, "hello"); // No boxing, direct call

using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Text;
using System.Text;

[Generator]
public class MyIncrementalGenerator : IIncrementalGenerator
{
    public void Initialize(IncrementalGeneratorInitializationContext context)
    {
        var classDeclarations = context.SyntaxProvider.CreateSyntaxProvider(
            predicate: (node, _) => node is ClassDeclarationSyntax,
            transform: (ctx, _) => (ClassDeclarationSyntax)ctx.Node)
            .Where(c => c != null);

        context.RegisterSourceOutput(classDeclarations, (spc, classDecl) =>
        {
            var source = new StringBuilder($@"
namespace Generated
{{
    public static class {classDecl.Identifier.Text}Helper
    {{
        public static void Help() {{ }}
    }}
}}");
            spc.AddSource($"{classDecl.Identifier.Text}_Helper.g.cs", SourceText.From(source.ToString(), Encoding.UTF8));
        });
    }
}

using System;
using System.Runtime.InteropServices;

public class NativeReflection
{
    [UnmanagedCallersOnly]
    public static void MyNativeMethod(int arg1, IntPtr arg2)
    {
        Console.WriteLine($"Native call: {arg1}, {arg2}");
    }

    public unsafe void DynamicCall()
    {
        // Get function pointer from delegate
        var del = new Action<int, IntPtr>(MyNativeMethod);
        IntPtr ptr = Marshal.GetFunctionPointerForDelegate(del);
        
        // Cast to function pointer and invoke
        delegate* managed<int, IntPtr, void> funcPtr = (delegate* managed<int, IntPtr, void>)ptr;
        funcPtr(10, IntPtr.Zero);
    }
}

// Usage
unsafe
{
    delegate* managed<int, string, void> funcPtr = &ManagedMethod;
    funcPtr(1, "test");
}

static void ManagedMethod(int x, string y) => Console.WriteLine($"{x} {y}");