在 C# 中以更少的代码重复处理可变数量的输出参数

Question

我正在尝试编写一个函数，用数组的内容填充字符串，或者将它们设置为 null。字符串的数量可能会有所不同，我不想添加要求，比如它们都是同一个数组或类的一部分。

在 C# 中，您不能组合 param 和 out。因此，这样做的唯一方法似乎是像这样重载方法：

    public void ParseRemainders(string[] remainders, out string p1)
    {
        p1 = null;
        if ((remainders != null) && (remainders.Length > 0))
            p1 = remainders[0];
    }

    public void ParseRemainders(string[] remainders, out string p1, out string p2)
    {
        p1 = null;
        p2 = null;
        if (remainders != null)
        {
            ParseRemainders(remainders, out p1);
            if (remainders.Length > 1)
                p2 = remainders[1];
        }
    }

    public void ParseRemainders(string[] remainders, out string p1, out string p2, out string p3)
    {
        p1 = null;
        p2 = null;
        p3 = null;
        if (remainders != null)
        {
            ParseRemainders(remainders, out p1, out p2);
            if (remainders.Length > 2)
                p3 = remainders[2];
        }
    }

    .... and on forever ....

如何避免所有这些代码重复，理想情况下接受任意数量的参数？

---

编辑：这很有用，因为您可以使用ParseRemainders(remainders, out inputFileName, out outputFileName, out configFileName)，然后避免手动操作

if (remainder.Length > 0) inputFileName = remainder[0];
if (remainder.Length > 1) outputFileName = remainder[1];
if (remainder.Length > 2) configFileName = remainder[2];
...

抱歉，如果不清楚，我有一个特定的目标，我为什么不简单地返回 List<>。

---

结论：感谢 Botond Balázs 的回答，特别是这被称为“数组解构”的提示。正如他们指出的那样，正如这个问题所证实的那样，在当前版本的 C# 中是不可能的：Destructuring assignment - object properties to variables in C#

Answer 1

我会采取与迄今为止的任何答案不同的方法。

static class Extensions {
  public static SafeArrayReader<T> MakeSafe<T>(this T[] items)
  {
    return new SafeArrayReader<T>(items);
  }
}
struct SafeArrayReader<T> 
{
  private T[] items;
  public SafeArrayReader(T[] items) { this.items = items; }
  public T this[int index] 
  {
    get
    {
      if (items == null || index < 0 || index >= items.Length)
        return default(T);
      return items[index];
    }
  }
}

现在你有了一个数组，它给你一个默认值而不是抛出：

var remainder = GetRemainders().MakeSafe();
var input = remainder[0];
var output = remainder[1];
var config = remainder[2];

简单易懂。您对数据类型的语义有疑问吗？ 制作一个更好的数据类型来封装所需的语义。

Answer 2

如果我理解正确，您的用例将如下所示：

var remainders = new[] { "a", "b", "c" };
string a, b, c;
ParseRemainders(remainders, a, b, c); // after this, a == "a", b == "b" and c == "c"

您希望在 C# 中拥有的功能称为 数组解构，就像在 JavaScript 中一样：

var remainders = ["a", "b", "c"];
var [a, b, c] = remainders; // after this, a == "a", b == "b" and c == "c"

不幸的是，据我所知，

这不能使用 C# 以一般方式解决。

C# 7 将有元组解构。

Answer 3

好吧，您可以将方法更改为类似

public IEnumerable<string> ParseRemainders(string[] remainders)
{
    var result = new List<string>();

    ///... your logic here, fill list with your strings according to your needs

    return result;
}

Answer 4

Andys 方法很好，但我会返回 string[]，因为它应该与输入数组具有相同的大小，并且如果输入数组是 null，则还返回 null：

public string[] ParseRemainders(string[] remainders)
{
    if(remainders == null) return null;
    var parsed = new string[remainders.Length];
    for(int i = 0; i < remainders.Length; i++)
        parsed[i] = ParseRemainder(remainders[i]);
    return parsed;
}

澄清ParseRemainder（单个string的不同方法）的作用：

public string ParseRemainder(string remainder)
{
    // parsing logic here...
    return "the parsing result of remainder";
}

Answer 5

为了完整起见，这就是您可以在 C#7 (Visual Studio 2017) 中执行此类操作的方式：

string[] test = { "One", "Two", "Three", "Four", "Five" };

var (a, b, c) = (test[0], test[2], test[4]);

Debug.Assert(a == "One");
Debug.Assert(b == "Three");
Debug.Assert(c == "Five");

这里重要的一行是var (a, b, c) = (test[0], test[2], test[4]);，它向您展示了从数组的某些元素中分配几个不同变量的简写方式。

但是，如果数组不够长，这对分配 null 没有帮助。你可以通过编写一个辅助类来解决这个问题：

public sealed class ElementsOrNull<T> where T: class
{
    readonly IList<T> array;

    public ElementsOrNull(IList<T> array)
    {
        this.array = array;
    }

    public T this[int index]
    {
        get
        {
            if (index < array.Count)
                return array[index];

            return null;
        }
    }
}

然后：

string[] test = { "One", "Two", "Three", "Four", "Five" };

var t = new ElementsOrNull<string>(test);
var (a, b, c) = (t[0], t[2], t[6]);

Debug.Assert(a == "One");
Debug.Assert(b == "Three");
Debug.Assert(c == null);

但我敢肯定，大多数人（包括我自己）会认为这比它的价值更麻烦。

Answer 6

我认为这非常接近您想要的。它不需要 C# 7，适用于任何数据元素类型，并且不限于数组。不过，您可能希望选择比 ValueReader/ReadValue 更好的名称。

static class Extensions
{
    public static ValueReader<T> ReadValue<T>(this IEnumerable<T> source, out T value)
    {
        var result = new ValueReader<T>(source);
        result.ReadValue(out value);
        return result;
    }
}

class ValueReader<T>
{
    IEnumerator<T> _enumerator;

    public ValueReader(IEnumerable<T> source)
    {
        if (source == null) source = new T[0];
        _enumerator = source.GetEnumerator();
    }

    public ValueReader<T> ReadValue(out T value)
    {
        bool hasNext = _enumerator.MoveNext();
        value = hasNext ? _enumerator.Current : default(T);
        return this;
    }
}

static class TestApp
{
    public static void Main()
    {
        var remainders = new string[] { "test1", "test2", "test3" };

        string inputFileName, outputFileName, configFileName, willBeSetToNull;

        remainders
            .ReadValue(out inputFileName)
            .ReadValue(out outputFileName)
            .ReadValue(out configFileName)
            .ReadValue(out willBeSetToNull);
    }
}

Answer 7

只需在数组中使用一个索引，例如：

remainers[0];  //same as p1
remainers[1];  //same as p2  
remainers[2];  //same as p3

Answer 8

根据您的描述，我猜您的用例类似于：

public void SomeMethod( ... )
{
    string p1;
    string p2;

    ....
    ParseRemainders(string[] remainders, out string p1, out string p2);
    ...
}

public void SomeOtherMethod( ... )
{
    string p1;
    string p2;
    string p3;

    ....
    ParseRemainders(string[] remainders, out string p1, out string p2, out string p3);
    ...
}

您不需要以这种方式返回字符串。正如其他答案/ cmets 中已经指出的那样，您可以简单地返回一个字符串数组：

 string[] ParseRemainders(string[] remainders)
 {
     var result = new string[remainder.Length];
     result[0] = //whatever p1 would be
     result[1] = //whatever p2 would be
     //etc.
 }

你会这样使用它：

public void SomeMethod( ... )
{
    ....
    var parsed = ParseRemainders(string[] remainders);
    string p1 = parsed[0];
    string p2 = parsed[1];  
    ....
}

看起来好多了。

Answer 9

感觉就像您试图使简单的空检查过于复杂，只需回到基础并保持简单：

public string GetRemainder(string[] remainders, int index)
{
    if ((remainders != null) && (remainders.Length > index))
        return remainders[index];
    return null;
}

用法：

var inputFileName = GetRemainder(remainder, 0);
var outputFileName = GetRemainder(remainder, 1);
var configFileName = GetRemainder(remainder, 2);