1using System;
2
3public class MyService
4{
5    public string Name { get; set; } = "Default";
6}
7
8// Runtime instantiation — uses reflection internally
9object instance = Activator.CreateInstance(typeof(MyService));
10
11// Generic version — slightly cleaner syntax
12MyService service = Activator.CreateInstance<MyService>();
13
14// With constructor parameters
15var withArgs = (MyService)Activator.CreateInstance(typeof(MyService), "Custom");

1using System;
2using System.Linq.Expressions;
3
4public static class FastActivator<T> where T : new()
5{
6    // Compile once, reuse many times
7    private static readonly Func<T> Factory =
8        Expression.Lambda<Func<T>>(Expression.New(typeof(T))).Compile();
9
10    public static T Create() => Factory();
11}
12
13// Usage — near-native speed after first call
14MyService service = FastActivator<MyService>.Create();
15
16// Non-generic version for runtime types
17public static class FastActivator
18{
19    private static readonly Dictionary<Type, Func<object>> Cache = new();
20
21    public static object Create(Type type)
22    {
23        if (!Cache.TryGetValue(type, out var factory))
24        {
25            var expr = Expression.Lambda<Func<object>>(
26                Expression.Convert(Expression.New(type), typeof(object))
27            );
28            factory = expr.Compile();
29            Cache[type] = factory;
30        }
31        return factory();
32    }
33}

1using System;
2using System.Collections.Concurrent;
3using System.Reflection;
4
5public static class CachedActivator
6{
7    private static readonly ConcurrentDictionary<Type, ConstructorInfo> CtorCache = new();
8
9    public static object Create(Type type)
10    {
11        var ctor = CtorCache.GetOrAdd(type, t =>
12            t.GetConstructor(Type.EmptyTypes)
13            ?? throw new InvalidOperationException($"No parameterless constructor on {t}"));
14
15        return ctor.Invoke(null);
16    }
17
18    // With parameters
19    public static object Create(Type type, params object[] args)
20    {
21        var argTypes = Array.ConvertAll(args, a => a.GetType());
22        var ctor = type.GetConstructor(argTypes)
23            ?? throw new InvalidOperationException("No matching constructor");
24        return ctor.Invoke(args);
25    }
26}

1// When the type is known at compile time via generics
2public T CreateInstance<T>() where T : new()
3{
4    return new T();  // JIT compiles to direct constructor call
5}
6
7// In a factory pattern
8public interface IFactory<T>
9{
10    T Create();
11}
12
13public class DefaultFactory<T> : IFactory<T> where T : new()
14{
15    public T Create() => new T();
16}
17
18// Usage
19var factory = new DefaultFactory<MyService>();
20MyService service = factory.Create();  // no reflection

1using BenchmarkDotNet.Attributes;
2
3[MemoryDiagnoser]
4public class ActivatorBenchmarks
5{
6    [Benchmark(Baseline = true)]
7    public MyService DirectNew() => new MyService();
8
9    [Benchmark]
10    public object ActivatorCreate() => Activator.CreateInstance(typeof(MyService));
11
12    [Benchmark]
13    public MyService CompiledLambda() => FastActivator<MyService>.Create();
14
15    [Benchmark]
16    public object CachedCtor() => CachedActivator.Create(typeof(MyService));
17}
18
19// Typical results (relative to DirectNew):
20// DirectNew:         1.0x  (~2 ns)
21// CompiledLambda:    1.2x  (~2.5 ns)
22// CachedCtor:        5x    (~10 ns)
23// ActivatorCreate:   25x   (~50 ns)