如何从方法中返回多个值？ [复制]

Posted 2023-02-22

【中文标题】如何从方法中返回多个值？ [复制]

【英文标题】：How to return more than one value from a method? [duplicate]

【发布时间】：2019-03-02 22:16:51

【问题描述】：

我想从 C# 中的方法返回年龄值，如下所示

private int UpdateAges( int age1,  int age2,  int age3,  int age4)

    age1++;
    age2++;
    age3++;
    age4++;
    return (age1, age2, age3, age4);

我可以像下面这样使用它

MessageBox.Show(UpdateAges(45, 30, 45, 30).ToString());

【问题讨论】：

iEnumerable、元组、你自己的类...有很多选择。

将“private int”替换为“private (int,int,int,int)”

如果你没有团队负责人或没有人指导你，我建议你阅读编程书籍，阅读开源（c#/java）代码并学习如何编写代码。就您而言，您如何处理结果？你使用这些值吗？或者将它们转发给另一个函数？真正的答案需要更多信息，技术答案将是元组或创建“持有者类”并返回 1 个持有这 4 个 int 值的类

看看this answer。

【参考方案1】：

试试这个：

private Tuple<int, int, int, int> UpdateAges( int age1,  int age2,  int age3,  int age4)

    age1++;
    age2++;
    age3++;
    age4++;

    return Tuple.Create(age1, age2, age3, age4);

另见：关于C# 7 new included Tuples syntax

【参考方案2】：

如果你只想在消息框中显示结果，返回一个字符串：

private string UpdateAges(int age1, int age2, int age3, int age4)

    age1++;
    age2++;
    age3++;
    age4++;
    return "age1 = " + age1 + ", age2 = " + age2 + ", age3 = " + age3 + ", age4 = " + age4;


MessageBox.Show(UpdateAges(45, 30, 45, 30));

如果您还想在显示的消息框之后更新年龄值，请为每个参数添加 ref 关键字。

private string UpdateAges(ref int age1, ref int age2, ref int age3, ref int age4)

    age1++;
    age2++;
    age3++;
    age4++;
    return "age1 = " + age1 + ", age2 = " + age2 + ", age3 = " + age3 + ", age4 = " + age4;


MessageBox.Show(UpdateAges(ref age1, ref age2, ref age3, ref age4));

【参考方案3】：

参考这个 - How to Return Multiple Values From a Function in C#

从函数返回多个值的方法很少。

参考参数 输出参数 返回一个数组 返回类/结构类型的对象 -- 这是我们主要遵循的方式 返回元组

Ref- 从 C# 7 开始，由于 tuple types 和 tuple literals，您可以从方法中返回多个值。

(int, int, int, int) UpdateAges(int age1,  int age2,  int age3,  int age4) // tuple return type
   
    age1++;
    age2++;
    age3++;
    age4++;

    return (age1, age2, age3, age4);

用途：

var values = UpdateAges(1, 2, 2, 3);

使用元组：

private Tuple<int, int, int, int> UpdateAges(int age1, int age2, int age3, int age4)

    age1++;
    age2++;
    age3++;
    age4++;

    return Tuple.Create(age1, age2, age3, age4);

【讨论】：

命名元组更加甜美。 blogs.msdn.microsoft.com/dotnet/2017/03/09/…

【参考方案4】：

如何使用列表：

private static List<int> UpdateAges(int age1, int age2, int age3, int age4)

    return new List<int>  ++age1, ++age2, ++age3, ++age4 ;

然后这样称呼它：

Console.WriteLine(string.Join(",", UpdateAges(1, 2, 3, 4)));

好的，希望对您有所帮助。

【参考方案5】：

你也可以像这样使用'out int'。

private void UpdateAges(int IAge1, int IAge2, int IAge3, int IAge4, out int OAge1, out int OAge2, out int OAge3, out int OAge4)

    OAge1 = IAge1++;
    OAge2 = IAge2++;
    OAge3 = IAge3++;
    OAge4 = IAge4++;

当你调用这个时，你需要这样使用。

UpdateAges( Age1, Age2, Age3, Age4, out Age1, out Age2, out Age3, out Age4 );

【讨论】：

这个解决方案不必要的复杂。 void Update(out int i) => i++; 就足够了（例如，您只需要 out var，无需将参数数量加倍）。

【参考方案6】：

您可以通过多种方式解决此问题。

使用元组

private Tuple<int, int, int, int> UpdateAges(int age1, int age2, int age3, int age4)

    return Tuple.Create(++age1, ++age2, ++age3, ++age4);

使用列表

private List<int> UpdateAges(int age1, int age2, int age3, int age4)

    return new List()++age1, ++age2, ++age3, ++age4;

使用数组

private int[] UpdateAges(int age1, int age2, int age3, int age4)

    var results = new int[4];
    results[0] = ++age1;
    results[1] = ++age2;
    results[2] = ++age3;
    results[3] = ++age4;

使用参考参数

private List<int> UpdateAges(ref int age1, ref int age2, ref int age3, ref int age4)

    age1++;
    age2++;
    age3++;
    age4++;

【参考方案7】：

虽然您可以使用 Tuple 或 ref 来实现您想要的，但我不确定这是否是您的最佳做法。

你可以用一个专门的类来封装你所有的逻辑：

public class Ages

    public int Age1  get; set; 
    public int Age2  get; set; 
    public int Age3  get; set; 
    public int Age4  get; set; 

    private void UpdateAges()
    
        this.Age1++;
        this.Age2++;
        this.Age3++;
        this.Age4++;
    

    private string ToString() => 
        $"Age1 = this.age1, Age2 this.age2, Age3 = this.age3, Age4 age4";

这样，与处理年龄相关的所有内容都集中在一个地方，并且可以在您的代码中重复使用。

您当然可以更进一步，将“年龄”属性替换为List 或数组。

public class Ages

    public int[] Ages  get; 

    public Ages (params int[] ages)
    
        this.Ages = ages;
    

    private void UpdateAges() =>
        for (int i = 0; i < this.Ages.Length; i++) this.Ages[i]++;

    private string ToString() =>  
        string.Join(", ", 
            this.Ages.Select((age, i) => $"Agei = age"));



var ages = new Ages(31, 40, 12, 18);
ages.UpdateAges();
MessageBox.Show(ages.ToString());

【参考方案8】：

用方法参数params， 你可以传递任意数量的参数返回一个可枚举、列表数组等。 灵活调用Increment(1,2,3),Increment(1,2),Increment(myIntArray),Increment(1)` ..

static IEnumerable<int> Increment(params int[] args)

    return args.Select(x => x + 1);

允许调用如下：

var result = Increment(45, 30, 45, 30);
// 46, 31, 46, 31

对于显示，您可以使用string join。 string.Join(", ", result)

static void Main(string[] args)

    var uniqueValue = 99;
    var multipleValues = new[]  1, 2, 6 ;


    var uvResult = Increment(uniqueValue);
    var mvResult = Increment(multipleValues);


    Console.WriteLine($"uniqueValue = uniqueValue  => string.Join(", ",uvResult)");
    Console.WriteLine($"multipleValues = string.Join(", ",multipleValues)  => string.Join(", ",multipleValues)");

【讨论】：

您甚至可以致电Increment(1, 2, 3, 4);

@Emaro，是的，我知道。操作码UpdateAges(45, 30, 45, 30) 立即按此铃。只是忘记将其包含在答案中。感谢那。更新答案以使其清楚

【参考方案9】：

1.用完：

static void UpdateAges(out int age1, out int age2)

    age1++;
    age2++;


int age1;
int age2;
UpdateAges(out age1, out age2);
Console.WriteLine(age1);
Console.WriteLine(age2);

2.使用 KeyValuePair：

static KeyValuePair<int, int> UpdateAges(age1, age2)

    return new KeyValuePair<int, int>(age1++, age2++);


int age1;
int age2;
var pair = GetTwoNumbers(age1,age2);
Console.WriteLine(pair.Key);
Console.WriteLine(pair.Value);

3.使用元组：

static Tuple<int, int> UpdateAges(age1, age2)

    return new Tuple<int, int>(age1++, age2++);


int age1;
int age2;
var tuple = UpdateAges(age1,age2);
int a = tuple.age1;
int b = tuple.age2;

【讨论】：

A KeyValuePair 不应该像元组一样使用。 age1怎么能成为age2的key呢？

@Emaro 用于 age1 像 key 和 age2 像 value

我知道它是如何工作的。然而，它在语义上被滥用，我认为这是不好的做法。值元组(int a1, int a2) 会是更好的选择。