我读了这个问题的c++版本,但并没有真正理解它。

有人能解释清楚,如果它可以在c#中完成,以及如何?


当前回答

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

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自己的库中使用它,而不是在您自己的函数中。

其他回答

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

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

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

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

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

以下是基本的两种方法:

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

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

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

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

这看起来像:

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

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

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

class div
{
    public int remainder;

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

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

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

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

在c# 7及以上版本中,可以看到这个答案。

在以前的版本中,你可以使用。net 4.0+的元组:

例如:

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

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