C#中Linq和Lambda的一些用法

C# Linq是一种数据查询和处理语言，是C#中的一个强大的功能，可以极大地简化数据处理和查询的工作。下面是一些常见的C# Linq的用法：
1.创建一个Linq查询

var query = from item in source
            where item.Condition
            select item;

2.使用Lambda表达式创建一个Linq查询

var query = source.Where(item => item.Condition).Select(item => item);

3.过滤一个查询

var result = from item in source
             where item.Condition
             select item;

4.对查询结果进行排序

var result = from item in source
             orderby item.Property
             select item;

5.对查询结果进行分组

var result = from item in source
             group item by item.Property into groupItem
             select groupItem;

6.对查询结果进行聚合操作

var result = from item in source
             where item.Condition
             select item.Property;
var sum = result.Sum();
var max = result.Max();
var min = result.Min();
var avg = result.Average();

7.使用Linq对集合进行操作

var result = source.Where(item => item.Condition);
var list = result.ToList();
var array = result.ToArray();
var dictionary = result.ToDictionary(item => item.Key, item => item.Value);

8.使用Linq连接两个集合

var result = from item1 in source1
             join item2 in source2
             on item1.Key equals item2.Key
             select new { item1.Key, item1.Value, item2.Value };

9.使用Linq进行分页查询

var pageSize = 10;
var pageIndex = 1;
var result = from item in source
             where item.Condition
             select item;
var pagedResult = result.Skip((pageIndex - 1) * pageSize).Take(pageSize);

10.使用Linq进行嵌套查询

var result = from item1 in source1
             where item1.Condition
             select new
             {
                 Key = item1.Key,
                 Value = (from item2 in source2
                          where item2.Key == item1.Key
                          select item2.Value).FirstOrDefault()
             };

11.使用Linq进行左连接查询

var result = from item1 in source1
             join item2 in source2
             on item1.Key equals item2.Key into temp
             from item in temp.DefaultIfEmpty()
             select new { item1.Key, Value1 = item1.Value, Value2 = (item == null ? "" : item.Value) };

12.使用Linq进行内连接查询

var result = from item1 in source1
             join item2 in source2
             on item1.Key equals item2.Key
             select new { item1.Key, Value1 = item1.Value, Value2 = item2.Value };

13.使用All方法检查集合中的所有元素是否满足条件

var result = source.All(item => item.Condition);

14.使用Any方法检查集合中是否存在满足条件的元素

var result = source.Any(item => item.Condition);

15.使用Distinct方法获取集合中不同的元素

var result = source.Distinct();

16.使用First方法获取集合中满足条件的第一个元素

var result = source.First(item => item.Condition);

17.使用Last方法获取集合中满足条件的最后一个元素

var result = source.Last(item => item.Condition);

18.使用SingleOrDefault方法获取集合中满足条件的一个元素，如果满足条件的元素不唯一则返回默认值

var result = source.SingleOrDefault(item => item.Condition);

19.使用SelectMany方法将嵌套集合转化为扁平集合

var numbers = new List<List<int>>()
            {
              	    new List<int>{1,2,3},
               	    new List<int>{4,5,6},
                	new List<int>{7,8,9}
            };
var result = numbers.SelectMany(collection => collection).ToList();

20.使用Zip方法将两个集合一一对应地合并成一个新的集合

var l = new List<int>() { 1, 2, 3, 5, 6 };
var s = new List<string>{"A","B","C","D","E","F"};
var mergedSed = l.Zip(s, (x, y) => x + "_" + y).ToList();
            

21.使用Union方法将两个集合合并为一个集合，去除重复元素

var result = source1.Union(source2);

22.使用Except方法获取两个集合的差集

var result = source1.Except(source2);

23.使用Intersect方法获取两个集合的交集

var result = source1.Intersect(source2);

24.使用OfType方法获取集合中特定数据类型的元素

var result = source.OfType<int>();

25.使用SkipWhile方法跳过集合中满足条件的元素，直到第一个不满足条件的元素后开始返回剩余元素

var result = source.SkipWhile(item => item.Condition);

26.使用TakeWhile方法从集合的开头开始返回满足条件的元素，直到第一个不满足条件的元素为止

var result = source.TakeWhile(item => item.Condition);

27.使用Join方法将两个集合关联在一起

var result = source1.Join(source2, item1 => item1.Key, item2 => item2.Key, (item1, item2) => new { item1, item2 });

28.使用GroupJoin方法将一个集合分组并关联到另一个集合，返回分组后的结果（等同于SQL语句的左连接left join）

var result = source1.GroupJoin(source2, item1 => item1.Key, item2 => item2.Key, (item1, group) => new { item1, group });

29.使用Aggregate方法对集合中的元素进行累积运算

var nums = new[]{1,2,3,4};
var sum = nums.Aggregate( (a,b) => a + b);
Console.WriteLine(sum); // output: 10 (1+2+3+4)

var chars = new []{"a","b","c","d"};
var csv = chars.Aggregate( (a,b) => a + ',' + b);
Console.WriteLine(csv); // Output a,b,c,d

var multipliers = new []{10,20,30,40};
var multiplied = multipliers.Aggregate(5, (a,b) => a * b);
Console.WriteLine(multiplied); //Output 1200000 ((((5*10)*20)*30)*40)

30.使用GroupBy方法对集合中的元素进行分组

var result = source.GroupBy(item => item.Property);

31.使用MaxBy方法获取集合中某个属性最大值对应的元素

var result = source.MaxBy(item => item.Property);

32.使用MinBy方法获取集合中某个属性最小值对应的元素

var result = source.MinBy(item => item.Property);

33.使用Skip方法跳过指定数量的元素

var result = source.Skip(5);

34.使用Take方法从集合中取出指定数量的元素

var result = source.Take(10);

35.使用DefaultIfEmpty方法获取集合中第一个元素，如果集合为空则返回默认值

var result = source.DefaultIfEmpty();

36.使用ToDictionary方法将集合转化成字典（同37一个示例）

var result = source.ToDictionary(item => item.Key, item => item.Value);

37.使用ToLookup方法将集合转化成查找表

var initList = new List<LookUpModel>()
            {
                new LookUpModel(1,"男","小陈"),
                new LookUpModel(1,"男","小陈爸爸"),
                new LookUpModel(2,"女","小刘"),
                new LookUpModel(2,"女","小刘妈妈"),
                new LookUpModel(3,"男","小明"),
            };
            var lookTest1 = initList.ToLookup(x => x.Index);//以Index为分组
            var lookTest2 = initList.ToLookup(x => x.Index, x => x.Sex + x.Name).ToList();//以Index为分组，Sex+Name为值
            var dicTest1 = initList.ToDictionary(x => x.Name);//以Name为分组
            var dicTest2 = initList.ToDictionary(x => x.Name, x => x.Sex);//以Name为分组，Sex为值
// class
public class LookUpModel
{
     public LookUpModel(int i,string l,string l2)
      {
          this.Index = i;
          this.Sex = l;
          this.Name = l2;
      }
      public int   Index { get; set; }
      public string  Sex { get; set; }
      public string Name { get; set; }
}

38.使用AsParallel方法将集合转化成并行查询

var result = source.AsParallel().Where(item => item.Condition).ToList();

39.使用AsSequential方法将并行查询转化成顺序查询

var result = source.AsParallel().Where(item => item.Condition).AsSequential().ToList();

40.使用Concat方法将两个集合连接成一个集合

var result = source1.Concat(source2);

41.使用SequenceEqual方法判断两个集合是否相等

var result = source1.SequenceEqual(source2);