以下是基本的两种方法:

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及以上版本生效。元组类型是一个类。它将被分配到内存中托管堆上的一个单独位置。一旦创建了元组，就不能更改其字段的值。这使得元组更像一个结构体。

你可以试试这个

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

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

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

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

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

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

你可以使用动态对象。我认为它比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;
}

一些答案建议使用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# 4中，您将能够使用元组的内置支持轻松地处理这个问题。

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

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

这看起来像:

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

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