首页 / C# / Linq 常用方法解释
Linq 常用方法解释
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了Linq 常用方法解释，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含12199字，纯文字阅读大概需要18分钟。
内容图文
///
<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>publicstaticvoid Aggregate2()
{
// 1+2+3+4+5var 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>publicstaticvoid Aggregate3()
{
// 1+2+3+4+5var 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>publicstaticvoid All()
{
var list = Book.Books;
// 这个集合中是否 所有的页数都大于200页 如果都大于则返回true否则返回 falsevar result = list.All(item => item.PageCount > 100);
}
///<summary>/// 确定序列是否包含任何元素
///</summary>publicstaticvoid Any()
{
var list = Book.Books;
// 这个集合是否有元素 如果存在则有true 否则 返回falsevar result = list.Any();
}
///<summary>/// 确定序列是否包含任何元素
///</summary>publicstaticvoid Any1()
{
var list = Book.Books;
// 这个集合中是否 包含的页数大于200页的元素 如果包含则返回true否则返回 falsevar result = list.Any(item => item.PageCount > 200);
}
///<summary>/// 计算可以为 null 的 System.Decimal 值序列的平均值。
///</summary>publicstaticvoid 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>publicstaticvoid Average2()
{
var list = Book.Books;
// 求平均页数var result = list.Average(item => item.PageCount);
}
///<summary>/// 将 System.Collections.IEnumerable 的元素强制转换为指定的类型
///</summary>publicstaticvoid 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>publicstaticvoid 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>publicstaticvoid Contains()
{
IEnumerable<int> a = new List<int> { 1, 1, 2, 3, 4 };
// 序列是否包含 元素3bool rel = a.Contains(3);
var list = Book.Books;
// 使用自定义比较器bool rel1 = list.Contains(new Book { Title = "C#" }, new BookEqualityComparer());
}
///<summary>/// 返回序列中的元素数量。
///</summary>publicstaticvoid Count()
{
var list = Book.Books;
var count = list.Count();
var count1 = list.Count(item => item.Title == "C#");
}
///<summary>/// 返回指定序列的元素；如果序列为空，则返回单一实例集合中的类型参数的默认值。
///</summary>publicstaticvoid DefaultIfEmpty()
{
IEnumerable<Book> list = new List<Book>();
var rek = list.DefaultIfEmpty();
var rek1 = list.DefaultIfEmpty(new Book { Title = "VV" });
}
///<summary>/// 去除重复
///</summary>publicstaticvoid Distinct()
{
IEnumerable<int> a = new List<int> { 1, 1, 2, 3, 4 };
var rel = a.Distinct();
}
///<summary>/// 返回序列中指定索引处的元素。
///</summary>publicstaticvoid ElementAt()
{
IEnumerable<int> a = new List<int> { 1, 1, 2, 3, 4 };
// 返回索引为3的元素var rel = a.ElementAt(3);
// 返回序列中指定索引处的元素；如果索引超出范围，则返回默认值。
// int类型的默认值 则为0var rel1 = a.ElementAtOrDefault(50);
}
///<summary>/// 返回元素第一个元素
///</summary>publicstaticvoid 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>publicstaticvoid GroupBy()
{
var list = Book.Books;
// 计数var q = from p in list
group p by p.Title into g
selectnew
{
g.Key,
NumProducts = g.Count()
};
// 带条件计数var q1 = from p in list
group p by p.Title into g
selectnew
{
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() >= 10selectnew
{
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 selectnew { g.Key, g };
// 表达式(Expression)var categories1 = from p in list group p by new { Criterion = p.PageCount > 10 } into g select g;
}
///<summary>/// 排序
///</summary>publicstaticvoid 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>publicstaticvoid Select()
{
var list = Book.Books;
// 投影一个新的集合varselect = list.Select(item => new { T = item.Title });
// 投影一个待索引的集合var select1 = list.Select((item, index) => new { I = index });
}
///<summary>/// 将序列的每个元素投影并将结果序列合并为一个序列。
///</summary>publicstaticvoid 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>publicstaticvoid 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>publicstaticvoid Where()
{
var list = Book.Books;
// 页码大于2000页的var rel = list.Where(w => w.PageCount > 2000);
// 页码大于2000页的 并且索引大于2var rel1 = list.Where((a, b) => a.PageCount > 2000 && b > 2);
}
///<summary>/// 比较器
///</summary>publicclass 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>publicint Compare(string x, string y)
{
if (x.Length > y.Length)
{
return1;
}
elseif (x.Length < y.Length)
{
return -1;
}
return0;
}
}
///<summary>/// 书籍比较器
///</summary>publicclass BookEqualityComparer : IEqualityComparer<Book>
{
///<summary>/// 比较器
///</summary>///<param name="x">x</param>///<param name="y">y</param>///<returns>结果</returns>publicbool Equals(Book x, Book y)
{
return x.Title == y.Title;
}
///<summary>/// GetHashCode
///</summary>///<param name="obj">obj</param>///<returns>HashCode</returns>publicint GetHashCode(Book obj)
{
return obj.Title.GetHashCode();
}
}
///<summary>/// 获取一个值的集合
///</summary>///<param name="max">最大值</param>///<returns>一个值的集合</returns>publicstatic 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>publicclass Book
{
///<summary>/// 标题
///</summary>publicstring Title { get; set; }
///<summary>/// 页数
///</summary>publicint PageCount { get; set; }
///<summary>/// 默认的书籍集合
///</summary>publicstatic IEnumerable<Book> Books
{
get
{
returnnew 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>publicclass School
{
///<summary>/// m_Classes
///</summary>private IList<Class> classes = new List<Class>();
///<summary>/// Classes
///</summary>internal IList<Class> Classes
{
get { returnthis.classes; }
set { this.classes = value; }
}
}
///<summary>/// class
///</summary>publicclass Class
{
///<summary>/// m_Students
///</summary>private IList<Student> students = new List<Student>();
///<summary>/// Students
///</summary>internal IList<Student> Students
{
get { returnthis.students; }
set { this.students = value; }
}
}
///<summary>/// 学生
///</summary>publicclass 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>publicstring Name { get; set; }
///<summary>/// 性别
///</summary>publicint Sex { get; set; }
}
}
原文：http://www.cnblogs.com/liuxiaoji/p/4616466.html
内容总结
以上是互联网集市为您收集整理的Linq 常用方法解释全部内容，希望文章能够帮你解决Linq 常用方法解释所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。
来源：【匿名】