Linq 표준 쿼리 연산자
언어 집합 쿼리 Ganmge hteg.ratedQuw, LINQ는 C# 프로그래밍 언어 구문의 쿼리를 통합합니다. 동일한 구문을 사용하여 다양한 데이터 소스에 액세스할 수 있습니다. LINQ는 다양한 데이터 소스에 대한 추상화 계층을 제공하므로 동일한 구문을 사용할 수 있습니다.
1 필터 연산자
필터 연산자는 요소 반환 조건을 정의합니다.
| 筛选操作符 |
描述 |
| where |
使用谓词，返回布尔值 |
| OfType< TResult> |
根据类型筛选元素 |
애플리케이션 예:
사용법:
var racers = from r in Formulal.Racers
where r.Wins > 15 && r.Country == "Brazil" select r;
로그인 후 복사
OfType< 다른 유형의 새 객체로 변환
사용 예:
사용 선택
object[] data = {"one", 2, "three", 4, 5, "six"};
var rtnData = data.OfType<string>(); //返回类型为string的数据元素集合로그인 후 복사
selectMany 사용법
var racers = from r in Formulal.Racers
where r.Wins > 15 && r.Country == "Brazil"
select new
{
Name = string.Format("{0} {1}", r.FirstName, r.LastName),
Country = r.Country,
Wins = r.Wins
}; //输出为含有Name,Country,Wins共计3个属性的对象集合로그인 후 복사
3개의 정렬 연산자
change 요소 순서 반환
예:
var ferrariDrivers = Formulal.Racers.
SelectMany(r => r.Cars,
(r, c) => new { Racer = r, Car = c }).
Where(r => r.Car == "Ferrari").
OrderBy(r => r.Racer.LastName).
Select(r => r.Racer.FirstName + " " + r.Racer.LastName);//筛选出驾驶法拉利的选手集合로그인 후 복사
| 排序操作符 | 描述 |
|---|
| OrderBy | 升序排序 |
| OrderByDescending | 降序排序 |
| ThenBy | 第一次排序结果类似，用第二次升序排序 |
| ThenByDescending | 第一次排序结果类似，用第二次降序排序 |
| Reverse | 反转集合中元素的顺序 |
4개의 연결 연산자
는 직접 관련되지 않은 집합을 병합하는 데 사용됩니다.
var racers = from r in Formulal.Racers
where r.Country == "Brazil"
orderby r.Wins descending
select new
{
Name = string.Format("{0} {1}", r.FirstName, r.LastName),
Country = r.Country,
Wins = r.Wins
};//国家为巴西，按照胜场次数降序排列로그인 후 복사
결과:
| 连接运算符 | 描述 |
|---|
| Join | 可以根据键选择器函数连接连接2个集合 |
| GroupJoin | 连接两个集合,组合其结果 |
5개의 조합 연산자
| Yearj | Racerj | Teamj |
|---|
| Yearj=2004 | Racerj=Michael Schumacher | Teamj =Ferrari |
| Yearj=2005 | Racerj=Fernando Alonso | Teamj =Renault |
| Yearj=2006 | Racerj=Fernando Alonso | Teamj =Renault |
| Yearj=2007 | Racerj=Kimi Räikkönen | Teamj =Ferrari |
| Yearj=2008 | Racerj=Lewis Hamilton | Teamj =Ferrari |
| Yearj=2014 | Racerj=Lewis Hamilton | Teamj =Mercedes |
| Yearj=2015 | Racerj=Lewis Hamilton | Teamj =Mercedes |
| Yearj=2009 | Racerj=Jenson Button | Teamj =Brawn GP |
| Yearj=2010 | Racerj=Sebastian Vettel | Teamj =Red Bull Racing |
| Yearj=2011 | Racerj=Sebastian Vettel | Teamj =Red Bull Racing |
| Yearj=2012 | Racerj=Sebastian Vettel | Teamj =Red Bull Racing |
| Yearj=2013 | Racerj=Sebastian Vettel | Teamj =Red Bull Racing |
데이터 입력 groups
GroupBy 사용 예:
//Join连接
//获取冠军年份在2003年后的选手
var racer5 = from r in Formulal.Racers
from y in r.Years
where y > 2003
select new
{
Year = y,
Name = string.Format("{0} {1}", r.FirstName, r.LastName)
}; //获取冠军年份在2003年后的团队
var team1 = from r in Formulal.ChampionTeams
from y in r.Years
where y > 2003
select new
{
Year = y,
Name = string.Format("{0}", r.Name)
};
//连接
var racerAndTeams = from r in racer5
join t in team1 on r.Year equals t.Year
select new
{
Yearj= r.Year,
Racerj = r.Name,
Teamj = t.Name
};로그인 후 복사
| 组合运算符 | 描述 |
|---|
| GroupBy | 组合有公共键的元素 |
| ToLookUp | 通过创建一个一对多的字典，来组合元素。 |
결과:
6 수량자 연산자
| Country | Count |
|---|
| UK | 10 |
| Brazil | 3 |
| Finland | 3 |
요소 시퀀스가 지정된 조건을 만족하는 경우, 수량자 연산자는 부울 값을 반환합니다
var countries = from r in Formulal.Racers
group r by r.Country into g
orderby g.Count() descending, g.Key
where g.Count() > 2
select new
{
Country = g.Key,
Count = g.Count()
};//获取冠军次数大于2的国家로그인 후 복사
7 파티션 연산자
| 组合运算符 | 描述 |
|---|
| Any | 确定集合中是否有满足谓词函数的元素 |
| All | 确定集合中是否都满足谓词函数的元素 |
| Contains | 检查某个元素是否存在集合中 |
파티션 연산자는 하위 집합을 반환합니다. 부분적인 결과를 얻으려면 이를 사용하십시오.
int pageSize = 5;
int numberPages = (int)Math.Ceiling(Formulal.Racers.Count() / (double)pageSize);
for (int page = 0; page < numberPages; page++)
{ var racersPartition =
(from r in Formulal.Racers
orderby r.LastName, r.FirstName
select r.FirstName + " " + r.LastName).Skip(page * pageSize).Take(pageSize);
}로그인 후 복사
结果：
Page 0Fernando Alons
Mario Andretti
Alberto Ascari
Jack Brabham
Jenson ButtonPage 1Jim Clark
Juan Manuel Fa
Nino Farina
Emerson Fittipaldi
Mika Hakkinen
Page 2Lewis Hamilton
Mike Hawthorn
Damon Hill
Graham Hill
Phil Hill
로그인 후 복사
8集合操作符（Set operators）
集合操作符返回 一 个集合。除了Distinct之外，其他都需要2个集合。
| 集合操作符 | 描述 |
|---|
| Distinct | 从集合中删除重复的元素 |
| Union | 返回出现在其中一个集合中的唯一元素 |
| Intersect | 交集 |
| Except | 只出现在一个集合中的元素 |
| Zip | 通过使用指定的谓词函数合并2个集合 |
应用举例：
List<int> intList1 = new List<int>(5) {1, 2, 3, 4, 5,3};
List<int> intList2 = new List<int>(3) {2, 5, 0};
var delDuplic = intList1.Distinct(); //去重，结果{1,2,3,4,5}
var unionList = intList1.Union(intList2); //并集,结果{1,2,3,4,5,0}
var interList = intList1.Intersect(intList2); //交集，结果{2,5}
var exceptList = intList1.Except(intList2);//差集，结果{1,3,4}
var exceptList2 = intList2.Except(intList1);//差集，结果{0}
var unionList2 = intList1.Zip(intList2,((i1, i2) => i1+", "+i2));
结果：{{1,2}{2,5}{3,0}}로그인 후 복사
9元素操作符（Element operators）
这些元素操作符仅返回一 个元素。
| 元素操作符 | 描述 |
|---|
| First | 返回第一个满足条件的元素 |
| FirstOrDefault | 返回第一个满足条件的元素，但如果没有找到满足条件的元素,就返回类型的默认值 |
| Last | 返回最后一个满足条件的元素 |
| LastOrDefault | 返回最后一个满足条件的元素，但如果没有找到满足条件的元素,就返回类型的默认值 |
| ElementAt | 指定了要返回的元素的位置 |
| ElementAtOrDefault | 指定了要返回的元素的位置，但如果没有找到满足条件的元素,就返回类型的默认值 |
| Single | 只返回一个满足条件的元素，如果有多个满足条件，就抛出一个异常。 |
| SingleOrDefault | 只返回一个满足条件的元素，但如果没有找到满足条件的元素,就返回类型的默认值 |
应用举例：
List<int> intList1 = new List<int>(5) { 1, 8, 3, 4, 5, 3 };
int firstMore1 = intList1.First(r => r > 1);
//结果：8int firstMore17 = intList1.FirstOrDefault(r => r > 17);
//结果：0（因为不存在）int lastMore3 = intList1.Last(r => r > 3);
//结果5int last = intList1.ElementAt(2);
//结果3,（索引从0开始）로그인 후 복사
10聚合操作符（Aggregate operators）
聚合操作符计算集合的一个值。利用这些聚合操作符 ,可 以计算所有值的总和、所有元
素的个数、值最大和最小的元素 ,以 及平均值等
| 聚合操作符 | 描述 |
|---|
| Count | 所有值的个数 |
| Sum | 所有值的综合 |
| Min | 所有值的的最小值 |
| Max | 所有值的的最大值 |
| Average | 所有值的平均数 |
public class MyIntClass
{
public string Name { get; set; }
public int Integar { get; set; }
public MyIntClass(string name, int i)
{
this.Name = name;
this.Integar = Integar;
}
}
List<MyIntClass> intList1 = new List<MyIntClass>(5)
{
new MyIntClass("first",1),
new MyIntClass("second",8) ,
new MyIntClass("third",3) ,
new MyIntClass("fourth",4) ,
new MyIntClass("fifth",5) ,
new MyIntClass("sixth",3)
};
int count = intList1.Count;
int sum = intList1.Sum(r=>r.Integar);
int min = intList1.Min(r => r.Integar);
int max = intList1.Max(r => r.Integar);
double average = intList1.Average(r => r.Integar);로그인 후 복사
11转换操作符（Conversion operators）
转换操作符将集合转换为数组 :IEnumberable、 IList, IDictionary 等。
| Conversion operators | 描述 |
|---|
| ToArray | 集合转化为Array |
| AsEnumerable | 返回类型为IEnumerable< T> |
| ToList | 集合转化为List |
| ToDictionary | 集合转化为Dictionary |
| Cast< TResult> | 映射 |
还是上面的例子
IEnumerable<MyIntClass> ienuList = from r in intList1 where r.Integar > 3 select r; //返回默认的IEnumerable集合
List<MyIntClass> ienuList2 = (from r in intList1 where r.Integar > 3 select r).ToList(); //返回List
MyIntClass[] ienuList2 = (from r in intList1 where r.Integar > 3 select r).ToArray();//返回数组
var dict = (from r in intList1 where r.Integar > 3 select r).ToDictionary(r=>r.Name,r=>r.Integar); //字典，key是name, value：Integar
IEnumerable<MyIntClass> ienuList2 = (from r in intList1 where r.Integar > 3 select r).AsEnumerable();로그인 후 복사
12生成操作符（Generation operators）
这些生成操作符返回 一 个新集合
| Generation operators | 描述 |
|---|
| Empty | 集合是空的 |
| Range | 返回一系列数字 |
| Repeat | 返回始终重复一个值的集合 |
IEnumerable<int> ints = Enumerable.Range(3, 10);
//{3,4,5,6,7,8,9,10,11,12}IEnumerable<int> emptyInts = Enumerable.Empty<int>();
//生成一个空集合IEnumerable<int> ints2= Enumerable.Repeat(6,8);
//生成8个6的集合로그인 후 복사
附：展示所用到的实体类和数据
选手实体类
//选手实体类
public class Racer
{ public Racer(string firstName = null, string lastName = null,
string country = null, int starts = 0,int wins = 0, IEnumerable<int> years = null, IEnumerable<string> cars = null)
{ this.FirstName = firstName;
this.LastName = lastName;
this.Country = country;
this.Starts = starts;
this.Wins = wins;
var yearList = new List<int>();
if (years != null)
{
foreach (var year in years)
{
yearList.Add(year);
} this.Years = yearList.ToArray();
} if (cars != null)
{ var carList = new List<string>();
foreach (var car in cars)
{
carList.Add(car);
}
this.Cars = carList.ToArray();
} 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 string[] Cars { get; private set; } //赢得冠军的年份
public int[] Years { get; private set; }
}
}로그인 후 복사
选手数据
//选手实体类
public class Racer
{
public Racer(string firstName = null, string lastName = null, string country = null, int starts = 0,int wins = 0,
IEnumerable<int> years = null, IEnumerable<string> cars = null)
{
this.FirstName = firstName;
this.LastName = lastName;
this.Country = country;
this.Starts = starts;
this.Wins = wins;
var yearList = new List<int>();
if (years != null)
{
foreach (var year in years)
{
yearList.Add(year);
}
this.Years = yearList.ToArray();
}
if (cars != null)
{
var carList = new List<string>();
foreach (var car in cars)
{
carList.Add(car);
}
this.Cars = carList.ToArray();
}
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 string[] Cars { get; private set; }
//赢得冠军的年份
public int[] Years { get; private set; }
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
选手数据
//选手List
public static List<Racer> Racers = new List<Racer>(40)
{
new Racer("Nino", "Farina", "Italy", 33, 5, new int[] { 1950 }, new string[] { "Alfa Romeo" }),
new Racer("Alberto", "Ascari", "Italy", 32, 10, new int[] { 1952, 1953 }, new string[] { "Ferrari" }),
new Racer("Juan Manuel", "Fangio", "Argentina", 51, 24, new int[] { 1951, 1954, 1955, 1956, 1957 },
new string[] { "Alfa Romeo", "Maserati", "Mercedes", "Ferrari" }),
new Racer("Mike", "Hawthorn", "UK", 45, 3, new int[] { 1958 }, new string[] { "Ferrari" }),
new Racer("Phil", "Hill", "USA", 48, 3, new int[] { 1961 }, new string[] { "Ferrari" }),
new Racer("John", "Surtees", "UK", 111, 6, new int[] { 1964 }, new string[] { "Ferrari" }),
new Racer("Jim", "Clark", "UK", 72, 25, new int[] { 1963, 1965 }, new string[] { "Lotus" }),
new Racer("Jack", "Brabham", "Australia", 125, 14, new int[] { 1959, 1960, 1966 }, new string[] { "Cooper", "Brabham" }),
new Racer("Denny", "Hulme", "New Zealand", 112, 8, new int[] { 1967 }, new string[] { "Brabham" }),
new Racer("Graham", "Hill", "UK", 176, 14, new int[] { 1962, 1968 }, new string[] { "BRM", "Lotus" }),
new Racer("Jochen", "Rindt", "Austria", 60, 6, new int[] { 1970 }, new string[] { "Lotus" }),
new Racer("Jackie", "Stewart", "UK", 99, 27, new int[] { 1969, 1971, 1973 }, new string[] { "Matra", "Tyrrell" }),
new Racer("Emerson", "Fittipaldi", "Brazil", 143, 14, new int[] { 1972, 1974 }, new string[] { "Lotus", "McLaren" }),
new Racer("James", "Hunt", "UK", 91, 10, new int[] { 1976 }, new string[] { "McLaren" }),
new Racer("Mario", "Andretti", "USA", 128, 12, new int[] { 1978 }, new string[] { "Lotus" }),
new Racer("Jody", "Scheckter", "South Africa", 112, 10, new int[] { 1979 }, new string[] { "Ferrari" }),
new Racer("Alan", "Jones", "Australia", 115, 12, new int[] { 1980 }, new string[] { "Williams" }),
new Racer("Keke", "Rosberg", "Finland", 114, 5, new int[] { 1982 }, new string[] { "Williams" }),
new Racer("Niki", "Lauda", "Austria", 173, 25, new int[] { 1975, 1977, 1984 }, new string[] { "Ferrari", "McLaren" }),
new Racer("Nelson", "Piquet", "Brazil", 204, 23, new int[] { 1981, 1983, 1987 }, new string[] { "Brabham", "Williams" }),
new Racer("Ayrton", "Senna", "Brazil", 161, 41, new int[] { 1988, 1990, 1991 }, new string[] { "McLaren" }),
new Racer("Nigel", "Mansell", "UK", 187, 31, new int[] { 1992 }, new string[] { "Williams" }),
new Racer("Alain", "Prost", "France", 197, 51, new int[] { 1985, 1986, 1989, 1993 }, new string[] { "McLaren", "Williams" }),
new Racer("Damon", "Hill", "UK", 114, 22, new int[] { 1996 }, new string[] { "Williams" }),
new Racer("Jacques", "Villeneuve", "Canada", 165, 11, new int[] { 1997 }, new string[] { "Williams" }),
new Racer("Mika", "Hakkinen", "Finland", 160, 20, new int[] { 1998, 1999 }, new string[] { "McLaren" }),
new Racer("Michael", "Schumacher", "Germany", 287, 91, new int[] { 1994, 1995, 2000, 2001, 2002, 2003, 2004 },
new string[] { "Benetton", "Ferrari" }),
new Racer("Fernando", "Alonso", "Spain", 252, 32, new int[] { 2005, 2006 }, new string[] { "Renault" }),
new Racer("Kimi", "Räikkönen", "Finland", 230, 20, new int[] { 2007 }, new string[] { "Ferrari" }),
new Racer("Lewis", "Hamilton", "UK", 166, 43, new int[] { 2008, 2014, 2015 }, new string[] { "McLaren", "Mercedes" }),
new Racer("Jenson", "Button", "UK", 283, 15, new int[] { 2009 }, new string[] { "Brawn GP" }),
new Racer("Sebastian", "Vettel", "Germany", 156, 42, new int[] { 2010, 2011, 2012, 2013 }, new string[] { "Red Bull Racing" })
};로그인 후 복사
团队实体类
[Serializable] public class Team
{ public Team(string name, params int[] years)
{ this.Name = name; this.Years = years;
} public string Name { get; private set; }
public int[] Years { get; private set; }
}로그인 후 복사
团队数据
//冠军团队List
public static List<Team> ChampionTeams = new List<Team>()
{
new Team("Vanwall", 1958),
new Team("Cooper", 1959, 1960),
new Team("Ferrari", 1961, 1964, 1975, 1976, 1977, 1979, 1982, 1983, 1999, 2000, 2001, 2002, 2003, 2004, 2007,
2008), new Team("BRM", 1962),
new Team("Lotus", 1963, 1965, 1968, 1970, 1972, 1973, 1978),
new Team("Brabham", 1966, 1967),
new Team("Matra", 1969),
new Team("Tyrrell", 1971),
new Team("McLaren", 1974, 1984, 1985, 1988, 1989, 1990, 1991, 1998),
new Team("Williams", 1980, 1981, 1986, 1987, 1992, 1993, 1994, 1996, 1997),
new Team("Benetton", 1995),
new Team("Renault", 2005, 2006),
new Team("Brawn GP", 2009),
new Team("Red Bull Racing", 2010, 2011, 2012, 2013),
new Team("Mercedes", 2014, 2015)
};로그인 후 복사
以上就是C#Linq查询操作使用举例的内容，更多相关内容请关注PHP中文网（www.php.cn）！
![[웹 프런트엔드] Node.js 빠른 시작](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
