通用类型约束——我可以在方法级别上扩展类约束吗？

Question

I am working on some kind of a fluent API which would easily allow to register all necessary classes in the IoC container. For example:

builder
    .WithInput<EncryptedMessage>()
    .UseEncryptedMessageParser()
    // ...
    // .OtherEncryptedMessageFlowRegistrations()

builder
    .WithInput<StandardMessage>()
    .UseStandardMessageParser()
    // ...
    // .OtherStandardMessageFlowRegistrations()

What I'd like to achieve is to have less strict generic type constraints at the beginning, but make it more strict later in the hierarchy. Therefore, I am wondering if it's somehow possible to create a class with generic type constraints and then extend this generic type with additional constraints on method level ?

public class A<T> where T : class
{
    public void Foo(T input) where T : SomeBaseClass // additional constraints for generic type on class level
    {

    }
}

More realistic example:

public class MessageFlowBuilder<TInput> where TInput : class, new()
{
    private readonly IServiceCollection _services;

    public MessageFlowBuilder(IServiceCollection services)
    {
        _services = services;
    }

    public StandardMessageFlowBuilder<TInput> UseStandardMessageParser() 
        where TInput : StandardMessageBase // additional constraints for generic type on class level (required by parser)
    {
        _services.AddTransient<StandardMessageParser<TInput>>();
        return new StandardMessageFlowBuilder<TInput>();
    }

    public EncryptedMessageFlowBuilder<TInput> UseEncryptedMessageParser() 
        where TInput : EncryptedMessageBase // additional constraints for generic type on class level
    {
        _services.AddTransient<EncryptedMessageParser<TInput>>();
        return new EncryptedMessageFlowBuilder<TInput>();
    }
}

Or maybe is it possible to create another generic type on method level which then would have a constraint to be of the same type as class level argument?

public class A<T> where T : class
{
    public void Foo<T2>(T2 input) where T2 : SomeBaseClass // + some T == T2 type equality?
    {

    }
}

Answer 1

Could could make Foo a generic method, yes - but you can't constraint it to be the same as T , and you can't add a constraint to an existing type parameter.

Answer 2

Could you try something like this? I am not even sure right now whether this will compile fine or not. The method needs to be generic too on its own.

public class A<T> where T : class
{
    public void Foo<U>(U input) where U : T, SomeBaseClass, SomeInterface //whatever
    {

    }
}

Answer 3

public class A<T> where T : class
{
    public void Foo(T input) where T : SomeBaseClass // additional constraints for generic type on class level
    {

    }
}

No, the type T is declared when you instantiate the class, you can't change that at method level.

So by doing:

new A<SomeBase>();

You have effectively given the method the signature:

public void Foo(SomeBase input)