LINQ入门教程之各种标准查询操作符（二）
7． 聚合操作符
8． 集合操作符
9． 生成操作符
#region 生成操作符 即从现有序列的值中创建新的序列
/// <summary>
/// 返回一个指定类型的空集
/// </summary>
static void EmptyFunction()
{
string[] name1 = { "","" };
string[] name2={"","",""};
string[] name3 = { "", "", "", "" };
List<string[]> strlists=new List<string[]>{name1,name2,name3};
//无符合条件，返回空集合
IEnumerable<string> nameslist = strlists.Aggregate(Enumerable.Empty<string>( ),
(current, next) => next.Length > ? current.Union(next) : current); foreach (string item in nameslist)
{
Console.WriteLine(item);
}
}
/// <summary>
/// 创建一个包含数字序列的集合 包含两个参数，第一个参数是作为序列开始的整数值，第二个参数是要产生的整数序列中数字的个数
/// </summary>
static void RangeFunction()
{
IEnumerable<int> intAry = Enumerable.Range(, );
foreach (int item in intAry)
{
Console.Write(item + " ");
}
}//output: 2 3 4 5 6
/// <summary>
/// Repeat 操作符创建一个单值序列,将此值重复一定的次数
/// </summary>
static void RepeatFunction()
{
IEnumerable<string[]> strAry = Enumerable.Repeat(new string[]{"world","hello"}, );
foreach (string[] item in strAry)
{
Console.WriteLine(item[] +" "+item[] );
}
}
//outpupt:
//hello world
//hello world
#endregion
10． 转换操作符
#region 转换操作符 将输入对象的类型转变为序列的动作
/// <summary>
/// 将查询的输入以IEnumerable<Of T>类型返回
/// </summary>
static void AsEnumerableFunction()
{
DataContext context = new DataContext(StaticData.ConnectSql);
Table<Contact> contacts = context.GetTable<Contact>();
//使用AsEnumerable操作符将类型自带的Where方法替换为标准查询操作符Where的方法
//这里的Where方法 区分查询条件的大小写,
//如果用“G”，只能查询出‘G’开头的Firstname，若换做"g",可以查询出所有以g/G开头的Firstname
IEnumerable<Contact> query = contacts.AsEnumerable().Where(con=>con.FirstName.Contains("g"));
foreach (Contact item in query)
{
Console.Write(item.FirstName + " ");
}
//这里的Where方法 不区分查询条件的大小写 用g/G都可以
IEnumerable<Contact> query2 = contacts.Where(con => con.FirstName.Contains("G"));
Console.WriteLine("");
foreach (Contact item in query2)
{
Console.Write(item.FirstName + " ");
}
}
//output:
//Gong
//Gong gong1 gong2 gong3 gong4
/// <summary>
/// 将IEnumerable集合中的元素转换为某种指定的类型
/// </summary>
static void CastFunction( )
{
//ArrayList并不实现IEnumerable(Of T)
ArrayList names = new ArrayList( );
var repeatlist = Enumerable.Range(, );
foreach (int item in repeatlist)
{
names.Add(item);
}
//通过使用Cast操作符，可以使用标准查询操作符来查询此序列
IEnumerable<int> query=names.Cast<int>().Select(name=>name);
foreach (int item in query)
{
Console.Write(item +" ");
}
}
//output:
//1 2 3 4 5 6 7 8 9 10
/// <summary>
/// 实现一个基于特定的类型对IEnumerable对象的元素进行过滤
/// </summary>
static void OfTypeFunction()
{
ArrayList names = new ArrayList();
names.Add("hello");
names.Add("thank you");
names.Add();
names.Add();
names.Add("yy");
names.Add();
//oftype方法返回序列中可以转为int型的元素,通过在IEnumerable对象上使用OfType操作符，就可以使用标准查询操作符来查询此序列
IEnumerable<int> query = names.OfType<int>();
foreach (int item in query)
{
Console.Write(item+ " ");
}
}
//output:
//2 4 6
/// <summary>
/// 用于实现从一个IEnumerable序列创建一个数组 ,ToArray会强制查询立即执行
/// </summary>
static void ToArrayFunction()
{
DataContext context = new DataContext(StaticData.ConnectSql);
Table<Contact> contacts = context.GetTable<Contact>();
var query = contacts.Select(con => con.FirstName).ToArray();
foreach (string item in query)
{
Console.Write(item+" ");
}
}
//output:Gond gong2 gong3 gong4 gong5
/// <summary>
/// ToDictionary操作符将序列中的所有返回元素插入到一个Dictionary(Of TKey,TValue)对象中，会强制查询立即执行
/// </summary>
static void ToDictionaryFunction()
{
DataContext context = new DataContext(StaticData.ConnectSql);
Table<Contact> contact = context.GetTable<Contact>( );
Dictionary<string, Contact> dict = contact.Where(con=>con.FirstName.Contains("")).ToDictionary(con => con.FirstName);
foreach (KeyValuePair<string,Contact> item in dict)
{
Console.WriteLine(item.Key+" "+item.Value.MiddleName);
}
}
//output:
//gong2 wen2
/// <summary>
/// 将一个IEnumerable序列集合转换为一个List(Of T)对象，它也会强制查询立即执行
/// </summary>
static void ToListFunction( )
{
DataContext context = new DataContext(StaticData.ConnectSql);
Table<Contact> contact = context.GetTable<Contact>();
IEnumerable<string> query = (from c in contact where c.FirstName.Contains("") select c.FirstName).ToList();
foreach (string item in query)
{
Console.WriteLine(item);
}
}
//output: gong2
/// <summary>
/// 基于一个特定的主键，将返回的元素放置到一个Lookup(Of Tkey,TElement)对象中
/// Lookup是主键的集合，每个主键都映射到一个或多个值上，可以认为Lookup对象是一个一对多的字典
/// </summary>
static void ToLookupFunction()
{
DataContext context = new DataContext(StaticData.ConnectSql);
Table<Contact> contact = context.GetTable<Contact>();
//Title作为key，Middelname和lastanem作为Element， key对应多个Element
ILookup<string, string> lkp = contact.ToLookup(con => con.Title, con => con.MiddleName + con.LastName);
foreach (IGrouping<string,string> item in lkp)
{
Console.WriteLine(item.Key);
foreach (string subitem in item)
{
Console.WriteLine(" "+subitem);
}
}
}
//output:
//xinwen2
// wentao
// wenstaos
//xinwen
// wen2tao2
// wen3tao3
// wen4tao4
// wen5tao5
#endregion
11． 元素操作符
#region 元素操作符 从一个序列返回单个特定的元素
/// <summary>
/// 将一个空集合替换为包含默认的单个值得集合
/// </summary>
static void DefaultIfEmptyFunction()
{
DataContext context = new DataContext(StaticData.ConnectSql);
Table<Contact> contacts = context.GetTable<Contact>();
//必须指定类型，用var在foreach时会报错
IEnumerable<Contact> query=from con in contacts where con.FirstName.StartsWith("gg") select con;
Contact defaultContact = new Contact() { FirstName="test",MiddleName="defaultIfEmpty"};
foreach (Contact item in query.DefaultIfEmpty(defaultContact))
//foreach (string item in query.DefaultIfEmpty("none"))
{
Console.Write(item.FirstName+" "+item.MiddleName);
}
}
//output:
//test defaultIfEmpty
/// <summary>
/// ElementAt返回集合中给定索引处的元素。集合是零基（索引从0开始计）的，返回值是数据源中特定位置的元素
/// ElementAtOrDefault 将ElementAt操作符和DefaultIfEmpty操作符的部分功能结合在一起，返回在某一特定处的元素，如果索引超出范围则返回默认值
/// </summary>
static void ElementAtFunction()
{
DataContext context = new DataContext(StaticData.ConnectSql);
Table<Contact> contacts = context.GetTable<Contact>( );
IEnumerable<string> query = from c in contacts where c.FirstName.StartsWith("G") select c.FirstName;
Console.WriteLine(query.ElementAt());
try
{
query.ElementAt();
}
catch (Exception ex)
{
Console.WriteLine("error:"+ex.Message);
}
//超出索引范围 返回默认值
Console.WriteLine(query.ElementAtOrDefault());
}
//output:
//Gong
//"error:"+指定的参数已超出有效值的范围
//参数名：index
/// <summary>
/// First查询集合中符合条件的第一个元素 Last查询集合中符合条件的最后一个元素 ，若没有发现任何元素抛出异常
/// FirstDefault 和LastDefualt，若没有发现任何元素则返回默认值
/// </summary>
static void FirstLastFunction()
{
DataContext context = new DataContext(StaticData.ConnectSql);
Table<Contact> contacts = context.GetTable<Contact>();
IEnumerable<Contact> query = from c in contacts select c;
Contact model = new Contact() {FirstName="test" };
model = query.First();
//输出 gong
Console.WriteLine("First:" + model.FirstName);
//输出 gong
model = query.FirstOrDefault();
Console.WriteLine("FirstDefault" + model.FirstName);
try
{
model = query.Last(con => con == null);
Console.WriteLine("Last:" + model.FirstName);
}
catch (Exception ex)
{
//在query.Last处报错，error：序列不包含任何匹配元素
Console.WriteLine("Last error"+ex.Message);
}
model = query.LastOrDefault(con => con == null);
try
{
Console.WriteLine("LastDefault:" + model.FirstName);
}
catch (Exception ex)
{
//在调用model时报错，error：未将对象引用设置到对象的实例
Console.WriteLine("LastDefault Error:"+ex.Message);
}
}
/// <summary>
/// Single操作符从一个序列中返回单个元素，或唯一满足某一特定条件的元素，如果包含一个以上或没有发现元素则抛出异常
/// SingleOrDefault从一个序列中返回单个元素，如果没有发现元素会返回一个默认值，如果返回多个元素，则抛出异常
/// </summary>
static void SingleFunction( )
{
DataContext context = new DataContext(StaticData.ConnectSql);
Table<Contact> contacts = context.GetTable<Contact>( );
IEnumerable<string> quuery = contacts.Where(con => con.FirstName.Equals("Gong2")).Select(con => con.FirstName);
Console.WriteLine("single:"+quuery.Single());
IEnumerable<string> query2 = contacts.Where(con => con.FirstName.Equals("test")).Select(con => con.FirstName);
Console.WriteLine("single default:"+query2.SingleOrDefault());
}
//output:
//single:gong2
//single default:
#endregion
12． 相等操作符
#region 相等操作符
/// <summary>
/// SequenceEqual 通过比较两个序列来检查他们相应的元素是否相同，如果序列有相同数量的元素，并且对应元素的值相同，则返回true，否则返回false
/// </summary>
static void SequenceEqualFunction()
{
int[] numbers1 = { , , , , , , };
int[] numbers2 = { , , , , , , };
int[] numbers3 = { , , , , , , };
bool flag = numbers1.SequenceEqual(numbers2);
Console.WriteLine(flag);
flag = numbers1.SequenceEqual(numbers3);
Console.WriteLine(flag);
}
//output:
//True
//False
#endregion
13． 量词操作符
#region 量词操作符 返回一个Boolean值，指示序列中是否存在部分或全部元素符合某个特定的条件
/// <summary>
///All 判定在集合中是否所有的值都满足特定的条件，返回值是boolean类型。如果满足，返回true，否则 false。
/// </summary>
static void AllFunction()
{
Contact[] contacts = { new Contact{FirstName="gwt"}
,new Contact{FirstName="gwt1"}
,new Contact{FirstName="gwt2"}
,new Contact{FirstName="gwt3"}
,new Contact{FirstName="gwt4"}
,new Contact{FirstName="lining"}};
bool flag = contacts.All(name => name.FirstName.StartsWith("gwt"));
Console.WriteLine("All:"+flag);
flag = contacts.Any(name => name.FirstName.StartsWith("gwt"));
Console.WriteLine("Any:"+flag);
IEnumerable<string> query = contacts.Select(name => name.FirstName);
flag = query.Contains("gwt");
Console.WriteLine("Contains:"+flag);
}
//output:
//All:False
//Any:True
//Contains:True
#endregion
14． 分割操作符
#region 分割操作符 是指将一个单一的输入序列划分成两个或多个部分或序列 ，同时不会对输入元素重排序，然后返回一个新形成的部分
/// <summary>
/// Skip: 跳过一些元素 到达序列中一个特定的位置
/// SkipWhile只要特定的条件为真，就继续略过元素，直到出现条件不满足时，返回剩余的元素，剩余的元素不再做判断。
/// </summary>
static void SkipFunction()
{
IEnumerable<int> query = Enumerable.Range(, );
IEnumerable<int> query2 = query.Skip();
Console.WriteLine("Skip");
foreach (int item in query2)
{
Console.Write(item + " ");
}
Console.WriteLine();
Console.WriteLine("SkipWhile");
//条件为num>5, 满足大于5的数被略过，query 为5 4 3 2 1
//如果条件为num<5 ,则query集合为10,9,8,7,6,5,4,3,2,1（因为第一个10<5为false，剩余元素不再做判断）这是一个坑啊，弄了半天才整明白
IEnumerable<int> query3 = (from n in query orderby n descending select n ).SkipWhile(num=>num>);
foreach (int item in query3)
{
Console.Write(item+" ");
}
query3 = (from n in query orderby n descending select n).SkipWhile(num => num < );
Console.WriteLine();
foreach (int item in query3)
{
Console.Write(item + " ");
}
}
//output:
//6 7 8 9 10
//5 4 3 2 1
/// <summary>
/// 返回某个序列中连续的元素子序列，子序列开始于原序列的开头，结束于某个指定的位置。
/// Take :从序列的开头返回指定数量的连续元素
/// TakeWhile：只要满足指定的条件，就会返回序列的元素，一旦出现条件不满足，查询不会继续下去，即使后面有满足条件的元素。
/// </summary>
static void TakeFunction()
{
int[] randomNumbers = { ,,,,,,,,,,,,};
IEnumerable<int> takeTopFour = randomNumbers.OrderByDescending(num => num).Take();
Console.Write("Take:");
foreach (int item in takeTopFour)
{
Console.Write(item + " ");
}
Console.WriteLine();
Console.Write("TakeWhile：");
IEnumerable<int> takeGreaterThan50=(from n in randomNumbers orderby n select n).TakeWhile(n=>n<);
foreach (int item in takeGreaterThan50)
{
Console.Write(item+" ");
}
}
//output:
//Take:100 94 86 81
//TakeWhile:2 5 22 45
#endregion
最后出一个使用查询操作符的例子
#region 使用查询操作符
static void UseSearchOperate()
{
DataContext context = new DataContext(StaticData.ConnectSql);
Table<Contact> contacts = context.GetTable<Contact>();
Table<Employee> employees = context.GetTable<Employee>();
//使用查询语法
var query = from con in contacts
join emp in employees on con.ContactID equals emp.ContactID
where con.FirstName.StartsWith("gong2")
&& emp.HireDate.Year >
orderby con.FirstName
orderby con.LastName
select new { emp.EmployeeID, con.LastName, con.FirstName, emp.Title, con.EmailAddress, emp.HireDate };
//使用方法语法
var query2 = contacts.Join(employees, con => con.ContactID, emp => emp.ContactID, (con, emp) => new { con = con, emp = emp })
.Where(c => c.con.FirstName.StartsWith("gong2"))
.Where(c => c.emp.HireDate.Year > )
.OrderBy(c => c.con.FirstName)
.ThenBy(c => c.con.LastName)
.Select(o=>new {o.con.FirstName,o.con.LastName,o.con.EmailAddress,o.emp.EmployeeID,o.emp.Title,o.emp.HireDate});
foreach (var item in query2)
{
Console.WriteLine(item.FirstName + " " + item.HireDate + " " + item.EmailAddress);
}
}
//output:
//gong2 2013-08-01 97182234@qq.com
//gong2 2013-08-01 97182234@qq.com
//gong2 2013-08-01 97182234@qq.com
//gong2 2013-08-01 97182234@qq.com
#endregion
动动您的手指，点下支持，您的支持是我最大动力！
LINQ入门教程之各种标准查询操作符（二）的更多相关文章
- LINQ入门教程之各种标准查询操作符（一）
好久之前就想系统的学习下LINQ,好久之前…… 本篇文章主要介绍LINQ等的标准查询操作符,内容取自<LINQ高级编程>,后续还会介绍LINQ to XML ,LINQ to SQL. L ...
- LINQ标准查询操作符详解(转)
一. 关于LINQ LINQ 英文全称是“Language-Integrated Query”,中文为“语言集成查询”,它是微软首席架构师.Delphi 之父和C# 之父——Anders ...
- Linq to BBJECT之非延时标准查询操作符
非延时标准查询操作符是指不具备延时查询特性的标准查询操作符,这些操作符一般用于辅助延时标准查询操作符使用. 1.ToArray操作符 ToArray操作符用于将一个输入序列转换成一个数组. 方法原型: ...
- Linq to OBJECT延时标准查询操作符
1.Where 操作符用于限定输入集合中的元素,将符合条件的元素组织声称一个序列结果.2.Select 操作符用于根据输入序列中的元素创建相应的输出序列中的元素,输出序列中的元素类型可以与输入序列中 ...
- Linq 标准查询操作符三
本文介绍了LINQ标准查询操作符.没有这些操作符,LINQ就不会存在.本文为理解这些操作符的功能提供了很好的基础.了解它们将会很有帮助,因为LINQ的各种Provider都是基于这些操作符来完成各自丰 ...
- LINQ 标准查询操作符
本文介绍了LINQ标准查询操作符.没有这些操作符,LINQ就不会存在.本文为理解这些操作符的功能提供了很好的基础.了解它们将会很有帮助,因为LINQ的各种Provider都是基于这些操作符来完成各自丰 ...
- Linq to Object 延迟标准查询操作符
1.Where 操作符用于限定输入集合中的元素,将符合条件的元素组织声称一个序列结果.2.Select 操作符用于根据输入序列中的元素创建相应的输出序列中的元素,输出序列中的元素类型可以与输入序列中 ...
- Linq to Object之非延迟标准查询操作符
非延时标准查询操作符是指不具备延时查询特性的标准查询操作符,这些操作符一般用于辅助延时标准查询操作符使用. 1.ToArray操作符 ToArray操作符用于将一个输入序列转换成一个数组. 方法原型: ...
- Elasticsearch入门教程(五)：Elasticsearch查询(一)
原文:Elasticsearch入门教程(五):Elasticsearch查询(一) 版权声明:本文为博主原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接和本声明. 本文链接:h ...
随机推荐
- Docker的安装，配置，更新和卸载
我们可以在Linux中安装Docker并运行Hello world应用程序.通过下面这些操作,我们将会学到更多有关于Docker的基础特征.我们将会学到如何: 安装Docker引擎 在一个容器中运行软 ...
- spark standalone集群部署 实践记录
本文记录了一次搭建spark-standalone模式集群的过程,我准备了3个虚拟机服务器,三个centos系统的虚拟机. 环境准备: -每台上安装java1.8 -以及scala2.11.x (x代 ...
- 同时安装2个版本的python
使用pip 当Python2和Python3同时存在于windows上时,它们对应的pip都叫pip.exe,所以不能够直接使用 pip install 命令来安装软件包.而是要使用启动器py.exe ...
- java并发编程实战：第十六章----Java内存模型
一.什么是内存模型,为什么要使用它 如果缺少同步,那么将会有许多因素使得线程无法立即甚至永远看到一个线程的操作结果 编译器把变量保存在本地寄存器而不是内存中 编译器中生成的指令顺序,可以与源代码中的顺 ...
- Python WebDriver + Firefox 文件下载
firefox可以通过 在地址栏输入:about:config 或about:aupport 来查看或修改配置信息. 这里有两种解决方式, 1.设置自动保存下载 如下图勾选:以后自动采用相同的动作处理 ...
- CentOS 7 IPv6关闭
你可以用两个方法做到这个.方法 1编辑文件/etc/sysctl.conf,vi /etc/sysctl.conf添加下面的行:net.ipv6.conf.all.disable_ipv6 =1net ...
- elasticsearch不能使用root启动问题解决
问题: es安装好之后,使用root启动会报错:can not run elasticsearch as root [root@iZbp1bb2egi7w0ueys548pZ bin]# ./elas ...
- C语言--第0次作业；
第零次作业 1.你对网络专业或者计算机专业了解是怎样? 在高考之前,我就确定了自己的大学专业将会选择计算机方面.我认为计算机专业就业前景比较好,计算机行业发展也非常快,学科实践与创新能力也比较强,在当 ...
- Remoteland HDU - 4196
题意: 给出一个n,在[1, n] 中挑选几个不同的数相乘,求能的到的最大完全平方数 解析: 最大的肯定是n!, 然后n!不一定是完全平方数 (我们知道一个完全平方数,质因子分解后,所有质因子的质数均 ...
- 对this的理解？
回答一: (1) Js的this指向是不确定的,也就是说可以动态改变的.Call/apply 就是用于改变this指向的函数,这样设计可以让代码更加灵活,复用性更高 (2) This一般情况下,都是指 ...