blocks|key|4670951|text|如果要返回多个值，可以返回一个包含要返回的值的类/结构，或者在参数上使用"out“关键字，如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4670952|public+void+Foo(int+input,+out+int+output1,+out+string+output2,+out+string+errors)+{
++++//+set+out+parameters+inside+function
}|code-block|syntax|javascript|4670953|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

If you mean returning multiple values, you can either return a class/struct containing the values you want to return, or use the "out" keyword on your parameters, like so:

<pre><code>public void Foo(int input, out int output1, out string output2, out string errors) {
 // set out parameters inside function
}
</code></pre>

blocks|key|1170325|text|您可以返回一个类实例，也可以使用输出参数。下面是out参数的一个示例：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1170326|void+mymethod(out+int+param1,+out+int+param2)
{
++++param1+=+10;
++++param2+=+20;
}|code-block|syntax|javascript|1170327|这样叫它：|1170328|int+i,+j;
mymethod(out+i,+out+j);
//+i+will+be+20+and+j+will+be+10|1170329|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

You either return a class instance or use out parameters. Here's an example of out parameters:

<pre><code>void mymethod(out int param1, out int param2)
{
 param1 = 10;
 param2 = 20;
}
</code></pre>

Call it like this:

<pre><code>int i, j;
mymethod(out i, out j);
// i will be 20 and j will be 10
</code></pre>

blocks|key|3828142|text|您不能在C#中执行此操作。您可以做的是拥有一个out参数，或者返回您自己的类(如果您希望它是不可变的，则返回结构)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3828143|使用out参数|3828144|public+int+GetDay(DateTime+date,+out+string+name)
{
++//+...
}|code-block|syntax|javascript|3828145|使用自定义类(或结构)|3828146|public+DayOfWeek+GetDay(DateTime+date)
{
++//+...
}

public+class+DayOfWeek
{
++public+int+Day+{+get;+set;+}
++public+string+Name+{+get;+set;+}
}|3828147|entityMap^0|N|3|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|V|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|W|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|X|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|Y|8|@]|D|@]|E|$K|L]]|$1|Q|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|R|$]]

You cannot do this in C#. What you can do is have a <code>out</code> parameter or return your own class (or struct if you want it to be immutable).

Using out parameter

<pre><code>public int GetDay(DateTime date, out string name)
{
 // ...
}
</code></pre>

Using custom class (or struct)

<pre><code>public DayOfWeek GetDay(DateTime date)
{
 // ...
}

public class DayOfWeek
{
 public int Day { get; set; }
 public string Name { get; set; }
}
</code></pre>

blocks|key|1170372|text|类、结构、集合和数组可以包含多个值。还可以在函数中设置输出和参考参数。在动态和函数式语言中，可以通过元组返回多个值，但在C#中不可以。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1170373|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Classes, Structures, Collections and Arrays can contain multiple values. Output and reference parameters can also be set in a function. Return multiple values is possible in dynamic and functional languages by means of tuples, but not in C#.

blocks|key|3828254|text|在C#+4中，您将能够使用对元组的内置支持来轻松处理此问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3828255|在此期间，有两种选择。|3828256|首先，可以使用ref或out参数为参数赋值，这些值被传递回调用例程。|3828257|这看起来像这样：|3828258|void+myFunction(ref+int+setMe,+out+int+youMustSetMe);|code-block|syntax|javascript|3828259|其次，您可以将返回值包装到一个结构或类中，并将它们作为该结构的成员传回。KeyValuePair在2种情况下工作得很好--对于2种以上的情况，您需要一个自定义类或结构。|3828260|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|S|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|T|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|U|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

In C# 4, you will be able to use built-in support for tuples to handle this easily.

In the meantime, there are two options.

First, you can use ref or out parameters to assign values to your parameters, which get passed back to the calling routine.

This looks like:

<pre><code>void myFunction(ref int setMe, out int youMustSetMe);
</code></pre>

Second, you can wrap up your return values into a structure or class, and pass them back as members of that structure. KeyValuePair works well for 2 - for more than 2 you would need a custom class or struct.

blocks|key|1163300|text|之前的海报是对的。不能从C#方法返回多个值。但是，您确实有几个选择：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1163301|1163302|返回包含多个成员的结构|unordered-list-item|1163303|返回类的实例|1163304|使用输出参数(使用out或引用将字典或键值对作为输出|offset|length|style|BOLD|1163305|1163306|这里的利弊通常很难弄清楚。如果返回一个结构，请确保它很小，因为结构是值类型，并在堆栈上传递。如果你返回一个类的实例，这里有一些你可能想要使用的设计模式，以避免引起问题--类的成员可以被修改，因为C#通过引用传递对象(你没有像在VB中那样使用ByVal+)。|1163307|最后，您可以使用输出参数，但我会将它的使用限制在只有几个(例如3个或更少)参数的情况下-否则事情就会变得丑陋和难以维护。此外，输出参数的使用可能会阻碍敏捷性，因为每次需要向返回值添加某些内容时，方法签名都必须更改，而返回结构或类实例时，您可以在不修改方法签名的情况下添加成员。|1163308|从架构的角度来看，我建议不要使用键值对或字典。我发现这种编码风格需要使用该方法的代码中的“秘密知识”。它必须提前知道关键字是什么，值是什么意思，如果从事内部实现的开发人员更改了字典或KVP的创建方式，它可能很容易在整个应用程序中创建一个失败的级联。|1163309|entityMap^0|0|0|0|0|9|3|D|2|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|X|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|Y|8|@]|9|@]|A|$]]|$1|F|3|G|5|E|7|Z|8|@]|9|@]|A|$]]|$1|H|3|I|5|E|7|10|8|@$J|11|K|12|L|M]|$J|13|K|14|L|M]]|9|@]|A|$]]|$1|N|3|-4|5|6|7|15|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|16|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|17|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|18|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|19|8|@]|9|@]|A|$]]]|V|$]]

Previous poster is right. You cannot return multiple values from a C# method. However, you do have a couple of options:

<ul>
<li>Return a structure that contains multiple members</li>
<li>Return an instance of a class</li>
<li>Use output parameters (using the out or ref keywords)</li>
<li>Use a dictionary or key-value pair as output</li>
</ul>

The pros and cons here are often hard to figure out. If you return a structure, make sure it's small because structs are value type and passed on the stack. If you return an instance of a class, there are some design patterns here that you might want to use to avoid causing problems - members of classes can be modified because C# passes objects by reference (you don't have ByVal like you did in VB).

Finally you can use output parameters but I would limit the use of this to scenarios when you only have a couple (like 3 or less) of parameters - otherwise things get ugly and hard to maintain. Also, the use of output parameters can be an inhibitor to agility because your method signature will have to change every time you need to add something to the return value whereas returning a struct or class instance you can add members without modifying the method signature.

From an architectural standpoint I would recommend against using key-value pairs or dictionaries. I find this style of coding requires "secret knowledge" in code that consumes the method. It must know ahead of time what the keys are going to be and what the values mean and if the developer working on the internal implementation changes the way the dictionary or KVP is created, it could easily create a failure cascade throughout the entire application.

blocks|key|1170446|text|不，你不能在C#中从一个函数返回多个值(对于低于C#+7的版本)，至少不能用你在Python语言中可以做到的方式。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1170447|但是，有两种选择：|1170448|您可以返回一个object类型的数组，其中包含您想要的多个值。|1170449|private+object[]+DoSomething()
{
++++return+new+[]+{+'value1',+'value2',+3+};
}|code-block|syntax|javascript|1170450|您可以使用out参数。|offset|length|style|CODE|1170451|private+string+DoSomething(out+string+outparam1,+out+int+outparam2)
{
++++outparam1+=+'value2';
++++outparam2+=+3;
++++return+'value1';
}|1170452|entityMap^0|0|0|0|0|5|3|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|X|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|Y|8|@$M|Z|N|10|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|H|7|11|8|@]|9|@]|A|$I|J]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

No, you can't return multiple values from a function in C# (for versions lower than C# 7), at least not in the way you can do it in Python.

However, there are a couple alternatives:

You can return an array of type object with the multiple values you want in it.

<pre><code>private object[] DoSomething()
{
 return new [] { 'value1', 'value2', 3 };
}
</code></pre>

You can use <code>out</code> parameters.

<pre><code>private string DoSomething(out string outparam1, out int outparam2)
{
 outparam1 = 'value2';
 outparam2 = 3;
 return 'value1';
}
</code></pre>

blocks|key|3828410|text|有几种方法可以做到这一点。您可以使用ref参数：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3828411|int+Foo(ref+Bar+bar)+{+}|code-block|syntax|javascript|3828412|这会将一个引用传递给函数，从而允许函数修改调用代码堆栈中的对象。虽然从技术上讲，这不是一个“返回”值，但它是一种让函数执行类似操作的方法。在上面的代码中，该函数将返回一个int并(可能)修改bar。|3828413|另一种类似的方法是使用out参数。具有附加的编译器强制规则的out参数与ref参数相同。此规则是，如果将out参数传递给函数，则该函数需要在返回之前设置其值。除了该规则之外，out参数的工作方式与ref参数相同。|3828414|最后一种方法(在大多数情况下也是最好的)是创建一个封装了这两个值的类型，并允许函数返回：|3828415|class+FooBar+
{
++++public+int+i+{+get;+set;+}
++++public+Bar+b+{+get;+set;+}
}

FooBar+Foo(Bar+bar)+{+}|3828416|最后一种方法更简单，更容易阅读和理解。|3828417|entityMap^0|I|3|0|0|2D|3|2N|3|0|B|3|U|3|10|3|1G|3|2F|3|2Q|3|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|15|8|@$9|16|A|17|B|C]|$9|18|A|19|B|C]|$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]|$9|1E|A|1F|B|C]|$9|1G|A|1H|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|1I|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|1J|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|1K|8|@]|D|@]|E|$]]|$1|U|3|-4|5|6|7|1L|8|@]|D|@]|E|$]]]|V|$]]

There are several ways to do this. You can use <code>ref</code> parameters:

<pre><code>int Foo(ref Bar bar) { }
</code></pre>

This passes a reference to the function thereby allowing the function to modify the object in the calling code's stack. While this is not technically a "returned" value it is a way to have a function do something similar. In the code above the function would return an <code>int</code> and (potentially) modify <code>bar</code>.

Another similar approach is to use an <code>out</code> parameter. An <code>out</code> parameter is identical to a <code>ref</code> parameter with an additional, compiler enforced rule. This rule is that if you pass an <code>out</code> parameter into a function, that function is required to set its value prior to returning. Besides that rule, an <code>out</code> parameter works just like a <code>ref</code> parameter. 

The final approach (and the best in most cases) is to create a type that encapsulates both values and allow the function to return that:

<pre><code>class FooBar 
{
 public int i { get; set; }
 public Bar b { get; set; }
}

FooBar Foo(Bar bar) { }
</code></pre>

This final approach is simpler and easier to read and understand.

blocks|key|4671422|text|主要有两种方法。1.使用out/ref参数2.返回对象数组|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4671423|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Mainly two methods are there.
1. Use out/ref parameters
2. Return an Array of objects

blocks|key|1170590|text|你可以试试这个"KeyValuePair“|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1170591|private+KeyValuePair<int,+int>+GetNumbers()
{
++return+new+KeyValuePair<int,+int>(1,+2);
}


var+numbers+=+GetNumbers();

Console.WriteLine("Output+:+{0},+{1}",numbers.Key,+numbers.Value);|code-block|syntax|javascript|1170592|输出:|offset|length|style|BOLD|1170593|输出:+1，2|1170594|entityMap^0|0|0|0|3|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

you can try this "KeyValuePair"

<pre><code>private KeyValuePair&lt;int, int&gt; GetNumbers()
{
 return new KeyValuePair&lt;int, int&gt;(1, 2);
}


var numbers = GetNumbers();

Console.WriteLine("Output : {0}, {1}",numbers.Key, numbers.Value);
</code></pre>

Output :

Output : 1, 2

blocks|key|4671624|text|在C#+7和更高版本中，请参阅this+answer。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|4671625|在以前的版本中，您可以使用.NET+4.0%2B's+Tuple|4671626|例如：|4671627|public+Tuple<int,+int>+GetMultipleValue()
{
+++++return+Tuple.Create(1,2);
}|code-block|syntax|javascript|4671628|具有两个值的元组具有Item1和Item2属性。|style|CODE|4671629|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/36436255/316760|1|http://msdn.microsoft.com/en-us/library/system.tuple.aspx^0|F|B|0|0|D|H|1|0|0|0|A|5|G|5|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@$A|11|B|12|1|13]]|C|$]]|$1|D|3|E|5|6|7|14|8|@]|9|@$A|15|B|16|1|17]]|C|$]]|$1|F|3|G|5|6|7|18|8|@]|9|@]|C|$]]|$1|H|3|I|5|J|7|19|8|@]|9|@]|C|$K|L]]|$1|M|3|N|5|6|7|1A|8|@$A|1B|B|1C|O|P]|$A|1D|B|1E|O|P]]|9|@]|C|$]]|$1|Q|3|-4|5|6|7|1F|8|@]|9|@]|C|$]]]|R|$S|$5|T|U|V|C|$W|X]]|Y|$5|T|U|V|C|$W|Z]]]]

In C# 7 and above, see <a href="https://stackoverflow.com/a/36436255/316760">this answer</a>.

In previous versions, you can use <a href="http://msdn.microsoft.com/en-us/library/system.tuple.aspx" rel="noreferrer">.NET 4.0+'s Tuple</a>:

For Example:

<pre><code>public Tuple&lt;int, int&gt; GetMultipleValue()
{
 return Tuple.Create(1,2);
}
</code></pre>

Tuples with two values have <code>Item1</code> and <code>Item2</code> as properties.

blocks|key|1170613|text|你可以试试这个|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1170614|public+IEnumerable<string>+Get()
+{
+++++return+new+string[]+{+"value1",+"value2"+};
+}|code-block|syntax|javascript|1170615|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

you can try this 

<pre><code>public IEnumerable&lt;string&gt; Get()
 {
 return new string[] { "value1", "value2" };
 }
</code></pre>

blocks|key|607554|text|以下是基本的Two方法：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|607555|输出1)使用'**out**‘作为参数输出您也可以在4.0和次要版本中使用’‘。|BOLD|607556|‘out’的示例：|607557|using+System;

namespace+out_parameter
{
++class+Program
+++{
+++++//Accept+two+input+parameter+and+returns+two+out+value
+++++public+static+void+rect(int+len,+int+width,+out+int+area,+out+int+perimeter)
++++++{
++++++++area+=+len+*+width;
++++++++perimeter+=+2+*+(len+%2B+width);
++++++}
+++++static+void+Main(string[]+args)
++++++{
++++++++int+area,+perimeter;
++++++++//+passing+two+parameter+and+getting+two+returning+value
++++++++Program.rect(5,+4,+out+area,+out+perimeter);
++++++++Console.WriteLine("Area+of+Rectangle+is+{0}\t",area);
++++++++Console.WriteLine("Perimeter+of+Rectangle+is+{0}\t",+perimeter);
++++++++Console.ReadLine();
++++++}
+++}
}|code-block|syntax|javascript|607558|输出：|607559|矩形的面积是20|607560|矩形的周长是18|607561|*注意：*+out-keyword描述了其实际变量位置被复制到被调用方法的堆栈上的参数，其中可以重写这些相同的位置。这意味着调用方法将访问更改后的参数。|607562|2)+Tuple<T>|607563|元组的示例：|607564|使用Tuple<T>返回多个DataType值|607565|using+System;

class+Program
{
++++static+void+Main()
++++{
++++//+Create+four-item+tuple;+use+var+implicit+type.
++++var+tuple+=+new+Tuple<string,+string[],+int,+int[]>("perl",
++++++++new+string[]+{+"java",+"c#"+},
++++++++1,
++++++++new+int[]+{+2,+3+});
++++//+Pass+tuple+as+argument.
++++M(tuple);
++++}

++++static+void+M(Tuple<string,+string[],+int,+int[]>+tuple)
++++{
++++//+Evaluate+the+tuple's+items.
++++Console.WriteLine(tuple.Item1);
++++foreach+(string+value+in+tuple.Item2)
++++{
++++++++Console.WriteLine(value);
++++}
++++Console.WriteLine(tuple.Item3);
++++foreach+(int+value+in+tuple.Item4)
++++{
++++++++Console.WriteLine(value);
++++}
++++}
}|607566|输出|607567|perl
java
c#
1
2
3|607568|注意：对元组的使用在Framework4.0及更高版本的中有效。Tuple类型为class。它将被分配到内存中托管堆上的单独位置。一旦创建了Tuple，就无法更改其fields的值。这使得Tuple更像struct。|607569|entityMap^0|6|3|0|9|3|D|R|0|0|9|0|0|0|3|0|0|8|0|0|8|0|0|24|6|3|0|0|2|3|8|3|8|0|0|6|0|0|N|2|8|0|0|0|2|0|0|0|30|W|5|14|5|1Y|5|2A|6|2M|5|2T|6|0^^$0|@$1|2|3|4|5|6|7|1D|8|@$9|1E|A|1F|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1G|8|@$9|1H|A|1I|B|C]|$9|1J|A|1K|B|H]]|D|@]|E|$]]|$1|I|3|J|5|6|7|1L|8|@$9|1M|A|1N|B|H]]|D|@]|E|$]]|$1|K|3|L|5|M|7|1O|8|@]|D|@]|E|$N|O]]|$1|P|3|Q|5|6|7|1P|8|@$9|1Q|A|1R|B|H]]|D|@]|E|$]]|$1|R|3|S|5|6|7|1S|8|@$9|1T|A|1U|B|H]]|D|@]|E|$]]|$1|T|3|U|5|6|7|1V|8|@$9|1W|A|1X|B|H]]|D|@]|E|$]]|$1|V|3|W|5|6|7|1Y|8|@$9|1Z|A|20|B|H]|$9|21|A|22|B|C]]|D|@]|E|$]]|$1|X|3|Y|5|6|7|23|8|@$9|24|A|25|B|H]|$9|26|A|27|B|H]|$9|28|A|29|B|C]]|D|@]|E|$]]|$1|Z|3|10|5|6|7|2A|8|@$9|2B|A|2C|B|H]]|D|@]|E|$]]|$1|11|3|12|5|6|7|2D|8|@$9|2E|A|2F|B|H]|$9|2G|A|2H|B|C]]|D|@]|E|$]]|$1|13|3|14|5|M|7|2I|8|@]|D|@]|E|$N|O]]|$1|15|3|16|5|6|7|2J|8|@$9|2K|A|2L|B|H]]|D|@]|E|$]]|$1|17|3|18|5|M|7|2M|8|@]|D|@]|E|$N|O]]|$1|19|3|1A|5|6|7|2N|8|@$9|2O|A|2P|B|H]|$9|2Q|A|2R|B|C]|$9|2S|A|2T|B|C]|$9|2U|A|2V|B|C]|$9|2W|A|2X|B|C]|$9|2Y|A|2Z|B|C]|$9|30|A|31|B|C]]|D|@]|E|$]]|$1|1B|3|-4|5|6|7|32|8|@]|D|@]|E|$]]]|1C|$]]

Here are basic <code>Two</code> methods:

1) Use of '<code>out</code>' as parameter
You can use 'out' for both 4.0 and minor versions too.

Example of 'out':

<pre><code>using System;

namespace out_parameter
{
 class Program
 {
 //Accept two input parameter and returns two out value
 public static void rect(int len, int width, out int area, out int perimeter)
 {
 area = len * width;
 perimeter = 2 * (len + width);
 }
 static void Main(string[] args)
 {
 int area, perimeter;
 // passing two parameter and getting two returning value
 Program.rect(5, 4, out area, out perimeter);
 Console.WriteLine("Area of Rectangle is {0}\t",area);
 Console.WriteLine("Perimeter of Rectangle is {0}\t", perimeter);
 Console.ReadLine();
 }
 }
}
</code></pre>

Output:

Area of Rectangle is 20

Perimeter of Rectangle is 18 

*Note:*The <code>out</code>-keyword describes parameters whose actual variable locations are copied onto the stack of the called method, where those same locations can be rewritten. This means that the calling method will access the changed parameter.

2) <code>Tuple&lt;T&gt;</code> 

Example of Tuple:

Returning Multiple DataType values using <code>Tuple&lt;T&gt;</code>

<pre><code>using System;

class Program
{
 static void Main()
 {
 // Create four-item tuple; use var implicit type.
 var tuple = new Tuple&lt;string, string[], int, int[]&gt;("perl",
 new string[] { "java", "c#" },
 1,
 new int[] { 2, 3 });
 // Pass tuple as argument.
 M(tuple);
 }

 static void M(Tuple&lt;string, string[], int, int[]&gt; tuple)
 {
 // Evaluate the tuple's items.
 Console.WriteLine(tuple.Item1);
 foreach (string value in tuple.Item2)
 {
 Console.WriteLine(value);
 }
 Console.WriteLine(tuple.Item3);
 foreach (int value in tuple.Item4)
 {
 Console.WriteLine(value);
 }
 }
}
</code></pre>

Output

<pre><code>perl
java
c#
1
2
3
</code></pre>

NOTE: Use of Tuple is valid from Framework 4.0 and above.<code>Tuple</code> type is a <code>class</code>. It will be allocated in a separate location on the managed heap in memory. Once you create the <code>Tuple</code>, you cannot change the values of its <code>fields</code>. This makes the <code>Tuple</code> more like a <code>struct</code>.

blocks|key|607599|text|只需以面向对象的方式使用如下类：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|607600|class+div
{
++++public+int+remainder;

++++public+int+quotient(int+dividend,+int+divisor)
++++{
++++++++remainder+=+...;
++++++++return+...;
++++}
}|code-block|syntax|javascript|607601|函数成员返回大多数调用者主要感兴趣的商。此外，它还将剩余部分存储为数据成员，之后调用者可以轻松地访问该成员。|607602|通过这种方式，您可以拥有许多额外的“返回值”，这在实现数据库或网络调用时非常有用，因为这些调用可能需要大量错误消息，但只有在发生错误的情况下才会出现。|607603|我在OP提到的C%2B%2B问题中也输入了这个解决方案。|607604|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Just use in OOP manner a class like this:

<pre><code>class div
{
 public int remainder;

 public int quotient(int dividend, int divisor)
 {
 remainder = ...;
 return ...;
 }
}
</code></pre>

The function member returns the quotient which most callers are primarily interested in. Additionally it stores the remainder as a data member, which is easily accessible by the caller afterwards.

This way you can have many additional "return values", very useful if you implement database or networking calls, where lots of error messages may be needed but only in case an error occurs.

I entered this solution also in the C++ question that OP is referring to.

blocks|key|607643|text|您可以使用三种不同的方法|type|unstyled|depth|inlineStyleRanges|entityRanges|data|607644|1.REF/+out参数|offset|length|style|BOLD|607645|使用ref:的|607646|static+void+Main(string[]+args)
{
++++int+a+=+10;
++++int+b+=+20;
++++int+add+=+0;
++++int+multiply+=+0;
++++Add_Multiply(a,+b,+ref+add,+ref+multiply);
++++Console.WriteLine(add);
++++Console.WriteLine(multiply);
}

private+static+void+Add_Multiply(int+a,+int+b,+ref+int+add,+ref+int+multiply)
{
++++add+=+a+%2B+b;
++++multiply+=+a+*+b;
}|code-block|syntax|javascript|607647|使用out的：|607648|static+void+Main(string[]+args)
{
++++int+a+=+10;
++++int+b+=+20;
++++int+add;
++++int+multiply;
++++Add_Multiply(a,+b,+out+add,+out+multiply);
++++Console.WriteLine(add);
++++Console.WriteLine(multiply);
}

private+static+void+Add_Multiply(int+a,+int+b,+out+int+add,+out+int+multiply)
{
++++add+=+a+%2B+b;
++++multiply+=+a+*+b;
}|607649|2.结构/类|607650|使用结构的：|607651|struct+Result
{
++++public+int+add;
++++public+int+multiply;
}
static+void+Main(string[]+args)
{
++++int+a+=+10;
++++int+b+=+20;
++++var+result+=+Add_Multiply(a,+b);
++++Console.WriteLine(result.add);
++++Console.WriteLine(result.multiply);
}

private+static+Result+Add_Multiply(int+a,+int+b)
{
++++var+result+=+new+Result
++++{
++++++++add+=+a+*+b,
++++++++multiply+=+a+%2B+b
++++};
++++return+result;
}|607652|使用类：的|607653|class+Result
{
++++public+int+add;
++++public+int+multiply;
}
static+void+Main(string[]+args)
{
++++int+a+=+10;
++++int+b+=+20;
++++var+result+=+Add_Multiply(a,+b);
++++Console.WriteLine(result.add);
++++Console.WriteLine(result.multiply);
}

private+static+Result+Add_Multiply(int+a,+int+b)
{
++++var+result+=+new+Result
++++{
++++++++add+=+a+*+b,
++++++++multiply+=+a+%2B+b
++++};
++++return+result;
}|607654|元组3.元组|607655|元组类|607656|static+void+Main(string[]+args)
{
++++int+a+=+10;
++++int+b+=+20;
++++var+result+=+Add_Multiply(a,+b);
++++Console.WriteLine(result.Item1);
++++Console.WriteLine(result.Item2);
}

private+static+Tuple<int,+int>+Add_Multiply(int+a,+int+b)
{
++++var+tuple+=+new+Tuple<int,+int>(a+%2B+b,+a+*+b);
++++return+tuple;
}|607657|C#+7元组|607658|static+void+Main(string[]+args)
{
++++int+a+=+10;
++++int+b+=+20;
++++(int+a_plus_b,+int+a_mult_b)+=+Add_Multiply(a,+b);
++++Console.WriteLine(a_plus_b);
++++Console.WriteLine(a_mult_b);
}

private+static+(int+a_plus_b,+int+a_mult_b)+Add_Multiply(int+a,+int+b)
{
++++return(a+%2B+b,+a+*+b);
}|607659|entityMap^0|0|0|C|0|0|0|0|7|0|0|0|6|0|0|6|0|0|0|4|0|0|0|6|0|0|3|0|0|0|6|0|0^^$0|@$1|2|3|4|5|6|7|1E|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1F|8|@$D|1G|E|1H|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|1I|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|1J|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|1K|8|@$D|1L|E|1M|F|G]]|9|@]|A|$]]|$1|Q|3|R|5|L|7|1N|8|@]|9|@]|A|$M|N]]|$1|S|3|T|5|6|7|1O|8|@$D|1P|E|1Q|F|G]]|9|@]|A|$]]|$1|U|3|V|5|6|7|1R|8|@$D|1S|E|1T|F|G]]|9|@]|A|$]]|$1|W|3|X|5|L|7|1U|8|@]|9|@]|A|$M|N]]|$1|Y|3|Z|5|6|7|1V|8|@$D|1W|E|1X|F|G]]|9|@]|A|$]]|$1|10|3|11|5|L|7|1Y|8|@]|9|@]|A|$M|N]]|$1|12|3|13|5|6|7|1Z|8|@$D|20|E|21|F|G]]|9|@]|A|$]]|$1|14|3|15|5|6|7|22|8|@$D|23|E|24|F|G]]|9|@]|A|$]]|$1|16|3|17|5|L|7|25|8|@]|9|@]|A|$M|N]]|$1|18|3|19|5|6|7|26|8|@$D|27|E|28|F|G]]|9|@]|A|$]]|$1|1A|3|1B|5|L|7|29|8|@]|9|@]|A|$M|N]]|$1|1C|3|-4|5|6|7|2A|8|@]|9|@]|A|$]]]|1D|$]]

You can use three different ways

1. ref / out parameters

using ref:

<pre><code>static void Main(string[] args)
{
 int a = 10;
 int b = 20;
 int add = 0;
 int multiply = 0;
 Add_Multiply(a, b, ref add, ref multiply);
 Console.WriteLine(add);
 Console.WriteLine(multiply);
}

private static void Add_Multiply(int a, int b, ref int add, ref int multiply)
{
 add = a + b;
 multiply = a * b;
}
</code></pre>

using out:

<pre><code>static void Main(string[] args)
{
 int a = 10;
 int b = 20;
 int add;
 int multiply;
 Add_Multiply(a, b, out add, out multiply);
 Console.WriteLine(add);
 Console.WriteLine(multiply);
}

private static void Add_Multiply(int a, int b, out int add, out int multiply)
{
 add = a + b;
 multiply = a * b;
}
</code></pre>

2. struct / class

using struct:

<pre><code>struct Result
{
 public int add;
 public int multiply;
}
static void Main(string[] args)
{
 int a = 10;
 int b = 20;
 var result = Add_Multiply(a, b);
 Console.WriteLine(result.add);
 Console.WriteLine(result.multiply);
}

private static Result Add_Multiply(int a, int b)
{
 var result = new Result
 {
 add = a * b,
 multiply = a + b
 };
 return result;
}
</code></pre>

using class:

<pre><code>class Result
{
 public int add;
 public int multiply;
}
static void Main(string[] args)
{
 int a = 10;
 int b = 20;
 var result = Add_Multiply(a, b);
 Console.WriteLine(result.add);
 Console.WriteLine(result.multiply);
}

private static Result Add_Multiply(int a, int b)
{
 var result = new Result
 {
 add = a * b,
 multiply = a + b
 };
 return result;
}
</code></pre>

3. Tuple

Tuple class

<pre><code>static void Main(string[] args)
{
 int a = 10;
 int b = 20;
 var result = Add_Multiply(a, b);
 Console.WriteLine(result.Item1);
 Console.WriteLine(result.Item2);
}

private static Tuple&lt;int, int&gt; Add_Multiply(int a, int b)
{
 var tuple = new Tuple&lt;int, int&gt;(a + b, a * b);
 return tuple;
}
</code></pre>

C# 7 Tuples

<pre><code>static void Main(string[] args)
{
 int a = 10;
 int b = 20;
 (int a_plus_b, int a_mult_b) = Add_Multiply(a, b);
 Console.WriteLine(a_plus_b);
 Console.WriteLine(a_mult_b);
}

private static (int a_plus_b, int a_mult_b) Add_Multiply(int a, int b)
{
 return(a + b, a * b);
}
</code></pre>

blocks|key|3828824|text|方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3828825|1)+KeyValuePair+(最佳性能-+0.32+ns)：|3828826|++++KeyValuePair<int,+int>+Location(int+p_1,+int+p_2,+int+p_3,+int+p_4)
++++{+++++++++++++++++
+++++++++return+new+KeyValuePair<int,int>(p_2+-+p_1,+p_4-p_3);
++++}|code-block|syntax|javascript|3828827|2)元组-+5.40+ns：|3828828|++++Tuple<int,+int>+Location(int+p_1,+int+p_2,+int+p_3,+int+p_4)
++++{
++++++++++return+new+Tuple<int,+int>(p_2+-+p_1,+p_4-p_3);
++++}|3828829|3)+out+(1.64+ns)或ref+4)创建您自己的自定义类/结构|3828830|ns+->纳秒|3828831|参考：multiple-return-values。|offset|length|3828832|entityMap|0|LINK|mutability|MUTABLE|url|http://www.dotnetperls.com/multiple-return-values^0|0|0|0|0|0|0|0|3|M|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|13|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|14|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|15|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|16|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|17|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|18|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|19|8|@]|9|@$S|1A|T|1B|1|1C]]|A|$]]|$1|U|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]]|V|$W|$5|X|Y|Z|A|$10|11]]]]

Ways to do it:

1) KeyValuePair (Best Performance - 0.32 ns):

<pre><code> KeyValuePair&lt;int, int&gt; Location(int p_1, int p_2, int p_3, int p_4)
 { 
 return new KeyValuePair&lt;int,int&gt;(p_2 - p_1, p_4-p_3);
 }
</code></pre>

2) Tuple - 5.40 ns:

<pre><code> Tuple&lt;int, int&gt; Location(int p_1, int p_2, int p_3, int p_4)
 {
 return new Tuple&lt;int, int&gt;(p_2 - p_1, p_4-p_3);
 }
</code></pre>

3) out (1.64 ns) or ref
4) Create your own custom class/struct

ns -> nanoseconds

Reference: <a href="http://www.dotnetperls.com/multiple-return-values" rel="nofollow">multiple-return-values</a>.

blocks|key|3828857|text|接受委托的方法可以向调用方提供多个值。这借鉴了我的答案here，并使用了一点Hadas's+accepted+answer。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3828858|delegate+void+ValuesDelegate(int+upVotes,+int+comments);
void+GetMultipleValues(ValuesDelegate+callback)
{
++++callback(1,+2);
}|code-block|syntax|javascript|3828859|调用者提供lambda+(或命名函数)，而intellisense通过从委托复制变量名来提供帮助。|3828860|GetMultipleValues((upVotes,+comments)+=>
{
+++++Console.WriteLine($"This+post+has+{upVotes}+Up+Votes+and+{comments}+Comments.");
});|3828861|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/32515539/5062254|1|https://stackoverflow.com/a/10278769/5062254^0|R|4|0|12|N|1|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]|$A|10|B|11|1|12]]|C|$]]|$1|D|3|E|5|F|7|13|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|14|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|15|8|@]|9|@]|C|$G|H]]|$1|M|3|-4|5|6|7|16|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]|U|$5|P|Q|R|C|$S|V]]]]

A method taking a delegate can provide multiple values to the caller. This borrows from my answer <a href="https://stackoverflow.com/a/32515539/5062254">here</a> and uses a little bit from <a href="https://stackoverflow.com/a/10278769/5062254">Hadas's accepted answer</a>.

<pre><code>delegate void ValuesDelegate(int upVotes, int comments);
void GetMultipleValues(ValuesDelegate callback)
{
 callback(1, 2);
}
</code></pre>

Callers provide a lambda (or a named function) and intellisense helps by copying the variable names from the delegate.

<pre><code>GetMultipleValues((upVotes, comments) =&gt;
{
 Console.WriteLine($"This post has {upVotes} Up Votes and {comments} Comments.");
});
</code></pre>

blocks|key|607779|text|从this的文章中，你可以使用上面提到的三个选项。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|607780|KeyValuePair是最快的方式。|style|BOLD|607781|out位居第二。|607782|元组是最慢的。|607783|无论如何，这取决于什么对您的场景是最好的。|607784|entityMap|0|LINK|mutability|MUTABLE|url|http://www.dotnetperls.com/multiple-return-values^0|1|4|0|0|0|C|0|0|3|0|0|2|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@$A|W|B|X|1|Y]]|C|$]]|$1|D|3|E|5|6|7|Z|8|@$A|10|B|11|F|G]]|9|@]|C|$]]|$1|H|3|I|5|6|7|12|8|@$A|13|B|14|F|G]]|9|@]|C|$]]|$1|J|3|K|5|6|7|15|8|@$A|16|B|17|F|G]]|9|@]|C|$]]|$1|L|3|M|5|6|7|18|8|@]|9|@]|C|$]]|$1|N|3|-4|5|6|7|19|8|@]|9|@]|C|$]]]|O|$P|$5|Q|R|S|C|$T|U]]]]

From <a href="http://www.dotnetperls.com/multiple-return-values" rel="nofollow">this</a> article, you can use three options as posts above said.

KeyValuePair is quickest way.

out is at the second.

Tuple is the slowest.

Anyway, this is depend on what is the best for your scenario.

blocks|key|1170741|text|既然C#+7已经发布，您就可以使用新的包含的元组语法|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1170742|(string,+string,+string)+LookupName(long+id)+//+tuple+return+type
{
++++...+//+retrieve+first,+middle+and+last+from+data+storage
++++return+(first,+middle,+last);+//+tuple+literal
}|code-block|syntax|javascript|1170743|然后可以像这样使用它：|1170744|var+names+=+LookupName(id);
WriteLine($"found+{names.Item1}+{names.Item3}.");|1170745|您还可以为您的元素提供名称(这样它们就不是"Item1“、"Item2”等)。您可以通过在签名或返回方法中添加名称来完成此操作：|1170746|(string+first,+string+middle,+string+last)+LookupName(long+id)+//+tuple+elements+have+names|1170747|或|1170748|return+(first:+first,+middle:+middle,+last:+last);+//+named+tuple+elements+in+a+literal|1170749|它们也可以被解构，这是一个非常好的新特性：|1170750|(string+first,+string+middle,+string+last)+=+LookupName(id1);+//+deconstructing+declaration|1170751|请查看this+link，了解更多可以完成哪些操作的示例:)|offset|length|1170752|entityMap|0|LINK|mutability|MUTABLE|url|https://blogs.msdn.microsoft.com/dotnet/2017/03/09/new-features-in-c-7-0/^0|0|0|0|0|0|0|0|0|0|0|3|9|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|19|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1A|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|1B|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|1C|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|1D|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|1E|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|1F|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|1G|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|1H|8|@]|9|@]|A|$E|F]]|$1|W|3|X|5|6|7|1I|8|@]|9|@$Y|1J|Z|1K|1|1L]]|A|$]]|$1|10|3|-4|5|6|7|1M|8|@]|9|@]|A|$]]]|11|$12|$5|13|14|15|A|$16|17]]]]

Now that C# 7 has been released, you can use the new included Tuples syntax

<pre><code>(string, string, string) LookupName(long id) // tuple return type
{
 ... // retrieve first, middle and last from data storage
 return (first, middle, last); // tuple literal
}
</code></pre>

which could then be used like this:

<pre><code>var names = LookupName(id);
WriteLine($"found {names.Item1} {names.Item3}.");
</code></pre>

You can also provide names to your elements (so they are not "Item1", "Item2" etc). You can do it by adding a name to the signature or the return methods:

<pre><code>(string first, string middle, string last) LookupName(long id) // tuple elements have names
</code></pre>

or 

<pre><code>return (first: first, middle: middle, last: last); // named tuple elements in a literal
</code></pre>

They can also be deconstructed, which is a pretty nice new feature:

<pre><code>(string first, string middle, string last) = LookupName(id1); // deconstructing declaration
</code></pre>

Check out <a href="https://blogs.msdn.microsoft.com/dotnet/2017/03/09/new-features-in-c-7-0/" rel="noreferrer">this link</a> to see more examples on what can be done :)

blocks|key|3828967|text|您可以使用动态对象。我认为它比Tuple有更好的可读性。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3828968|static+void+Main(string[]+args){
++++var+obj+=+GetMultipleValues();
++++Console.WriteLine(obj.Id);
++++Console.WriteLine(obj.Name);
}

private+static+dynamic+GetMultipleValues()+{
++++dynamic+temp+=+new+System.Dynamic.ExpandoObject();
++++temp.Id+=+123;
++++temp.Name+=+"Lorem+Ipsum";
++++return+temp;
}|code-block|syntax|javascript|3828969|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You could use a dynamic object. I think it has better readability than Tuple.

<pre><code>static void Main(string[] args){
 var obj = GetMultipleValues();
 Console.WriteLine(obj.Id);
 Console.WriteLine(obj.Name);
}

private static dynamic GetMultipleValues() {
 dynamic temp = new System.Dynamic.ExpandoObject();
 temp.Id = 123;
 temp.Name = "Lorem Ipsum";
 return temp;
}
</code></pre>

blocks|key|1163720|text|未来版本的C#将包含命名元组。看一下演示https://channel9.msdn.com/Events/Build/2016/B889的channel9会话|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1163721|跳到13:00了解元组的内容。这将允许像这样的东西：|1163722|(int+sum,+int+count)+Tally(IEnumerable<int>+list)
{
//+calculate+stuff+here
return+(0,0)
}

int+resultsum+=+Tally(numbers).sum|code-block|syntax|javascript|1163723|(视频中的不完整示例)|1163724|entityMap|0|LINK|mutability|MUTABLE|url|https://channel9.msdn.com/Events/Build/2016/B889^0|K|1C|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|Z|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|C|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

Future version of C# is going to include named tuples.
Have a look at this channel9 session for the demo
<a href="https://channel9.msdn.com/Events/Build/2016/B889" rel="nofollow">https://channel9.msdn.com/Events/Build/2016/B889</a>

Skip to 13:00 for the tuple stuff. This will allow stuff like:

<pre><code>(int sum, int count) Tally(IEnumerable&lt;int&gt; list)
{
// calculate stuff here
return (0,0)
}

int resultsum = Tally(numbers).sum
</code></pre>

(incomplete example from video)

blocks|key|4672026|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4672027|一些答案建议使用out+parameters，但由于，我建议不要使用它，它们不能与异步方法一起使用。有关详细信息，请参阅this。|blockquote|offset|length|style|BOLD|4672028|4672029|4672030|其他答案使用元组，我也推荐使用元组，但使用C#+7.0中引入的新功能。|4672031|(string,+string,+string)+LookupName(long+id)+//+tuple+return+type
{
++++...+//+retrieve+first,+middle+and+last+from+data+storage
++++return+(first,+middle,+last);+//+tuple+literal
}

var+names+=+LookupName(id);
WriteLine($"found+{names.Item1}+{names.Item3}.");|code-block|syntax|javascript|4672032|欲了解更多信息，请访问here。|4672033|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/18716928/how-to-write-a-async-method-with-out-parameter|1|https://blogs.msdn.microsoft.com/dotnet/2016/08/24/whats-new-in-csharp-7-0/^0|0|8|E|Q|J|1O|4|0|0|0|0|0|0|B|4|1|0^^$0|@$1|2|3|-4|4|5|6|12|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|13|7|@$D|14|E|15|F|G]|$D|16|E|17|F|G]]|8|@$D|18|E|19|1|1A]]|9|$]]|$1|H|3|-4|4|5|6|1B|7|@]|8|@]|9|$]]|$1|I|3|-4|4|5|6|1C|7|@]|8|@]|9|$]]|$1|J|3|K|4|5|6|1D|7|@]|8|@]|9|$]]|$1|L|3|M|4|N|6|1E|7|@]|8|@]|9|$O|P]]|$1|Q|3|R|4|5|6|1F|7|@]|8|@$D|1G|E|1H|1|1I]]|9|$]]|$1|S|3|-4|4|5|6|1J|7|@]|8|@]|9|$]]]|T|$U|$4|V|W|X|9|$Y|Z]]|10|$4|V|W|X|9|$Y|11]]]]

<blockquote>
 Some answers suggest using out parameters but I recommend
 not using this due to they don’t work with async methods. See
 <a href="https://stackoverflow.com/questions/18716928/how-to-write-a-async-method-with-out-parameter">this</a> for more information.
</blockquote>

Other answers stated using Tuple, which I would recommend too but using the new feature introduced in C# 7.0.

<pre><code>(string, string, string) LookupName(long id) // tuple return type
{
 ... // retrieve first, middle and last from data storage
 return (first, middle, last); // tuple literal
}

var names = LookupName(id);
WriteLine($"found {names.Item1} {names.Item3}.");
</code></pre>

Further information can be found <a href="https://blogs.msdn.microsoft.com/dotnet/2016/08/24/whats-new-in-csharp-7-0/" rel="noreferrer">here</a>.

blocks|key|4672041|text|您还可以使用OperationResult|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4672042|public+OperationResult+DoesSomething(int+number1,+int+number2)
{
//+Your+Code
var+returnValue1+=+"return+Value+1";
var+returnValue2+=+"return+Value+2";

var+operationResult+=+new+OperationResult(returnValue1,+returnValue2);
return+operationResult;
}|code-block|syntax|javascript|4672043|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can also use an OperationResult

<pre><code>public OperationResult DoesSomething(int number1, int number2)
{
// Your Code
var returnValue1 = "return Value 1";
var returnValue2 = "return Value 2";

var operationResult = new OperationResult(returnValue1, returnValue2);
return operationResult;
}
</code></pre>

blocks|key|3829069|text|在C#7中有一种新的Tuple语法：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3829070|static+(string+foo,+int+bar)+GetTuple()
{
++++return+("hello",+5);
}|code-block|syntax|javascript|3829071|您可以将其作为记录返回：|3829072|var+result+=+GetTuple();
var+foo+=+result.foo
//+foo+==+"hello"|3829073|您还可以使用新的解构函数语法：|3829074|(string+foo)+=+GetTuple();
//+foo+==+"hello"|3829075|但是要小心序列化，所有这些都是语法上的糖-在实际编译的代码中，这将是一个带有Item1和Item2的Tuple<string,+int>+(作为per+the+accepted+answer)，而不是foo和bar。这意味着序列化(或反序列化)将使用这些属性名称。|3829076|因此，对于序列化，声明一个record类并返回它。|3829077|C#7中的另一个新功能是改进了out参数的语法。您现在可以内联声明out，这在某些上下文中更适合：|3829078|if(int.TryParse("123",+out+int+result))+{
++++//+Do+something+with+result
}|3829079|但是，大多数情况下，您将在.NET自己的库中使用它，而不是在您自己的函数中。|3829080|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/10278769/905^0|A|5|0|0|0|0|0|0|12|5|18|5|1E|I|2S|3|2W|3|20|N|0|0|0|F|3|X|3|0|0|0^^$0|@$1|2|3|4|5|6|7|1A|8|@$9|1B|A|1C|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|1D|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1E|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|1F|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1G|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|1H|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|1I|8|@$9|1J|A|1K|B|C]|$9|1L|A|1M|B|C]|$9|1N|A|1O|B|C]|$9|1P|A|1Q|B|C]|$9|1R|A|1S|B|C]]|D|@$9|1T|A|1U|1|1V]]|E|$]]|$1|U|3|V|5|6|7|1W|8|@]|D|@]|E|$]]|$1|W|3|X|5|6|7|1X|8|@$9|1Y|A|1Z|B|C]|$9|20|A|21|B|C]]|D|@]|E|$]]|$1|Y|3|Z|5|H|7|22|8|@]|D|@]|E|$I|J]]|$1|10|3|11|5|6|7|23|8|@]|D|@]|E|$]]|$1|12|3|-4|5|6|7|24|8|@]|D|@]|E|$]]]|13|$14|$5|15|16|17|E|$18|19]]]]

In C#7 There is a new <code>Tuple</code> syntax:

<pre><code>static (string foo, int bar) GetTuple()
{
 return ("hello", 5);
}
</code></pre>

You can return this as a record:

<pre><code>var result = GetTuple();
var foo = result.foo
// foo == "hello"
</code></pre>

You can also use the new deconstructor syntax:

<pre><code>(string foo) = GetTuple();
// foo == "hello"
</code></pre>

Be careful with serialisation however, all this is syntactic sugar - in the actual compiled code this will be a <code>Tuple&lt;string, int&gt;</code> (as <a href="https://stackoverflow.com/a/10278769/905">per the accepted answer</a>) with <code>Item1</code> and <code>Item2</code> instead of <code>foo</code> and <code>bar</code>. That means that serialisation (or deserialisation) will use those property names instead.

So, for serialisation declare a record class and return that instead.

Also new in C#7 is an improved syntax for <code>out</code> parameters. You can now declare the <code>out</code> inline, which is better suited in some contexts:

<pre><code>if(int.TryParse("123", out int result)) {
 // Do something with result
}
</code></pre>

However, mostly you'll use this in .NET's own libraries, rather than in you own functions.

blocks|key|608008|text|<--Return+more+statements+like+this+you+can+-->+

public+(int,string,etc)+Sample(+int+a,+int+b)++
{
++++//your+code;
++++return+(a,b);++
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|608009|您可以接收到如下代码|unstyled|608010|(c,d,etc)+=+Sample(+1,2);|608011|我希望它能起作用。|608012|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$B|C]]|$1|I|3|J|5|F|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|F|7|Q|8|@]|9|@]|A|$]]]|L|$]]

<pre><code>&lt;--Return more statements like this you can --&gt; 

public (int,string,etc) Sample( int a, int b) 
{
 //your code;
 return (a,b); 
}
</code></pre>

You can receive code like 

<pre><code>(c,d,etc) = Sample( 1,2);
</code></pre>

I hope it works.

blocks|key|3829146|text|有很多方法；但是如果你不想创建一个新的对象或结构或类似的东西，你可以在C#+7.0之后像下面这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3829147|+(string+firstName,+string+lastName)+GetName(string+myParameter)
++++{
++++++++var+firstName+=+myParameter;
++++++++var+lastName+=+myParameter+%2B+"+something";
++++++++return+(firstName,+lastName);
++++}

++++void+DoSomethingWithNames()
++++{
++++++++var+(firstName,+lastName)+=+GetName("myname");

++++}|code-block|syntax|javascript|3829148|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-7^0|Z|6|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

There is many way; but if you don't want to create a new Object or structure or something like this you can do like below after <a href="https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-7" rel="noreferrer">C# 7.0</a> :

<pre><code> (string firstName, string lastName) GetName(string myParameter)
 {
 var firstName = myParameter;
 var lastName = myParameter + " something";
 return (firstName, lastName);
 }

 void DoSomethingWithNames()
 {
 var (firstName, lastName) = GetName("myname");

 }
</code></pre>

blocks|key|608087|text|作为另一种选择，您可以将您的方法设置为void并且不返回任何内容。相反，创建一个带有参数的公共类，并将它们设置在您的方法中。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|608088|public+class+FooBar()
{
++++public+string+foo+{+get;+set;+}
++++public+int+bar+{+get;+set;+}
}|code-block|syntax|javascript|608089|然后，对于您的方法，尝试如下所示|608090|public+void+MyMethod(Foo+foo,+Bar+bar)
{
++++FooBar+fooBar+=+new+FooBar();
++++fooBar.foo+=+"some+string";
++++fooBar.bar+=+1;
}|608091|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

As an alternative you could set your method to void and not return anything. Instead create a public class with parameters and set them inside your method.
<pre><code>public class FooBar()
{
 public string foo { get; set; }
 public int bar { get; set; }
}
</code></pre>
Then for your method try this
<pre><code>public void MyMethod(Foo foo, Bar bar)
{
 FooBar fooBar = new FooBar();
 fooBar.foo = &quot;some string&quot;;
 fooBar.bar = 1;
}
</code></pre>

I read the <a href="https://stackoverflow.com/questions/321068/returning-multiple-values-from-a-c-function">C++ version of this question</a> but didn't really understand it.
Can someone please explain clearly if it can be done in C#, and how?

Return multiple values to a method caller

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我读了，但并不是真的理解它。有没有人能清楚地解释一下，是否可以用C#实现，以及如何实现？

问将多个值返回给方法调用者
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问将多个值返回给方法调用者EN