将大量方法重载转换为通用方法，设计问题

Question

我试图在这里重构其他人之前完成的一些代码，因为我发现它非常不切实际 这是一个例子

protected void SetParameterValue(SqlParameter parameter, string parameterValue, bool isNullable)
{
     if ((null == parameterValue || parameterValue == NULL_STRING) && isNullable)
            parameter.Value = DBNull.Value;
     else   parameter.Value = parameterValue;
}

protected void SetParameterValue(SqlParameter parameter, int parameterValue, bool isNullable)
{
     if (parameterValue == NULL_INT && isNullable)
            parameter.Value = DBNull.Value;
     else   parameter.Value = parameterValue;
}

protected void SetParameterValue( SqlParameter parameter, Int64 parameterValue, bool isNullable)
{
     if (parameterValue == NULL_LONG && isNullable)
            parameter.Value = DBNull.Value;
     else   parameter.Value = parameterValue;
}

类似的例子还有很多。现在我需要创建一个接受新类型的类型（它还没有方法），并决定也许我可以清理一下，使其更好。 我的想法是创建类似的东西

protected void SetParameterValue<T>(SqlParameter parameter, T parameterValue, bool isNullable)

，但是，我不知道什么是最好的方法，我可以在这个通用方法中封装什么，以及我还需要在单独的方法中做什么。值得吗？或者“很多方法”的方法可以吗？我将从通用产品中获得什么？谢谢！

Answer 1

消除对开关的需要的一种方法是使用某种字典来保存委托，该委托确定每种可能类型的 null 构成。尽管我认为你必须坚持这个目标。因此，您将拥有一本字典并将其设置为：

private Dictionary<Type, Func<object, bool, bool>> _nullChecks = new Dictionary<Type, Func<object, bool, bool>>();

private void SetupNullChecks(){
    _nullChecks.Add(typeof(string), (object parameterValue, bool isNullable) => { return (null == parameterValue || parameterValue.ToString() == NULL_STRING) && isNullable; });
    _nullChecks.Add(typeof(int), (object parameterValue, bool isNullable) => { return (int)parameterValue == NULL_INT && isNullable; });
    _nullChecks.Add(typeof(long), (object parameterValue, bool isNullable) => { return (long)parameterValue == NULL_LONG && isNullable; });
}

您的检查将类似于：

public void SetParameterValue(SqlParameter parameter, object parameterValue, bool isNullable)
{
    if (_nullChecks[parameterValue.GetType()].Invoke(parameterValue, isNullable))
        parameter.Value = DBNull.Value;
    else parameter.Value = parameterValue;
}

尽管按照其他人的建议，更改代码以使用 Nullable 类型会更好。

Answer 2

您始终可以使用

Protected void SetParameterValue(SqlParameter parameter, 
 object parameterValue, bool isNullable)....

parameter.Value 获取一个对象，因此减去每种类型的验证，您实际上不需要将它们分开。

您可以创建一个验证参数方法，该方法反映并提取参数的类型类型，并检查是否针对该类型设置了空值。
这样

bool IsNull (object value){
   if (value is int){
     check int..
   }
}
//this is a quick and dirty example, there are more elegant ways to handle it.

可以压缩类型验证和所有重载，并且也消除了对泛型方法的需要。

Answer 3

方法定义的“多重签名”方法非常好——它给了我们多态性。就我个人而言，我更愿意保留该技术而不是按照您的建议进行重构。

然而，我想要做的是用对“master”方法的调用来替换除了一个方法体之外的所有方法体的重复，从而转换参数：

protected void SetParameterValue(SqlParameter parameter, int parameterValue, bool isNullable)
{
  SetParameterValue(parameter, (Int64)parameterValue, isNullable);
}
protected void SetParameterValue(SqlParameter parameter, Int64 parameterValue, bool isNullable)
{
  if (parameterValue == NULL_INT && isNullable)
    parameter.Value = DBNull.Value;
  else
    parameter.Value = parameterValue;
}

这预设了parameterValue当然，可以重新铸造，没有太多麻烦。

Answer 4

我认为您可以使用可空类型而不是 bool isNullable。

protected void SetParameterValue<T>(SqlParameter parameter, T parameterValue)
{
if (parameterValue == null)
  parameter.Value = DBNull.Value;
else
  parameter.Value = parameterValue;
}

并可能用此签名相应地调用它。
喜欢
设置参数（参数，空）
设置参数(param,5)

Answer 5

最后很难用 switch/if 语句“消除”这个问题，必须有人去做。
您可以选择覆盖/封装对象或类的 null 值，但您仍然必须检查每个概念中的 null 值。

我不知道这是否会让事情变得更好，但您可以首先通过创建前面所说的方法来隔离重复，或者仅隔离空值检查。最后一个是我所做的：

protected void SetParameterValue(SqlParameter parameter,object parameterValue){
    if(IsParameterNull(parameterValue) && parameter.IsNullable){
        parameter.Value = DBNull.Value;
    }
    else{
        parameter.Value = parameterValue;
    }
}

List<NULLTYPE> nulls = new List<NULLTYPE>(){new NULLTYPE(NULL_INT), new NULLTYPE(NULL_LONG), new NULLTYPE(null)}
protected bool IsParameterNull(object parameterValue){
    if(nulls.Contains(parameterValue)) return true;
    else return false;
}

这里的工作是创建一个 NULLTYPE 类来封装 null 的概念，并且 nulls.Contains(parameterValue) 检查是否值存在于列表中。
您可以进一步重写 Contains 来检查您自己的方式，但您必须考虑您想要在这方面花费多少工作。