C#.Net 튜토리얼

.NET Framework - LINQ9 클래스 연산자에서 사용되는 샘플 코드

黄舟

Mar 20, 2017 pm 12:02 PM

Linq StandardQueryOperator

Language Set Query Ganmge hteg.ratedQuw, LINQ는 C# 프로그래밍 언어의 쿼리 구문을 통합하고 동일한 구문을 사용할 수 있습니다. 다양한 데이터 소스에 액세스하기 위한 것입니다. LINQ는 다양한 데이터 소스에 대한 추상화 계층을 제공하므로 동일한 구문을 사용할 수 있습니다.

1 필터 연산자

필터 연산자는 요소 반환 조건을 정의합니다.

筛选操作符	描述
where	使用谓词，返回布尔值
OfType	根据类型筛选元素

응용 사례:
사용법:

 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的数据元素集合

2 투영 연산자

🎜>객체 다른 유형의 새로운 객체로 변환

투영 연산자

설명

선택

selectMany

投射操作符	描述
select
selectMany

td>

사용 예:
사용 선택

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个属性的对象集合

selectMany 사용

            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);//筛选出驾驶法拉利的选手集合

3개의 정렬 연산자

반환된 요소의 순서 변경

排序操作符	描述
OrderBy	升序排序
OrderByDescending	降序排序
ThenBy	第一次排序结果类似，用第二次升序排序
ThenByDescending	第一次排序结果类似，用第二次降序排序
Reverse	反转集合中元素的顺序

예:

    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
                          };//国家为巴西，按照胜场次数降序排列

4 연결연산자

는 직접 관련되지 않은

//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
                };

连接运算符	描述
Join	可以根据键选择器函数连接连接2个集合
GroupJoin	连接两个集合,组合其结果

결과:

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

5개의 조합 연산자

그룹에 데이터 넣기

组合运算符	描述
GroupBy	组合有公共键的元素
ToLookUp	通过创建一个一对多的字典，来组合元素。

GroupBy 사용 예:

 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的国家

결과:

Country	Count
UK	10
Brazil	3
Finland	3

그룹화가 여러 필드를 기반으로 해야 하는 경우 다음과 같이 작성해야 합니다.

            //按组合键分组后，每组元素个数大于2的分组，按降序排序
            var rtnByVal1 = from item in dataSource                            
            group item by new { item.Val1, item.Val2 }                                
            into g                                
            where g.Count()>1
                                orderby g.Count() descending
                                select g;            //按Val1和Val2组合为字典键，元素个数为值
            var dict = rtnByVal1.ToDictionary(g=>g.First(),g=>g.Count());

정량자연산자

요소 시퀀스가 지정된 조건을 충족하면 수량자 연산자는 부울 값을 반환합니다

합성 연산자	설명
모두	세트 중 하나라도 조건자를 만족하는지 여부를 결정합니다. 함수
모두 td>	집합의 모든 요소가 조건자 함수를 충족하는지 확인
포함	집합에 요소가 존재하는지 확인

            List<int> intList1 = new List<int>(5) {1, 2, 3, 4, 5};           
            bool any3 = intList1.Any(r => r == 3);//确定集合中是否有3，返回true
            bool any0 = intList1.Any(r => r == 0);//确定集合中是否有0，返回false
            bool allMoreZero = intList1.All(r => r > 0);//确定序列中所有元素都满足大于0，返回true
            bool allMore2 = intList1.All(r => r > 2); //返回false
            bool contains3 = intList1.Contains(3); //元素3是否在集合中，true

7分区操作符

分区操作符，返回一个子集。使用它们可以得到部分结果。

分区运算符	描述
Take	必须制定提取元素的个数
Skip	跳过指定的元素个数，提取其他元素
TakeWhile	提取条件为真的元素
SkipWhile	跳过条件为真的元素

            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);//结果：8
int firstMore17 = intList1.FirstOrDefault(r => r > 17); //结果：0（因为不存在）
int lastMore3 = intList1.Last(r => r > 3); //结果5
int 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
ToList	集合转化为List
ToDictionary	集合转化为Dictionary
Cast	映射

还是上面的例子

         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; }   
         }
      }

选手数据

//选手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)
        };

위 내용은 .NET Framework - LINQ9 클래스 연산자에서 사용되는 샘플 코드의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!

성명

본 글의 내용은 네티즌들의 자발적인 기여로 작성되었으며, 저작권은 원저작자에게 있습니다. 본 사이트는 이에 상응하는 법적 책임을 지지 않습니다. 표절이나 침해가 의심되는 콘텐츠를 발견한 경우 admin@php.cn으로 문의하세요.

핫 AI 도구

Video Face Swap

완전히 무료인 AI 얼굴 교환 도구를 사용하여 모든 비디오의 얼굴을 쉽게 바꾸세요!

뜨거운 도구

안전한 시험 브라우저

안전한 시험 브라우저는 온라인 시험을 안전하게 치르기 위한 보안 브라우저 환경입니다. 이 소프트웨어는 모든 컴퓨터를 안전한 워크스테이션으로 바꿔줍니다. 이는 모든 유틸리티에 대한 액세스를 제어하고 학생들이 승인되지 않은 리소스를 사용하는 것을 방지합니다.

이 프로젝트는 osdn.net/projects/mingw로 마이그레이션되는 중입니다. 계속해서 그곳에서 우리를 팔로우할 수 있습니다. MinGW: GCC(GNU Compiler Collection)의 기본 Windows 포트로, 기본 Windows 애플리케이션을 구축하기 위한 무료 배포 가능 가져오기 라이브러리 및 헤더 파일로 C99 기능을 지원하는 MSVC 런타임에 대한 확장이 포함되어 있습니다. 모든 MinGW 소프트웨어는 64비트 Windows 플랫폼에서 실행될 수 있습니다.