使处理程序通用

Question

所以我正在编写一个 C# System.Commandline 应用程序，并且我注意到我的方法都遵循类似的结构 - 每个 Handler 类都有一个公共方法 RunHandlerAndReturnExitCode，采用一组不同的选项，我已经封装到一个类中作为参数传递。如下：

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

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

等等。我尝试创建一个 OptionsBase 抽象类，并让我的其他 Options 类从它继承，然后创建了一个处理程序接口，如下所示：

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

处理程序看起来像：

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

编辑：我还有从 OptionsBase 继承的 Options 类：

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

还有 OptionsBase 类：

public abstract class OptionsBase { }

但这会返回错误“类型参数 'FirstOptions' 的约束必须与类型参数 T 的约束匹配。（请考虑改用显式接口实现）。

我哪里错了？这甚至是正确的方法吗？

Answer 1

根据您要执行的操作，您可以按照以下方式进行操作。

接口应该设置通用类型，即。 IHandler<T> where T : OptionsBase，然后分别实现FirstHandler和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();
    }
}

这使您能够单独测试每个处理程序，引入基本抽象类，并使用 DependencyInjection 作为选项：如以下示例：

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

Answer 2

您正在函数级别设置抽象和约束，这意味着任何实现该接口的类都将实现带有约束的抽象方法。

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

您可以在服务中将其注册为：

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