控制器内部的架构验证

本文关键字：验证 内部 控制器 | 更新日期: 2023-09-27 18:31:39

我正在寻找给定数据中的最佳解决方案：一个带有 Put 方法的控制器，其中包含 2 个字符串作为参数：key 和 jsonValue .

我要做的是：检查jsonValue是否是有效的<key>类型并插入 Db。

我所做的是创建一个具有所有<key>可能性的枚举，并在Put内部我编写了一个开关 （ Enum.Key ）

Enum.TryParse(key, true, out configType);
switch (configType)
{
    case ConfigType.Configuration:
        if(IsValid(key, value))
            Insert();
        break;
    case ConfigType.Configuration2:
        ...
private bool IsValid(key, value)
{
    Enum.TryParse(key, true, out configType);
        switch (configType)
        {
            case ConfigType.Configuration:
                var values = JsonConvert.DeserializeObject<IEnumerable<ConfigData>>(value);
                if (!routingConfigurationData.Any())
                    return false;
                break;
            case ConfigType.Configuration2:
                ...
}

这是很菜鸟的事情...我正在考虑创建一个工厂，ConfigurationFactory使用方法Create该方法将根据键返回泛型类型（我可以将键映射到类型）......但是对于Create方法，每种类型我需要 4-5 个类（例如签名配置创建、配置2 创建 => T 创建）。

你能给我一些更好的主意吗？

谢谢大家！

控制器内部的架构验证

下面演示了如何将代码从开关大小写转换为责任链。

用于实现抽象的接口和请求实体：

public interface IProcessor
{
    public bool Process(ProcessRequest request);
    public bool IsResponsible();
}
/// <summary>
/// Add any data required to supply to the processors.
/// </summary>
public class ProcessRequest
{
    public ConfigType Type { get; set; }
    public string Value { get; set; }
}

现在，基类用于执行一些管道工作，以决定执行派生类方法的业务。

public abstract class ProcessorBase : IProcessor
{
    protected IProcessor successor;
    public ProcessorBase(IProcessor successorObj)
    {
        this.successor = successorObj;
    }
    public bool Process(ProcessRequest request)
    {
        if (request == null)
        {
            throw new ArgumentNullException("request");
        }
        if (this.IsResponsible(request.Type))
        {
            return this.InnerProcess(request);
        }
        else
        {
            return this.successor.Process(request);
        }
    }
    public abstract bool InnerProcess(ProcessRequest request);
    public abstract bool IsResponsible(ConfigType type);
}

现在来了您的具体类，它们将成为处理配置数据的实际处理器。

public class Configuration1Processor : ProcessorBase
{
    public Configuration1Processor(IProcessor successor)
        : base(successor) { }
    public override bool InnerProcess(ProcessRequest request)
    {
        var values = JsonConvert.DeserializeObject<IEnumerable<ConfigData>>(request.Value);
        if (routingConfigurationData.Any())
        {
            return true;
        }
        return false;
    }
    public override bool IsResponsible(ConfigType type)
    {
        return type == ConfigType.Configuration1;
    }
}
public class Configuration2Processor : ProcessorBase
{
    public Configuration2Processor(IProcessor successor)
        : base(successor) { }
    public override bool InnerProcess(ProcessRequest request)
    {
        // here goes the business logic
        return false;
    }
    public override bool IsResponsible(ConfigType type)
    {
        return type == ConfigType.Configuration2;
    }
}

现在我们只需要一个构建器方法类，它将充当创建具体处理器对象和构建链的工厂。 

public static class ProcessorChainBuilder
{
    public static IProcessor Build()
    {
        return new Configuration1Processor(
                new Configuration2Processor(null)
            );
    }
}

用法- 

Enum.TryParse(key, true, out configType);
ProcessorChainBuilder.Build().Process(new ProcessRequest
{
    Type = ConfigType,
    Value = value
});

注意 - 此时此刻，您一定在想，当一个简单的开关案例可以工作时，我为什么要编写这么多样板代码。好吧，这就是您构建体系结构和编写可扩展代码的方式。考虑一种情况，要添加新的处理器类型，您只需要创建新的 Concrete 处理器并将其添加到 Build() 方法中的链中。

您可以创建一个Dictionary<YourEnum,Func<boo>>，并且可以在IsValid方法中调用它，例如return dictionary[YourEnum]();

您可以选择如何定义Func<bool>，即在公开它们的配置类中，在同一类中内联等。希望这有帮助。

相关文章：