.NET Core3.1 LINQ查詢

1、LINQ介紹

　　LINQ（Language Integrated Query，語言集成查詢），是c#編程語言中的一種查詢語法。有了LINQ，使得以相同的語法訪問不同的數據源成為可能。這是因為，LINQ提供了不同數據源的抽象層。

2、LINQ查詢基礎

　　本節介紹了一個簡單的LINQ查詢。在此基礎上，着重理解：c#提供了轉換為方法調用的集成查詢語言。

　　2.1、准備列表和實體

　　　　接下來的幾個章節的LINQ查詢是在一個錦標賽的集合上進行的。這個集合需要用到.NET的類庫：

　　　　　　System

　　　　　　System.Collection.Generic

　　2.2、Racer類型。

　　　　Racer定義了幾個屬性和一個重載的ToString()方法，該方法以字符串格式顯示賽車手。實現了IFormattable接口，以支持字符串的不同變體；還實現了IComparable<Racer>接口，它根據Lastname為一組賽車手排序。為了演示更高級的查詢，Racer類還定義了多值屬性，如Cars和Years。Years屬性列出了賽車手獲得冠軍的年份（車手可以多次獲得冠軍）。Cars屬性列出了賽車手在獲得冠軍的年份中使用的所有車型：

    //這是一個賽車手
    public class Racer:IComparable<Racer>,IFormattable
    {
        public string FirstName { get; }
        public string LastName { get; } 
        public string Country { get; }  
        public int Starts { get; }      
        public int Wins { get; }        
        public object Years { get; }       //包含車手獲得冠軍的年份（可以多次獲得冠軍）
        public object Cars { get; }       //車手獲得冠軍年份中使用的車型。參加不同比賽，使用的車型可能不一樣

        public Racer(string firstName,string lastName,string country,int starts,int wins)
            :this(firstName,lastName,country,starts,wins,null,null){ }

        public Racer(string firstName, string lastName, string country, int starts, int wins, IEnumerable<int> years, IEnumerable<string> cars)
        {
            FirstName = firstName;
            LastName = lastName;
            Country = country;
            Starts = starts;
            Wins = wins;
            Years = years;
            Cars = cars;
        }
        public override string ToString() => $"{FirstName} {LastName}";

        int IComparable<Racer>.CompareTo(Racer other) => FirstName.CompareTo(other?.FirstName);

        public string ToString(string format) => ToString(format, null);

        public string ToString(string format, IFormatProvider formatProvider)
        {
            switch (format)
            {
                case null:
                case "N":
                    return ToString();
                case "F":
                    return FirstName;
                case "L":
                    return LastName;
                case "C":
                    return Country;
                case "S":
                    return Starts.ToString();
                case "W":
                    return Wins.ToString();
                case "A":
                    return $"姓名：{FirstName} {LastName},國家：{Country}; 開始：{Starts}; 獲勝次數：{Wins}";
                default:
                    throw new FormatException($"不支持格式:{format}");
            }
        }
    }

　　2.3、Team類

　　　　這個類僅包含車隊冠軍的名字和獲得冠軍的年份。

    //包含冠軍姓名和獲得冠軍的年份
    public class Team
    {
        public string Name { get; }
        public IEnumerable<int> Years { get; }
        public Team(string name,params int[] years)
        {
            Name = name;
            Years = years != null ? new List<int>(years) : new List<int>();
        }
    }

　　2.4、Formulal類

　　　　該類的GetChampions()方法返回了一組賽車手。GetConstructorChampions()方法返回所有車隊冠軍的列表：

    public static class Formulal
    {
        private static List<Racer> s_racers;

        public static IList<Racer> GetChampions() => s_racers ?? InitalizeRacers();

        private static List<Racer> InitalizeRacers() => new List<Racer>
        {
            new Racer("趙",   "一","中國",22,55,new int[] {1952,1925},     new string[]{ "賓利", "法拉利"}),
            new Racer("武",   "二","美國",22,55,new int[] {1967,1976},     new string[]{ "豐田","奧迪"}),
            new Racer("張",   "三","日本",22,55,new int[] {1974,1947},     new string[]{ "本田","大眾"}),
            new Racer("李",   "四","朝鮮",22,55,new int[] {1951,1915},     new string[]{ "長安","長安"}),
            new Racer("王",   "五","英國",22,55,new int[] {1952,1925},     new string[]{ "奧迪", "馬自達"}),
            new Racer("趙",   "六","德國",22,55,new int[] {1945,1954,2054},new string[]{ "大眾","迪奧"}),
            new Racer("孫",   "七","法國",22,55,new int[] {1928,1982,2082},new string[]{ "長安","特斯拉"}),
            new Racer("王",   "八","瑞典",22,55,new int[] {1989,1998,2098},new string[]{ "奧迪", "賓利"}),
            new Racer("劉",   "九","印度",22,55,new int[] {1986,1968,2068},new string[]{ "大眾","豐田"}),
            new Racer("Marry","sa","韓國",22,55,new int[] {1966,1966,2066},new string[]{ "長安","本田"}),
            new Racer("Jack", "jw","中國",22,55,new int[] {1963,1936,2036},new string[]{ "奧迪", "長安"}),
            new Racer("WC",   "sa","美國",22,55,new int[] {1930,1903,2003},new string[]{ "法拉利", "法拉利"})
        };

        private static List<Team> s_teams;
        public static IList<Team> GetConstructorChampions()
        {
            if(s_racers == null)
            {
                s_teams = new List<Team>()
                {
                    new Team("趙",   1958),
                    new Team("武",   1922,1233,1933),
                    new Team("張",   1932,1941),
                    new Team("李",   1914,1942,1941),
                    new Team("王",   1945),
                    new Team("趙",   1995,1988,1966,1978,1935,1968),
                    new Team("孫",   2015,20145,2058),
                    new Team("王",   2055),
                    new Team("劉",   2001,2015),
                    new Team("Marry",2016,2047),
                    new Team("Jack", 2055,2044),
                    new Team("WC",   2041,2087)
                };
            }
            return s_teams;
        }
    }

　　2.5、LINQ查詢

　　數據准備完畢，下面開始演示LINQ的應用。這是一個控制台應用程序。

　　例如，查詢來自中國的所有冠軍，並按照奪冠次數降序排序：

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

namespace LINQDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            LINQQuery();
            ExtensionMethod();
        }
        /// <summary>
        /// Linq
        /// </summary>
        static void LINQQuery()
        {
            var query = from r in Formulal.GetChampions()
                        where r.Country =="中國"
                        orderby r.Wins descending
                        select r;
            foreach(var r in query)
            {
                Console.WriteLine($"{r:A}");
            }
        }
        static void ExtensionMethod()
        {
            var champions = new List<Racer>(Formulal.GetChampions());
            var champion = champions.Where(r => r.Country == "中國")
                .OrderByDescending(s => s.Wins)
                .Select(c=>c);
            foreach(var r in champion)
            {
                Console.WriteLine($"{r:A}");
            }
        }
    }
}

　　運行結果：

　　

 

 　　其中，LINQQuery()方法實現中主要演示了LINQ查詢的表達式：

            var query = from r in Formulal.GetChampions()
                        where r.Country =="中國"
                        orderby r.Wins descending
                        select r;

　　from、where、orderby、descending和select都是預定義的關鍵字。查詢表達式必須以from子句開頭，以select或者group子句結束。這兩個子句之間，可以使用where、orderby、join、let和其他from子句。

　　注意：變量query只是指定了LINQ查詢，該查詢不是通過這個賦值語句執行的，只要使用foreach循環訪問查詢，該查詢就會執行。

　　ExtensionMethod()方法演示了LINQ的擴展方法的使用。下面重點介紹。

3、擴展方法

　　定義：擴展方法在靜態類中聲明，定義為一個靜態方法，其中第一個參數定義了它擴展的類型。為了區分擴展方法和一般靜態方法，擴展方法需要對第一個參數使用this關鍵字。

　　作用：①擴展方法可以將該方法寫入到類中（該類最初是沒有這個方法的）；②開可以把方法添加到實現了某個特定接口的任何類中，這樣多個類就可以使用相同的實現代碼。

　　例如，String類沒有Foo()方法，並且不能從封閉的類String繼承，但是可以創建一個擴展方法：

static class StringExtension
    {
        public static void Foo(this string s)
        {
            Console.WriteLine($"擴展方法Foo被調用：{s}");
        }
    }

　　使用帶string類型的Foo()方法：

  string s = "haha";
  s.Foo();

　　運行結果：

　　

 

 　　也許這看起來違反了面向對象的規則，因為給一個類型定義了新方法，但沒有改變該類型或它的派生類。但實際上並非如此。擴展方法不能訪問它擴展的類型的私有成員。調用擴展方法只是調用靜態方法的一種新語法。對於上面例子中的字符串，可以使用如下方式調用Foo()方法，會獲得相同的結果：

string s = "haha";
StringExtension.Foo(s);

要調用靜態方法，應在類名的后面加上方法名。擴展方法是調用靜態方法的另一種形式。不必提供靜態方法的類名，相反，編譯器調用靜態方法是因為它帶的參數類型。

上面的例子中，只需要導入包含該類的名稱空間，就可以將Foo()擴展方法放在String類的作用域中。

 

　　LINQ擴展方法

　　編譯器會轉換LINQ查詢，以調用方法而不是LINQ查詢。定義LINQ擴展方法的一個類是System.Linq名稱空間中的Enumeable，它為IEnumerable<T>接口提供了各種擴展方法，以便在實現了該接口的任意集合上使用LINQ。只需要導入這個名稱空間，就可以打開這個類的擴展方法的作用域。

　　下面是Where()擴展方法的實現代碼：

    public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source,Func<TSource,bool> predicate)
    {
        foreach(TSource item in source)
        {
            if (predicate(item))
                yield return item;
        }
    }

　　分析：Where()擴展方法的第一個參數包含了this關鍵字，類型是IEnumerable<T>。這樣Where()方法就可以用於實現了IEnumerable<T>接口的每個類型，例如：數組和List<T>類實現了IEnumerable<T>接口。第二個參數是一個Func(T,bool)委托（引用的是輸入參數類型為T、返回類型為布爾型的方法）。這個謂詞在實現代碼中調用，檢查IEnumerable<T>源中的項是否應該放在結果集合中。如果委托引用了該方法，yield return 語句就將源中的項返回給結果。

　　因為Where()作為一個泛型方法實現，所以它可以用於包含在集合中的任意類型。實現了IEnumerable<T>接口的任意集合都支持它。

　　到現在，就可以使用Enumerable類中的擴展方法Where()、OrderByDescending()和Select()。這些方法都返回IEnumerable<TSource>。通過擴展方法的參數，使用定義了委托參數的實現代碼的匿名方法。

        static void ExtensionMethod()
        {
            var champions = new List<Racer>(Formulal.GetChampions());
            var champion = champions.Where(r => r.Country == "中國")
                .OrderByDescending(s => s.Wins)
                .Select(c=>c);
            foreach(var r in champion)
            {
                Console.WriteLine($"{r:A}");
            }
        }

4、推遲查詢的執行

　　定義查詢表達式時，查詢並不會執行。查詢會在迭代數據項時運行。原因就是擴展方法Where()，它使用yield return返回謂詞為true的元素。這時，編譯器會創建一個枚舉器，在訪問枚舉中的項后，才返回他們。

　　這會導致下面例子中有趣的現象，本例中創建一個string元素的集合，初始化它；然后給集合增加元素：

        static void DeferredQuery()
        {
            var name = new List<string> { "a1", "a2", "b", "c", "d" };
            var nameWithA = from n in name
                            where n.StartsWith("a")
                            orderby n
                            select n;
            foreach (var item in nameWithA)
            {
                Console.WriteLine($"{item}");
            }
            Console.WriteLine("更改數據源后，再次迭代同樣的LINQ語句：");
            name.Add("a3");
            name.Add("a4");
            name.Add("a5");
            foreach (var item in nameWithA)
            {
                Console.WriteLine($"{item}");
            }
        }

 

　　觀察結果，發現每次迭代時，可以檢測出源數據中的變化：　　

　　

 

 　　特殊情況，調用擴展方法ToArray()、ToList()等可以改變上述結果。下面示例中，ToList遍歷集合，返回一個實現了IList<string >的集合。然后對返回的列表遍歷兩次：

        private static void DeferredQueryDemo()
        {
            var name = new List<string> { "a1", "a2", "b", "c", "d" };
            var nameWhithA = (from n in name
                             where n.StartsWith("a")
                             orderby n
                             select n).ToList();
            Console.WriteLine("第一次迭代：");
            foreach(var iten in nameWhithA)
            {
                Console.WriteLine(iten);
            }
            Console.WriteLine("更改數據源后，再次迭代同樣的LINQ語句：");
            name.Add("a3");
            name.Add("a4");
            name.Add("a5");
            foreach (var iten in nameWhithA)
            {
                Console.WriteLine(iten);
            }
        }

 

 　　觀察結果，發現，雖然集合中的元素發生了變化，但是兩次迭代之間的的輸出保持不變：