Making Handlers Generic-CodePudding

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?

CodePudding user response：

you are setting abstraction and constraints on function level, what means whichever class will implement that interface it will implement abstract method with its constraints, so you need to add where T : OptionsBase for the implementation as well, as @Hazrelle suggested in the comments.

public class FirstHandler : IHandler
{
    public int RunHandlerAndReturnExitCode<T>(T options) where T : OptionsBase
    {
        return 0;
    }
}

I don't know what your solution is meant for, but it also could be done this way

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

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

but in your case, just cause it's about passing options for function, the way you are trying to do it might be better

CodePudding user response：

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();
    }
}