C#中列表赋值的变量？

在PHP中，您可以编写

$arr = array(1,2);
list($a, $b) = $arr;

这基本上相当于

$a = $arr[0];
$b = $arr[1];

C#中是否有等价物

---

只是让我讨厌，因为我经常写这样的东西

var split = action.Split('.');
string controllerName = split[0];
string actionName = split[1];

而

split

只是一个一次性变量，我想不出一个像样的名字。“块”、“位”、“块”、“部分”，。。。除了这个，所有的都是毫无意义的吉伯瑞什语。

a = arr[0];
b = arr[1];

没有。

除了这个

a = arr[0];
b = arr[1];

---

不。

没有与你的第一个例子等价的东西。

没有与你的第一个例子等价的东西。

等价的东西是你在第二个例子中写的东西，

等价的东西是你在第二个例子中写的东西，

不幸的是，这是不可能的。

不幸的是，这是不可能的。

您可以编写自己的方法，如：

int[] arr = new[] { 1, 2 };

int a, b;
Populate(arr, out a, out b);

static void Populate<T>(T[] arr, out T t1, out T t2)
{
    t1 = arr[0];
    t2 = arr[1];
}

int[]arr=new[]{1,2}；
INTA，b；
填充（arr、out a、out b）；
静态空隙填充（T[]arr，T t1，T t2）
{
t1=arr[0]；
t2=arr[1]；
}

---

不过，我不建议这样做……您必须小心选择正确数量的参数，而且我不认为有任何方法可以实现任意大小—C#在签名中有“params array”的概念，但我不认为使用“out”参数就可以做到这一点。

您可以编写自己的方法，如：

int[] arr = new[] { 1, 2 };

int a, b;
Populate(arr, out a, out b);

static void Populate<T>(T[] arr, out T t1, out T t2)
{
    t1 = arr[0];
    t2 = arr[1];
}

int[]arr=new[]{1,2}；
INTA，b；
填充（arr、out a、out b）；
静态空隙填充（T[]arr，T t1，T t2）
{
t1=arr[0]；
t2=arr[1]；
}

不过，我不建议这样做……您必须小心选择正确数量的参数，而且我不认为有任何方法可以实现任意大小—C#在签名中有“params array”的概念，但我不认为您可以使用“out”参数进行操作。

要扩展，输入不必是数组。它可以是一个

IEnumerable

，允许您传递任何数据源。一旦你这么做了，它看起来应该是一个扩展方法。此外，与总是假设集合中的项目与输入参数的数量相同不同，有时允许数字不匹配比较方便

public static void AssignTo<T>(this IEnumerable<T> source, out T dest1, out T dest2)
{
    using (var e = source.GetEnumerator())
    {
        dest1 = e.MoveNext() ? e.Current : default(T);
        dest2 = e.MoveNext() ? e.Current : default(T);
    }
}

将输出：

x, x, y x, y 但是你可以直接写

string key, value;
query.Split('=').AssignTo(out key, out value);

但是，如果您需要参数的确切数目，只需抛出异常而不是指定null：

public static void AssignToExact<T>(this IEnumerable<T> source, out T dest1, out T dest2)
{
    using (var e = source.GetEnumerator())
    {
        if (e.MoveNext()) dest1 = e.Current;
        else throw new ArgumentException("Only 0 of 2 arguments given", "source");
        if (e.MoveNext()) dest2 = e.Current;
        else throw new ArgumentException("Only 1 of 2 arguments given", "source");
        if (e.MoveNext()) throw new ArgumentException("More than 2 arguments given", "source");
    }
}

public static void AssignToExact（此IEnumerable源，out T dest1，out T dest2）
{
使用（var e=source.GetEnumerator（））
{
如果（e.MoveNext（））dest1=e.Current；
else抛出新的ArgumentException（“仅给出2个参数中的0个”，“源”）；
如果（e.MoveNext（））dest2=e.Current；
否则抛出新的ArgumentException（“仅给出2个参数中的1个”，“源”）；
如果（e.MoveNext（））抛出新的ArgumentException（“给出了2个以上的参数”，“源”）；
}
}

要展开，输入不必是数组。它可以是一个

IEnumerable

，允许您传递任何数据源。一旦你这么做了，它看起来应该是一个扩展方法。此外，与总是假设集合中的项目与输入参数的数量相同不同，有时允许数字不匹配比较方便

public static void AssignTo<T>(this IEnumerable<T> source, out T dest1, out T dest2)
{
    using (var e = source.GetEnumerator())
    {
        dest1 = e.MoveNext() ? e.Current : default(T);
        dest2 = e.MoveNext() ? e.Current : default(T);
    }
}

将输出：

x, x, y x, y 但是你可以直接写

string key, value;
query.Split('=').AssignTo(out key, out value);

但是，如果您需要参数的确切数目，只需抛出异常而不是指定null：

public static void AssignToExact<T>(this IEnumerable<T> source, out T dest1, out T dest2)
{
    using (var e = source.GetEnumerator())
    {
        if (e.MoveNext()) dest1 = e.Current;
        else throw new ArgumentException("Only 0 of 2 arguments given", "source");
        if (e.MoveNext()) dest2 = e.Current;
        else throw new ArgumentException("Only 1 of 2 arguments given", "source");
        if (e.MoveNext()) throw new ArgumentException("More than 2 arguments given", "source");
    }
}

public static void AssignToExact（此IEnumerable源，out T dest1，out T dest2）
{
使用（var e=source.GetEnumerator（））
{
如果（e.MoveNext（））dest1=e.Current；
else抛出新的ArgumentException（“仅给出2个参数中的0个”，“源”）；
如果（e.MoveNext（））dest2=e.Current；
否则抛出新的ArgumentException（“仅给出2个参数中的1个”，“源”）；
如果（e.MoveNext（））抛出新的ArgumentException（“给出了2个以上的参数”，“源”）；
}
}

显示“out”和“params”不混合。。。我想我需要一堆重载来实现这一点，但仍然很酷。非常好的实现-而且如果将10或12个重载组合在一起，将其扩展到尽可能多的合理范围内，真的不需要太多工作-只是大量的复制/粘贴，或者可能是一个快速而肮脏的代码生成器。可能有太多或太少的值对我来说有点吓人，但我想这取决于你的需要。它看起来“out”和“params”并不混合。。。我想我需要一堆重载来实现这一点，但仍然很酷。非常好的实现-而且如果将10或12个重载组合在一起，将其扩展到尽可能多的合理范围内，真的不需要太多工作-只是大量的复制/粘贴，或者可能是一个快速而肮脏的代码生成器。可能有太多或太少的价值观对我来说有点可怕，但我想这取决于你的需要。