要么返回类实例，要么使用out参数。这里有一个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

以下是基本的两种方法:

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

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

2） 元组<T>

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

注意:使用Tuple从Framework 4.0及以上版本生效。元组类型是一个类。它将被分配到内存中托管堆上的一个单独位置。一旦创建了元组，就不能更改其字段的值。这使得元组更像一个结构体。

方法:

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 ->纳秒

参考:多个返回值。

一些答案建议使用out参数，但我建议 不使用这个，因为它们不与异步方法一起工作。看到 这是更多的信息。

其他的答案是使用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}.");

更多信息可以在这里找到。

有许多方法;但如果你不想创建一个新的对象或结构或类似的东西，你可以在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");

    }

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

int Foo(ref Bar bar) { }

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

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

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

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

FooBar Foo(Bar bar) { }

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