1

我有一个带有大量参数的方法。其中一些是可选的。因此，为了轻松使用此方法，我使用了可选参数功能。

Dictionary<string,string>此外，此方法仅针对非空参数构建一个以参数名称作为字典键、参数值作为字典值的方法。

这是方法：

public string CreateParameterDictionary(
    string id,
    string firstName,
    string lastName,
    string address,
    string postalCode,
    string lorem = null,
    string ipsum = null,
    string dolor = null,
    //...
    string sit = null,
    string amet = null)
{
    if (String.IsNullOrWhiteSpace(id) ||
        String.IsNullOrWhiteSpace(firstName) ||
        String.IsNullOrWhiteSpace(lastName) ||
        String.IsNullOrWhiteSpace(address) ||
        String.IsNullOrWhiteSpace(postalCode))
    {
        throw new ArgumentNullException($"nameof((id) nameof(firstName) nameof(lastName) nameof(address) nameof(postalCode)");
    }

    Dictionary<string,string> parametersDictionary = new Dictionary<string, string>();
    parametersDictionary.Add(nameof(((id),((id);
    parametersDictionary.Add(nameof(firstName),firstName);
    parametersDictionary.Add(nameof(lastName),lastName);
    parametersDictionary.Add(nameof(address),address);
    parametersDictionary.Add(nameof(postalCode),postalCode);

    if (!String.IsNullOrWhiteSpace(lorem)) parametersDictionary.Add(nameof(lorem), lorem);
    if (!String.IsNullOrWhiteSpace(ipsum)) parametersDictionary.Add(nameof(ipsum), ipsum);
    if (!String.IsNullOrWhiteSpace(dolor)) parametersDictionary.Add(nameof(dolor), dolor);
    //...
    if (!String.IsNullOrWhiteSpace(sit)) parametersDictionary.Add(nameof(sit), sit);
    if (!String.IsNullOrWhiteSpace(amet)) parametersDictionary.Add(nameof(amet), amet);

    return parametersDictionary;
}

可以使用命名参数调用：

CreateParameterDictionary(5, "Dexter, "Morgan", "Miami", 12345, dolor: 5);

如您所见，该方法有点冗长。我想知道是否有更简洁的写法（无需反思）

谢谢 ！

编辑

谢谢您的回答但是，我的问题并不清楚。只是一个精度：

  • 我的真实方法中的参数名称不是 param1、param2 等，而是更多的业务名称，如 id、firstName、lastName、address1 = null。像这样当我们使用这种方法时，更容易知道哪个参数是强制性的。在此之前，我使用了 params string[]，但是当我使用它时，我无法获得参数的名称。

希望我的解释现在更清楚。

4

5 回答 5

3

好吧，具有这么多参数的方法肯定是代码异味。我会考虑创建一个支持类，用作 DTO（数据传输对象）。

像这样简单的东西：

public class YourBusinessObjectRequestDto
{
    public string id { get; set; }
    public string firstName { get; set; }
    public string lastName { get; set; }
    public string address { get; set; }
    public string postalCode { get; set; }
    ...

    public Dictionary<string, string> ToDictionary()
    {
        var dict = new Dictionary<string, string>()
        {
          { "id", id },
          { "firstName", firstName },
          { "lastName", lastName },
          { "address", address },
          { "postalCode", postalCode },
          { "...", ... }
        };

        return dict.Where(pair => pair.Value != null).ToDictionary(pair => pair.Key, pair => pair.Value);
    }
}

代码略有重复，但尽可能简单，并且足以满足我的口味。

如果您可以在易于维护性和性能之间进行权衡，那么您可以利用绝大多数 Json 库的动态序列化功能。

使用Json.Net，您可以执行以下操作：

public Dictionary<string, string> ToDictionary()
{
    var json = JsonConvert.SerializeObject(this);

    var serializerSettings = new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore };

    return JsonConvert.DeserializeObject<Dictionary<string, string>>(json, serializerSettings);
}

它不会尽可能快，但只要您处理简单类型，它就会执行得很好并适应您可以放入列表中的每个参数。

这种方法具有调试和管理非常简单的巨大优势：不需要位置参数。

编辑：我错过了“排除非空值”的要求。我编辑了代码以支持它。

于 2016-06-20T09:58:27.940 回答
0

我建议使用params而不是参数列表：

// you want to return Dictionary<String, String>  - right?
// static - I can't see any use of "this" in the method
public static Dictionary<string, string> CreateParameterDictionary(
  params String[] values) {

  if (null == values)
    throw new ArgumentNullException("values");

  // Required: we want at least 5 parameters
  if (values.Length < 5)
    throw new ArgumentException("Too few parameters");

  // First 5 parameters must not be null or empty
  if (values.Take(5).Any(item => String.IsNullOrEmpty(item)))
    throw new ArgumentException("First five parameters must not be null or empty");

  return values
    .Select((item, index) => new {
      index = index + 1,
      value = item
    })
    .Where(item => !String.IsNullOrWhiteSpace(item.value))
    .ToDictionary(item => "param" + item.index.ToString(),
                  item => item.value);
}

测试：

  var result = CreateParameterDictionary("A", "B", "C", "D", "E", "F");

  String report = String.Join(Environment.NewLine, 
    result.Select(pair => String.Format("{0} = {1}", pair.Key, pair.Value)));

  // param1 = A
  // param2 = B
  // param3 = C
  // param4 = D
  // param5 = E
  // param6 = F
  Console.Write(report);
于 2016-06-20T08:56:18.297 回答
0

将方法重构为以下内容并使用代码协定检查参数长度。这样，如果您尝试使用少于 5 个参数的参数，您将遇到编译时错误。

 public string CreateParameterDictionary(
      string param1,
      string param2,
      string param3,
      string param4,
      string param5,
      params string[] optionalParametes)
    {
      Contract.Requires(optionalParametes.Length <= 24);

    }
于 2016-06-20T08:46:48.403 回答
0

将来，如果您有那么多参数：

  • 使用数组，或
  • 而是将它们放在结构或类中。

在这种情况下，您可以使用数组：

public string CreateParameterDictionary(string[] param)
{
    ... same as before, but using param[4] instead of param4, etc...
}
于 2016-06-20T08:47:20.417 回答
0

请考虑改用 param 关键字。查看此示例以了解 params 关键字的用法。它将帮助您将可变数量的参数传递给方法。更改后，您的方法签名将如下所示：

public string CreateParameterDictionary(
        string param1,
        string param2,
        string param3,
        string param4,
        string param5,
        param string[] variableParams = null,
       )
    {
          //variableParams will contain your parameters from param6 to param30
    }
于 2016-06-20T08:47:51.823 回答