向方法调用者返回多个值

如果你的意思是返回多个值，你可以返回一个包含你想返回的值的类/结构，或者在参数上使用"out"关键字，如下所示:

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

您可以返回类实例或使用出参数。这里有一个out参数的例子:

void mymethod(out int param1, out int param2)
{
param1 = 10;
param2 = 20;
}

这样叫它:

int i, j;
mymethod(out i, out j);
// i will be 20 and j will be 10

你不能在c#中这样做。您可以使用out形参或返回您自己的类(如果您希望它是不可变的，也可以返回结构)。

public int GetDay(DateTime date, out string name)
{
// ...
}

public DayOfWeek GetDay(DateTime date)
{
// ...
}


public class DayOfWeek
{
public int Day { get; set; }
public string Name { get; set; }
}

类、结构、集合和数组可以包含多个值。也可以在函数中设置输出和引用参数。在动态和函数式语言中可以通过元组返回多个值，但在c#中不可以。

在c# 4中，您将能够使用元组的内置支持轻松地处理这个问题。

与此同时，我们有两种选择。

首先，可以使用ref或out参数为参数赋值，然后将这些值传递回调用例程。

这看起来像:

void myFunction(ref int setMe, out int youMustSetMe);

其次，您可以将返回值包装到结构或类中，并将它们作为该结构的成员传递回去。KeyValuePair适用于2 -超过2你需要一个自定义类或结构。

之前的帖子是对的。c#方法不能返回多个值。然而，你确实有几个选择:

• 返回一个包含多个成员的结构
• 返回类的实例
• 使用输出参数(使用出或裁判关键字)
• 使用字典或键值对作为输出

这里的利与弊通常很难弄清楚。如果您返回一个结构，请确保它很小，因为结构是值类型并传递给堆栈。如果你返回一个类的实例，这里有一些设计模式，你可能想要使用，以避免引起问题-类的成员可以修改，因为c#通过引用传递对象(你不像在VB中那样有ByVal)。

最后，您可以使用输出参数，但我将限制在只有两个(如3个或更少)参数的情况下使用此方法-否则事情将变得丑陋且难以维护。此外，输出参数的使用可能会抑制灵活性，因为每次需要向返回值中添加内容时都必须更改方法签名，而返回结构或类实例时无需修改方法签名即可添加成员。

从架构的角度来看，我建议不要使用键值对或字典。我发现这种编码风格需要使用方法的代码中的“秘密知识”。它必须提前知道键将是什么，值的含义是什么，如果开发人员在内部实现中改变了字典或KVP的创建方式，那么很容易在整个应用程序中创建故障级联。

不，在c#中(对于低于c# 7的版本)，你不能从一个函数返回多个值，至少不能像在Python中那样。

然而，也有一些选择:

您可以返回一个object类型的数组，其中包含您想要的多个值。

private object[] DoSomething()
{
return new [] { 'value1', 'value2', 3 };
}

您可以使用out参数。

private string DoSomething(out string outparam1, out int outparam2)
{
outparam1 = 'value2';
outparam2 = 3;
return 'value1';
}

有几种方法可以做到这一点。你可以使用ref参数:

int Foo(ref Bar bar) { }

这将向函数传递一个引用，从而允许函数在调用代码的堆栈中修改对象。虽然这在技术上不是一个“返回”值，但它是一种让函数做类似事情的方法。在上面的代码中，该函数将返回int并(可能)修改bar。

另一种类似的方法是使用out参数。out形参与ref形参相同，只是附加了编译器强制的规则。这条规则是，如果您将out参数传递给一个函数，该函数需要在返回之前设置它的值。除此之外，out参数的工作原理与ref参数类似。

最后一种方法(在大多数情况下是最好的)是创建一个封装两个值的类型，并允许函数返回该类型:

class FooBar
{
public int i { get; set; }
public Bar b { get; set; }
}


FooBar Foo(Bar bar) { }

最后一种方法更简单，更容易阅读和理解。

主要有两个方法。 1. 使用out/ref参数 2. 返回对象数组

你可以试试这个KeyValuePair

private KeyValuePair<int, int> GetNumbers()
{
return new KeyValuePair<int, int>(1, 2);
}




var numbers = GetNumbers();


Console.WriteLine("Output : {0}, {1}",numbers.Key, numbers.Value);

输出:

输出:1,2

在c# 7及以上版本中，参见这个答案。

在以前的版本中，你可以使用.NET 4.0+的元组:

例如:

public Tuple<int, int> GetMultipleValue()
{
return Tuple.Create(1,2);
}

具有两个值的元组具有Item1和Item2作为属性。

你可以试试这个

public IEnumerable<string> Get()
{
return new string[] { "value1", "value2" };
}

下面是Two的基本方法:

1)使用“out”作为参数 你也可以在4.0和次要版本中使用'out'

'out'的例子:

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();
}
}
}

输出:

矩形的面积为20

矩形的周长是18

*# eyz0 -关键字描述了其实际变量位置被复制到被调用方法的堆栈上的参数，这些相同的位置可以被重写。这意味着调用方法将访问已更改的形参。

# EYZ1

Tuple的例子:

使用Tuple<T>返回多个数据类型值

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);
}
}
}

输出

perl
java
c#
1
2
3

# EYZ6 # EYZ7。Tuple类型是class。它将被分配到内存中托管堆上的一个单独位置。一旦创建了Tuple，就不能更改其fields的值。这使得Tuple更像struct。

在面向对象的方式中使用一个这样的类:

class div
{
public int remainder;


public int quotient(int dividend, int divisor)
{
remainder = ...;
return ...;
}
}

函数成员返回大多数调用者主要感兴趣的商。此外，它将余数存储为数据成员，之后调用者可以很容易地访问它。

通过这种方式，您可以有许多额外的“返回值”，这在实现数据库或网络调用时非常有用，在这些调用中可能需要大量的错误消息，但仅在发生错误时才需要。

我也在OP提到的c++问题中输入了这个解决方案。

你可以用三种不同的方法

1. Ref / out参数

使用参考:

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;
}

使用:

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;
}

2. 结构/类

使用结构体:

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;
}

使用类:

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;
}

3.元组

Tuple类

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 + b, a * b);
return tuple;
}

c# 7元组

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);
}

方法:

1) KeyValuePair(最佳性能- 0.32 ns):

    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);
}

2)元组- 5.40 ns:

    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);
}

3) out (1.64 ns) or ref 4)创建自己的自定义类/结构

Ns ->纳秒

参考:# EYZ0。

接受委托的方法可以向调用者提供多个值。这借鉴了我的答案在这里，并使用了哈达斯接受的答案的一点内容。

delegate void ValuesDelegate(int upVotes, int comments);
void GetMultipleValues(ValuesDelegate callback)
{
callback(1, 2);
}

调用方提供lambda(或命名函数)，智能感知通过从委托复制变量名来帮助实现。

GetMultipleValues((upVotes, comments) =>
{
Console.WriteLine($"This post has {upVotes} Up Votes and {comments} Comments.");
});

从这文章中，您可以使用上面提到的三个选项。

KeyValuePair是最快的方法。

出在第二。

元组最慢。

不管怎样，这取决于什么对你的情况是最好的。

现在c# 7已经发布了，您可以使用新包含的元组语法

(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}.");

您还可以为元素提供名称(因此它们不是“Item1”、“Item2”等)。你可以通过在签名或返回方法中添加一个名字来实现:

(string first, string middle, string last) LookupName(long id) // tuple elements have names

或

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

它们也可以被解构，这是一个非常好的新功能:

(string first, string middle, string last) = LookupName(id1); // deconstructing declaration

查看这个链接查看更多关于可以做什么的例子:)

你可以使用动态对象。我认为它比Tuple有更好的可读性。

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;
}

跳到13:00讲元组的内容。这将允许如下内容:

(int sum, int count) Tally(IEnumerable<int> list)
{
// calculate stuff here
return (0,0)
}


int resultsum = Tally(numbers).sum

(视频中不完整的例子)

一些答案建议使用输出参数，但我建议 不使用这个，因为它们不能与异步方法一起工作。看到

. 这获取更多信息

其他的答案是使用Tuple，我也会推荐它，但是使用c# 7.0中引入的新特性。

(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}.");

更多信息请访问在这里。

您还可以使用OperationResult

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;
}

在c# 7中有一个新的Tuple语法:

static (string foo, int bar) GetTuple()
{
return ("hello", 5);
}

你可以返回一个记录:

var result = GetTuple();
var foo = result.foo
// foo == "hello"

你也可以使用新的解构器语法:

(string foo) = GetTuple();
// foo == "hello"

但是要小心序列化，所有这些都是语法糖——在实际编译的代码中，这将是Tuple<string, int>(作为根据接受的答案)和Item1和Item2，而不是foo和bar。这意味着序列化(或反序列化)将使用这些属性名。

因此，对于序列化，声明一个记录类并返回它。

c# 7中的另一个新功能是改进了out参数的语法。你现在可以内联声明out，这在某些情况下更适合:

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

但是，大多数情况下，您将在. net自己的库中使用它，而不是在您自己的函数中。

<--Return more statements like this you can -->


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

你可以收到类似的代码

(c,d,etc) = Sample( 1,2);

我希望它能奏效。

有许多方法;但如果你不想创建一个新的对象或结构或类似的东西，你可以在c# 7.0后这样做:

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


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


}

作为一种替代方法，您可以将方法设置为void并且不返回任何内容。相反，创建一个带有参数的公共类，并在方法中设置它们。

public class FooBar()
{
public string foo { get; set; }
public int bar { get; set; }
}

然后试试这个方法

public void MyMethod(Foo foo, Bar bar)
{
FooBar fooBar = new FooBar();
fooBar.foo = "some string";
fooBar.bar = 1;
}

当您的方法是异步并且您希望返回多个属性时。你必须这样做:

public async Task<(int, int)> GetMultipleValues(){
return (1,2);
}