Linq学习总结（5）——标准查询运算符

筛选信息

在Linq中可以通过两种方法筛选信息，where和OfType。Where子句大家应该都很熟，OfType是用于筛选能够转换为特定类型的值。

static void Main(string[] args)
   {
    Object[] objects = new Object[] { 123, "hello", 67.5f, 7M, "six", 89, true };
    var intArray = objects.OfType<int>();

    foreach (var item in intArray)
    {
        Console.WriteLine(item);
    }
    /*Output
     * 123
     * 89
     */
    }

限定符

限定符All、Any、Contains都是扩展方法，他们返回一个布尔值，指示集合中的部分或者全部元素是否满足限定符的参数条件。All判断是否每个成员都满足条件。Any返回一个布尔值，指示是否有满足条件的成员。Contains用于查询符合条件的单个元素。

class Program
{
    static void Main(string[] args)
    {
       
        var persons = new List<Person>{new Person{Name="Jack",Gender="Male",Age="32"}
            ,new Person{Name="Chris",Gender="Male",Age="27"}
            ,new Person{Name="Paul",Gender="Male",Age="25"}
        };

        bool anyJack = persons.Any(m => m.Name == "Jack");
        Console.WriteLine("是否有人叫Jack：{0}",anyJack);
        bool allMale = persons.All(m => m.Gender == "Male");
        Console.WriteLine("是否都是男性：{0}",allMale);
       /*Output
        * 是否有人叫Jack：true
        * 是否都是男性：true
        */

    }
}

class Person
{
    public String Name { get; set; }
    public String Gender { get; set; }
    public String Age { get; set; }

    public override string ToString()
    {
        return string.Format("Name={0},Gender={1},Age={2}", Name, Gender, Age);
    }
}

分区操作

Skip、skipWhile、Take和TakeWhile用于将集合拆分成两个部分并返回其中的一个。Skip会根据你输入的整数参数跳到相应的位置，并返回之后的所有元素；SkipWhile会根据你输入的条件，跳到直到你第一个输入条件为假的元素位置，并返回之后的所有元素；Take会返回你指定位置之前的 所有元素；TakeWhile会跳到直到你第一个输入条件为假的元素位置，并返回之前的所有元素。

static void Main(string[] args)
{
      int[] ints = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

     var result1 = ints.Take(5);
     Array.ForEach(result1.ToArray(), n => Console.Write(string.Format("{0} ", n)));
       Console.WriteLine();

       var result2 = ints.Skip(5);
      Array.ForEach(result2.ToArray(), n => Console.Write(string.Format("{0} ", n)));
     Console.WriteLine();

     var result3 = ints.TakeWhile(n => n < 5);
     Array.ForEach(result3.ToArray(), n => Console.Write(string.Format("{0} ", n)));
     Console.WriteLine();

     var result4 = ints.SkipWhile(n => n < 5);
     Array.ForEach(result4.ToArray(), n => Console.Write(string.Format("{0} ", n)));
     Console.WriteLine();

    /*Output
     * 1 2 3 4 5
     * 6 7 8 9 10
     * 1 2 3 4
     * 5 6 7 8 9 10
     */
}

生成运算

生成运算有DefaultIfEmpty、Empty、Range以及Repeat。

DefaultIfEmpty在一个序列为空时，生成单一序列的默认值；如果序列不为空，则直接返回序列。这个方法在联接查询中很有用。

static void Main(string[] args)
{
    List<int> numbers = new List<int>();
    Console.WriteLine(numbers.Count);
    var defalutNumbers = numbers.DefaultIfEmpty();
    Console.WriteLine(defalutNumbers.Count());
    /*Output
     * 0
     * 1
     */ 
}

Empty会根据传入的参数生成一个空的序列。

static void Main(string[] args)
{
    var empties = Enumerable.Empty<int>();

    Console.WriteLine(empties.Count());
    /*Output
     * 0
     */
}

Range会生成指定范围的数列，它有两个参数，第一个参数为序列中第一个数的值，第二个参数为生成数列的个数。

static void Main(string[] args)
{
   var numbers = Enumerable.Range(0, 10);
   foreach (var item in numbers)
   {
       Console.WriteLine(item);
   }
   /*Output
    * 0
    * 1
    * 2
    * 3
    * 4
    * 5
    * 6
    * 7
    * 8
    * 9
    */
}

Repeat用来生成一个重复的数列。

static void Main(string[] args)
{
    var repeatStr = Enumerable.Repeat<String>("Jim", 10);
    foreach (var item in repeatStr)
    {
        Console.WriteLine(item);
    }
    //输出十行Jim
}

相等性操作

SequenceEqual和Except可以用来比较数列的相等性和计算差集。

static void Main(string[] args)
{
    int[] nums1 = { 1, 2, 3 };
    int[] nums2 = { 1, 2, 3 };
    int[] nums3 = { 1, 2, 3, 4, 5 };

    Console.WriteLine(nums1.SequenceEqual(nums2));
    Console.WriteLine(nums1.SequenceEqual(nums3));

    var exceptNums = nums3.Except(nums1);
    foreach (var item in exceptNums)
    {
        Console.WriteLine(item);
    }
    /*Output
     * Ture
     * False
     * 4
     * 5
     */ 
}

获取指定元素操作

获取指定元素操作方法有：ElementAt、ElementAtOrDefault、Frist、FristOfDefault、Last、LastOrDefault、Single以及SingleOrDefault。

ElementAt返回序列中的指定的元素。ElementAtOrDefault返回序列中指定元素，如果超出序列范围，则返回该类型的默认值。Frist返回序列中的第一个元素。FristOfDefault返回序列中满足条件的第一个元素，没有则返回一个默认值。Last和LastOfDefault方法与Frist和FirstOfDefault一样，不过是返回最后一个。Single是返回集合中的唯一条件。SingleOrDefault则返回序列中满足条件的唯一值，如果没有则返回默认值。

static void Main(string[] args)
{
    var numbers = Enumerable.Range(0, 9);

    //elementAt
    var elemnt = numbers.ElementAt(5);
    Console.WriteLine("Element at 5 is {0}",elemnt);

    //elementOrDefault
    var elemntOrDefault = numbers.ElementAtOrDefault(11);
    Console.WriteLine("Element at 11 or default is {0}",elemntOrDefault);

    //frist
    var fristNumber = numbers.First();
    Console.WriteLine("Frist:{0}",fristNumber);

    //fristOrDefault
    var fristOrDefault = numbers.FirstOrDefault(n => n > 10);
    Console.WriteLine("Frist Or Default",fristOrDefault);

    //single
    var single = numbers.Single(n => n == 5);
    Console.WriteLine("Single:{0}",single);

    //singleOrDefault
    var singleOrDefault = numbers.SingleOrDefault(n => n == 11);
    Console.WriteLine("Single or default:{0}",singleOrDefault);

}

串联序列

Conect将一个序列附加到另一个序列上。

static void Main(string[] args)
{
      var fristNumbers = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    var secondNumbers = new int[] { 10,11,12,13,14,15,16,17,18,19};

    var conectNumbers = fristNumbers.Concat(secondNumbers);

    foreach (var item in conectNumbers)
    {
        Console.WriteLine(item);
    }

}