C#学习日记 LINQ语句

最新推荐文章于 2024-05-28 09:34:56 发布
最新推荐文章于 2024-05-28 09:34:56 发布
阅读量299 收藏
点赞数
分类专栏： C#学习日记 文章标签： C#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/july_yeye/article/details/69062728
版权

自己做的一些查询有错误。

using System;
using System.Collections.Generic;
using System.Linq;

namespace Sample.LINQ
{
	public class MainEntryPoint
	{
		static int Main(string[] args)
		{
			//LinqQuery();

			/*var names = new List<string>{ "Nino", "Alberto", "Juan", "Mike", "Phil"};
			var nameWithJ = from n in names
							where n.StartsWith("J")
							orderby n
							select n;
			Console.Write("Before:");
			foreach(string n in nameWithJ)
			{
				Console.Write(" "+n);
			}
			names.Add("John");
			names.Add("Jack");
			names.Add("Jim");
			Console.WritLine();
			Console.Write("After:");
			foreach(string n in nameWithJ)
			{
				Console.Write(" "+n);
			}*/

			/*var names = new List<string>{ "Nino", "Alberto", "Juan", "Mike", "Phil"};
			var nameWithJ = (from n in names
							where n.StartsWith("J")
							orderby n
							select n).ToList();
			Console.Write("Before:");
			foreach(string n in nameWithJ)
			{
				Console.Write(" "+n);
			}
			names.Add("John");
			names.Add("Jack");
			names.Add("Jim");
			Console.WritLine();
			Console.Write("After:");
			foreach(string n in nameWithJ)
			{
				Console.Write(" "+n);
			}*/

			/*var racers = from r in Formula1.GetRacers()
						 where (r.Wins > 15) && (r.Country == "USA" || r.Country == "UK")
				         select r;
			foreach(Racer r in racers)
			{
				Console.WriteLine("{0:A}", r);
			}*/
			/*var racers = Formula1.GetRacers().
						Where( r => (r.Wins > 15) && (r.Country == "USA" || r.Country =="UK")).
						Select( r => r);
			foreach(Racer r in racers)
			{
				Console.WriteLine("{0:A}", r);
			}*/

			/*var racers = Formula1.GetRacers().
						 Where( (r, index) => r.LastName.StartsWith("A") && index % 2 == 0).
						 Select( r => r);
			foreach(Racer r in racers)
			{
				Console.WriteLine("{0:A}", r);
			}*/

			/*object[] data ={ 123, "abc", 456, "def"};
			var query = data.OfType<string>();
			foreach(var s in query)
			{
				Console.WriteLine(s);
			}*/

			/*var query = from r in Formula1.GetRacers()
						from c in r.Cars
						where c == "Ferrari"
						select r.LastName+" "+r.FirstName;
			foreach(string s in query)
			{
				Console.WriteLine(s);
			}*/
			/*var result = Formula1.GetRacers().
						SelectMany(r => r.Cars, (r, c) => new{ Racer = r, Car = c}).
						Where( r => r.Car = "Ferrari").
						Select(r => r.FirstName+" "+r.LastName);
			foreach(string s in result)
			{
				Console.WriteLine(s);
			}*/
			
			/*var racers = from r in Formula1.GetRacers()
						 where r.Country == "UK"
						 orderby r.Wins descending
						 select r;*/
			/*var racers = Formula1.GetRacers().
						 Where( r => r.Country == "UK").
						 OrderByDescending(r => r.Wins).
						 Select(r => r);*/
			/*var racers = from r in Formula1.GetRacers()
						 orderby r.Country, r.FirstName, r.LastName
						 select r;
			var racers = Formula1.GetRacers().
						 OrderBy(r => r.Country).
						 ThenBy( r => r.FirstName).
						 ThenBy( r => r.LastName).
						 Select( r => r);*/
			/*var query = from r in Formula1.GetRacers()
				        group r by r.Country into g
						orderby g.Count() descending, g.Key
						where g.Count() >= 2
						select new{
									Count = g.Count(),
									Country = g.Key
									};
			var query = Formula1.GetRacers().
						GroupBy( r => r.Country).
						OrderBy( g => g.Count()).
						ThenBy( g => g.Key).
						Where( g => g.Count() >= 2).
						Select( g => new {Country = g.Key, Count = g.Count()});
			
			foreach(var i in query)
			{
				Console.WriteLine("{0} {1}",i.Country , i.Count);
			}*/
			/*var result = from r in Formula1.GetRacers()
						 group r by r.Country into g
						 orderby g.Count() descending,g.Key
						 where g.Count() >= 2
						 select new
								{
									Count = g.Count(),
									Country = g.Key,
									Racers = from r1 in g
											 orderby r1.LastName
											 select r1.FirstName+" "+r1.LastName
								};
			foreach(var i in result)
			{
				Console.WriteLine("{0,-10} {1}",i.Country, i.Count);
				foreach(var r in i.Racers)
				{
					Console.WriteLine(r);
				}
			}*/
			/*var racers = from r in Formula1.GetRacers()
						 from y in r.Years
						 select new{
									Year = y,
									Name = r.FirstName+" "+r.LastName
									};
			var teams = from t in Formula1.GetTeams()
						from y in t.Years
				        select new{
									Name = t.Name,
									Year = y
									};
			var result = from r in racers
						 join t in teams on r.Year equals t.Year
						select new{
									r.Year,
									TeamName = t.Name,
									Name = r.Name
									};*/
			/*var racers = from r in Formula1.GetRacers()
			from y in r.Years
			select new{
						Year = y,
						Name = r.FirstName+" "+r.LastName
						};
			var teams = from t in Formula1.GetTeams()
						from y in t.Years
				        select new{
									Name = t.Name,
									Year = y
									};
			var result = from r in racers
						 join t in teams on r.Year equals t.Year into rt
						 from t in rt.DefaultIfEmpty()
						 orderby r.Year
						 select new{
									r.Year,
									TeamName = t==null ? "no team":t.Name,
									Name = r.Name
									};
			foreach(var i in result)
			{
				Console.WriteLine("{0} {1} {2}",i.TeamName, i.Name, i.Year);
			}*/
			//有错误
			/*var racersList = Formula1.GetRacerTeamShip().
							 SelectMany( rts => new List<RacerInfo>()
							{
								new RacerInfo{
									Year = rts.Year,
									Position = 1,
									FirstName = rts.First.FirstName(),
									LastName = rts.First.LastName()
								},
								new RacerInfo{
									Year = rts.Year,
									Position = 2,
									FirstName = rts.Second.FirstName(),
									LastName = rts.Second.LastName()
								},
								new RacerInfo{
									Year = rts.Year,
									Position = 3,
									FirstName = rts.Third.FirstName(),
									LastName = rts.Third.LastName()
								}
							});
			var result = from r in Formula1.GetRacers()
						 join r2 in racersList
						 on
						 new
						{
							FirstName = r.FirstName,
							LastName = r.LastName
						}
						equals
						new
						{
							FirstName = r2.FirstName,
							LastName = r2.LastName
						}
						into yearResults
						select new
						{
							FirstName = r.FirstName,
							LastName = r.LastName,
							Wins = r.Wins,
							Starts = r.Starts,
							Result = yearResults
						};
			foreach(var i in result)
			{
				Console.WriteLine("{0} {1}", i.FirstName, i.LastName);
				foreach(var j in i.Results)
				{
					Console.WriteLine("{0} {1}",j.Year, j.Position);
				}
			}*/
			/*foreach(var i in racersList)
			{
				Console.WriteLine("{0} {1} {2} {3}", i.Year, i.FirstName, i.LastName, i.Position);
			}*/

			/*var ferrariDrivers = from r in Formula1.GetRacers()
								 from c in r.Cars
								 where c == "Ferrari"
								 select r;*/

			/*var ferrariDrivers = GetRacersByCar("Ferrari");
			Func<string, IEnumerable<Racer>> racersByCar = car
								=> from r in Formula1.GetRacers()
								   from c in r.Cars
								   where c == car
								   select r;
			foreach(Racer r in ferrariDrivers.Intersect(racersByCar("Alfa Romeo")))
			{
				Console.WriteLine("{0:A}", r);
			}*/
			/*var racersName = from r in Formula1.GetRacers()
							 where r.Country == "UK"
							 orderby r.Wins descending
							 select new 
							 {
								 Name = r.FirstName + " "+r.LastName
							 };
			var racersNameAndStarts = from r in Formula1.GetRacers()
									 where r.Country == "UK"
									 orderby r.Wins descending
									 select new
									 {
										 LastName = r.LastName,
										 Starts = r.Starts
									 };
			var racers = racersName.Zip(racersNameAndStarts, (first, second) => first.Name + " ,Starts:"+second.Starts);					
			foreach(var i in racers)
			{
				Console.WriteLine(i);
			}*/
			/*int pagesize = 2;
			int numberPages = (int)Math.Ceiling(Formula1.GetRacers().Count()/(double)(pagesize));
			for(int i = 0; i < numberPages ; i++)
			{
				Console.WriteLine("Page {0}:",i);
				var racers = (from r in Formula1.GetRacers()
							 orderby r.LastName, r.FirstName
							 select r.FirstName + " " +r.LastName).
							 Skip(pagesize * i).Take(pagesize);
				foreach(var name in racers)
				{
					Console.WriteLine(name);
				}
			}*/
			/*var query = from r in Formula1.GetRacers()
						let yearsCount = r.Years.Count()
						where yearsCount >= 1
						orderby yearsCount descending, r.LastName
						select new
						{
							Name = r.FirstName + " " +r.LastName,
							YearsCount = yearsCount
						};
			foreach(var i in query)
			{
				Console.WriteLine(i.Name+" "+i.YearsCount);
			}*/
			/*var query = (from x in
						(from r in Formula1.GetRacers()
						group r by r.Country into c
						select new
						{
							Country = c.Key,
							Wins = (from r1 in c
									select r1.Wins).Sum()
						})
						orderby x.Wins descending, x.Country
						select x).Take(3);
			foreach(var i in query)
			{
				Console.WriteLine(i.Country+" "+i.Wins);
			}*/
			/*List<Racer> list = (from r in Formula1.GetRacers()
							   where r.Starts > 20
							   orderby r.Starts descending
							   select r).ToList();
			foreach(Racer r in list)
			{
				Console.WriteLine("{0:A}", r);
			}*/
			/*var query = (from r in Formula1.GetRacers()
						from c in r.Cars
						select new
						{
							Car = c,
							Racer = r
						}).ToLookup( r => r.Car, r => r.Racer);
			if(query.Contains("Ferrari"))
			{
				foreach(var i in query["Ferrari"])
				{
					Console.WriteLine("{0:A}",i);
				}
			}*/
			var list = new System.Collections.ArrayList(Formula1.GetRacers() as System.Collections.ICollection);
			var query = from r in list.Cast<Racer>()
						where r.Country == "UK"
						orderby r.Wins descending
						select r;
			foreach(Racer r in query)
			{
				Console.WriteLine("{0:A}", r);
			}
			return 0;
		}
		private static IEnumerable<Racer> GetRacersByCar(string car)
		{
			return from r in Formula1.GetRacers()
								 from c in r.Cars
								 where c == car
								 select r;
		}
		public static void LinqQuery()
		{
			var query = from r in Formula1.GetRacers()
						where r.Country == "UK"
						orderby r.Wins descending
						select r;
			foreach(Racer r in query)
			{
				Console.WriteLine("{0:A}", r);
			}
		}
	}
	public static class StringExtension
	{
		public static string FirstName(this string name)
		{
			int ix = name.LastIndexOf(' ');
			return name.Substring(0, ix);
		}
		public static string LastName(this string name)
		{
			int ix = name.LastIndexOf(' ');
			return name.Substring(ix+1);
		}
	}
	[Serializable]
	public class RacerInfo
	{
		public int Year { get; set;}
		public int Position { get; set;}
		public string FirstName { get; set;}
		public string LastName { get; set;}
	}
	[Serializable]
	public class RacerTeamShip
		{
			public int Year{ get; set;}
			public string First { get; set;}
			public string Second { get; set;}
			public string Third { get; set;}
		}
	[Serializable]
	public class Racer : IComparable<Racer>, IFormattable
	{
		public string FirstName { get; set;}
		public string LastName { get; set;}
		public int Wins { get; set;}
		public string Country { get; set;}
		public int Starts { get; set;}
		public IEnumerable<string> Cars { get; private set;}
		public IEnumerable<int> Years { get; private set;}

		public Racer(string firstName, string lastName, int wins, string country, int starts, IEnumerable<string> cars,IEnumerable<int> years)
		{
			this.FirstName = firstName;
			this.LastName = lastName;
			this.Wins = wins;
			this.Country = country;
			this.Starts = starts;
			this.Cars = new List<string>(cars);
			this.Years =new List<int>(years);
		}
		public Racer(string firstName, string lastName, int wins, string country, int starts): this(firstName, lastName, wins, country, starts, null, null)
		{
		}
		public override string ToString()
		{
			return string.Format("{0} {1}", FirstName, LastName);
		}
		public int CompareTo(Racer other)
		{
			if(other == null)
				return -1;
			return string.Compare(this.LastName, other.LastName);
		}
		public string ToString(string format)
		{
			return ToString(format, null);
		}
		public string ToString(string format, IFormatProvider formatProvider)
		{
			switch(format)
			{
				case null:
				case "N":
					return ToString();
				case "F":
					return FirstName;
				case "L":
					return LastName;
				case "C":
					return Country;
				case "S":
					return Starts.ToString();
				case "W":
					return Wins.ToString();
				case "A":
					return string.Format("{0} {1}, {2}, starts: {3}, wins: {4}", FirstName, LastName, Country, Starts, Wins);
				default:
					throw new FormatException(string.Format("Format {0} not supported", format));
			}
		}
	}
	[Serializable]
	public class Team
	{
		public string Name { get; private set;}
		public IEnumerable<int> Years { get; private set;}

		public Team(string name, params int[] years)
		{
			this.Name = name;
			this.Years = new List<int>(years);
		}
	}
	public static class Formula1
	{
		private static List<Racer> racers;
		public static IList<Racer> GetRacers()
		{
			if(racers == null)
			{
				racers = new List<Racer>(40);
				racers.Add(new Racer("Nino","Farina", 33,"Italy", 5, new string[]{"Alfa Romeo", "Ferrari"}, new int[] { 1950 } ));
				racers.Add(new Racer("Juan Manuel","Fangio", 51,"Argentia", 24, new string[] {"Alfa Romeo", "Ferrari", "Mercedes", "Maserati"}, new int[]{ 1952, 1954, 1955, 1956, 1957 } ));
				racers.Add(new Racer("Alberto","Ascari", 32, "Italy", 10, new string[] {"Ferrari"}, new int[] { 1952, 1953 } ));
				racers.Add(new Racer("Mike","Hawthron", 45, "UK", 3, new string[] { "Ferrari"}, new int[] { 1961 } ));
				racers.Add(new Racer("Phil","Hill", 48,"USA", 3, new string[] { "Ferrari"}, new int[] { 1950 } ));
				racers.Add(new Racer("John","Surtees", 111,"UK", 6, new string[] { "Ferrari"}, new int[] { 1954 } ));
				racers.Add(new Racer("Jim","Clark", 72,"UK", 25, new string[] { "Lotus"}, new int[] { 1963, 1965 }));
			}
			return racers; 
		}
		private static List<Team> teams;
		public static IList<Team> GetTeams()
		{
			if(teams == null)
			{
				teams = new List<Team>()
				{
					new Team("Vanwall", 1958),
					new Team("Cooper", 1959, 1956),
					new Team("Ferrai", 1961, 1964, 1975, 1976, 1977, 1979, 1982, 1983, 1999, 2000, 2001, 2002, 2003, 2004, 2007, 2008),
					new Team("BRM", 1962)
				};
			}
			return teams;
		}
		private static List<RacerTeamShip> racerTeamShips;
			public static IEnumerable<RacerTeamShip> GetRacerTeamShip()
			{
				if(racerTeamShips == null)
				{
					racerTeamShips = new List<RacerTeamShip>();
					racerTeamShips.Add(new RacerTeamShip
						{
							Year = 1950,
							First = "Nino Farina",
							Second = "Juan Manuel Fangio",
							Third = "Liugi Fagioli"
						});
						racerTeamShips.Add(new RacerTeamShip
						{
							Year = 1951,
							First = "Juan Manuel Fangio",
							Second = "Alberto Ascari",
							Third = "Froilan Gonzalez"
						});
						
				}
				return racerTeamShips;
			}
	}
}


yayakoo-
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C#的LINQ
weixin_30419799的博客
05-25 60
　　在过去如果我们如果需要去查询某些集合或者数组里面的某些元素，我们需要写出大量的带有筛选的遍历集合的代码，但是有了Linq之后，我们就不用写出那些冗余麻烦的遍历代码，只需要关注其中的筛选，排列的函数就可以实现了。Linq的语法看上去有点像SQL，完成的功能也和SQL相似，但是面向的数据不同且写法上也略有不同，下面介绍一下基本的使用。 　　下面是一个使用的场景，要求从下面的名字中筛选出长度大于4...
C#学习日记19
NLP工程化
02-14 1228
1.判断某个字符串是否为合法的GUID 解析： [1]方法1[Guid.Parse或Guid.TryParse] public static class GuidEx { public static bool IsGuid(string value) { Guid x; return Guid.TryParse(value, out x); } } [2]方法2[.NET4.0之前版本，构造函数] public static bool TryPars
C#学习日记4
NLP工程化
10-09 1723
1.LINQ强制执行 解析：要强制立即执行任何查询并缓存其结果，可调用ToList或ToArray方法。如下所示： List<int> numQuery2 = (from num in numbers where (num % 2) == 0 select num).ToList(); var numQuery3 = (from num in numbers where (num % 2) == 0 select num).ToArray(); 2.查询关键字 解析： [1]from：指定数据
C#学习日记5
NLP工程化
10-10 344
1.LINQ构成 解析： [1]查询运算符 [2]查询表达式 [3]表达式树 [4]LINQ的DLL及命名空间 说明：LINQ包括五个部分LINQ to Objects、LINQ to DataSets、LINQ to SQL、LINQ to Entities、LINQ to XML。 2.查询运算符 解析： 3.查询表达式 解析： 4.LINQ查询表达式 解析：查询表达式必须以from子句开头，以select或group子句结束。第一个from子句和最后一个select子句或group子句之间，可以包
学习日记02-刘铁猛《C#语言入门详解》
iyuansa的博客
05-22 944
上一篇匆忙地结束了，有几点需要补充：1.writeLine:将要输出的字符串与换行控制字符一起输出,当次语句执行完毕时候,光标会移到目前输出字符串的下一行。2..NET WEB FORMS(OLD)是老版本，.NET MVC是新版本，新的原因在于加了MVCcontroller（个人理解）其实很重要，是现实世界物质的缩影（事物的模型）；就是个模板，好比女娲对类吹口气，创造出的就是人，在这世上每个人都是不同的；人是，小明就是4.和。
C#菜鸟教程学习笔记
最新发布
m0_52801429的博客
05-28 114
/定义命名空间（类的住址）:对类进行逻辑上的划分，避免重名。//c#入门经典 第三章。//代码大全2第十章。
C#学习日记3
NLP工程化
10-09 278
1.反射的用途 解析：System.Reflection类如下所示： [1]它允许在运行时查看特性[attribute]信息。 [2]它允许审查集合中的各种类型，以及实例化这些类型。 [3]它允许延迟绑定的方法和属性[property]。 [4]它允许在运行时创建新类型，然后使用这些类型执行一些任务。 2.C#索引器 解析：索引器允许一个对象可以像数组一样被索引。当为类定义一个索引器时，该类的行为就会像一个虚拟数组[virtual array]一样。可以使用数组访问运算符（[]）来访问该类的实例。一维索引器
C#学习日记2
NLP工程化
07-21 536
1.C#委托 解析：所有的委托都派生自System.Delegate类。 [1]声明委托 假设有一个委托，如下所示： public delegate int MyDelegate (string s); 上面的委托可被用于引用任何一个带有一个单一的string参数的方法，并返回一个int类型变量。 声明委托的语法，如下所示： delegate <return type> <de...
学习日记--LINQ2EF
oLanJieKou的专栏
11-08 837
今天发现了  一个对我来说富有转折意义的问题 一直认为LINQ+EF读取数据会致使代码效率底下    后来经过论坛激烈的讨论  发现linq语句在未展开的时候，是不会读取数据的,即是说  之前个人的习惯是查询之后tolist  这是一个性能损失的大问题   在数据层返回Iqueryable数据   然后在逻辑层再进行分页的话   这样能大大减少读取的数据   从而避免性能的损失。。。切记   查
C#50个经典小程序(新手必备)
02-18
10. **LINQ查询**：学习使用LINQ进行数据查询和操作，简化数据访问和处理流程。 11. **反射**：了解如何在运行时动态获取类的信息并操作它们，这在插件式架构和元编程中很有用。 12. **泛型接口与委托**：结合泛型...
C#程序开发范例宝典（第2版）.part12
11-12
实例229　C#中实现文件拖放 317 实例230 文件比较 318 实例231 获取文件夹中的图标资源 319 实例232 获取文件夹下的所有文件夹及文件的名称 321 第７章 操作系统与Windows相关程序 324 7.1 启动相关 325 实例...
C#程序开发范例宝典（第2版）.part08
11-12
实例229　C#中实现文件拖放 317 实例230 文件比较 318 实例231 获取文件夹中的图标资源 319 实例232 获取文件夹下的所有文件夹及文件的名称 321 第７章 操作系统与Windows相关程序 324 7.1 启动相关 325 实例...
C#程序开发范例宝典（第2版）.part02
11-12
实例229　C#中实现文件拖放 317 实例230 文件比较 318 实例231 获取文件夹中的图标资源 319 实例232 获取文件夹下的所有文件夹及文件的名称 321 第７章 操作系统与Windows相关程序 324 7.1 启动相关 325 实例...
C#学习笔记 IEquatable<T> 接口 IEqualityComparer<T> 接口
yayakoo
04-02 6166
IEquatable 接口类内重写Equals方法，就可以实现比较。IEqualityComparer 接口可以写一个自定义类的比较类。 using System; using System.Collections.Generic; using System.Collections; namespace Wrox { public class MainEntryPoint { stat
C#学习笔记 IEumerable接口 IEumerator接口
yayakoo
04-02 1664
foreach语句，就是调用GetEnumerator（）方法，得到一个数组的枚举器，然后在while循环中判断MoveNext（），如果为true，就可以用Current属性来访问数组中的元素。 根据网上的例子，自己打的代码。IEnumerable接口和IEnumerator接口都在System。Collections里。 using System; using System.Collect
C#学习日记 BitArray BitVector32
yayakoo
04-03 1328
BitArray类可以重新设置大小，事先不知道大小的可以用它，它可以包含很多位。它是引用类型的。位里存储的是bool类型，有Not Or And Xor 方法。 using System; using System.Collections; namespace Sample { public class MainEntryPoint { static int Main(string[]
C#学习笔记 IComparable接口 IComparable<T>接口 IComparer接口
yayakoo
04-02 1130
ArrayList中有一个Sort（）方法，它可以实现对集合的排序。但是集合中的类型必须要实现IComparable接口，因为排序需要类型的比较方法CompareTo（），参数为该类型的一个对象。 所以我们自己写的一个类，想要使用这个Sort（）方法，必须实现这个IComparable（）接口。CompareTo（）方法的返回值是int类型的，如果大于1，就说明前者比后者大，如果为0，说明两者相
C#中的LINQ语句怎么使用
06-10
在C#中使用LINQ语句需要引入System.Linq命名空间，然后使用IEnumerable或IQueryable类型的数据集合进行LINQ操作。LINQ语句的基本语法如下： ``` var query = from item in collection [where condition] [orderby...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值