简体中文(ZH-CN) English(EN) 繁体中文(ZH-TW) 日本語(JA) 한국어(KO) Melayu(MS) Français(FR) Deutsch(DE)
Home > Backend Development > C#.Net Tutorial > body text

.NET Framework-Sample code used by LINQ9 class operators

黄舟
Release： 2017-03-20 12:02:13
Original
1312 people have browsed it

Linq standardQueryOperator

Language set query Ganmge hteg.ratedQuw, LINQ, integrates the query syntax in the C# programming language, and can use the same Syntax for accessing different data sources. LINQ provides an abstraction layer for different data sources, so the same syntax can be used.

1Filter operator

Filter operator defines the conditions for returning elements.

##where Use predicates to return a Boolean valueOfType< TResult>Filter elements based on type
Filter operator Description
Application examples:

where Usage: 

 var racers = from r in Formulal.Racers                         
 where r.Wins > 15 && r.Country == "Brazil" select r;
Copy after login

OfType< New Object

Projection OperatorDescription

selectMany##Usage example: 
object[] data = {"one", 2, "three", 4, 5, "six"};            
var rtnData = data.OfType<string>(); //返回类型为string的数据元素集合
Copy after login
3 Sorting operatorChange the order of returned elements
##select

select usage selectMany usage
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个属性的对象集合
Copy after login


Sort operator

Description

OrderByAscending orderOrderByDescendingDescending sortThenByThe first sorting result is similar, use the second ascending sortThenByDescendingThe first sorting result is similar, use the second descending sortingReverseReverse the order of the elements in the setExample: 
            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);//筛选出驾驶法拉利的选手集合
Copy after login
Operator is used to merge collections that are not directly related
4 connection

Join OperatorDescription

JoinJoins can be joined based on key selector functions 2 collectionsGroupJoinConnect two collections and combine the resultsResult: Racerj
##
    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
                          };//国家为巴西，按照胜场次数降序排列
Copy after login
Yearj
Teamj

##Yearj=2004Racerj=Michael SchumacherTeamj =FerrariYearj=2005Racerj=Fernando AlonsoTeamj =RenaultYearj=2006Racerj=Fernando AlonsoTeamj =RenaultRacerj=Kimi RäikkönenRacerj=Lewis HamiltonRacerj=Lewis HamiltonRacerj=Lewis Hamilton##Yearj=2009Racerj=Jenson ButtonTeamj =Brawn GPTeamj =Red Bull RacingTeamj =Red Bull RacingTeamj =Red Bull RacingTeamj =Red Bull Racing5 Combination OperatorPut data in groups
##Yearj= 2007
Teamj =FerrariYearj=2008
Teamj =FerrariYearj=2014
Teamj =Mercedes Yearj=2015
Teamj =Mercedes
##Yearj=2010Racerj=Sebastian Vettel
Yearj=2011Racerj=Sebastian Vettel
Yearj=2012 Racerj=Sebastian Vettel
Yearj=2013Racerj=Sebastian Vettel
Combining Operator Description

GroupBy

Group elements with a common keyGroupBy usage example: Result: ##Country Count
ToLookUpcombines elements by creating a one-to-many dictionary. 
//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
                };
Copy after login

UK

10

##BrazilFinland3Ifgrouping, it should be written like this: 6QuantifierOperatorIf the element sequence meets the specified conditions, the quantifier operator returns a Boolean value
3
needs to be based on multiple fields
 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的国家
Copy after login
Composition operator

Description

##AnyDetermine whether there is a Elements that satisfy the predicate function

AllDetermine whether all elements in the set satisfy the predicate functionContainsCheck whether an element exists in the collection
            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
Copy after login

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);                       
            }
Copy after login

结果：

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
Copy after login

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}}
Copy after login

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开始）
Copy after login

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);
Copy after login

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();
Copy after login

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的集合
Copy after login

附：展示所用到的实体类和数据

选手实体类

   //选手实体类
   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; }   
         }
      }
Copy after login

选手数据

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

        };
Copy after login

团队实体类

    [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; }
    }
Copy after login

团队数据

        //冠军团队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)
        };
Copy after login


The above is the detailed content of .NET Framework-Sample code used by LINQ9 class operators. For more information, please follow other related articles on the PHP Chinese website!

Related labels：
.NET框架，LINQ9，操作符
source：php.cn
Previous article：.NET Framework-detailed explanation of exception design principles Next article：.NET Framework-detailed introduction to WinForm Mortgage Analyzer (graphics and text)
Statement of this Website
The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn
Latest Articles by Author
Latest Issues
Create scalable signposts using HTML, CSS and SVG I want to make a button in the form of a signpost (a rectangle with a tip). _______|\|____...
From 2024-03-31 14:45:14
0
1
294
Related Topics
More>
Popular Recommendations
Popular Tutorials
More>
Related Tutorials
Popular Recommendations
Latest courses
Latest Downloads
More>
Web Effects
Website Source Code
Website Materials
Front End Template
About us Disclaimer Sitemap
php.cn：Public welfare online PHP training，Help PHP learners grow quickly！