C#元组的用法

定义：
元组是包含多个字段以表示数据成员的轻量级数据结构，相比较 class 和 struct 类型来说元组是更为简单灵活的数据容器。这句话的意思是元组就是将一组相对松散的对象简单的组合在一起，类似与数组的用法。但是元组比数组更加灵活，因为数组中的元素类型是统一的，而元组使用的是泛型参数，每个元素都是互相独立的。
有朋友可能好奇这不是和类一样嘛，可创建 class 或 struct 来承载多个元素。 但这样做不仅加大了工作量，还掩盖了你的设计意图。 创建 struct或 class 意味着定义一个具有数据和行为的类型。 很多时候，你其实只是想存储单个对象中的多个值而已。这种情况下使用元组无疑是最好的选择。而且元组将所有元素分配给Item属性，其中表示序号，例如Item1、Item2等，取决于元素个数，可容纳1~8个。

元组基本用法：

(double, int) t1 = (4.5, 3);
Console.WriteLine($"Tuple with elements {t1.Item1} and {t1.Item2}.");
// Output:
// Tuple with elements 4.5 and 3.

(double Sum, int Count) t2 = (4.5, 3);
Console.WriteLine($"Sum of {t2.Count} elements is {t2.Sum}.");
// Output:
// Sum of 3 elements is 4.5.

这就是元组的简单用法，在官网上可以看到详细的说明。相当于Class来说使用元组的好处我在下面例子中演示一下：

public class Dog
{
    private int age{get;set;}
    private string name{get;set;}
}
 
Dog d = new Dog() {Age=1,Name="dog1" };
Console.WriteLine(d.Age);

这是使用了类，那下面使用元组我们看一下：

(int age , string name) Dog = (1,"Dog1");
Console.WriteLine(Dog.age);

可以看到使用元组还是比较简洁的，这并不是说元组比类要好，而是每个特定环境下都有不同的用法。
拿我现在做的一个项目为例子来看一下元组在实际项目中是怎么使用的。
先看一下我同事的做法：

public async Task<ResultData> Load()
        {
            ResultData resultData = new ResultData() { 
                statu = 0,
                message = "success"
            };
            
            try
            {
                var logsection = await _basesectionRepository.Load();
                var total = logsection.Count();
                var rows = logsection.ToList();
                List<LOGSECTION> logSectionsList = new List<LOGSECTION>();
                for (int i=0;i<total;i++)
                {
                    LOGSECTION logSection = new LOGSECTION();
                    logSection.SECTN = rows[i].SECTN;
                    logSection.DSCRB = rows[i].DSCRB;
                    logSection.DEMO1 = rows[i].DEMO1;
                    logSection.DEMO3 = rows[i].DEMO3;
                    logSectionsList.Add(logSection);
                }
                resultData.data = logSectionsList;

            }
            catch (Exception ex)
            {
                resultData.statu = 1;
                resultData.message = ex.Message;
            }
            return resultData;
        }

这边可以看到他的做法是调用仓储层的查询语句，然后又查出来总行数，最后用循环取出值赋值给resultData.data，然后返回回去，这里他应该后续优化了返回总行数和分页情况，这段时间由于个人原因并没有太关注于项目进度。
针对这个功能我使用到了元组，不过我的写法有点和公司的整体思想不大兼容，大家可以看一下随便提下意见，按公司定的开发规则，是仓储层来写增删改查，服务层来学业务，这边我就有点本末倒置了，我把业务写进了仓储层：

 public (List<LogErpIn>,int) Query(int bars, int pages)
        {
            var curd = _fsql.Select<LogErpIn>();
            var list = curd.Page(bars, pages).ToList();
            var rows = curd.Count();
            (List<LogErpIn>, int) t1 = (list, (int)rows);
            return t1;
        }

大家可以看到我这样写相对来说比较简洁，而且就只返回了一个t1，接下来我们看一下服务层是怎么调用的：

 public async Task<ResultData> Query(int pages, int bars)
        {
            try
            {
                if (bars == 0) bars = 20;
                if (pages == 0) pages = 1;
                //使用元组调用仓储层元组方法，这个方法的返回值是元组，元组的成员是异步函数，
                //方法本身不是异步函数，故不能使用await
                var t1 = _erpInRepository.Query(bars, pages);
                resultData.data = t1.Item1;
                resultData.rows = (int)t1.Item2;
                return resultData;
            }
            catch (Exception ex)
            {
                resultData.message = ex.Message;
                resultData.statu = 1;
            }
            return resultData;
        }      

在服务层中我们也说明了一个t1来调用接收仓储层，然后我们取出t1的值，最后返回一个resultData，总体来说使用哪种方法都可以实现，像分页这种功能靠纯前端也是可以实现的，所以说通过目标的路有很多，我们选择适合自己的就好！