使处理程序通用

Question

So I'm writing a C# System.Commandline app, and I've noticed that my methods all follow a similar structure - each Handler class has a single public method, RunHandlerAndReturnExitCode, taking a different set of options which I've encapsulated into a class to be passed as the parameter. Like below:

public class FirstHandler
{
    public int RunHandlerAndReturnExitCode(FirstOptions options) { }
}

public class SecondHandler
{
    public int RunHandlerAndReturnExitCode(SecondOptions options) { }
}

And so on. I've tried making an OptionsBase abstract class, and having my other Options classes inherit from it, then created a handler interface like the below:

internal interface IHandler
    {
        int RunHandlerAndReturnExitCode<T>(T options) where T : OptionsBase;
    }

With the handlers looking like:

public class FirstHandler : IHandler
{
    public int RunHandlerAndReturnExitCode<FirstOptions>(FirstOptions options) { }
}

Edit: I also have the Options classes inheriting from OptionsBase:

public class FirstOptions : OptionsBase
{
    public string FirstProperty { get; set; }
}

And the OptionsBase class:

public abstract class OptionsBase { }

But this returns the error "The constraints for type parameter 'FirstOptions' must match the constraints for type parameter T. (Consider using an explicit interface implementation instead).

Where am I going wrong? Is this even the right approach?

Answer 1

you are setting abstraction and constraints on function level, which means whichever class will implement that interface will implement an abstract method with its constraints.

public class Program
{
    public static void Main()
    {
        new GenericHandler<FirstOptions>().RunHandlerAndReturnExitCode(new FirstOptions
        {
            FirstProperty = "FirstOptionProp",
            SomeBaseOptionOne = 1,
            SomeBaseOptionTwo = 2,
        });
        new FirstHandler().RunHandlerAndReturnExitCode(new FirstOptions
        {
            FirstProperty = "FirstOptionProp",
            SomeBaseOptionOne = 1,
            SomeBaseOptionTwo = 2,
        }); ;
    }
}

public abstract class OptionsBase
{
    public int SomeBaseOptionOne { get; set; }
    public int SomeBaseOptionTwo { get; set; }
}

public class FirstOptions : OptionsBase
{
    public string FirstProperty { get; set; }
}

internal interface IHandler<T>
    where T : OptionsBase
{
    int RunHandlerAndReturnExitCode(T options);
}

public class FirstHandler : IHandler<FirstOptions>
{
    public int RunHandlerAndReturnExitCode(FirstOptions options)
    {
        return options.SomeBaseOptionTwo;
    }
}

public class GenericHandler<T> : IHandler<T>
{
    public int RunHandlerAndReturnExitCode(T options)
    {
        //TODO: do some generic imlementation

        return 0;
    }
}

you can register it in services as:

services.AddScoped(typeof(IHandler<FirstOptions>), typeof(FirstHandler))
services.AddScoped(typeof(IHandler<>), typeof(GenericHandler<>))

Answer 2

Based on what you are trying to do, you can do it like the following.

The Interface should have the Generic Type set on it, ie. IHandler<T> where T: OptionsBase , Then have separate implementations of the FirstHandler and SecondHandler .

public class OptionsBase
{

}

public class FirstOptions : OptionsBase
{

}

public class SecondOptions : OptionsBase
{

}

internal interface IHandler<T> where T : OptionsBase
{
    int RunHandlerAndReturnExitCode(T options);
}

public class FirstHandler : IHandler<FirstOptions>
{
    public int RunHandlerAndReturnExitCode(FirstOptions options)
    {
        throw new NotImplementedException();
    }
}    

public class SecondHandler : IHandler<SecondOptions>
{
    public int RunHandlerAndReturnExitCode(SecondOptions options)
    {
        throw new NotImplementedException();
    }
}

This gives you the ability to test each handler individually, introduce a base abstract class, and also use DependencyInjection for the options: Like the following example:

public abstract class AbstracHandler<T> : IHandler<T> where T : OptionsBase
{
    protected readonly T _options;

    public AbstracHandler(T options)
    {
        _options = options;
    }
    public abstract int RunHandlerAndReturnExitCode(T options);
}

public class FirstHandler : AbstracHandler<FirstOptions>
{
    public FirstHandler(FirstOptions options) : base(options)
    {

    }

    public override int RunHandlerAndReturnExitCode(FirstOptions options)
    {
        throw new NotImplementedException();
    }
}