c# linq相关

已于 2022-08-12 22:36:31 修改
阅读量929 收藏
点赞数
分类专栏： C#Language 文章标签： c# linq 开发语言
于 2017-06-02 17:24:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/game_jqd/article/details/72841925
版权

using System;

using System.Collections.Generic;

using System.Linq;

 namespace LinqTest{

   class Program

    {

 static void Main()

        {

            List<Product>listProduct = new List<Product>{

                    new Product{StockNum=1,ProductNo="01",Tag="a"},

                    new Product{StockNum=2,ProductNo="01",Tag="b"},

                    new Product{StockNum=3,ProductNo="02",Tag="c"},

                    new Product{StockNum=4,ProductNo="02",Tag="d"},

                    new Product{StockNum=5,ProductNo="03",Tag="e"},

                };

 

            //注:处理目标->将"编号(ProductNo)"相同的产品记录，"库存量(StockNum)"合并，"附属标签(Tag)"合并

 

            //合并处理

            listProduct.ForEach(c=> {

                var group = listProduct.Where(a=> a.ProductNo == c.ProductNo);

                c.StockNum= group.Sum(x => x.StockNum);

                c.Tag= group.Select(t => t.Tag).ToList().Join();

            });

 

            //去重复

            listProduct= listProduct.Distinct(new ProductNoComparer()).ToList();

 

            //输出验证

            listProduct.ForEach(c=>

            {

                Console.WriteLine("ProductNo={0},StockNum={1},Tag={2}",c.ProductNo, c.StockNum, c.Tag);

            }); 

         

            //输出结果:

            //ProductNo=01,StockNum=3,Tag=a,b

            //ProductNo=02,StockNum=7,Tag=c,d

            //ProductNo=03,StockNum=5,Tag=e

 

            Console.Read();

        }

 

}

    /// <summary>

    ///工具类(一般开发中，可定义在自己的工具类库里)

    /// </summary>

    static class Utils {

 

        ///<summary>

        ///List扩展方法，将List元素用分隔符连接后，返回字符串

        ///</summary>

        ///<typeparam name="T"></typeparam>

        ///<param name="list"></param>

        ///<param name="splitStr"></param>

        ///<returns></returns>

        public static StringJoin<T>(this List<T> list, string splitStr=",")

        {

            string result = string.Empty;

            foreach (var item in list)

            {

                result+= item.ToString() + splitStr;

            }

            return result.Trim(splitStr.ToCharArray());

        }

    }

 

    ///<summary>

    /// 产品实体类

    ///</summary>

    class Product

    {

        ///<summary>

        ///库存

        ///</summary>

        public int StockNum{ set; get; }

         

        ///<summary>

        ///产品编号

        ///</summary>

        public String ProductNo { set; get; }

         

        ///<summary>

        ///附属标签

        ///</summary>

        public String Tag { set; get; }

    }

 

    /// <summary>

    ///去"重复"时候的比较器(只要ProductNo相同，即认为是相同记录)

    ///</summary>

    class ProductNoComparer : IEqualityComparer<Product>

    {

        public bool Equals(Product p1,Product p2)

        {

            if (p1 == null)

                return p2 == null;

            return p1.ProductNo == p2.ProductNo;

        }

 

        public int GetHashCode(Productp)

        {

            if (p == null)

                return 0;

            return p.ProductNo.GetHashCode();

        }

    }

}

 

 

C# 使用Dictionary、linq实现根据集合里面的字符串进行分组

//对下面集合里面的字符串按照“_”进行分组。

List<string>list = new List<string>(){ "1_32", "2_10", "1_8", "1_25", "2_3", "3_5", "5_15", "3_16" };

#region //使用字典，键值对集合保存分组数据。
            Dictionary<string, List<string>> groupDic = new Dictionary<string, List<string>>();
            foreach (var item in list)
            {
                //取KEY值
                string key = item.Split('_')[0];
                //根据key值判断集合中是否存在指定的键，不存在则创建一个。
                if (!groupDic.ContainsKey(key))
                {
                    groupDic.Add(key, new List<string>()); //初始化
                }
                groupDic[key].Add(item); //直接把当前元素添加到，key对应的List集合中。
            }
 
 
            foreach (var item in groupDic)
 
 
            {
 
 
                var s = groupDic[item.Key];
 
 
                for (int i = 0; i < s.Count; i++)
 
 
                {
 
 
                    Console.WriteLine("KEY:{0} Value:{1}", item.Key, s[i]);
 
 
                }
 
 
            } 
 
 
            #endregion
 
 
#region //使用linq 分组
 
 
            var groupList = from s in list
 
 
                            group s by s.Split('_')[0] into g
 
 
                            select g;
 
 
 
 
            foreach (var item in groupList)
 
 
            {
 
 
                var s = groupDic[item.Key];
 
 
                for (int i = 0; i < s.Count; i++)
 
 
                {
 
 
                    Console.WriteLine("KEY:{0} Value:{1}", item.Key, s[i]);
 
 
                }
 
 
            } 
 
 
            #endregion
 
 
#region //使用lambda 分组
 
 
            var groupList2 = list.GroupBy(s => s.Split('_')[0]).Select(g => g);
 
 
 
 
            foreach (var item in groupList2)
 
 
            {
 
 
                var s = groupDic[item.Key];
 
 
                for (int i = 0; i < s.Count; i++)
 
 
                {
 
 
                    Console.WriteLine("KEY:{0} Value:{1}", item.Key, s[i]);
 
 
                }
 
 
            }
 
 
            #endregion
 
 
 
 
 
//  c# Lamda
 
 
1. 普通绑定：
 
 
public void button1_Click(object sender, EventArgs e)
 
 
        {
 
 
            MessageBox.Show("ok");
 
 
        }
 
 
 
 
this.button1.Click += button1_Click;
 
 
2. 匿名委托：
 
 
this.button1.Click += delegate(object sender, EventArgs e)
 
 
            {
 
 
                MessageBox.Show("Click");
 
 
            };
 
 
3. LAMDA表达式：
 
 
this.button1.Click += ((sender, e) =>
 
 
            {
 
 
                MessageBox.Show("Click");
 
 
            });
 
 
4. 过滤条件：
 
 
List<User> users = new List<User>();
 
 
 
 
            Func<User, bool> predicate = (
 
 
                (user) =>
 
 
                {
 
 
                    return user.UserId > 100;
 
 
                }
 
 
                );
 
 
            List<User> temps = users.Where(predicate).ToList();
 
 
等同于：
 
 
List<User> temps = users.Where(p => p.UserId > 100).ToList();
 
 
List<User> temps = (from p in users where p.UserId > 100 select p).ToList();
 
 
List<User> users = new List<User>();
 
 
            Func<User, bool> predicate = (
 
 
                (user) => user.UserId > 100
 
 
                );
 
 
            List<User> temps = users.Where(predicate).ToList();
 
 
5. 排序：
 
 
List<User> users = new List<User>();
 
 
            List<User> temp1 = users.OrderBy(p=>p.UserId).ToList();
 
 
            Func<User, int> orderby = (user => user.UserId);
 
 
            List<User> temp2 = users.OrderBy(orderby).ToList();
 
 
 
 
 
/c# linq 及 lamda表达式 GroupBy分组
 
 
public partial class Form1 : Form  
 
 
   {  
 
 
       public Form1()  
 
 
       {  
 
 
            InitializeComponent();  
 
 
       }  
 
 
     
 
 
       List<Person> persons1 = new List<Person>();  
 
 
     
 
 
       private void Form1_Load(object sender, EventArgs e)  
 
 
       {  
 
 
            initForm();  
 
 
       }  
 
 
       private void initForm()  
 
 
       {//窗体初始化  
 
 
            persons1.Add(new Person("张三", "男", 20, 1500));  
 
 
            persons1.Add(new Person("王成", "男", 32, 3200));  
 
 
            persons1.Add(new Person("李丽", "女", 19, 1700));  
 
 
            persons1.Add(new Person("何英", "女", 35, 3600));  
 
 
            persons1.Add(new Person("何英", "女", 18, 1600));  
 
 
            dataGridView1.DataSource =persons1;   
 
 
       }  
 
 
     
 
 
       private void button1_Click(object sender, EventArgs e)  
 
 
       {  
 
 
            //******* 对集合按Name属于进行分组GroupBy查询 ********  
 
 
            //结果中包括的字段：  
 
 
            //1、分组的关键字：Name = g.Key  
 
 
            //2、每个分组的数量：count = g.Count()  
 
 
            //3、每个分组的年龄总和：ageC = g.Sum(item => item.Age)  
 
 
            //4、每个分组的收入总和：moneyC = g.Sum(item =>item.Money)  
 
 
     
 
 
            //写法1：lamda 表达式写法（推荐）  
 
 
            var ls = persons1.GroupBy(a =>a.Name).Select(g => (new { name = g.Key, count = g.Count(), ageC =g.Sum(item => item.Age), moneyC = g.Sum(item => item.Money) }));  
 
 
            //写法2：类SQL语言写法最终编译器会把它转化为lamda表达式  
 
 
           var ls2 = from ps inpersons1  
 
 
                     group ps by ps.Name  
 
 
                         into g  
 
 
                         select new { name =g.Key, count = g.Count(), ageC = g.Sum(item => item.Age), moneyC =g.Sum(item => item.Money) };  
 
 
     
 
 
            dataGridView1.DataSource =ls.ToList();  
 
 
           //dataGridView1.DataSource =ls2.ToList();  
 
 
       }  
 
 
   }  
 
 
     
 
 
   /// <summary>  
 
 
   /// 手动设计一个Person类。用于放到List泛型中  
 
 
   /// </summary>  
 
 
   public class Person  
 
 
   {  
 
 
        public string Name { get; set; }  
 
 
       public int Age  { get;private set;}  
 
 
       public string Sex { get; set; }  
 
 
       public int Money { get; set; }  
 
 
     
 
 
       public Person(string name, string sex, int age, int money)  
 
 
       {  
 
 
            Name = name;  
 
 
            Age = age;  
 
 
            Sex = sex;  
 
 
            Money = money;  
 
 
       }  
 
 
}
 
 
 
 
 
//  c# selectlist Distinct() 去重 
 
 
List<ModelJD> data = myDalJD.GetAllDataList(); 
 
 
List<string> list= new List<string>();
 
 
list= datalist4.Select(p => p.name).ToList();  //只取name字段，重新生成新的List集合
 
 
this.cmbJdUserName.DataSource = list.Distinct().ToList(); //去重复，绑定数据后面要加ToList()
 
 
 
 
 
//  解释linq 
 
 
class Program { 
 static void Main(string[] args) { 
 IList<string> numbers = new List<string>()  { "One", "Two", "Three", "Four", "Five", "Six", "Seven"  }; 
 var numbersLengthThree = numbers.Where(x => x.Length == 3).Select(x=> x).ToList(); 
 numbersLengthThree.ForEach(x => Console.WriteLine(x)); 
 } } }
 
 
上面的代码会产生一个string类型的列表(列表中是数字)存储在List<string>中,上面的程序会找出在这些项中字符总数是3的并且将结果存储到另外一个新的列表中.最后在控制台中打印出这些数字.这个程序输出的结果如下: 
 
 
One 
 
 
Two 
 
 
Six 
 
 
让我们做一个研究去找出它是如何工作的.在上面的例子中最重要的代码是numbers.Where(x=> x.Length == 3).Select(x => x).ToList().下边的图表会为我们解释整个的执行过程. 
 
 
通过上面的图表我们可以知道CLR伴随着MulticastDelegate实例(持有着关于<Main>b_1方法的信息)将数字列表作为输入参数传递到Where方法,其中<Main>b_1创建于匿名函数(x=>x.Length==3).通过Where方法它会返回一个WhereListIterator<string>迭代器的实例,这个实例将会作为输入参数传递到Select子句中,伴随着另外一个MulticastDelegate实例(持有着关于<Main>b_2方法的信息),<Main>b_2通过匿名方法(x=>x)创建。Select方法将根据输入内容实例化相关的迭代器。在这种情况下，它会实例化出WhereSelectListIterator<string,string>迭代器。这个迭代器将作为输入参数传递到ToList()方法中。此方法最终通过循环遍历对原始列表进行处理并得到一个基于过滤条件的新列表。
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
using System;
 
 
using System.Collections.Generic;
 
 
using System.Linq;
 
 
using System.Text;
 
 
using System.Collections;
 
 
using System.Linq.Expressions;
 
 
 
 
namespace Linq_Learning
 
 
{
 
 
   //public static class Enumerable
 
 
   //{
 
 
    //    public static IEnumerable<TSource>Where<TSource>(
 
 
   //        thisIEnumerable<TSource> source, Func<TSource, bool> predicate);
 
 
   //}
 
 
 
 
   //public static class Queryable
 
 
   //{
 
 
   //    public staticIQueryable<TSource> Where<TSource>(
 
 
   //        thisIQueryable<TSource> source, Expression<Func<TSource, bool>>predicate);
 
 
   //}
 
 
 
 
   static class MyEnumerable
 
 
    {
 
 
       // 自定义扩展方法示例
 
 
       public static IEnumerable<TSource> MyWhere<TSource>(
 
 
           this IEnumerable<TSource> source, Func<TSource, bool>predicate)
 
 
       {
 
 
           foreach (TSource item in source)
 
 
           {
 
 
                if (predicate(item))
 
 
                    yield return item;
 
 
           }
 
 
       }
 
 
    }
 
 
 
 
    class Program
 
 
    {
 
 
       static string Hello(string a, string b)
 
 
       {
 
 
           return "欢迎光临我的博客" + Environment.NewLine + a + " " + b;
 
 
       }
 
 
 
 
       static void Main(string[] args)
 
 
       {
 
 
 
 
           #region begion
 
 
 
 
           // 委托函数
 
 
           Func<string, string, string> func1 = Hello;
 
 
           // 匿名方法
 
 
           Func<string, string, string> func2 =
 
 
                delegate(string a, string b)
 
 
                {
 
 
                    return "欢迎光临我的博客"+ Environment.NewLine + a + " " + b;
 
 
                };
 
 
           // Lambda表达式
 
 
           Func<string, string, string> func3 =
 
 
                (a, b) => { return "欢迎光临我的博客"+ Environment.NewLine + a + " " + b; };
 
 
 
 
            // 调用Func委托
 
 
           string helloStr = func2("滴答的雨",@"http://www.cnblogs.com/heyuquan/");
 
 
 
 
           Console.WriteLine(helloStr);
 
 
           Console.WriteLine();
 
 
 
 
           #endregion
 
 
 
 
           #region 延迟计算注意点
 
 
 
 
           //DelayCalculate();
 
 
 
 
           #endregion
 
 
 
 
           #region 过滤操作符（Where，OfType，Distinct）
 
 
 
 
           //Where_Query();
 
 
           //Where_Fluent();
 
 
           //OfType_Fluent();
 
 
 
 
           #endregion
 
 
 
 
           #region 投影操作符（Select，SelectMany）
 
 
 
 
           //SelectMany_Query();
 
 
           //SelectMany_Fluent();
 
 
 
 
           #endregion
 
 
 
 
           #region 排序操作符（Order，OrderByDescending，ThenBy，ThenByDescending，Reverse）
 
 
 
 
           //Order_Query();
 
 
           //Order_Fluent();
 
 
           //Reverse_Fluent();
 
 
 
 
           #endregion
 
 
 
 
           #region 连接操作符（Join，GroupJoin）
 
 
 
 
           //Join_Query();
 
 
           //Join_Fluent();
 
 
           //GroupJoin_Query();
 
 
           //GroupJoin_Fluent();
 
 
 
 
           #endregion
 
 
 
 
           #region 分组操作符（Group，GroupBy）
 
 
 
 
           //Group_Query();
 
 
           //Group_Fluent1();
 
 
           //Group_Fluent2();
 
 
 
 
           #endregion
 
 
 
 
           #region 量词操作符（All、Any、Contains）
 
 
 
 
           //Any_Fluent();
 
 
 
 
           #endregion
 
 
 
 
           #region 分区操作符（Skip,Take）
 
 
 
 
           //Paging_Query();
 
 
 
 
           #endregion
 
 
 
 
           #region 集合操作符（Union，Concat，Intersect，Except，Zip，SequenceEqual）
 
 
 
 
           //Intersect_Fluent();
 
 
           //Zip_Fluent();
 
 
           //SequenceEqual_Fluent();
 
 
 
 
           #endregion
 
 
 
 
           #region 元素操作符（First，FirstOrDefault，Last，LastOrDefault，ElementAt，ElementAtOrDefault，Single，SingleOrDefault）
 
 
 
 
           //ElementAt_Fluent();
 
 
 
 
           #endregion
 
 
 
 
           #region 合计操作符（Count、LongCount、Sum、Max、Min、Average、Aggregate）
 
 
 
 
           //Sum_Fluent();
 
 
           //Aggregate_Fluent();
 
 
 
 
           #endregion
 
 
 
 
           #region 转换操作符（Cast，ToArray，ToList，ToDictionary，ToLookup，AsEnumerable，DefaultIfEmpty）
 
 
 
 
           //Lookup_Fluent();
 
 
           //DefaultIfEmpty_Fluent();
 
 
 
 
           #endregion
 
 
 
 
           #region 生成操作符（Range，Empty，Repeat）
 
 
 
 
           //Range_Fluent();
 
 
 
 
           #endregion
 
 
 
 
           Console.Read();
 
 
       }
 
 
 
 
       #region 延迟计算注意点
 
 
 
 
       private static void DelayCalculate()
 
 
       {
 
 
           IEnumerable<char> query = "Not what you might expect";
 
 
           foreach (char item in "aeiou")
 
 
                query = query.Where(c => c!= item);
 
 
           // 只删除了'u'----Not what yo might expect 
 
 
           foreach (char c in query)
 
 
                Console.Write(c);
 
 
 
 
           // 因为item变量是循环外部声明的，同一个变量重复声明更新,
 
 
           // 所以每个lambda表达式获取的是同样的item.之后枚举查询时，
 
 
           // 所有的lambda表达式引用了这个变量的当前值,即'u'。          
 
 
           Console.WriteLine();
 
 
           // 为了解决这个问题，必须将循环变量赋值到一个在循环代码块内声明的变量
 
 
 
 
           IEnumerable<char> query1 = "Not what you might expect";
 
 
           foreach (char item in "aeiou")
 
 
           {
 
 
                char temp = item;
 
 
                query1 = query1.Where(c => c!= temp);
 
 
           }
 
 
           // Nt wht y mght xpct 
 
 
           foreach (char c in query1)
 
 
                Console.Write(c);
 
 
       }
 
 
 
 
       #endregion
 
 
 
 
       #region 过滤操作符（Where，OfType，Distinct）
 
 
       /// <summary>
 
 
       /// 查询获得车手冠军次数大于15次且是Austria国家的一级方程式赛手
 
 
       /// </summary>
 
 
       private static void Where_Query()
 
 
       {
 
 
           Console.WriteLine();
 
 
           Console.WriteLine("过滤操作符：where示例（查询表达式）");
 
 
 
 
           var racer = from r in Formula1.GetChampions()
 
 
                        where r.Wins > 15&& r.Country == "Austria"
 
 
                        select r;
 
 
           foreach (var item in racer)
 
 
           {
 
 
               Console.WriteLine("{0:A}", item);
 
 
           }
 
 
       }
 
 
 
 
       /// <summary>
 
 
       /// 查询获得车手冠军次数大于15次且是Austria国家的一级方程式赛手
 
 
       /// </summary>
 
 
       private static void Where_Fluent()
 
 
       {
 
 
           Console.WriteLine();
 
 
           Console.WriteLine("过滤操作符：where示例（方法语法）");
 
 
 
 
           var racer = Formula1.GetChampions().Where(r => r.Wins > 15
 
 
                && r.Country =="Austria");
 
 
 
 
           foreach (var item in racer)
 
 
           {
 
 
               Console.WriteLine("{0:A}", item);
 
 
           }
 
 
       }
 
 
 
 
       /// <summary>
 
 
       /// 过滤object数组中的元素，返回字符串类型的数组
 
 
       /// </summary>
 
 
       private static void OfType_Fluent()
 
 
       {
 
 
           Console.WriteLine();
 
 
           Console.WriteLine("过滤操作符：OfType()示例");
 
 
 
 
           object[] data = { "one", 2, 3, "four","five", 6 };
 
 
           var query = data.OfType<string>();
 
 
           foreach (var item in query)
 
 
           {
 
 
                Console.WriteLine(item);
 
 
           }
 
 
       }
 
 
       #endregion
 
 
 
 
       #region 投影操作符（Select，SelectMany）
 
 
 
 
       /// <summary>
 
 
       /// （Racer类定义了一个属性Cars，Cars是一个字符串数组。）过滤驾驶Ferrari的所有冠军
 
 
       /// </summary>
 
 
       private static void SelectMany_Query()
 
 
       {
 
 
           Console.WriteLine();
 
 
           Console.WriteLine("投影操作符：SelectMany示例（查询表达式）");
 
 
 
 
           var ferrariDrivers = from r in Formula1.GetChampions()
 
 
                                 from c inr.Cars
 
 
                                 where c =="Ferrari"
 
 
                                 orderbyr.LastName
 
 
                                 selectr.FirstName + " " + r.LastName;
 
 
           foreach (var item in ferrariDrivers)
 
 
           {
 
 
                Console.WriteLine(item);
 
 
           }
 
 
       }
 
 
 
 
       /// <summary>
 
 
       /// （Racer类定义了一个属性Cars，Cars是一个字符串数组。）过滤驾驶Ferrari的所有冠军
 
 
       /// </summary>
 
 
       private static void SelectMany_Fluent()
 
 
       {
 
 
           Console.WriteLine();
 
 
           Console.WriteLine("投影操作符：SelectMany示例（方法语法）");
 
 
           var ferrariDrivers = Formula1.GetChampions()
 
 
                .SelectMany(
 
 
                    r => r.Cars,
 
 
                    (r, c) => new { Racer =r, Car = c }
 
 
                )
 
 
                .Where(r => r.Car =="Ferrari")
 
 
                .OrderBy(r =>r.Racer.LastName)
 
 
                .Select(r =>r.Racer.FirstName + " " + r.Racer.LastName);
 
 
           foreach (var item in ferrariDrivers)
 
 
           {
 
 
                Console.WriteLine(item);
 
 
           }
 
 
       }
 
 
 
 
       #endregion
 
 
 
 
       #region 排序操作符（Order，OrderByDescending，ThenBy，ThenByDescending，Reverse）
 
 
 
 
       private static void Order_Query()
 
 
       {
 
 
           Console.WriteLine();
 
 
           Console.WriteLine("排序操作符：排序操作符示例（查询表达式）");
 
 
           var racers = from r in Formula1.GetChampions()
 
 
                         orderby r.Country,r.LastName descending, r.FirstName
 
 
                         select r;
 
 
           foreach (var item in racers)
 
 
           {
 
 
                Console.WriteLine(item);
 
 
           }
 
 
       }
 
 
 
 
       private static void Order_Fluent()
 
 
       {
 
 
           Console.WriteLine();
 
 
           Console.WriteLine("排序操作符：排序操作符 ectMany示例（方法语法）");
 
 
           var racers = Formula1.GetChampions()
 
 
                .OrderBy(r => r.Country)
 
 
                .ThenByDescending(r => r.LastName)
 
 
                .ThenBy(r => r.FirstName);
 
 
           foreach (var item in racers)
 
 
           {
 
 
                Console.WriteLine(item);
 
 
           }
 
 
       }
 
 
 
 
       private static void Reverse_Fluent()
 
 
       {
 
 
           Console.WriteLine();
 
 
           Console.WriteLine("排序操作符：Reverse 示例（方法语法）");
 
 
           var racers = Formula1.GetChampions()
 
 
                .OrderBy(r => r.Country)
 
 
                .Reverse();
 
 
           foreach (var item in racers)
 
 
           {
 
 
                Console.WriteLine(item);
 
 
           }
 
 
       }
 
 
 
 
       #endregion
 
 
 
 
       #region 连接操作符（Join，GroupJoin）
 
 
 
 
       /// <summary>
 
 
       /// 返回1958到1965年间的车手冠军和车队冠军信息，根据年份关联
 
 
       /// </summary>
 
 
       private static void Join_Query()
 
 
       {
 
 
           Console.WriteLine();
 
 
           Console.WriteLine("连接操作符：Join 示例（查询表达式）");
 
 
           var racers = from r in Formula1.GetChampions()
 
 
                         from y in r.Years
 
 
                         where y > 1958&& y < 1965
 
 
                         select new
 
 
                         {
 
 
                             Year = y,
 
 
                             Name = r.FirstName+ " " + r.LastName
 
 
                         };
 
 
 
 
           var teams = from t inFormula1.GetContructorChampions()
 
 
                        from y in t.Years
 
 
                        where y > 1958&& y < 1965
 
 
                        select new { Year = y,Name = t.Name };
 
 
 
 
           var racersAndTeams = from r in racers
 
 
                                 join t inteams on r.Year equals t.Year
 
 
                                 select new
 
 
                                 {
 
 
                                     Year =r.Year,
 
 
                                     Racer =r.Name,
 
 
                                     Team =t.Name
 
 
                                 };
 
 
           Console.WriteLine("年份\t\t车手冠军\t\t车队冠军");
 
 
           foreach (var item in racersAndTeams)
 
 
           {
 
 
                Console.WriteLine("{0}\t\t{1}\t\t{2}"
 
 
                    , item.Year, item.Racer,item.Team);
 
 
           }
 
 
       }
 
 
 
 
       /// <summary>
 
 
       /// 返回1958到1965年间的车手冠军和车队冠军信息，根据年份关联
 
 
       /// </summary>
 
 
       private static void Join_Fluent()
 
 
       {
 
 
           Console.WriteLine();
 
 
           Console.WriteLine("连接操作符：Join 示例（方法语法）");
 
 
           var racers = Formula1.GetChampions()
 
 
                .SelectMany(y => y.Years,(r, y)
 
 
                    => new { Year = y, Name= r.FirstName + " " + r.LastName })
 
 
                .Where(ty => ty.Year >1958 && ty.Year < 1965);
 
 
 
 
           var teams = Formula1.GetContructorChampions()
 
 
                .SelectMany(y => y.Years,(t, y) => new { Year = y, Name = t.Name })
 
 
                .Where(ty => ty.Year > 1958&& ty.Year < 1965);
 
 
 
 
           var racersAndTeams = racers.Join(teams
 
 
                    , r => r.Year, t =>t.Year
 
 
                    , (r, t) => new { Year =r.Year, Racer = r.Name, Team = t.Name }
 
 
                );
 
 
 
 
           Console.WriteLine("年份\t\t车手冠军\t\t车队冠军");
 
 
           foreach (var item in racersAndTeams)
 
 
           {
 
 
               Console.WriteLine("{0}\t\t{1}\t\t{2}"
 
 
                    , item.Year, item.Racer,item.Team);
 
 
           }
 
 
       }
 
 
 
 
       /// <summary>
 
 
       /// 返回1958到1965年间的车手冠军和车队冠军信息，根据年份关联并分组
 
 
       /// </summary>
 
 
       private static void GroupJoin_Query()
 
 
       {
 
 
           Console.WriteLine();
 
 
           Console.WriteLine("连接操作符：GroupJoin 示例（查询表达式）");
 
 
           var racers = from r in Formula1.GetChampions()
 
 
                         from y in r.Years
 
 
                         where y > 1958&& y < 1965
 
 
                         select new
 
 
                         {
 
 
                             Year = y,
 
 
                             Name = r.FirstName+ " " + r.LastName
 
 
                         };
 
 
 
 
           var teams = from t in Formula1.GetContructorChampions()
 
 
                        from y in t.Years
 
 
                        where y > 1958&& y < 1965
 
 
                        select new { Year = y,Name = t.Name };
 
 
 
 
           var racersAndTeams = from r in racers
 
 
                                 join t inteams on r.Year equals t.Year
 
 
                                 intogroupTeams
 
 
                                 select new
 
 
                                {
 
 
                                     Year =r.Year,
 
 
                                     Racer =r.Name,
 
 
                                     GroupTeams= groupTeams
 
 
                                 };
 
 
           Console.WriteLine("年份\t\t车手冠军\t\t车队冠军数");
 
 
           foreach (var item in racersAndTeams)
 
 
           {
 
 
               Console.WriteLine("{0}\t\t{1}\t\t{2}"
 
 
                    , item.Year, item.Racer,item.GroupTeams.Count());
 
 
           }
 
 
       }
 
 
 
 
       /// <summary>
 
 
       /// 返回1958到1965年间的车手冠军和车队冠军信息，根据年份关联并分组
 
 
       /// </summary>
 
 
       private static void GroupJoin_Fluent()
 
 
       {
 
 
           Console.WriteLine();
 
 
           Console.WriteLine("连接操作符：GroupJoin 示例（方法语法）");
 
 
            var racers = Formula1.GetChampions()
 
 
                .SelectMany(y => y.Years,(r, y)
 
 
                    => new { Year = y, Name= r.FirstName + " " + r.LastName })
 
 
                .Where(ty => ty.Year >1958 && ty.Year < 1965);
 
 
 
 
           var teams = Formula1.GetContructorChampions()
 
 
                .SelectMany(y => y.Years,(t, y) => new { Year = y, Name = t.Name })
 
 
                .Where(ty => ty.Year >1958 && ty.Year < 1965);
 
 
 
 
           var racersAndTeams = racers
 
 
                .GroupJoin(teams
 
 
                    , r => r.Year, t =>t.Year
 
 
                    , (r, t) => new { Year =r.Year, Racer = r.Name, GroupTeams = t }
 
 
                );
 
 
 
 
           Console.WriteLine("年份\t\t车手冠军\t\t车队冠军数");
 
 
           foreach (var item in racersAndTeams)
 
 
           {
 
 
               Console.WriteLine("{0}\t\t{1}\t\t{2}"
 
 
                    , item.Year, item.Racer,item.GroupTeams.Count());
 
 
           }
 
 
       }
 
 
 
 
       #endregion
 
 
 
 
       #region 分组操作符（Group，GroupBy）
 
 
 
 
       /// <summary>
 
 
       /// 按城市分组，获取每个城市的车手冠军
 
 
       /// </summary>
 
 
       private static void Group_Query()
 
 
       {
 
 
           Console.WriteLine();
 
 
           Console.WriteLine("分组操作符：Group 示例（查询表达式）");
 
 
           var countries = from r in Formula1.GetChampions()
 
 
                            group r byr.Country into g
 
 
                            select new {Country = g.Key, Racers = g };
 
 
 
 
           Console.WriteLine("城市\t\t车手冠军数");
 
 
           foreach (var item in countries)
 
 
           {
 
 
               Console.WriteLine("{0}\t\t{1}", item.Country,item.Racers.Count());
 
 
           }
 
 
       }
 
 
 
 
       /// <summary>
 
 
       /// 按城市分组，获取每个城市的车手冠军
 
 
       /// </summary>
 
 
       private static void Group_Fluent1()
 
 
       {
 
 
           Console.WriteLine();
 
 
           Console.WriteLine("分组操作符：Group 示例1（方法语法）");
 
 
           var countries = Formula1.GetChampions()
 
 
                .GroupBy(r => r.Country)
 
 
                .Select(g => new { Country =g.Key, Racer = g });
 
 
 
 
           Console.WriteLine("城市\t\t车手冠军数");
 
 
           foreach (var item in countries)
 
 
           {
 
 
               Console.WriteLine("{0}\t\t{1}", item.Country,item.Racer.Count());
 
 
           }
 
 
       }
 
 
 
 
       /// <summary>
 
 
       /// 按城市分组，获取每个城市的车手冠军
 
 
       /// </summary>
 
 
       private static void Group_Fluent2()
 
 
       {
 
 
           Console.WriteLine();
 
 
           Console.WriteLine("分组操作符：Group 示例2（方法语法）");
 
 
           var countries = Formula1.GetChampions()
 
 
                 .GroupBy(r => r.Country,(k, g) => new { Country = k, Racer = g });
 
 
 
 
           Console.WriteLine("城市\t\t车手冠军数");
 
 
           foreach (var item in countries)
 
 
           {
 
 
               Console.WriteLine("{0}\t\t{1}", item.Country, item.Racer.Count());
 
 
           }
 
 
       }
 
 
 
 
       #endregion
 
 
 
 
       #region 量词操作符（All、Any、Contains）
 
 
 
 
       /// <summary>
 
 
       /// 获取是否存在姓为“Schumacher”的车手冠军
 
 
       /// </summary>
 
 
       private static void Any_Fluent()
 
 
       {
 
 
           Console.WriteLine();
 
 
           Console.WriteLine("量词操作符：All 示例（方法语法）");
 
 
           var hasRacer_Schumacher = Formula1.GetChampions()
 
 
                .Any(r => r.LastName =="Schumacher");
 
 
           Console.WriteLine("是否存在姓为“Schumacher”的车手冠军？{0}", hasRacer_Schumacher ? "是" :"否");
 
 
       }
 
 
 
 
       #endregion
 
 
 
 
       #region 分区操作符（Skip,Take）
 
 
 
 
       // 扩展方法Take()和Skip()操作添加到查询的最后可用于分页
 
 
 
 
       /// <summary>
 
 
       /// 将车手冠军列表按每页5个名字进行分页
 
 
       /// </summary>
 
 
       private static void Paging_Query()
 
 
       {
 
 
           int pageSize = 5;
 
 
 
 
           int numberPages = (int)Math.Ceiling(
 
 
                Formula1.GetChampions().Count()/ (double)pageSize);
 
 
 
 
           for (int page = 0; page < numberPages; page++)
 
 
           {
 
 
                Console.WriteLine("Page{0}", page);
 
 
 
 
                var racers = (
 
 
                              from r inFormula1.GetChampions()
 
 
                              orderbyr.LastName
 
 
                              selectr.FirstName + " " + r.LastName
 
 
                             )
 
 
                              .Skip(page *pageSize).Take(pageSize);
 
 
 
 
                foreach (var name in racers)
 
 
                {
 
 
                    Console.WriteLine(name);
 
 
                }
 
 
                Console.WriteLine();
 
 
           }
 
 
       }
 
 
 
 
       #endregion
 
 
 
 
       #region 集合操作符（Union，Concat，Intersect，Except，Zip，SequenceEqual）
 
 
 
 
       /// <summary>
 
 
       /// 获取使用车型”Ferrari”和车型”Mclaren”都获得过车手冠军车手列表
 
 
       /// </summary>
 
 
       private static void Intersect_Fluent()
 
 
       {
 
 
           Func<string, IEnumerable<Racer>> racersByCar =
 
 
                Car => from r inFormula1.GetChampions()
 
 
                       from c in r.Cars
 
 
                       where c == Car
 
 
                       orderby r.LastName
 
 
                       select r;
 
 
 
 
           foreach (var racer in racersByCar("Ferrari")
 
 
               .Intersect(racersByCar("McLaren")))
 
 
           {
 
 
                Console.WriteLine(racer);
 
 
           }
 
 
       }
 
 
 
 
       /// <summary>
 
 
       /// 合并html开始标签和结束标签
 
 
       /// </summary>
 
 
       private static void Zip_Fluent()
 
 
       {
 
 
           string[] start = { "<html>", "<head>","<body>" };
 
 
           string[] end = { "</html>", "</head>","</body>" };
 
 
 
 
           var tags = start.Zip(end, (s, e) => { return s + e; });
 
 
 
 
           foreach (string item in tags)
 
 
           {
 
 
                Console.WriteLine(item);
 
 
           }
 
 
       }
 
 
 
 
       /// <summary>
 
 
       /// 判断两个序列是否相等，需要内容及顺序都相等
 
 
       /// </summary>
 
 
       private static void SequenceEqual_Fluent()
 
 
       {
 
 
           int[] arr1 = { 1, 4, 7, 9 };
 
 
           int[] arr2 = { 1, 7, 9, 4 };
 
 
           Console.WriteLine("排序前是否相等：{0}"
 
 
                , arr1.SequenceEqual(arr2) ?"是" : "否");  // 否
 
 
           Console.WriteLine();
 
 
           Console.WriteLine("排序后是否相等：{0}"
 
 
                ,arr1.SequenceEqual(arr2.OrderBy(k => k)) ? "是" :"否"); // 是
 
 
       }
 
 
 
 
       #endregion
 
 
 
 
       #region 元素操作符（First，FirstOrDefault，Last，LastOrDefault，ElementAt，ElementAtOrDefault，Single，SingleOrDefault）
 
 
 
 
       /// <summary>
 
 
       /// 获取冠军数排名第三的车手冠军
 
 
       /// </summary>
 
 
       private static void ElementAt_Fluent()
 
 
       {
 
 
           var Racer3 =Formula1.GetChampions()
 
 
                .OrderByDescending(r =>r.Wins)
 
 
                .ElementAtOrDefault(2);
 
 
           Console.WriteLine("获取冠军数排名第三的车手冠军为：{0} {1},获奖次数：{2}"
 
 
                , Racer3.LastName,Racer3.FirstName, Racer3.Wins);
 
 
       }
 
 
 
 
       #endregion
 
 
 
 
       #region 合计操作符（Count、LongCount、Sum、Max、Min、Average、Aggregate）
 
 
 
 
       private static void Sum_Fluent()
 
 
       {
 
 
           var racerCount = Formula1.GetChampions().Count();
 
 
       }
 
 
 
 
       private static void Aggregate_Fluent()
 
 
       {
 
 
           int[] numbers = { 1, 2, 3 };
 
 
           // 1+2+3 = 6
 
 
           int y = numbers.Aggregate((prod, n) => prod + n);
 
 
           // 0+1+2+3 = 6
 
 
           int x = numbers.Aggregate(0, (prod, n) => prod + n);
 
 
           // （0+1+2+3）*2 = 12
 
 
           int z = numbers.Aggregate(0, (prod, n) => prod + n, r => r * 2);
 
 
       }
 
 
 
 
       #endregion
 
 
 
 
       #region 转换操作符（Cast，ToArray，ToList，ToDictionary，ToLookup，AsEnumerable，DefaultIfEmpty）
 
 
 
 
       /// <summary>
 
 
       /// 将车手冠军按其使用车型进行分组，并显示使用”williams”车型的车手名字。
 
 
       /// </summary>
 
 
       private static void Lookup_Fluent()
 
 
       {
 
 
           ILookup<string, Racer> racers =
 
 
                (from r inFormula1.GetChampions()
 
 
                 from c in r.Cars
 
 
                 select new
 
 
                 {
 
 
                     Car = c,
 
 
                     Racer = r
 
 
                 }
 
 
                 ).ToLookup(cr => cr.Car, cr=> cr.Racer);
 
 
 
 
           if (racers.Contains("Williams"))
 
 
           {
 
 
               foreach (varwilliamsRacer in racers["Williams"])
 
 
                {
 
 
                   Console.WriteLine(williamsRacer);
 
 
                }
 
 
           }
 
 
       }
 
 
 
 
       private static void DefaultIfEmpty_Fluent()
 
 
       {
 
 
           var defaultArrCount = (new int[0]).DefaultIfEmpty().Count(); // 1
 
 
           Console.WriteLine("空int数组的DefaultIfEmpty返回的集合元素个数为:{0}", defaultArrCount);
 
 
       }
 
 
 
 
       #endregion
 
 
 
 
       #region 生成操作符（Range，Empty，Repeat）
 
 
 
 
       // 生成操作符 Range()，Empty()，Repeat() 不是扩展方法，而是返回序列的正常静态方法。
 
 
 
 
       private static void Range_Fluent()
 
 
       {
 
 
           var values = Enumerable.Range(1, 20);
 
 
           foreach (var item in values)
 
 
           {
 
 
                Console.Write("{0} ",item);
 
 
            }
 
 
           Console.WriteLine();
 
 
       }
 
 
 
 
       #endregion
 
 
 
 
    }
 
 
}
 
 
 
 
 
 
///ElementAt 在序列(集合)中,这个方法返回一个特定索引的一个元素
 
 
IList<string> numbers = new List<string>() 
 
 
{ 
 
 
"One","Two","Three" 
 
 
}; 
 
 
var elementAt = numbers.ElementAt(1); 
 
 
Console.WriteLine(elementAt); 
 
 
Empty返回一个指定类型参数的空Ienumerable<T>
 
 
var emptyList = Enumerable.Empty<int>(); 
 
 
Console.WriteLine(emptyList.Count()); 
 
 
Except方法可以用在从一个集合中删除一个项集合.它放回一个由两个序列产生的集合///差.比如,我有个由{1,2,3,4,5,6,7}组成的集合A和由{1,2,3}组成的集合B,A 除了(except) B 将会输出{4,5,6,7}
 
 
IList<int> firstNumbers = new List<int>() 
 
 
{ 
 
 
1,2,3,4,5,6,7 
 
 
}; 
 
 
IList<int> secondNumbers = new List<int>() 
 
 
{ 
 
 
1,2,3 
 
 
}; 
 
 
var result = firstNumbers.Except(secondNumbers).ToList(); 
 
 
result.ForEach(x => Console.WriteLine(x)); 
 
 
///First 返回序列的第一个元素
 
 
IList<int> numbers = new List<int>() 
 
 
{ 
 
 
1,2,3,4,5,6,7 
 
 
}; 
 
 
var firstItem = numbers.First(); 
 
 
var firstItemBasedOnConditions = numbers.First(item => item > 3); 
 
 
///FirstOrDefault它返回序列中第一个元素或者当没有元素未被找到时放回默认值.这个方法是///First和Default的综合
 
 
/Union 这个方法将会Union(并集)两个序列(集合).例如,我们有两个集合,A={1,2,3,4,5,6,7}和B={5,6,7,8,9},并集A和B则返回{1,2,3,4,5,6,7,8,9}.在.NET中,它将连接两个列表(集合)并生成一个新列表(集合). 
 
 
IList<int> firstList = new List<int>()  
 
 
{  
 
 
1,2,3,4 
 
 
}; 
 
 
IList<int> secondList = new List<int>()  
 
 
{  
 
 
7,9,3,4,5,6,7 
 
 
}; 
 
 
var result = firstList.Union(secondList); 
 
 
result.ToList().ForEach(x => Console.WriteLine(x)); 
 
 
Intersect 它将产生两个序列的交集
 
 
IList<int> listA = new List<int>() { 1, 2, 3, 4, 5 }; 
 
 
IList<int> listB = new List<int>() { 4, 5 }; 
 
 
var intersectResult = listA.Intersect(listB);
 
 
intersectResult.ToList().ForEach(x => Console.Write("{0}\t",x)); 
 
 
 
 
//
 
 
using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using UnityEngine;
 
 
namespace MyOtherTools
 {
     public class TestLinq : MonoBehaviour
     {
         
         void Start()
         {
             LinqSelectWhere();
 
 
            LinqGroupBy();
 
 
            LinqSelectMany();
 
 
            LinqWhereOrderBySelect();
 
 
            LinqToList();
 
 
            LinqFindConvert();
 
 
            LinqOrderReverse();
 
 
        }
 
 
        private void LinqDefault()
         {
             int[] source = new[] { 5, 10, 22, 7, 3, 16 };
             var result0 = source.ElementAt(2);
 
 
            var result1 = source.First();
             // -> 5
 
 
            var result2 = source.First(e => e > 8);
             // -> 10
 
 
            var result3 = source.FirstOrDefault(e => e > 30);
         }
 
 
        private void LinqOrderReverse()
         {
             var fruitList = new[]
             {
                 new {Name = "apple", Price = 300},
                 new {Name = "Banana", Price = 200},
                 new {Name = "Pineapple", Price = 1000},
                 new {Name = "Strawberry", Price = 500},
             };
 
 
            var orderByList = fruitList.OrderBy(x => x.Price);
             UnityEngine.Debug.LogFormat("<color=#ff0000> === orderByList === </color>");
             UnityEngine.Debug.LogFormat("[{0}]", string.Join(", ", orderByList)); // [{ Name = Banana, Price = 200 }, { Name = apple, Price = 300 }, { Name = Strawberry, Price = 500 }, { Name = Pineapple, Price = 1000 }]
 
 

             var orderByDescendingList = fruitList.OrderByDescending(x => x.Price);
             UnityEngine.Debug.LogFormat("<color=#ff0000> === orderByDescendingList === </color>");
             UnityEngine.Debug.LogFormat("[{0}]", string.Join(", ", orderByDescendingList)); // [{ Name = Pineapple, Price = 1000 }, { Name = Strawberry, Price = 500 }, { Name = apple, Price = 300 }, { Name = Banana, Price = 200 }]
 
 

             var reverseList = fruitList.Reverse();
             UnityEngine.Debug.LogFormat("<color=#ff0000> === reverseList === </color>");
             UnityEngine.Debug.LogFormat("[{0}]", string.Join(", ", reverseList)); // [{ Name = Strawberry, Price = 500 }, { Name = Pineapple, Price = 1000 }, { Name = Banana, Price = 200 }, { Name = apple, Price = 300 }]
 
 

             var fruitList1 = new[]
             {
                 new {Name = "apple", Price = 300},
                 new {Name = "Banana", Price = 300},
                 new {Name = "Pineapple", Price = 1000},
                 new {Name = "Strawberry", Price = 500},
             };
 
 
            var fruitList2 = new[]
             {
                 new {Name = "Apples", Stock = 100},
                 new {Name = "Banana", Stock = 50},
                 new {Name = "Pineapple", Stock = 40},
             };
 
 
            var fruitList3 = new[]
             {
                 new {Name = "Grapes", Price = 700},
                 new {Name = "Momo", Price = 600},
             };
 
 
            var joinList = fruitList1.Join(
                 fruitList2,
                 outer => outer.Name,
                 inner => inner.Name,
                 (outer, inner) => new
                 {
                     outer.Name,
                     outer.Price,
                     inner.Stock
                 });
             UnityEngine.Debug.LogFormat("<color=#ff0000> === joinList === </color>");
             UnityEngine.Debug.LogFormat("[{0}]", string.Join(", ", joinList)); // [{ Name = Banana, Price = 300, Stock = 50 }, { Name = Pineapple, Price = 1000, Stock = 40 }]
             
             var groupJoinList = fruitList1.GroupJoin(
                 fruitList2,
                 outer => outer.Name,
                 inner => inner.Name,
                 (outer, inner) => new
                 {
                     outer.Name,
                     outer.Price,
                     Stock = inner.Select(x => x.Stock).Sum()
                 });
             UnityEngine.Debug.LogFormat("<color=#ff0000> === groupJoinList === </color>");
             UnityEngine.Debug.LogFormat("[{0}]", string.Join(", ", groupJoinList)); // [{ Name = apple, Price = 300, Stock = 0 }, { Name = Banana, Price = 300, Stock = 50 }, { Name = Pineapple, Price = 1000, Stock = 40 }, { Name = Strawberry, Price = 500, Stock = 0 }]
 
 
            var concatList = fruitList1.Concat(fruitList3);
             UnityEngine.Debug.LogFormat("<color=#ff0000> === concatList === </color>");
             UnityEngine.Debug.LogFormat("[{0}]", string.Join(", ", concatList)); // [{ Name = apple, Price = 300 }, { Name = Banana, Price = 300 }, { Name = Pineapple, Price = 1000 }, { Name = Strawberry, Price = 500 }, { Name = Grapes, Price = 700 }, { Name = Momo, Price = 600 }]
             
         }
 
 

         private void LinqFindConvert()
         {
             var list = new List<int> {1, 84, 95, 95, 40, 6};
 
 
            UnityEngine.Debug.LogFormat("First: {0}", list.First()); // First: 1
             //UnityEngine.Debug.LogFormat("First: {0}", list.First(x => x > 10)); // First: 1
             UnityEngine.Debug.LogFormat("First: {0}", list.First()); // First: 1
             UnityEngine.Debug.LogFormat("Last: {0}", list.Last()); // Last: 6
             UnityEngine.Debug.LogFormat("Max: {0}", list.Max()); // Max: 95
             UnityEngine.Debug.LogFormat("Min: {0}", list.Min()); // Min: 1
             UnityEngine.Debug.LogFormat("Average: {0}", list.Average()); // Average: 53.5
             UnityEngine.Debug.LogFormat("Sum: {0}", list.Sum()); // Sum: 321
             UnityEngine.Debug.LogFormat("Count: {0}", list.Count()); // Count: 6
 
 
            int[] array = list.ToArray();
             UnityEngine.Debug.LogFormat("<color=#ff0000> === array === </color>");
             UnityEngine.Debug.LogFormat("[{0}]", string.Join(", ", array)); // [1, 84, 95, 95, 40, 6]
 
 
            List<object> objectList = list.Cast<object>().ToList();
             UnityEngine.Debug.LogFormat("<color=#ff0000> === objectList === </color>");
             UnityEngine.Debug.LogFormat("[{0}]", string.Join(", ", objectList)); // [1, 84, 95, 95, 40, 6]
 
 
            var distinctList = list.Distinct();
             UnityEngine.Debug.LogFormat("<color=#ff0000> === distinctList === </color>");
             UnityEngine.Debug.LogFormat("[{0}]", string.Join(", ", distinctList)); // [1, 84, 95, 40, 6]
 
 
            var skipList = list.Skip(3);
             UnityEngine.Debug.LogFormat("<color=#ff0000> === skipList === </color>");
             UnityEngine.Debug.LogFormat("[{0}]", string.Join(", ", skipList)); // [95, 40, 6]
 
 
            var takeList = list.Take(3);
             UnityEngine.Debug.LogFormat("<color=#ff0000> === takeList === </color>");
             UnityEngine.Debug.LogFormat("[{0}]", string.Join(", ", takeList)); // [1, 84, 95]
 
 
            UnityEngine.Debug.LogFormat("All: {0}", list.All(x => x < 100)); // All: True
 
 
            UnityEngine.Debug.LogFormat("Any: {0}", list.Any(x => x < 0)); // Any: False
 
 
            UnityEngine.Debug.LogFormat("Contains: {0}", list.Contains(40)); // Contains: True
 
 

             var findAllList = list.FindAll(x => x % 2 == 0);
             UnityEngine.Debug.LogFormat("<color=#ff0000> === findAllList === </color>");
             UnityEngine.Debug.LogFormat("[{0}]", string.Join(", ", findAllList)); // [84, 40, 6]
 
 
            var convertAllList = list.ConvertAll(x => x * 3);
             UnityEngine.Debug.LogFormat("<color=#ff0000> === convertAllList === </color>");
             UnityEngine.Debug.LogFormat("[{0}]", string.Join(", ", convertAllList)); // [3, 252, 285, 285, 120, 18]
 
 
            var convertAllList2 = list.ConvertAll(delegate(int x) { return x * 3; });
             UnityEngine.Debug.LogFormat("<color=#ff0000> === convertAllList2 === </color>");
             UnityEngine.Debug.LogFormat("[{0}]", string.Join(", ", convertAllList2)); // [3, 252, 285, 285, 120, 18]
 
 
            var resultList1 = list
                 .Distinct()         
                 .Skip(2)            
                 .OrderBy(x => x);   
             UnityEngine.Debug.LogFormat("<color=#ff0000> === resultList1 === </color>");
             UnityEngine.Debug.LogFormat("[{0}]", string.Join(", ", resultList1)); // [6, 40, 95]
 
 
            var resultList2 = list
                 .FindAll(x => x % 2 == 0)
                 .OrderBy(x => x)
                 .ToList() 
                 .ConvertAll(x => x * 3);
             UnityEngine.Debug.LogFormat("<color=#ff0000> === resultList2 === </color>");
             UnityEngine.Debug.LogFormat("[{0}]", string.Join(", ", resultList2)); // [18, 120, 252]
 
 
            var resultList3 =
                 from x in list
                 where x % 2 == 0
                 orderby x
                 select x * 3;
             UnityEngine.Debug.LogFormat("<color=#ff0000> === resultList3 === </color>");
             UnityEngine.Debug.LogFormat("[{0}]", string.Join(", ", resultList3)); // [18, 120, 252]
 
 
            var list2 = new List<int> { 1, 16, 39, 33, 7, 84 };
             var unionList = list.Union(list2);
             UnityEngine.Debug.LogFormat("<color=#ff0000> === unionList === </color>");
             UnityEngine.Debug.LogFormat("[{0}]", string.Join(", ", unionList)); // [1, 84, 95, 40, 6, 16, 39, 33, 7]
 
 
            var exceptList = list.Except(list2);
             Console.WriteLine("=== exceptList ===");
             UnityEngine.Debug.LogFormat("<color=#ff0000> === exceptList === </color>");
             UnityEngine.Debug.LogFormat("[{0}]", string.Join(", ", exceptList)); // [95, 40, 6]
 
 
            var intersectList = list.Intersect(list2);
             UnityEngine.Debug.LogFormat("<color=#ff0000> === intersectList === </color>");
             UnityEngine.Debug.LogFormat("[{0}]", string.Join(", ", intersectList)); // [1, 84]
 
 
        }
 
 
        private void LinqToList()
         {
             List<int> nums = new List<int>()
             {
                 1, 2, 5, 9, 11, 14, 18, 21
             };
 
 
            var query1 = nums.Where(x => x % 2 == 0).Select(x => x);
             UnityEngine.Debug.LogFormat("<color=#ff0000> [{0}] </color>", string.Join(", ", query1)); // [2, 14, 18] 
             var query2 = nums.Where(x => x % 2 == 0).ToList();
             UnityEngine.Debug.LogWarningFormat("<color=#ff0000> [{0}] </color>", string.Join(", ", query2)); // [2, 14, 18] 
         }
 
 
        private void LinqWhereOrderBySelect()
         {
             var list = new List<int> { 1, 3, 8, 27, 4, 6 };
 
 
            var query1 = from x in list
                 where x % 2 == 0
                 orderby x
                 select x * 2;
             UnityEngine.Debug.LogFormat("<color=#ff0000> [{0}] </color>", string.Join(", ", query1)); // [8, 12, 16] 
 
 
            var query2 = list
                 .Where(x => x % 2 == 0)
                 .OrderBy(x => x)
                 .Select(x => x * 2);
             UnityEngine.Debug.LogWarningFormat("<color=#ff0000> [{0}] </color>", string.Join(", ", query2)); // [8, 12, 16] 
         }
 
 
        //public NamePriceModel[] AllProducts()
         //{
         //    try
         //    {
         //        using (UserDataDataContext db = new UserDataDataContext())
         //        {
         //            return db.mrobProducts
         //                .Where(x => x.Status == 1)
         //                .Select(x => new NamePriceModel
         //                {
         //                    Name = x.Name,
         //                    Id = x.Id,
         //                    Price = x.Price
         //                })
         //                .OrderBy(x => x.Id)
         //                .ToArray();
         //        }
         //    }
         //    catch
         //    {
         //        return null;
         //    }
         //}
 
 
        private void LinqSelectMany()
         {
             MyQuarter[] myq = new MyQuarter[]
             {
                 new MyQuarter {Period = "第1四半期", Months = new List<string> {"4月", "5月", "8月"}},
                 new MyQuarter {Period = "第2四半期", Months = new List<string> {"7月", "8月", "9月"}},
                 new MyQuarter {Period = "第3四半期", Months = new List<string> {"10月", "11月", "12月"}},
                 new MyQuarter {Period = "第4四半期", Months = new List<string> {"1月", "2月", "3月"}}
             };
 
 
            var query = myq.SelectMany(x => x.Months);
             UnityEngine.Debug.LogWarningFormat("<color=#ff0000> [{0}] </color>", string.Join(", ", query)); // [4月, 5月, 8月, 7月, 8月, 9月, 10月, 11月, 12月, 1月, 2月, 3月] 
             
             query = query.Distinct();
             UnityEngine.Debug.LogWarningFormat("<color=#ff0000> [{0}] </color>", string.Join(", ", query)); // [4月, 5月, 8月, 7月, 9月, 10月, 11月, 12月, 1月, 2月, 3月] 
         }
 
 
        private void LinqSelectWhere()
         {
             int[] src = { 0, 1, 2, 3, 4, 5 };
 
 
            var query1 = src.Select(x => x % 3);
             UnityEngine.Debug.LogWarningFormat("[{0}]", string.Join(", ", query1)); // [0, 1, 2, 0, 1, 2]
 
 
            var query2 = src.Where(x => x > 1).Select(x => x % 3);
             //foreach (int num in src)
             //{
             //    if (num > 1)
             //    {
             //        int mod = num % 3;
             //        UnityEngine.Debug.LogWarningFormat("{0}", mod);
             //    }
             //}
             UnityEngine.Debug.LogWarningFormat("[{0}]", string.Join(", ", query2)); // [2, 0, 1, 2]
         }
 
 
        private void LinqGroupBy()
         {
             var result = new List<GroupingTest>
             {
                 new GroupingTest {GoodsKind = "书写工具", GoodsNum = 15, GoodsName = "圆珠笔"},
                 new GroupingTest {GoodsKind = "纸制品", GoodsNum = 36, GoodsName = "笔记本"},
                 new GroupingTest {GoodsKind = "美术用品", GoodsNum = 10, GoodsName = "水彩颜料"},
                 new GroupingTest {GoodsKind = "书写工具", GoodsNum = 22, GoodsName = "万年笔"},
                 new GroupingTest {GoodsKind = "纸制品", GoodsNum = 41, GoodsName = "信封"},
                 new GroupingTest {GoodsKind = "美术用品", GoodsNum = 12, GoodsName = "日本绘画颜料"},
                 new GroupingTest {GoodsKind = "书写工具", GoodsNum = 34, GoodsName = "铅笔"},
                 new GroupingTest {GoodsKind = "纸制品", GoodsNum = 50, GoodsName = "专辑"},
                 new GroupingTest {GoodsKind = "美术用品", GoodsNum = 45, GoodsName = "画笔"},
             };
 
 
            var query = result.GroupBy(x => x.GoodsKind);
 
 
            foreach (var group in query)
             {
                 UnityEngine.Debug.LogWarningFormat("<color=#ff0000> {0} </color>的库存数量如下: ", group.Key);
                 foreach (var item in group)
                 {
                     UnityEngine.Debug.LogWarningFormat("{0}:{1}", item.GoodsName, item.GoodsNum);
                 }
             }
         }
 
 
        
     }
 
 
    public class GroupingTest
     {
         public string GoodsKind;
         public int GoodsNum;
         public string GoodsName;
 
 
        public GroupingTest()
         {
 
 
        }
 
 
        public GroupingTest(string goodsKind, int goodsNum, string goodsName)
         {
 
 
        }
     }
 
 
    public class MyQuarter
     {
         public string Period { get; set; }
         public List<String> Months { get; set; }
 
 
        public MyQuarter()
         {
 
 
        }
     }
 
 
}
 
 
 
 
//
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 


                

        

        

    

  


    

      

        

            

              
                
                  警醒与鞭策
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
C#高级篇(二)---LINQ、反射、线程

				
			

			

				

					yoyo的博客
				

				

					10-09
					
					1397
					
				

			

		

		

			
				
LINQ用法
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _013_LINQ {
    class Kongfu {
        public int Id { get; set;

			
		

	



                

              
                



	

		

			

				
					
LINQ之Contains

				
			

			

				

					lcy的博客
				

				

					04-21
					
					4447
					
				

			

		

		

			
				
返回LINQ大全首页
Contains()
Contains()可以用来判断序列中是否存在指定的元素。
MSDN
public static bool Contains<TSource>( this IEnumerable<TSource> source, TSource value );
但是要注意此行为会根据元素是值类型还是引用类型而略有变化。
代码示例：
public...

			
		

	



                


  
              

                


	

		

			

				
					
c# Linq Contains 字符串集合中是否包含某集合中字符

				
			

			

				

					
				

				

					06-20
					
					805
					
				

			

		

		

			
				
public class UnitTest1
    {
        [Fact]
        public void Test1()
        {
            var list_A = new List<string> { "MU", "CA", "PA" };
            var list_B = new List<string&g...

			
		

	





	

		

			

				
					
C# Linq学习

				
			

			

				

					gunjiu4462的博客
				

				

					12-13
					
					135
					
				

			

		

		

			
				
using System;
using System.Linq;
using System.Collections.Generic;

namespace linqLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hell...

			
		

	



		

			
		



	

		

			

				
					
C# 基础知识系列- 7 Linq详解（一篇知道Linq的常用操作）

				
			

			

				

					菜鸡成长日记
				

				

					04-04
					
					1261
					
				

			

		

		

			
				
前言
在上一篇中简单介绍了Linq的入门级用法，这一篇尝试讲解一些更加深入的使用方法，与前一篇的结构不一样的地方是，这一篇我会先介绍Linq里的支持方法，然后以实际需求为引导，分别以方法链的形式和类SQL的形式写出来。
前置概念介绍

Predicate<T>  谓词、断言，等价于 Func<T,bool> 即返回bool的表达式
Expression<TDelega...

			
		

	





	

		

			

				
					
c# linq的差集,并集,交集,去重代码(分享)

				
			

			

				

					12-31
				

			

		

		

			
				
using System.Linq; List<string> ListA = new List(); List<string> ListB = new List(); List<string> ListResult = new List(); ListResult = ListA.Distinct().ToList();//去重 ListResult = ListA.Except(ListB...

			
		

	





	

		

			

				
					
c# Linq常用的小技巧

				
			

			

				

					12-17
				

			

		

		

			
				
【C# LINQ常用小技巧】  LINQ（Language Integrated Query，语言集成查询）是C#中的一个强大特性，它使得在代码中处理数据变得更加简洁和高效。LINQ结合了SQL的查询语法，并与Lambda表达式相结合，使得代码更加优雅...

			
		

	





	

		

			

				
					
C# LinqXML使用LINQ技术对XML文件进行读取

				
			

			

				

					10-27
				

			

		

		

			
				
`System.Xml.Linq` 命名空间包含了 LINQ to XML 相关的类和方法。  **一、创建XML对象** 在LinqXML中，XML文档被表示为一个`XDocument`对象。你可以通过各种方式创建一个`XDocument`，例如从XML字符串、XML文件或XML...

			
		

	





	

		

			

				
					
数据库 C#linq基础程序程序练习案例.rar

				
			

			

				

					09-05
				

			

		

		

			
				
数据库C# LINQ（Language Integrated Query，语言集成查询）是.NET框架中的一种强大的数据查询工具，主要用于处理对象集合，同时也支持与SQL数据库的交互。它允许开发者使用类似于SQL的语法在C#代码中进行查询，使得...

			
		

	





	

		

			

				
					
Linq to SQL Contains

				
			

			

				

					jingmeifeng的专栏
				

				

					11-06
					
					6023
					
				

			

		

		

			
				
说明：用于判断集合中是否包含有某一元素；不延迟。它是对两个序列进行连接操作的。

string[] customerID_Set =

    new string[] { "AROUT", "BOLID", "FISSA" };

var q = (

    from o in db.Orders

    where customerID_Set.Contains(o.C

			
		

	





	

		

			

				
					
LINQ to SQL语句

				
			

			

				

					GuoHX
				

				

					11-13
					
					1256
					
				

			

		

		

			
				
LINQ to SQL语句(1)之Where
  适用场景：实现过滤，查询等功能。
  
  说明：与SQL命令中的Where作用相似，都是起到范围限定也就是过滤作用的，而判断条件就是它后面所接的子句。Where操作包括3种形式，分别为简单形式、关系条件形式、First()形式。下面分别用实例举例下：
1.简单形式： 
例如：使用where筛选在伦敦的客户var q =
    from c in

			
		

	





	

		

			

				
					
C#版本LINQ增强开源库

					
最新发布

				
			

			

				

					2201_75761617的博客
				

				

					08-10
					
					121
					
				

			

		

		

			
				
LINQ对应的中文名称是：语言集成查询，是对一系列直接将查询功能集成到C#语言技术的统称，我们最常用的场景是，用于数据库的查询功能。该项目与LINQ规范保持一致，针对Objects进行扩展，总共扩展了100多个方法，功能非常齐全且强大。在.Net中，本身对Objects也支持LINQ的扩展，但是对于一些特定的功能，就需要我们自己去扩展。所以，今天给大家推荐一个LINQ扩展库，主要是针对“LINQ to Objects”的扩展。

			
		

	





	

		

			

				
					
linq中的contains条件

				
			

			

				

					weixin_34124939的博客
				

				

					05-23
					
					388
					
				

			

		

		

			
				
在sql查询语句中，in 在linq 中用contains，并且contains前面是数组，而后面是列名，如：人力资源查询SELECT distinct BH FROM cd where (LB = '身份') AND (LM IN ('合同工','临时工'))转换成Linq 是这样的：如果sf是变量，是在程序中根据用户选择的条件临时添加的，sf可以为空，也可不为空，在程序中定义sf，在程序中...

			
		

	





	

		

			

				
					
LINQ查询表达式

				
			

			

				

					滕柳
				

				

					02-19
					
					1028
					
				

			

		

		

			
				
select orderby

			
		

	





	

		

			

				
					
Linq-Exists/In/Any/All/Contains操作符

				
			

			

				

					dasuyan8263的博客
				

				

					08-11
					
					216
					
				

			

		

		

			
				
适用场景：用于判断集合中元素，进一步缩小范围。
Any
说明：用于判断集合中是否有元素满足某一条件；不延迟。（若条件为空，则集合只要不为空就返回True，否则为False）。有2种形式，分别为简单形式和带条件形式。
1.简单形式：
仅返回没有订单的客户：
var q =
 from c in db.Customers
 where !c.Orders.Any()...

			
		

	





	

		

			

				
					
C#中的委托和Lambda表达式

				
			

			

				

					jiq•钦's technical Blog
				

				

					01-07
					
					1834
					
				

			

		

		

			
				
今天看Curator源码时发现其请求ZooKeeper集群时内部封装了重试机制，代码如下：
Stat resultStat = RetryLoop.callWithRetry
        (
            client.getZookeeperClient(),
            new Callable()
            {

			
		

	





	

		

			

				
					
C#两个对象集合常用lambda操作

				
			

			

				

					星期一兴起
				

				

					08-21
					
					2389
					
				

			

		

		

			
				
ORACLE行转列，列转行

			
		

	





	

		

			

				
					
C# LINQ详解（一）

				
			

			

				

					weixin_30856965的博客
				

				

					12-02
					
					1455
					
				

			

		

		

			
				
原文标题:How does it work in C#?-Part 3 (C# LINQ in detail),作者:MohammandA Rahman.





目录

LINQ基础

扩展方法-幕后的工作



扩展方法列表

Where and Select


All


Average


Concat

...

			
		

	





	

		

			

				
					
C# LINQ完全指南

				
			

			

				

					
				

			

		

		

			
				
"《LINQ Unleashed for C#》是由Paul Kimmel撰写的一本关于C#编程语言中LINQ技术的专业书籍。本书详细介绍了如何在C#环境中充分利用LINQ (Language Integrated Query) 这一强大的查询工具。"   LINQ（Language ...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  





	
打赏作者

	

		

		
			
		
		

		

			
警醒与鞭策

			
你的鼓励将是我创作的最大动力

		

	

	

			

	

	

    ¥1
    ¥2
    ¥4
    ¥6
    ¥10
    ¥20
	

	

		

			

				

					扫码支付：¥1
				

				

					

					
					获取中
					

				

				

					
					
					扫码支付
				

			

		

		

			
您的余额不足，请更换扫码支付或充值

			
打赏作者

		

	



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值