c#中LINQ的基本用法(二)

2022-04-12 19:00:40

1.篩選

LINQ查詢使用where子句新增條件表示式來篩選，where子句可以合併多個表示式。

var racers = from r in Formula1.GetChampions() 
                    where r.Wins>15 && 
                        (r.Country == "Brazil" || r.Country =="Austria")
                    select r;
                    
        foreach(var r in racers)
        {
            Console.WriteLine("{0:A}", r);
        }

上述LINQ表示式對映為C# LINQ查詢的擴充套件方法：

　　var racers = Formula1.GetChampions().Where(r =>r.Wins>15 &&
　　　　(r.Country == "Brazil" || r.Country =="Austria")).Select(r => r);

注意,並不是所以查詢都可以使用LINQ查詢語法，也不是所有的擴充套件方法都對映到LINQ查詢。高階查詢需要使用擴充套件方法。

2.用索引篩選

不能使用LINQ查詢的一個例子是Where()方法的過載。在WHere()方法的過載中，可以傳遞第二個引數————索引。索引是篩選器返回的每個結果的計數器。可以在表示式中使用這個索引，執行基於索引的計算：

var racers = Formula1.GetChampions().
            Where((r, index) => r.LastName.StartsWith("A") && index % 2 != 0);
        foreach (var r in racers)
        {
            Console.WriteLine("{0:A}", r);
        }

3.型別篩選

為了進行基於型別的篩選，可以使用OfType()擴充套件方法。

object[] data = { "one", 2, 3, "four", "five", 6 };
          var query = data.OfType<string>();
          foreach (var s in query)
          {
            Console.WriteLine(s);
          }

輸出：

　　　　one
　　　　four
　　　　five

從集合僅返回字串。

4.複合的from子句

如果需要根據物件的成員進行篩選，而該成員本身是一個系列，就可以使用複合from子句。例如，LINQ基礎(一)（https://www.jb51.net/article/244208.htm）中的Racer類定義了一個屬性Cars，Cars是一個字串陣列。
篩選駕駛Ferrari的所以冠軍：

var ferrariDrivers = from r in Formula1.GetChampions()
                           from c in r.Cars
                           where c == "Ferrari"
                           orderby r.LastName
                           select r.FirstName + " " + r.LastName;

      foreach (var racer in ferrariDrivers)
      {
        Console.WriteLine(racer);
      }

第一個from子句存取Formula1.GetChampions()方法返回的Racer物件，第二個from子句存取Racer類的Cars屬性，以返回所以sting型別的賽車。
C#編譯器把複合的from子句和LINQ查詢轉換為SelectMany()擴充套件方法。SelectMany()擴充套件方法可以迭代序列中的序列。
SelectMany()的過載版本：

　　public static IEnumerable<TResult> SelectMany<TSource, TCollection, TResult>(this IEnumerable<TSource> source,
　　　　Func<TSource, IEnumerable<TCollection>> collectionSelector,
　　　　　　Func<TSource, TCollection, TResult> resultSelector);

第一個引數是隱式引數，它從Formula1.GetChampions()方法接受Racer物件序列。第二個引數是collectionSelector委託，其中定義了內部序列，是序列的序列,本例子為Cars。第三個引數也是一個委託，為每個Racer物件的Cars屬性的每個元素呼叫這個委託。
這裡Cars是一個字串陣列，會將每個Racer和每個字串作為引數，呼叫這個委託。

var ferrariDrivers = Formula1.GetChampions().SelectMany(
            c => c.Cars, (r, s) => new { Racer=r,Car =s}).Where(
            s =>s.Car == "Ferrari").OrderBy(
            r => r.Racer.LastName).Select(r => r.Racer.FirstName + " " + r.Racer.LastName);

        foreach (var racer in ferrariDrivers)
        {
            Console.WriteLine(racer);
        }

5.排序

要對序列排序，可以使用前面使用過的orderby.也可以使用orderrby descending子句（降序）。

var racers = (from r in Formula1.GetChampions()
                      orderby r.Country  descending
                      select r);

        foreach (var racer in racers)
        {
            Console.WriteLine("{0}: {1}, {2}", racer.Country, racer.LastName, racer.FirstName);
        }

orderby子句解析為OrderBy()方法，orderby r.Country descending解析為OrderByDescending()方法：

　　var racers = Formula1.GetChampions().OrderByDescending(r => r.Country).Select(r=>r);

OrderBy()和OrderByDescending()方法返回IOrderEnumerable<TSource>。這個介面派生自IEnumerable<TSource>介面，但包含一個額外的方法CreateOrderEnumerable<TSource>()方法。這個方法用於進一步給序列排序，可以在最後一個引數指定升序還是降序：

// 摘要:
        //     根據某個鍵對 System.Linq.IOrderedEnumerable<TElement> 的元素執行後續排序。
        //
        // 引數:
        //   keySelector:
        //     用於提取每個元素的鍵的 System.Func<T,TResult>。
        //
        //   comparer:
        //     用於比較鍵在返回序列中的位置的 System.Collections.Generic.IComparer<T>。
        //
        //   descending:
        //     如果為 true，則對元素進行降序排序；如果為 false，則對元素進行升序排序。
        //
        // 型別引數:
        //   TKey:
        //     keySelector 生成的鍵的型別。
        //
        // 返回結果:
        //     一個 System.Linq.IOrderedEnumerable<TElement>，其元素按鍵排序。
        IOrderedEnumerable<TElement> CreateOrderedEnumerable<TKey>(Func<TElement, TKey> keySelector, IComparer<TKey> comparer, bool descending);

例子：

// Create an array of strings to sort.
              string[] fruits = { "apricot", "orange", "banana", "mango", "apple", "grape", "strawberry" };
              // First sort the strings by their length.
              IOrderedEnumerable<string> sortedFruits2 =
                  fruits.OrderBy(fruit => fruit.Length);
              // Secondarily sort the strings alphabetically, using the default comparer.
              IOrderedEnumerable<string> sortedFruits3 =
                  sortedFruits2.CreateOrderedEnumerable<string>(
                      fruit => fruit,
                      Comparer<string>.Default, false);

使用ThenBy和ThenByDescending()方法進行進一步排序，可以新增任意多個：

　　var racers = Formula1.GetChampions().OrderByDescending(r => r.Country).ThenByDescending(
　　　　r => r.LastName).ThenByDescending(r => r.FirstName).Select(r => r);

6.分組

要根據一個關鍵字值對查詢結果分組，可以使用group子句。

// group r by r.Country into g 根據Country屬性組合所有的賽車手，並定義為一個新的集合g，用於存取分組的結果資訊。
        //select子句建立一個帶Country和Count屬性的匿名型別。Country = g.Key Key是r.Country
        var countries = from r in Formula1.GetChampions()
                      group r by r.Country into g
                      orderby g.Count() descending, g.Key
                      where g.Count() >= 2
                      select new
                      {
                        Country = g.Key,
                        Count = g.Count()
                      };
        foreach (var item in countries)
          {
            Console.WriteLine("{0, -10} {1}", item.Country, item.Count);
          }

輸出：

使用擴充套件方法執行相同的操作，把group r by r.Country 子句解析為GroupBy()方法。在GroupBy()方法的宣告中，它返回實現了IGrouping<TKey, TSource>介面的列舉物件。IGrouping<TKey, TSource>介面定義了Key屬性，所以在呼叫了這個方法後，可以存取分組的關鍵字：

　　public static IEnumerable<IGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this IEnumerable<TSource> source,
　　　　Func<TSource, TKey> keySelector);

使用GroupBy方法：

var countries = Formula1.GetChampions().GroupBy(r => r.Country).OrderByDescending(
            g => g.Count()).ThenBy(g => g.Key).Where(g => g.Count() >= 2).Select(
            g=>new
                      {
                          Country = g.Key,
                          Count = g.Count()
                      });

7.對巢狀的物件分組

如果得到的分組的物件需要包含巢狀的序列，就可以改變select子句建立匿名型別。

//返回的物件不僅需要包含國家名和賽車手這兩個屬性，還應包含賽車手集合。
        //使用from r1 in g orderby r1.LastName select r1.FirstName + " " + r1.LastName 內部子句
        var countries = from r in Formula1.GetChampions()
                      group r by r.Country into g
                      orderby g.Count() descending, g.Key
                      where g.Count() >= 2
                      select new
                      {
                        Country = g.Key,
                        Count = g.Count(),
                        Racers = from r1 in g
                                 orderby r1.LastName
                                 select r1.FirstName + " " + r1.LastName
                      };
      foreach (var item in countries)
      {
        Console.WriteLine("{0, -10} {1}", item.Country, item.Count);
        foreach (var name in item.Racers)
        {
          Console.Write("{0}; ", name);
        }
        Console.WriteLine();
      }

8.內連線

使用join子句可以根據特定的條件合併兩個資料來源，但之前要獲得兩個連線的列表。
使用了LINQ基礎(一)（https://www.jb51.net/article/244208.htm）的程式碼

//GetChampions獲得冠軍賽車手
        var racers = from r in Formula1.GetChampions()
                   from y in r.Years
                   select new
                   {
                     Year = y,
                     Name = r.FirstName + " " + r.LastName
                   };
        //GetContructorChampions獲取冠軍車隊
          var teams = from t in Formula1.GetContructorChampions()
                      from y in t.Years
                      select new
                      {
                        Year = y,
                        Name = t.Name
                      };
        //得到每一年獲得冠軍的賽車手和車隊
        //通過join t in teams on r.Year equals t.Year into rt 子句連線兩個資料來源
          var racersAndTeams =
            (from r in racers
             join t in teams on r.Year equals t.Year into rt
             from t in rt.DefaultIfEmpty()
             orderby r.Year
             select new
             {
               Year = r.Year,
               Champion = r.Name,
               Constructor = t == null ? "no constructor championship" : t.Name
             });

          Console.WriteLine("Year  Championtt   Constructor Title");
          foreach (var item in racersAndTeams)
          {
            Console.WriteLine("{0}: {1,-20} {2}",
               item.Year, item.Champion, item.Constructor);
          }

9.左連線

使用內連線返回匹配r.Year equals t.Year的結果。左連線返回左邊資料來源的全部元素，即使在右邊的資料來源中沒有匹配的元素。

var racers = from r in Formula1.GetChampions()
                   from y in r.Years
                   select new
                   {
                     Year = y,
                     Name = r.FirstName + " " + r.LastName
                   };

      var teams = from t in Formula1.GetContructorChampions()
                  from y in t.Years
                  select new
                  {
                    Year = y,
                    Name = t.Name
                  };
        //左連線用join和DefaultIfEmpty方法定義。
        //如果查詢到左側資料來源沒有和右邊資料來源Year相同的結果，使用DefaultIfEmpty方法定義右側的預設值（為空）
      var racersAndTeams =
        (from r in racers
         join t in teams on r.Year equals t.Year into rt
         from t in rt.DefaultIfEmpty()
         orderby r.Year
         select new
         {
           Year = r.Year,
           Champion = r.Name,
           Constructor = t == null ? "no constructor championship" : t.Name
         });

      Console.WriteLine("Year  Championtt   Constructor Title");
      foreach (var item in racersAndTeams)
      {
        Console.WriteLine("{0}: {1,-20} {2}",
           item.Year, item.Champion, item.Constructor);
      }

10.組連線

組連線類似內連線，內連線通過某一項連線兩個資料來源（如 r.Year equals t.Year），組連線使用一組項連線，例如下面的例子，
通過

        new
　　　　{
　　　　　　FirstName = r.FirstName,
　　　　　　LastName = r.LastName
　　　　}
　　　　equals
　　　　new
　　　　{
　　　　　　FirstName = r2.FirstName,
　　　　　　LastName = r2.LastName
　　　　}

連線兩個資料來源

var racers = Formula1.GetChampionships()
        .SelectMany(cs => new List<RacerInfo>()
        {
         new RacerInfo {
           Year = cs.Year,
           Position = 1,
           FirstName = cs.First.FirstName(),
           LastName = cs.First.LastName()        
         },
         new RacerInfo {
           Year = cs.Year,
           Position = 2,
           FirstName = cs.Second.FirstName(),
           LastName = cs.Second.LastName()        
         },
         new RacerInfo {
           Year = cs.Year,
           Position = 3,
           FirstName = cs.Third.FirstName(),
           LastName = cs.Third.LastName()        
         }
       });

      var q = (from r in Formula1.GetChampions()
               join r2 in racers on
               new
               {
                 FirstName = r.FirstName,
                 LastName = r.LastName
               }
               equals
               new
               {
                 FirstName = r2.FirstName,
                 LastName = r2.LastName
               }
               into yearResults
               select new
               {
                 FirstName = r.FirstName,
                 LastName = r.LastName,
                 Wins = r.Wins,
                 Starts = r.Starts,
                 Results = yearResults
               });

      foreach (var r in q)
      {
        Console.WriteLine("{0} {1}", r.FirstName, r.LastName);
        foreach (var results in r.Results)
        {
          Console.WriteLine("{0} {1}", results.Year, results.Position);
        }
      }

11.集合操作

擴充套件方法Distinct()，Union()，Intersect()（獲取交集），Except()都是集合操作。

//獲取同時駕駛Ferrari和駕駛McLaren獲得過冠軍的賽車手
        static void SetOperations()
        {
            //定義一個委託，用來查詢駕駛Ferrari獲得過冠軍的賽車手和駕駛McLaren獲得過冠軍的賽車手
          Func<string, IEnumerable<Racer>> racersByCar =
              car => from r in Formula1.GetChampions()
                     from c in r.Cars
                     where c == car
                     orderby r.LastName
                     select r;

          Console.WriteLine("World champion with Ferrari and McLaren");
          //使用Intersect方法獲取兩個資料來源的交集
          foreach (var racer in racersByCar("Ferrari").Intersect(racersByCar("McLaren")))
          {
            Console.WriteLine(racer);
          }
        }

12.合併

Zip()方法是.NET 4.0新增的，允許用一個為此函數把兩個相關的序列合併為一個。
對於合併，第一個集合中的第一項與第二個集合的第一項合併，第一個集合中的第二項與第二個集合的第二項合併，以此類推。如果兩個序列的項數不同，Zip()方法就會在達到較小集合的末尾時停止。
第一個集合中的元素有一個Name屬性，第二個集合中的元素有LastName和Starts屬性。
在racerNames集合上使用Zip()方法，需要把第二個集合racerNamesAndStarts作為第一個引數。第二個引數是一個委託，它通過引數first接受第一個集合的元素，通過引數second接受第二個集合的元素。其實現程式碼返回一個字串：

var racerNames = from r in Formula1.GetChampions()
                       where r.Country == "Italy"
                       orderby r.Wins descending
                       select new
                       {
                         Name = r.FirstName + " " + r.LastName
                       };

          var racerNamesAndStarts = from r in Formula1.GetChampions()
                                    where r.Country == "Italy"
                                    orderby r.Wins descending
                                    select new
                                    {
                                      LastName = r.LastName,
                                      Starts = r.Starts
                                    };


          var racers = racerNames.Zip(racerNamesAndStarts, (first, second) => first.Name + ", starts: " + second.Starts);
          foreach (var r in racers)
          {
              Console.WriteLine(r);
          }

13.分割區

擴充套件方法Take()和Skip()等的分割區操作可用於分頁。
例如，在第一頁只顯示5個賽車手，下一頁顯示接下來的5個賽車手...
Skip(page * pageSize)方法調到指定索引出，忽略前面的資料。Take(pageSize)方法顯示pageSize條資料

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 in Formula1.GetChampions()
                orderby r.LastName, r.FirstName
                select r.FirstName + " " + r.LastName).
               Skip(page * pageSize).Take(pageSize);

            foreach (var name in racers)
            {
              Console.WriteLine(name);
            }
            Console.WriteLine();
          }

TakeWhile()和SkipWhile()方法，傳遞一個委託，滿足這個條件的資料就提取或跳轉：

　　public static IEnumerable<TSource> SkipWhile<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate);

14.聚合操作符

聚合操作符（如Count(),Sum(),Min(),Max(),Average(),Aggregate()）不返回一個序列，而是返回一個值。
例如，使用Count方法應用於Racer的Years屬性，篩選獲得冠軍次數超過3次的賽車手。因為多次使用r.Years.Count()，所以使用let子句定義了一個變數。

var query = from r in Formula1.GetChampions()
                  let numberYears = r.Years.Count()
                  where numberYears >= 3
                  orderby numberYears descending, r.LastName
                  select new
                  {
                    Name = r.FirstName + " " + r.LastName,
                    TimesChampion = numberYears
                  };

          foreach (var r in query)
          {
            Console.WriteLine("{0} {1}", r.Name, r.TimesChampion);
          }

Aggregate()方法傳遞一個委託，將資料來源中的每個元素作為委託的引數，並使用指定的函數累加。

15.轉換操作符

LINQ基礎(一)（https://www.jb51.net/article/244208.htm）提到，查詢會推遲到迭代資料項時才執行，使用轉換操作符會立即執行查詢，把查詢結果放在陣列，列表和字典中。

//轉換為陣列
        var names = new List<string> { "Nino", "Alberto", "Juan", "Mike", "Phil" };

        var namesWithJ = (from n in names
                         where n.StartsWith("J")
                         orderby n
                         select n).ToList();

轉換為Lookup<TKey,TElement>

//把Car賽車屬性作為鍵，每個鍵關聯多個車手Racer
            var racers = (from r in Formula1.GetChampions()
                      from c in r.Cars
                      select new
                      {
                          Car = c,
                          Racer = r
                          }).ToLookup(cr => cr.Car, cr => cr.Racer);
            foreach (var v in racers)
            {
                Console.Write(v.Key+"........");
                foreach (var k in racers[v.Key])
                {
                    Console.WriteLine(k);
                }
            }

ToLookup(cr => cr.Car, cr => cr.Racer)方法的一個過載版本傳遞一個鍵和一個元素選擇器
如果需要在非型別化的集合上使用LINQ查詢，可以使用Cast()方法，定義強型別化的查詢：

var list = new System.Collections.ArrayList(Formula1.GetChampions() as System.Collections.ICollection);

          var query = from r in list.Cast<Racer>()
                      where r.Country == "USA"
                      orderby r.Wins descending
                      select r;
          foreach (var racer in query)
          {
            Console.WriteLine("{0:A}", racer);
          }

Cast<Racer>()將 System.Collections.IEnumerable 的元素強制轉換為指定的型別。

16.生成操作符

生成操作符Range(),Empty(),Repeat()方法不是擴充套件方法，而是返回序列的正常靜態方法。在LING to Object中，這些方法可用於Enumerable類。
Range()方法用來填充一個範圍的數位。第一個引數作為起始值，第二個引數作為要填充的項數：

　　　　var values = Enumerable.Range(1,20);

結果為1至20的集合。

可以把該結果與其它擴充套件方法合併：

　　　　var values = Enumerable.Range(1,20).Select(n=> n*3);

Empty()方法返回一個不返回值的迭代器，它用於需要一個集合的引數，其中可以給引數傳遞空集合。
Repeat()方法返回指定個數的重複值的集合迭代器。

到此這篇關於c#中LINQ的基本用法的文章就介紹到這了。希望對大家的學習有所幫助，也希望大家多多支援it145.com。