Tuple <T1, T2, ......... T> using simple tuple

Tuple: a data structure, separated by commas, for transmitting a series of program or operating system combination is worth

NET Framework directly supports one to seven elements have an array

Tuple<T1>

Tuple<T1,T2>

Tuple<T1,T2,T3>

Tuple<T1,T2,T3,T4>

Tuple<T1,T2,T3,T4,T5>

Tuple<T1,T2,T3,T4,T5,T6>

Tuple<T1,T2,T3,T4,T5,T6,T7>

 

Can also create eight / have a plurality of elements and then Rest tuple attributes Tuple <T1, T2, T3, T4, T5, T6, T7, TRestle> be nested objects by tuple objects obtained

Examples of single-:

[csharp]  view plain  copy

 

1. // elements of a tuple  
2. Tuple<int> test = new Tuple<int>(34);  
3.   
4. // tuples 1 <n two elements <8  
5. Tuple<string, int> test2 = Tuple.Create<string, int>("str", 2);  
6. Tuple<int, int> test2_1 = new Tuple<int, int>(2,2);  
7.   
8. // tuple element 8 (note, Tuple <... Type>: Basic "type" up to seven, the eighth element type must tuple)  
9. Tuple<int, int, int, int, int, int, int, Tuple<int>> test3 =   
10. new Tuple<int, int, int, int, int, int, int, Tuple<int>>(1, 2, 3, 4, 5, 6, 7, new Tuple<int>(8));  
11.   
12. // this can be  
13. Tuple<int, int, Tuple<int, int>> test_i_i_Tii = new Tuple<int, int, Tuple<int, int>>(1,1,new Tuple<int,int>(2,3));  
14. Console.WriteLine(test.Item1);  
15. Console.WriteLine(test2.Item1 + test2.Item2);  
16. Console.WriteLine(test2_1.Item1 + test2_1.Item2);  
17. Console.WriteLine(test3.Item1 + test3.Item2 + test3.Item3 + test3.Item4 + test3.Item5 + test3.Item6 + test3.Item7 + test3.Rest.Item1);  

Results:


2) multiple return values issues
in general we are using the out keyword (compared to other languages, such as golang, out keywords or a little bit of trouble), then we can use tuples to achieve:

[csharp]  view plain  copy

 

1. namespace TupleDemo  
2. {  
3.     class Program  
4.     {  
5.         static void Main(string[] args)  
6.         {  
7.   
8.             // get use out multiple return values  
9.             string outparam = "";  
10.             int returnvalue = FunOutParamDemo(out outparam);  
11.             Console.WriteLine(returnvalue + "    " + outparam);  
12.   
13.             // get the plurality of tuple values ​​return  
14.             Tuple<int, string> r = FunTupleParamDemo();  
15.             Console.WriteLine(r.Item1 + "    " + r.Item2);  
16.   
17.             Console.Read();  
18.         }  
19.         /// <summary>  
20.         /// out keywords, implementation returns two return values  
21.         /// </summary>  
22.         /// <param name="o"></param>  
23.         /// <returns></returns>  
24.         public static int FunOutParamDemo(out string o)  
25.         {  
26.             o = "returnValue";  
27.             return 10;  
28.         }  
29.   
30.         /// <summary>  
31.         /// tuple achieve indirect] [[two] Return Value Returns  
32.         /// </summary>  
33.         /// <returns></returns>  
34.         public static Tuple<int, string> FunTupleParamDemo() {  
35.             return new Tuple<int, string>(10, "returnValue");  
36.         }  
37.     }  
38. }  

operation result:

 

Original blog address https://www.cnblogs.com/mschen/p/8333903.html