Linq 常用方法解释

/// <summary>
/// linq
/// </summary>
public class Linq
{
/// <summary>
/// 测试
/// </summary>
public static void Test()
{
Aggregate1();
Aggregate2();
Aggregate3();
All();
Any();
Any1();
Average1();
Cast();
Concat();
Contains();
DefaultIfEmpty();
Distinct();
ElementAt();
First();
OrderBy();
Select();
SelectMany();
Skip();
Where();
}

/// <summary>
/// 对序列应用累加器函数。
/// </summary>
public static void Aggregate1()
{
// 1+2+3+4+5
var numbers = GetArray(5);
var result = numbers.Aggregate<int>((a, b) => a + b);
Console.WriteLine("和为:{0}", result);
/*
* Aggregate 接收一个 Func<TSource, TSource, TSource> func 参数
* 要对每个元素调用的累加器函数
* 累加器的最终值
* 所以1-5的最终累加结果为15
* 如果在1-5累加的时候 需要首先加个5怎么办 见 Aggregate2()
*/
}

/// <summary>
///  对序列应用累加器函数。 将指定的种子值用作累加器初始值。
/// </summary>
public static void Aggregate2()
{
// 1+2+3+4+5
var numbers = GetArray(5);
var result = numbers.Aggregate<int, int>(5, (a, b) => a + b);
Console.WriteLine("和为:{0}", result);
/*
* Aggregate 接收2个参数 TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> func
* seed 累加器的初始值
* func 要对每个元素调用的累加器函数
* 累加器的最终值
* 所以1-5的最终累加结果为20 因为累加的初始值是5
* 如果要对最终结果 在-2 怎么处理呢 Aggregate3()
*/
}

/// <summary>
///  对序列应用累加器函数。 将指定的种子值用作累加器初始值。
/// </summary>
public static void Aggregate3()
{
// 1+2+3+4+5
var numbers = GetArray(5);
var result = numbers.Aggregate<int, int, int>(5, (a, b) => a + b, rel => rel - 2);
Console.WriteLine("和为:{0}", result);
/*
* Aggregate 接收3个参数 TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> func, Func<TAccumulate, TResult> resultSelector
* seed 累加器的初始值
* func 要对每个元素调用的累加器函数
* resultSelector 结果处理
* 累加器的最终值
* 所以1-5的最终累加结果为18 因为累加的初始值是5 并且最终几个会 -2
*
*/
}

/// <summary>
/// 确定序列中的所有元素是否满足条件
/// </summary>
public static void All()
{
var list = Book.Books;

// 这个集合中是否 所有的页数都大于200页 如果都大于则返回true否则返回 false
var result = list.All(item => item.PageCount > 100);
}

/// <summary>
/// 确定序列是否包含任何元素
/// </summary>
public static void Any()
{
var list = Book.Books;

// 这个集合是否有元素 如果存在则有true 否则 返回false
var result = list.Any();
}

/// <summary>
/// 确定序列是否包含任何元素
/// </summary>
public static void Any1()
{
var list = Book.Books;

// 这个集合中是否 包含的页数大于200页的元素 如果包含则返回true否则返回 false
var result = list.Any(item => item.PageCount > 200);
}

/// <summary>
/// 计算可以为 null 的 System.Decimal 值序列的平均值。
/// </summary>
public static void Average1()
{
var numbers = GetArray(5);

// 平均值
var result = numbers.Average();

// 最大值
var rel = numbers.Max();

// 最小值
var rel1 = numbers.Min();

// 求和
var rel2 = numbers.Sum();

var list = Book.Books;
}

/// <summary>
/// 计算序列的平均值。
/// </summary>
public static void Average2()
{
var list = Book.Books;

// 求平均页数
var result = list.Average(item => item.PageCount);
}

/// <summary>
/// 将 System.Collections.IEnumerable 的元素强制转换为指定的类型
/// </summary>
public static void Cast()
{
// 首先创建一个以前版本的集合
ArrayList arraylist = new ArrayList();

// 原本希望在这里初始化，但是这个初始化功能不支持以前的版本
arraylist.Add("111");
arraylist.Add("222333");
arraylist.Add("333333333");
arraylist.Add("xxxxxxxxx");

// 数据类型不一直的时候 Cast会抛出异常OfType 则会返回一个空序列
// IEnumerable<int> lists = arraylist.Cast<int>();
IEnumerable<int> lists = arraylist.OfType<int>();
foreach (int list in lists)
{
Console.WriteLine(list);
}
}

/*Concat/Union/Intersect/Except操作*/
/*
* 连接操作
* Concat  :连连接两个序列
* Union  : 通过使用默认的相等比较器生成两个序列的并集
* Intersect : 通过使用默认的相等比较器对值进行比较生成两个序列的交集
* Except : 排除相交项；延迟。即是从某集合中删除与另一个集合中相同的项。先遍历第一个集合，找出所有唯一的元素，然后再遍历第二个集合，返回第二个集合中所有未出现在前面所得元素集合中的元素
*/

/// <summary>
/// 连连接两个序列
/// </summary>
public static void Concat()
{
// 假设有两序列：
var a = new List<int> { 1, 1, 2, 3, 4 };
var b = new List<int> { 4, 5, 5, 6, 7 };
/*
* 那么A.Concat(B) 表示将A序列和B序列串联起来，以创建新的序列，不去除重复部分;
* A.Union(B)表示将A序列和B序列串联起来，并去除重复部分，以创建新的序列;
* 而A.Intersect(B) 只取A序列和B序列相同的部分(交集)，以创建新的序列。
* Except则是差集
*/
var concat = a.Concat(b).ToList();
var union = a.Union(b).ToList();
var intersect = a.Intersect(b).ToList();
var except = a.Except(b).ToList();
}

/// <summary>
/// 通过使用默认的相等比较器确定序列是否包含指定的元素
/// </summary>
public static void Contains()
{
IEnumerable<int> a = new List<int> { 1, 1, 2, 3, 4 };

// 序列是否包含 元素3
bool rel = a.Contains(3);

var list = Book.Books;

// 使用自定义比较器
bool rel1 = list.Contains(new Book { Title = "C#" }, new BookEqualityComparer());
}

/// <summary>
/// 返回序列中的元素数量。
/// </summary>
public static void Count()
{
var list = Book.Books;
var count = list.Count();
var count1 = list.Count(item => item.Title == "C#");
}

/// <summary>
/// 返回指定序列的元素；如果序列为空，则返回单一实例集合中的类型参数的默认值。
/// </summary>
public static void DefaultIfEmpty()
{
IEnumerable<Book> list = new List<Book>();
var rek = list.DefaultIfEmpty();
var rek1 = list.DefaultIfEmpty(new Book { Title = "VV" });
}

/// <summary>
/// 去除重复
/// </summary>
public static void Distinct()
{
IEnumerable<int> a = new List<int> { 1, 1, 2, 3, 4 };
var rel = a.Distinct();
}

/// <summary>
/// 返回序列中指定索引处的元素。
/// </summary>
public static void ElementAt()
{
IEnumerable<int> a = new List<int> { 1, 1, 2, 3, 4 };

// 返回索引为3的元素
var rel = a.ElementAt(3);

// 返回序列中指定索引处的元素；如果索引超出范围，则返回默认值。
// int类型的默认值 则为0
var rel1 = a.ElementAtOrDefault(50);
}

/// <summary>
/// 返回元素第一个元素
/// </summary>
public static void First()
{
var a = Book.Books;

// 返回第一个元素 没有元素则报错
var r1 = a.First();

// 返回第一个元素 没有元素则返回默认值
var r2 = a.FirstOrDefault();

// 返回序列的唯一元素；如果该序列并非恰好包含一个元素，则会引发异常
// var r3 = a.Single();

// 返回序列中的唯一元素；如果该序列为空，则返回默认值；如果该序列包含多个元素，此方法将引发异常。
// var r4 = a.SingleOrDefault();

// 返回最后一个元素 没有元素则报错
var r5 = a.Last();

// 返回最后一个元素 没有元素则返回默认值
var r6 = a.LastOrDefault();
}

/// <summary>
/// 分组
/// </summary>
public static void GroupBy()
{
var list = Book.Books;

// 计数
var q = from p in list
group p by p.Title into g
select new
{
g.Key,
NumProducts = g.Count()
};

// 带条件计数
var q1 = from p in list
group p by p.Title into g
select new
{
g.Key,
NumProducts = g.Count(p => p.PageCount > 200)
};

// Where限制
var q2 = from p in list
group p by p.Title into g
where g.Count() >= 10
select new
{
g.Key,
NumProducts = g.Count(p => p.PageCount > 200)
};

// 多列(Multiple Columns)
var categories = from p in list group p by new { p.Title, p.PageCount } into g select new { g.Key, g };

// 表达式(Expression)
var categories1 = from p in list group p by new { Criterion = p.PageCount > 10 } into g select g;
}

/// <summary>
/// 排序
/// </summary>
public static void OrderBy()
{
var list = Book.Books;

// 根据页码升序
var rel1 = list.OrderBy(o => o.PageCount);

// 根据页码+标题升序
var rel11 = list.OrderBy(o => o.PageCount).ThenBy(o => o.Title);

// 根据页码降序
var rel2 = list.OrderByDescending(o => o.PageCount);

// 根据页码+标题降序
var rel22 = list.OrderByDescending(o => o.PageCount).ThenByDescending(o => o.Title);

// 根据标题的长度升序 排序
var rel = list.OrderBy(o => o.Title, new BookComparer()).ToList();
}

/// <summary>
/// 投影
/// </summary>
public static void Select()
{
var list = Book.Books;

// 投影一个新的集合
var select = list.Select(item => new { T = item.Title });

// 投影一个待索引的集合
var select1 = list.Select((item, index) => new { I = index });
}

/// <summary>
/// 将序列的每个元素投影并将结果序列合并为一个序列。
/// </summary>
public static void SelectMany()
{
/*
* 类School下面有一个Class的集合，每个Class下面有有一个Student的集合。每个学生有Name和Sex两个属性。现在需要遍历School下面的所有的学生，当然我们可以用两个嵌套的foreach语句类遍历School下面的所有的Class，然后再用foreach来遍历Class下面的所有的Student，把他们添加到一个List里去。这个场景也是实际编程中经常遇到的。有了Linq我们就可以大大的简化我们的代码：
*/

// 初始化数据
School s = new School();
for (int i = 0; i < 5; i++)
{
s.Classes.Add(new Class());
}
s.Classes[0].Students.Add(new Student(1, "a0"));
s.Classes[1].Students.Add(new Student(1, "b0"));
s.Classes[2].Students.Add(new Student(0, "c0"));
s.Classes[3].Students.Add(new Student(0, "d0"));
s.Classes[4].Students.Add(new Student(0, "e0"));
s.Classes[0].Students.Add(new Student(0, "a1"));
s.Classes[0].Students.Add(new Student(1, "a1"));
s.Classes[0].Students.Add(new Student(1, "a2"));
s.Classes[0].Students.Add(new Student(1, "a3"));
s.Classes[1].Students.Add(new Student(0, "b1"));
s.Classes[2].Students.Add(new Student(0, "c1"));
s.Classes[3].Students.Add(new Student(0, "d1"));

// 取出school下的所有性别是0的student
var x = s.Classes.SelectMany(b => b.Students).Where(i => i.Sex == 0);
foreach (var b in x)
{
Console.WriteLine(b.Name);
}

// 合并
var x1 = s.Classes.SelectMany(b => b.Students, (a, c) => new { a.Students.Count, c.Name });
}

/// <summary>
///  跳过序列中指定数量的元素，然后返回剩余的元素。
/// </summary>
public static void Skip()
{
var list = Book.Books;

// 跳高前2个元素
var rel = list.Skip(2);

// 只要满足指定的条件，就跳过序列中的元素，然后返回剩余元素。
var rel1 = list.SkipWhile(iem => iem.PageCount < 2000).ToList();

// 返回前2个元素
var rel2 = list.Take(2);

// 只要满足指定的条件，就会返回序列的元素。
var rel3 = list.TakeWhile(w => w.PageCount < 2000).ToList();
}

/// <summary>
/// 查询
/// </summary>
public static void Where()
{
var list = Book.Books;

// 页码大于2000页的
var rel = list.Where(w => w.PageCount > 2000);

// 页码大于2000页的 并且索引大于2
var rel1 = list.Where((a, b) => a.PageCount > 2000 && b > 2);
}

/// <summary>
/// 比较器
/// </summary>
public class BookComparer : IComparer<string>
{
/// <summary>
/// 实现
/// </summary>
/// <param name="x">x</param>
/// <param name="y">y</param>
/// <returns>一个有符号整数，指示 x 与 y 的相对值，如下表所示。 值 含义 小于零 x 小于 y。 零 x 等于 y。 大于零 x 大于 y</returns>
public int Compare(string x, string y)
{
if (x.Length > y.Length)
{
return 1;
}
else if (x.Length < y.Length)
{
return -1;
}

return 0;
}
}

/// <summary>
/// 书籍比较器
/// </summary>
public class BookEqualityComparer : IEqualityComparer<Book>
{
/// <summary>
/// 比较器
/// </summary>
/// <param name="x">x</param>
/// <param name="y">y</param>
/// <returns>结果</returns>
public bool Equals(Book x, Book y)
{
return x.Title == y.Title;
}

/// <summary>
/// GetHashCode
/// </summary>
/// <param name="obj">obj</param>
/// <returns>HashCode</returns>
public int GetHashCode(Book obj)
{
return obj.Title.GetHashCode();
}
}

/// <summary>
/// 获取一个值的集合
/// </summary>
/// <param name="max">最大值</param>
/// <returns>一个值的集合</returns>
public static IEnumerable<int> GetArray(int max)
{
List<int> result = new List<int>(max);
for (int i = 0; i < max; i++)
{
result.Add(i + 1);
}
return result;
}

/// <summary>
/// 书籍
/// </summary>
public class Book
{
/// <summary>
/// 标题
/// </summary>
public string Title { get; set; }

/// <summary>
/// 页数
/// </summary>
public int PageCount { get; set; }

/// <summary>
/// 默认的书籍集合
/// </summary>
public static IEnumerable<Book> Books
{
get
{
return new List<Book>
{
new Book { Title = "C#", PageCount = 1200 },
new Book { Title = "MVC", PageCount = 2200 },
new Book { Title = "ASP.NET", PageCount = 12200 },
new Book { Title = "java", PageCount = 1500 },
new Book { Title = "jquery", PageCount = 2140 },
};
}
}
}

/// <summary>
/// 学校
/// </summary>
public class School
{
/// <summary>
/// m_Classes
/// </summary>
private IList<Class> classes = new List<Class>();

/// <summary>
/// Classes
/// </summary>
internal IList<Class> Classes
{
get { return this.classes; }
set { this.classes = value; }
}
}

/// <summary>
/// class
/// </summary>
public class Class
{
/// <summary>
/// m_Students
/// </summary>
private IList<Student> students = new List<Student>();

/// <summary>
/// Students
/// </summary>
internal IList<Student> Students
{
get { return this.students; }
set { this.students = value; }
}
}

/// <summary>
/// 学生
/// </summary>
public class Student
{
/// <summary>
/// Initializes a new instance of the <see cref="Student"/> class.
/// </summary>
/// <param name="i">
/// The i.
/// </param>
/// <param name="name">
/// The name.
/// </param>
public Student(int i, string name)
{
this.Sex = i;
this.Name = name;
}

/// <summary>
/// 姓名
/// </summary>
public string Name { get; set; }

/// <summary>
/// 性别
/// </summary>
public int Sex { get; set; }
}
}