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

本文基於Roslyn項目中的Issue:#347 展開討論.

　　1. C# 7.0 新特性1： 基於Tuple的“多”返回值方法

　　2. C# 7.0 新特性2： 本地方法

　　3. C# 7.0 新特性3： 模式匹配

　　4. C# 7.0 新特性4： 返回引用

 

回顧

首先，提出一個問題，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 。。天知道都是何物。即使在實現方法里，也讓人面對這種只見類型不見實際意義的值表示一頭霧水。

 

本文鏈接：http://www.cnblogs.com/ylvict/p/5573094.html (轉載請注明) 

目前(2016年6月)C#7.0還未正式發布，大家如果想體驗部分特性，可以去下載VS15預覽版，最終發布的語法可能和本文中提及的有所不同，最新動態請大家關注Roslyn項目。