LINQ学习笔记(二)

1、LINQ与泛型

LINQ查询结果一般使用泛型List、或接口IEnumerable存储,其中IEnumerable支持Foreach操作访问每一个元素。

IEnumerable customerQuery =
    from cust in customers
    where cust.City == "London"
    select cust;

foreach (Customer customer in customerQuery)
{
    Console.WriteLine(customer.LastName + ", " + customer.FirstName);
}

2、数据操作

  • 分组

    通过group关键字则可以实现分组。返回的结果为一个有序的列表,列表中每个元素都有相同的关键字key,列表中的元素按照关键字被分组。查询结果时,使用双层foreach,外层循环访问组,内层循环访问组内元素。

var queryCustomersByCity =
      from cust in customers
      group cust by cust.City;

  // customerGroup is an IGrouping
  foreach (var customerGroup in queryCustomersByCity)
  {
      Console.WriteLine(customerGroup.Key);
      foreach (Customer customer in customerGroup)
      {
          Console.WriteLine("    {0}", customer.Name);
      }
  }

  • 排序

    通过Orderby则可以实现排序操作,通常为升序,若要降序排列则使用orderby...descending

var queryLondonCustomers3 =
    from cust in customers
    where cust.City == "London"
    orderby cust.Name ascending
    select cust;

3、使用LINQ进行数据转换

  • 将多个输入连接到一个输出序列中

class Student
{
    public string First { get; set; }
    public string Last {get; set;}
    public int ID { get; set; }
    public string Street { get; set; }
    public string City { get; set; }
    public List<int> Scores;
}

class Teacher
{
    public string First { get; set; }
    public string Last { get; set; }
    public int ID { get; set; }
    public string City { get; set; }
}
class DataTransformations
{
    static void Main()
    {
        // Create the first data source.
        List students = new List()
        {
            new Student {First="Svetlana",
                Last="Omelchenko",
                ID=111,
                Street="123 Main Street",
                City="Seattle",
                Scores= new List<int> {97, 92, 81, 60}},
            new Student {First="Claire",
                Last="O’Donnell",
                ID=112,
                Street="124 Main Street",
                City="Redmond",
                Scores= new List<int> {75, 84, 91, 39}},
            new Student {First="Sven",
                Last="Mortensen",
                ID=113,
                Street="125 Main Street",
                City="Lake City",
                Scores= new List<int> {88, 94, 65, 91}},
        };

        // Create the second data source.
        List teachers = new List()
        {               
            new Teacher {First="Ann", Last="Beebe", ID=945, City = "Seattle"},
            new Teacher {First="Alex", Last="Robinson", ID=956, City = "Redmond"},
            new Teacher {First="Michiyo", Last="Sato", ID=972, City = "Tacoma"}
        };
       
        // Create the query.
        var peopleInSeattle = (from student in students
                    where student.City == "Seattle"
                    select student.Last)
                    .Concat(from teacher in teachers
                            where teacher.City == "Seattle"
                            select teacher.Last);

        Console.WriteLine("The following students and teachers live in Seattle:");
        // Execute the query.
        foreach (var person in peopleInSeattle)
        {
            Console.WriteLine(person);
        }
       
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }
}
/* Output:
    The following students and teachers live in Seattle:
    Omelchenko
    Beebe
*/

  • 选择元素的子集

    选择元素的一个成员

r query = from cust in Customers 
            select cust.City; 

选择元素的多个成员

  var query = from cust in Customer 
            select new {Name = cust.Name, City = cust.City}; 

  • 将内存中对象转换为XML

    LINQ 查询可以方便地在内存中数据结构、SQL 数据库、ADO.NET 数据集和 XML 流或文档之间转换数据。

class XMLTransform
{
    static void Main()
    {           
        // Create the data source by using a collection initializer.
        // The Student class was defined previously in this topic.
        List students = new List()
        {
            new Student {First="Svetlana", Last="Omelchenko", ID=111, Scores = new List<int>{97, 92, 81, 60}},
            new Student {First="Claire", Last="O’Donnell", ID=112, Scores = new List<int>{75, 84, 91, 39}},
            new Student {First="Sven", Last="Mortensen", ID=113, Scores = new List<int>{88, 94, 65, 91}},
        };

        // Create the query.
        var studentsToXML = new XElement("Root",
            from student in students
            let x = String.Format("{0},{1},{2},{3}", student.Scores[0],
                    student.Scores[1], student.Scores[2], student.Scores[3])
            select new XElement("student",
                       new XElement("First", student.First),
                       new XElement("Last", student.Last),
                       new XElement("Scores", x)
                    ) // end "student"
                ); // end "Root"

        // Execute the query.
        Console.WriteLine(studentsToXML);

        // Keep the console open in debug mode.
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }
}

XML输出结果
<Root> <student> 
    <First>SvetlanaFirst> 
    <Last>OmelchenkoLast> 
    <Scores>97,92,81,60Scores> 
  student> 
  <student> 
    <First>ClaireFirst> 
    <Last>O'DonnellLast> 
    <Scores>75,84,91,39Scores> 
  student> 
  <student> 
    <First>SvenFirst> 
    <Last>MortensenLast> 
    <Scores>88,94,65,91Scores> 
  student> 
Root> 

  • 对源元素进行操作

    返回的结果不一定是源元素或者源元素的子集,也可能是源元素或源元素子集的计算结果。

class FormatQuery
{
    static void Main()
    {           
        // Data source.
        double[] radii = { 1, 2, 3 };

        // Query.
        IEnumerable<string> query =
            from rad in radii
            select String.Format("Area = {0}", (rad * rad) * 3.14);

        // Query execution.
        foreach (string s in query)
            Console.WriteLine(s);

        // Keep the console open in debug mode.
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }
}
/* Output:
    Area = 3.14
    Area = 12.56
    Area = 28.26
*/

  • 你好

 

 


 

你可能感兴趣的:(LINQ学习笔记(二))