In my last post about LINQ I shown you an example about how to use the language integrated query to select information about directories. In this post I’ll get more into the syntax and show you something about the functional querying style.<\/p>\n
My examples will focus on displaying information about UEFA Champions Leage winners. Thus, I have created a class called Winner that looks this this:<\/p>\n
\r\nclass Winner\r\n{\r\n string _name;\r\n string _country;\r\n int _year;\r\n\r\n public string Name\r\n {\r\n get { return _name; }\r\n set { _name = value; }\r\n }\r\n public string Countryr\r\n {\r\n get { return _country; }\r\n set { _country = value; }\r\n }\r\n\r\n public int Year\r\n {\r\n get { return _year; }\r\n set { _year = value; }\r\n }\r\n\r\n public Winner(string name, string country, int year)\r\n {\r\n _name = name;\r\n _country = country;\r\n _year = year;\r\n }\r\n};\r\n<\/pre>\n<\/p>\n
Also I have created a utility class that returns a list (incomplete) of UCL winners:<\/p>\n
\r\nclass UCL\r\n{\r\n public static IEnumerable<Winner> GetWinners()\r\n {\r\n Winner [] winners = \r\n {\r\n new Winner(\"Barcelona\", \"Spain\", 2006),\r\n new Winner(\"Liverpool\", \"England\", 2005),\r\n new Winner(\"FC Porto\", \"Portugal\", 2004),\r\n new Winner(\"AC Milan\", \"Italy\", 2003),\r\n new Winner(\"Real Madrid\", \"Spain\", 2002),\r\n new Winner(\"Bayern Munchen\", \"Germany\", 2001),\r\n new Winner(\"Real Madrid\", \"Spain\", 2000),\r\n new Winner(\"Manchester Utd.\", \"England\", 1999),\r\n new Winner(\"Real Madrid\", \"Spain\", 1998),\r\n new Winner(\"Olimpique Marseille\", \"France\", 1993),\r\n };\r\n\r\n return winners;\r\n }\r\n};\r\n<\/pre>\n<\/p>\n
Now, let’s see how we could display all this info ascending by the year of winning:<\/p>\n
\r\nIEnumerable<Winner> winners = UCL.GetWinners();\r\nvar result = from w in winners\r\n orderby w.Year\r\n select w;\r\n\r\nforeach (var w in result)\r\n{\r\n Console.WriteLine(\"{0}\\t{1}, {2}\",\r\n w.Year, w.Name, w.Country);\r\n}\r\n<\/pre>\n<\/p>\n
That lists the following:<\/p>\n
\r\n1993 Olimpique Marseille, France\r\n1998 Real Madrid, Spain\r\n1999 Manchester Utd., England\r\n2000 Real Madrid, Spain\r\n2001 Bayern Munchen, Germany\r\n2002 Real Madrid, Spain\r\n2003 AC Milan, Italy\r\n2004 FC Porto, Portugal\r\n2005 Liverpool, England\r\n2006 Barcelona, Spain\r\n<\/pre>\n<\/p>\n
This SQL-like syntax is however only a “shell” over the functional syntax. It’s just like with the foreach statement. To be able to iterate with foreach, the collection must implement IEnumerable, which has a method that returns a class that implements IEnumerator. What the compiler is doing when using foreach is calling GetEnumerator to get an iterator, and then Reset() on it, and inserts a while(iterator.MoveNext()), using Current to access the current object from the collection. The same happens here with the declarative query syntax. <\/p>\n
Now, let’s suppose we want to list only the winners from England. What we have to do is adding a filtering:<\/p>\n
\r\nvar result = from w in winners\r\n orderby w.Year\r\n where w.Country == \"England\"\r\n select w;\r\n<\/pre>\n<\/p>\n
What I wrote above is actually the same with:<\/p>\n
\r\nvar result = winners.\r\n OrderBy(w => w.Year).\r\n Where(w => w.Country == \"England\").\r\n Select(w => w);\r\n<\/pre>\n<\/p>\n
Here we used the operators OrderBy, Where and Select. These are two of the query operators that allow you to perform filtering, projection and key extraction. These are built of the concept of Lambda expression, which are similar to the CLR delegates. We could rewrite the last query list this:<\/p>\n
\r\nFunc<Winner, bool> filter = w => w.Country == \"England\";\r\nFunc<Winner, int> criteria = w => w.Year;\r\nFunc<Winner, Winner> project = w => w;\r\n\r\nvar result = winners.OrderBy(criteria).Where(filter).Select(project);\r\n<\/pre>\n<\/p>\n
OrderBy and OrderByDescending are operators that impose a partial order over the keys. Operators ThenBy and ThenByDescending are used to apply additional sorting criteria by only on sorted sequences (SortedSequence).<\/p>\nWhere is used to exclude items from the collection.<\/p>\n
Select and SelectMany are operators for projecting only those fields or info that is wanted.<\/p>\n
Now, let’s try something more complicated: grouping the winners by country, and inside each group ascending by the winning year. In declarative syntax that would be like this:<\/p>\n
\r\nvar result = from w in winners\r\n orderby w.Year\r\n group w.Name by w.Country into groups\r\n orderby groups.Key\r\n select groups;\r\n\r\nforeach (var w in result)\r\n{\r\n Console.WriteLine(\"\\n{0}\", w.Key);\r\n\r\n foreach (var e in w)\r\n {\r\n Console.WriteLine(\"{0}\", e);\r\n }\r\n}\r\n<\/pre>\n<\/p>\n
\r\nEnagland\r\nManchester Utd.\r\nLiverpool\r\n\r\nFrance\r\nOlimpique Marseille\r\n\r\nGermany\r\nBayern Munchen\r\n\r\nItaly\r\nAC Milan\r\n\r\nPortugal\r\nFC Porto\r\n\r\nSpain\r\nReal Madrid\r\nReal Madrid\r\nReal Madrid\r\nBarcelona\r\n<\/pre>\n<\/p>\n
In functional programming syntax, the same query is written as:<\/p>\n
\r\nvar result = winners.\r\n OrderByDescending(w => w.Year).\r\n GroupBy(w => w.Country, w => w.Name).\r\n OrderBy(w => w.Key).\r\n Select(w => w);\r\n<\/pre>\n\nThe GroupBy operator imposes a partitioning over a sequence of values based on a key extraction function. It returns a sequence of Grouping values, which contains both the key as well as the group of values mapped to the key. The interface of Grouping is:<\/p>\n
\r\npublic sealed class Grouping<K, T>{\r\n public Grouping(K key, IEnumerable<T> group);\r\n public Grouping();\r\n public K Key {get; set;}\r\n public IEnumerable<T> Group {get; set;}\r\n}\r\n<\/pre>\n<\/p>\n
You may wonder why the declarative syntax starts with the from clause. The SQL language has a problem, i.e. the order of clauses is not natural. Select is the first by at the time of selecting, you don’t know where do you select from. The from clause is naturally the first one, and this was rectified in LINQ. You always have to put from as the first clause in a query (when using the declarative syntax). In the functional syntax you can see you have to apply the operators on a collection, a sequence of items (in our case winners). That is the functional equivalent of from.<\/p>\n","protected":false},"excerpt":{"rendered":"
In my last post about LINQ I shown you an example about how to use the language integrated query to select information about directories. In this post I’ll get more into the syntax and show you something about the functional querying style. My examples will focus on displaying information about UEFA Champions Leage winners. Thus, … Read more<\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_uag_custom_page_level_css":"","advgb_blocks_editor_width":"","advgb_blocks_columns_visual_guide":"","_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_feature_clip_id":0,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":false,"jetpack_social_options":{"image_generator_settings":{"template":"highway","default_image_id":0,"font":"","enabled":false},"version":2},"jetpack_post_was_ever_published":false},"categories":[11,14],"tags":[],"class_list":["post-27","post","type-post","status-publish","format-standard","hentry","category-csharp","category-linq"],"aioseo_notices":[],"aioseo_head":"\n\t\t\n\t\n\t\n\t\n\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t