C# 7.0 新特性1之基于Tuple的“多”返回值方法

原文链接：

回顾
 首先，提出一个问题，c#中，如何使一个方法可返回"多个"返回值？
 我们先来回顾一下c#6.0 及更早版本的做法。 
 在c#中，通常我们有以下4种方式使一个方法返回多条数据。
•使用 keyvalue 组合

•

static void main(string[] args)
{
 int int1 = 15;
 int int2 = 25;
 var result = add_multiply(int1, int2);
 console.writeline(result.key);
 console.writeline(result.value);
}

private static keyvaluepair<int, int> add_multiply(int int1, int int2)
{
 var keyvaluepair = new keyvaluepair<int, int>(int1 + int2, int1 * int2);
 return keyvaluepair;
}

•使用 ref/out 参数

•ref
•

static void main(string[] args)
{
 int int1 = 15;
 int int2 = 25;
 int add = 0;
 int multiply = 0;
 add_multiply(int1, int2, ref add, ref multiply);
 console.writeline(add);
 console.writeline(multiply);
}

private static void add_multiply(int int1, int int2, ref int add, ref int multiply)
{
 add = int1 + int2;
 multiply = int1 * int2;
}

•out
•

static void main(string[] args)
{
 int int1 = 15;
 int int2 = 25;
 int add = 0;
 int multiply = 0;
 add_multiply(int1, int2, out add, out multiply);
 console.writeline(add);
 console.writeline(multiply);
}

private static void add_multiply(int int1, int int2, out int add, out int multiply)
{
 add = int1 + int2;
 multiply = int1 * int2;
}

•使用 struct 或者 class •struct
•

struct result
{
 public int add;
 public int multiply;
}
static void main(string[] args)
{
 int int1 = 53;
 int int2 = 17;
 var result = add_multiply(int1, int2);
 console.writeline(result.add);
 console.writeline(result.multiply);
}

private static result add_multiply(int int1, int int2)
{
 var result = new result
 {
  add = int1 + int2,
  multiply = int1 * int2
 };
 return result;
}

•class
•

class result
{
 public int add;
 public int multiply;
}
static void main(string[] args)
{
 int int1 = 13;
 int int2 = 27;
 var result = add_multiply(int1, int2);
 console.writeline(result.add);
 console.writeline(result.multiply);
}

private static result add_multiply(int int1, int int2)
{
 var result = new result
 {
  add = int1 + int2,
  multiply = int1 * int2
 };
 return result;
}

•dynamic
•

static void main(string[] args)
{
 int int1 = 13;
 int int2 = 27;
 var result = add_multiply(int1, int2);
 console.writeline(result.add);
 console.writeline(result.multiply);
}

private static dynamic add_multiply(int int1, int int2)
{
 var result = new
 {
  add = int1 + int2,
  multiply = int1 * int2
 };
 return result;
}

•使用 tuple
•

static void main(string[] args)
{
 int int1 = 25;
 int int2 = 28;
 var result = add_multiply(int1, int2);
 console.writeline(result.item1);
 console.writeline(result.item2);
}

private static tuple<int, int> add_multiply(int int1, int int2)
{
 var tuple = new tuple<int, int>(int1 + int2, int1 * int2);
 return tuple;
}

okay, 回顾的废话有些多了。我们来看看c#7.0中的写法
新特性（c#7.0）
 老规矩，先上代码

static void main(string[] args)
{
 int int1 = 25;
 int int2 = 28;
 var result = add_multiply(int1, int2);
 console.writeline($"add: {result.add}, multiply: {result.multiply}");
 //(var add, var multiply) = add_multiply(int1, int2);
 //console.writeline($"add: {add}, multiply: {multiply}");
}
public (int add, int multiply) add_multiply(int int1, int int2) 
 => (int1 + int2, int1 * int2);

怎么样？比起6.0及以前的c#，有没有一种非常清爽的感觉。
其实只是基于tuple 做了语法简化的语法糖罢了，只是给人一种多个返回值的错觉。 

总结： 
这个特性虽然不是多么振奋人心的变化，但是解决了之前很多码农的一些痒点。 
1. 看看keyvalue对的方式，本来很简单的一个操作，写出来的代码会显得非常的笨拙，取值的时候又根据key获取。而且，最重要的是，如果不在运行时，外面调用的代码是不知道有那些key的。 
2. 再说ref/out，这种方式应该是传统意义上最流行的写法了。甚至c#7.0的该特性，也无法取缔ref在一定情景下的性质。但至少在ref用于返回值这种情况下，代码体现出的风格明显是和实际逻辑不符合的，明明是返回值，却要以参数的形式进出，非常不合理。 
3. struct和class的方式就不多说了，如果你针对的是一个实体，还能讲得通，但如果本身目的是返回多个相关性不大的数据，专门为方法间传递而加一个本没有用处的model类或结构，只能说是当时解决方案下的无奈。dynamic虽然从表现形式上没有这种问题，但是存在更坑的问题是，除非在运行时，否则外部调用代码根本不知道方法里传出来什么。 
4. 说到传统的tuple，其实是和该特性最接近的了，但是看看调用时的*.item1，*.item2 。。天知道都是何物。即使在实现方法里，也让人面对这种只见类型不见实际意义的值表示一头雾水。 
最后，解释一下，目前(2016年6月)c#7.0还未正式发布，大家如果想体验部分特性，可以去下载vs15预览版，最终发布的语法可能和本文中提及的有说不同，最新动态请大家关注roslyn项目。

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。