Different Proxy

[kaylumah]

public class TestProxy
    {
        readonly IServiceProvider _ServiceProvider;

        public TestProxy(IServiceProvider serviceProvider)
        {
            _ServiceProvider = serviceProvider;
        }

        public TContract Create<TContract>() where TContract : notnull
        {
            TContract instance = _ServiceProvider.GetRequiredService<TContract>();
            return instance;
        }
        
        public TContract Create<TContract>(Type type, params object[] parameters)
        {
            object instance = ActivatorUtilities.CreateInstance(_ServiceProvider, type, parameters);
            if (instance is TContract instanceAsContract)
            {
                return instanceAsContract;
            }

            throw new InvalidOperationException();
        }
    }

bool IsProxyableClass(Type type)
{
    return !type.IsSealed
        && (type.IsPublic || type.IsNestedPublic)
        && type.GetMethods(BindingFlags.Public | BindingFlags.Instance)
                .Any(m => m.IsVirtual && !m.IsFinal);
}

bool IsClassProxyable(Type type)
{
    if (type.IsInterface)
        return true; // handled separately

    if (type.IsSealed)
        return false;

    if (!type.IsPublic && !type.IsNestedPublic)
        return false;

    if (type.IsAbstract)
        return false;

    if (type.IsGenericTypeDefinition)
        return false;

    // Must have at least one accessible constructor
    var hasCtor = type.GetConstructors(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
                      .Any(c => c.IsPublic || c.IsFamily || c.IsAssembly);
    if (!hasCtor)
        return false;

    // Must have at least one virtual method (optional, but good to check)
    var hasVirtuals = type.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
                          .Any(m => m.IsVirtual && !m.IsFinal && !m.IsStatic);
    return hasVirtuals;
}

[kaylumah]

var ctor = typeof(T).GetConstructors().First();
var parameters = ctor.GetParameters();
var args = parameters.Select(p => _ServiceProvider.GetRequiredService(p.ParameterType)).ToArray();

T proxy = _ProxyGenerator.CreateClassProxy(args, _Interceptors.ToArray());

T proxy = (T)ActivatorUtilities.CreateInstance(_ServiceProvider,
ProxyGenerator.CreateClassProxyType(typeof(T), Type.EmptyTypes, ProxyGenerationOptions.Default)
);