第三十三讲 初窥LINQ

主要内容：
    概述
        1. LINQ起源
            1. LINQ-语言集成查询(Language Intergrated Query 简称LINQ)
            2. LINQ定义了大约40个查询操作符，如select,form,in,where以及order by。
            3. LINQ是一种能够快速对大部分数据源进行访问和数据整合的一种技术，使用相同的基本查询表达式模式来查询和转换SQL数据库，ADO.NET数据集，XML文档和流，以及.NET集合中的数据。
            4. LINQ通过对象的方式对数据库进行描述。
            
            
        2. LINQ架构
            1. LINQ从.NET3.5开始被引入
            2. LINQ to Objects
            3. LINQ to DataSet
            4. LINQ to SQL
            5. LINQ to Entities
            6. LINQ to XML
            已经生成截图
            
        3. LINQ相关的命名空间
            已经生成截图
            
        4. 简单的示例--查询并筛选数组
        
    查询表达式基础
        1. 查询概念和用途
            查询的对象为IEnumerable<T> 或 IQueryable<T> 集合
            
            实例操作
                排序、
                类型转换、
                查询数据源的单一值(最大，最小，总数......)
                
        2. 查询表达式语法
            1. 查询表达可用于查询和转换来自任意支持LINQ的数据源中的数据
            2. 在您循环访问foreach语句中的查询变量之前，不会执行查询
            3. 查询表达式中的变量都是强类型的，但许多情况下你不需要显示提供类型，因为编译器可以推断类型。
            
            语法：
            Var 查询变量=
                from 临时变量 in 数据源
                where 条件语句(where, orderby, join, from子句)
                select 查询目标

               

我个人百度收集了一些相关的基础知识，那个排序就跟SQL里的一个ASC,DESC只是在Linq中不是简写了，要全写

升序就是Ascending,而降序就是Descending。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
using System.Web.Security;

namespace Con33
{
    
    class Program
    {
        /// <summary>
        /// Linq入门
        /// </summary>
        /// <param name="args"></param>
        static void Main(string[] args)
        {
            //创建一个数组
            string[] strArray = new string[] { "我", "中华", "人民", "共和国", "老虎苍蝇", "一起打" };
            //使用Linq语法
            var str1 = from s in strArray
                       //卧槽，这里声明查寻变量必须要用var吗？看了下面的才知道原来是懒敲IEnumerable<T>
                       select string.Format("这个字符串是：{0}", s);

            IEnumerable<string> str2 = from s in strArray
                                       //卧槽，原来系酱子，即将数组的元素存到一个泛型集合中去
                                       select string.Format("这个字符串是：{0}", s);

            //遍历查寻结果1
            foreach (var s in str1) //注意这个是泛型str1
            {
                Console.WriteLine(s);
            }

            Console.WriteLine("\n=======以下是同样的结果========\n");

            //遍历查寻结果2
            foreach (var s in str2)//注意这个是泛型str2
            {
                Console.WriteLine(s);
            }

            Console.WriteLine("\n=======排序看看========\n");
            //再写个数据组，排序看看
            int[] integrate = new[] {6,5,4,9,8,0,2,1,3,7 };
            var res = from r in integrate
                      orderby r descending //降序，而 ascending是升序
                      select string.Format("-----{0}-----",r);
            foreach (var v in res)
            {
                Console.WriteLine(v);
            }

            Console.WriteLine("\n=======扩展方法测试========\n");
            Console.WriteLine("1".In(new[] { "1", "2", "3" }));

            Console.WriteLine("\n=======匿名类型数据测试========\n");
            var data = new {a="1",b="2" };//光秃秃的也没有类名
            Console.WriteLine("匿名类中的a= {0},\n匿名中的b= {1}",data.a,data.b);

            Console.WriteLine("\n=======类的自动属性测试========\n");
            Person p = new Person();
            Console.WriteLine("Person类中自动属性username的值是{0}",p.username);

            Console.WriteLine("\n=======对象初始化器测试========\n");
            ObjectInit o = new ObjectInit() { name1 = "看到我了吗？" };
            Console.WriteLine(o.ToString());

            Console.WriteLine("\n=======集合初始化器测试========\n");
            var str = new List<object> {
                new ObjectInit{name1="集合初始化测试一次"},
                new ObjectInit{name1="集合初始化测试二次"},
                new ObjectInit{name1="集合初始化测试三次"}
            };

            foreach (var a in str)
            {
                Console.WriteLine(a.ToString());
            }

            Console.WriteLine("\n=======Lambda表达式测试========\n");
            var lam = new [] {"ab","ac","cd","edab" };
            //使用Array的FindAll方法从一个数组中查寻匹配的字符串
            var result = Array.FindAll(lam, s => (s.IndexOf('a') > 0));//语法：（参数列表）=>(表达式或语句块)
            foreach (var v in result)
            {
                Console.WriteLine("找到的匹配字符串是：{0}",v);
            }

            //多参数的Lambda表达式
            Console.WriteLine("\n=======Lambda表达式多参数测试========\n");
            //对于我们这些个初始学者来说，刚接触能似懂非懂很不错了，我这是在比葫芦画瓢的节奏，顺便写一些自己的理解
            Console.WriteLine((1.Oper(2,(a,b)=>(a+b))).ToString());//这我里用toSting()，其实不用也行，看下面
            Console.WriteLine(3.Oper(5,(c,d)=>(c-d)));//Lambda表达式表现的就是匿名方法的使用

            Console.WriteLine("\n=======让我更郁闷的Lambda表达式测试========\n");
            var str3 = new List<object> {
                new ObjectInit{name1="集合初始化测试一次"},
                new ObjectInit{name1="集合初始化测试二次"},
                new ObjectInit{name1="集合初始化测试三次000"}
            };

            var rs = from a in str3 //Linq表达的写法
                     where a.ToString().IndexOf("一") > 0
                     select a.ToString();

            var rs2 = str3.Where(a => a.ToString().IndexOf("三")>9).Select(a=>a.ToString());//Linq的Lambda表达式写法

            foreach (var s in rs) //Linq
            {
                Console.WriteLine(s);
            }
            foreach (var s in rs2) //Lambda
            {
                Console.WriteLine(s);
            }

            Console.ReadKey();
        }

        
    }

    /// <summary>
    /// 要学好Linq需要先弄懂啥是匿名类，扩展方法，匿名方法等
    /// 一些平时我们接触很少的东东
    /// 以下是一个创建扩展方法的静态类
    /// 注意：扩展方法只能在静态类中定义且是静态方法
    /// 同时注意：如果扩展方法名与原有方法名冲突，那么扩展方法将失效
    /// 再要注意：扩展方法必须写在顶级类中，不能写在嵌套类中
    /// </summary>
    public static class helper
    {
        public static bool In(this object o, IEnumerable<object> b)
        {
            bool bl = false; ;
            foreach (object obj in b)
            {
                if (obj == o)
                {
                    bl = true;
                    break;
                }
                else
                {
                    bl = false;
                }
            }
            return bl;
        }
    }
    /// <summary>
    /// 自动属性在类中的使用
    /// </summary>
    public class Person
    {
        public string username { get; set; }
        public int age { get; set; }

        public Person()
        {
            this.username = "John";
        }
    }
    /// <summary>
    /// 初始化测试类
    /// </summary>
    public class ObjectInit
    {
        public string name1 { get; set; }

        public override string ToString()
        {
            return string.Format("初始化器测试值是：{0}",this.name1);
        }
    }

    /// <summary>
    /// 使用委托类型测试Lambda表达式
    /// 委托类型以我的理解，就是一个定义方法的类型
    /// 它还可以配合事件驱动来更方便的进行传递数据
    /// 如何窗口程序中的控件的事件都是通过委托来实现的
    /// </summary>
    /// <param name="a"></param>
    /// <param name="b"></param>
    /// <returns></returns>
    public delegate int mydg(int a,int b);

    public static class LambdaTest
    {
        public static int Oper(this int a, int b, mydg dg)//dg这个参数就是一个方法
        {
            return dg(a, b);//方法的返回值是int类型的
        }
    }
}

我说的东东都个人见解，不可全信，各自有各自的理解，如果在下有不正确的地方，还请朋友帮忙纠正。谢过！