C# LINQ标准查询操作符

首先添加数据集合

 [Serializable]
     public class Racer : IComparable<Racer>, IFormattable
     {
         public Racer()
         { }
         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)
         {
             this.FirstName = firstName;
             this.LastName = lastName;
             this.Country = country;
             this.Starts = starts;
             this.Wins = wins;
             this.Years = new List<int>(years);
             this.Cars = new List<string>(cars);
         }
         public string FirstName { get; set; }
         public string LastName { get; set; }
         public string Country { get; set; }
         public int Wins { get; set; }
         public int Starts { get; set; }
         public IEnumerable<string> Cars { get; private set; }
         public IEnumerable<int> Years { get; private set; }

         public override string ToString()
         {
             return String.Format("{0} {1}", FirstName, LastName);
         }

         public int CompareTo(Racer other)
         {
             if (other == null) return -;
             return string.Compare(this.LastName, other.LastName);
         }

         public string ToString(string format)
         {
             return 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 String.Format("{0} {1}, {2}; starts: {3}, wins: {4}",
                           FirstName, LastName, Country, Starts, Wins);
                 default:
                     throw new FormatException(String.Format("Format {0} not supported", format));
             }
         }
     }

  private static List<Racer> racers;

     public static IList<Racer> GetChampions()
     {
       if (racers == null)
       {
         racers = new List<Racer>();
         racers.Add(new Racer("Nino", "Farina", "Italy", , , new int[] {  }, new string[] { "Alfa Romeo" }));
         racers.Add(new Racer("Alberto", "Ascari", "Italy", , , new int[] { ,  }, new string[] { "Ferrari" }));
         racers.Add(new Racer("Juan Manuel", "Fangio", "Argentina", , , new int[] { , , , ,  }, new string[] { "Alfa Romeo", "Maserati", "Mercedes", "Ferrari" }));
         racers.Add(new Racer("Mike", "Hawthorn", "UK", , , new int[] {  }, new string[] { "Ferrari" }));
         racers.Add(new Racer("Phil", "Hill", "USA", , , new int[] {  }, new string[] { "Ferrari" }));
         racers.Add(new Racer("John", "Surtees", "UK", , , new int[] {  }, new string[] { "Ferrari" }));
         racers.Add(new Racer("Jim", "Clark", "UK", , , new int[] { ,  }, new string[] { "Lotus" }));
         racers.Add(new Racer("Jack", "Brabham", "Australia", , , new int[] { , ,  }, new string[] { "Cooper", "Brabham" }));
         racers.Add(new Racer("Denny", "Hulme", "New Zealand", , , new int[] {  }, new string[] { "Brabham" }));
         racers.Add(new Racer("Graham", "Hill", "UK", , , new int[] { ,  }, new string[] { "BRM", "Lotus" }));
         racers.Add(new Racer("Jochen", "Rindt", "Austria", , , new int[] {  }, new string[] { "Lotus" }));
         racers.Add(new Racer("Jackie", "Stewart", "UK", , , new int[] { , ,  }, new string[] { "Matra", "Tyrrell" }));
         racers.Add(new Racer("Emerson", "Fittipaldi", "Brazil", , , new int[] { ,  }, new string[] { "Lotus", "McLaren" }));
         racers.Add(new Racer("James", "Hunt", "UK", , , new int[] {  }, new string[] { "McLaren" }));
         racers.Add(new Racer("Mario", "Andretti", "USA", , , new int[] {  }, new string[] { "Lotus" }));
         racers.Add(new Racer("Jody", "Scheckter", "South Africa", , , new int[] {  }, new string[] { "Ferrari" }));
         racers.Add(new Racer("Alan", "Jones", "Australia", , , new int[] {  }, new string[] { "Williams" }));
         racers.Add(new Racer("Keke", "Rosberg", "Finland", , , new int[] {  }, new string[] { "Williams" }));
         racers.Add(new Racer("Niki", "Lauda", "Austria", , , new int[] { , ,  }, new string[] { "Ferrari", "McLaren" }));
         racers.Add(new Racer("Nelson", "Piquet", "Brazil", , , new int[] { , ,  }, new string[] { "Brabham", "Williams" }));
         racers.Add(new Racer("Ayrton", "Senna", "Brazil", , , new int[] { , ,  }, new string[] { "McLaren" }));
         racers.Add(new Racer("Nigel", "Mansell", "UK", , , new int[] {  }, new string[] { "Williams" }));
         racers.Add(new Racer("Alain", "Prost", "France", , , new int[] { , , ,  }, new string[] { "McLaren", "Williams" }));
         racers.Add(new Racer("Damon", "Hill", "UK", , , new int[] {  }, new string[] { "Williams" }));
         racers.Add(new Racer("Jacques", "Villeneuve", "Canada", , , new int[] {  }, new string[] { "Williams" }));
         racers.Add(new Racer("Mika", "Hakkinen", "Finland", , , new int[] { ,  }, new string[] { "McLaren" }));
         racers.Add(new Racer("Michael", "Schumacher", "Germany", , , new int[] { , , , , , ,  }, new string[] { "Benetton", "Ferrari" }));
         racers.Add(new Racer("Fernando", "Alonso", "Spain", , , new int[] { ,  }, new string[] { "Renault" }));
         racers.Add(new Racer("Kimi", "Räikkönen", "Finland", , , new int[] {  }, new string[] { "Ferrari" }));
         racers.Add(new Racer("Lewis", "Hamilton", "UK", , , new int[] {  }, new string[] { "McLaren" }));
         racers.Add(new Racer("Jenson", "Button", "UK", , , new int[] {  }, new string[] { "Brawn GP" }));
         racers.Add(new Racer("Sebastian", "Vettel", "Germany", , , new int[] { ,  }, new string[] { "Red Bull Racing" }));
       }

       return racers;
     }

1、where子句

 var racers = from r in Formula1.GetChampions()
                          where r.Wins >  && (r.Country == "Brazil" || r.Country == "Austria")
                          select r;
 var item = Formula1.GetChampions().Where(p => p.Wins >  && (p.Country == "Brazil" || p.Country == "Austria")).Select(r => r);

2、根据索引筛选

     var racers = Formula1.GetChampions().
                     Where((r, index) => r.LastName.StartsWith("A") && index %  != );

3、类型筛选

  object[] data = { "one", , , "four", "five",  };
  var query = data.OfType<string>();

4、复合的from子句

          var ferrariDrivers = from r in Formula1.GetChampions()
                                  from c in r.Cars
                                  where c == "Ferrari"
                                  orderby r.LastName
                                  select r.FirstName + " " + r.LastName;
             var item = 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);

5、排序

 var racers = from r in Formula1.GetChampions()
                          where r.Country == "Brazil"
                          orderby r.Wins descending
                          select r;
 var racers2= from r in Formula1.GetChampions()
                          orderby r.Country,r.LastName,r.FirstName
                          select r;
 var racers3 = Formula1.GetChampions().OrderBy(r => r.Country).ThenBy(r => r.LastName).ThenBy(r => r.FirstName);

6、分组

 var countries = from r in Formula1.GetChampions()
                             group r by r.Country into g
                             orderby g.Count() descending, g.Key
                             where g.Count() >=
                             select new { Country = g.Key, Count = g.Count() };

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

7、内链接

   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
                         };

8、左连接

  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
                }).Take();

9、zip 合并

  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);

10、聚合函数

  var query = from r in Formula1.GetChampions()
                         let numberYears = r.Years.Count()

                         where numberYears >=
                         orderby numberYears descending, r.LastName
                         select new
                         {
                             Name = r.FirstName + " " + r.LastName,
                             TimesChampion = numberYears
                         };

  var countries = (from c in
                                  from r in Formula1.GetChampions()
                                  group r by r.Country into c
                                  select new
                                  {
                                      Country = c.Key,
                                      Wins = (from r1 in c
                                              select r1.Wins).Sum()
                                  }
                              orderby c.Wins descending, c.Country
                              select c).Take();