I found an example in the [VS2008 Examples][1] for Dynamic LINQ that allows you to use a SQL-like string (e.g. `OrderBy(&quot;Name, Age DESC&quot;))` for ordering. Unfortunately, the method included only works on `IQueryable&lt;T&gt;`. Is there any way to get this functionality on `IEnumerable&lt;T&gt;`?


  [1]: http://msdn2.microsoft.com/en-us/bb330936.aspx

Dynamic LINQ OrderBy on IEnumerable&lt;T&gt; / IQueryable&lt;T&gt;

I have a class `Items` with `properties (Id, Name, Code, Price)`.

The List of `Items` is populated with duplicated items. 

For ex.: 

    1         Item1       IT00001        $100
    2         Item2       IT00002        $200
    3         Item3       IT00003        $150
    1         Item1       IT00001        $100
    3         Item3       IT00003        $150

How to remove the duplicates in the list using linq?


Remove duplicates in the list using linq

I have the name of the &quot;sort by property&quot; in a string. I will need to use Lambda/Linq to sort the list of objects.

Ex:

    public class Employee
    {
      public string FirstName {set; get;}
      public string LastName {set; get;}
      public DateTime DOB {set; get;}
    }
    
    
    public void Sort(ref List&lt;Employee&gt; list, string sortBy, string sortDirection)
    {
      //Example data:
      //sortBy = &quot;FirstName&quot;
      //sortDirection = &quot;ASC&quot; or &quot;DESC&quot;

      if (sortBy == &quot;FirstName&quot;)
      {
        list = list.OrderBy(x =&gt; x.FirstName).toList();    
      }
    
    }

1. Instead of using a bunch of ifs to check the fieldname (sortBy), is there a cleaner way of doing the sorting
2. Is sort aware of datatype?

Sorting a list using Lambda/Linq to objects

Using the C# compilers query comprehension features, you can write code like:

    var names = new string[] { &quot;Dog&quot;, &quot;Cat&quot;, &quot;Giraffe&quot;, &quot;Monkey&quot;, &quot;Tortoise&quot; };
    var result =
        from animalName in names
        let nameLength = animalName.Length
        where nameLength &gt; 3
        orderby nameLength
        select animalName; 

In the query expression above, the `let` keyword allows a value to be passed forward to the where and orderby operations without duplicate calls to `animalName.Length`.

What is the equivalent set of LINQ extension method calls that achieves what the &quot;let&quot; keyword does here?

Code equivalent to the &#39;let&#39; keyword in chained LINQ extension method calls

I have a list of `orders`.  
I want to select `orders` based on a set of order statuses.

So essentially `select orders where order.StatusCode in (&quot;A&quot;, &quot;B&quot;, &quot;C&quot;)`

    // Filter the orders based on the order status
    var filteredOrders = from order in orders.Order
                         where order.StatusCode.????????(&quot;A&quot;, &quot;B&quot;, &quot;C&quot;)
                         select order;

Linq select objects in list where exists IN (A,B,C)

I often see people using `Where.FirstOrDefault()` to do a search and grab the first element. Why not just use `Find()`? Is there an advantage to the other? I couldn&#39;t tell a difference.

    namespace LinqFindVsWhere
    {
        class Program
        {
            static void Main(string[] args)
            {
                List&lt;string&gt; list = new List&lt;string&gt;();
                list.AddRange(new string[]
                {
                    &quot;item1&quot;,
                    &quot;item2&quot;,
                    &quot;item3&quot;,
                    &quot;item4&quot;
                });
    
                string item2 = list.Find(x =&gt; x == &quot;item2&quot;);
                Console.WriteLine(item2 == null ? &quot;not found&quot; : &quot;found&quot;);
                string item3 = list.Where(x =&gt; x == &quot;item3&quot;).FirstOrDefault();
                Console.WriteLine(item3 == null ? &quot;not found&quot; : &quot;found&quot;);
                Console.ReadKey();
            }
        }
    }

Find() vs. Where().FirstOrDefault()

## Overview
One of the things I&#39;ve asked a lot about on this site is [LINQ][1]. The questions I&#39;ve asked have been wide and varied and often don&#39;t have much context behind them. So in an attempt to consolidate the knowledge I&#39;ve acquired on Linq I&#39;m posting this question with a view to maintaining and updating it with additional information as I continue to learn about LINQ. 

I also hope that it will prove to be a useful resource for other people wanting to learn about LINQ. 

## What is LINQ?
From [MSDN][2]:

&gt; The LINQ Project is a codename for a
&gt; set of extensions to the .NET
&gt; Framework that encompass
&gt; language-integrated query, set, and
&gt; transform operations. It extends C#
&gt; and Visual Basic with native language
&gt; syntax for queries and provides class
&gt; libraries to take advantage of these
&gt; capabilities.

What this means is that LINQ provides a standard way to query a variety of datasources using a common syntax. 

## What flavours of LINQ are there?
Currently there are a few different LINQ providers provided by Microsoft:

 - [Linq to Objects][3] which allows you to execute queries on any IEnumerable object.  
 - [Linq to SQL][4] which allows you to execute queries against a database in an object oriented manner.  
 - [Linq to XML][5] which allows you to query, load, validate, serialize and manipulate XML documents.
 - [Linq to Entities][6] as suggested by [Andrei][7]
 - [Linq to Dataset][8]

There are quite a few others, many of which are listed [here][9].
## What are the benefits?

 - Standardized way to query multiple datasources
 - Compile time safety of queries
 - Optimized way to perform set based operations on in memory objects
 - Ability to debug queries

## So what can I do with LINQ?
[Chook][10] provides a way to [output CSV files][11]  
[Jeff][12] shows how to [remove duplicates from an array][13]  
Bob gets a [distinct ordered list from a datatable][14]  
[Marxidad][15] shows how to [sort an array][16]  
Dana gets help implementing a [Quick Sort Using Linq][17]  

## Where to start?
**A summary of links from [GateKiller&#39;s question][18] are below**:  
Scott Guthrie provides an [intro to Linq on his blog][19]  
An overview of [LINQ on MSDN][20]  

**[ChrisAnnODell][21] suggests checking out:**  

  - [Hooked on Linq][22]  
  - [101 Linq Samples][23]
  - [LinqPad][24]  

## What do I need to use LINQ?

Linq is currently available in VB.Net 9.0 and C# 3.0 so you&#39;ll need Visual Studio 2008 or greater to get the full benefits. (You could always write your code in notepad and compile using MSBuild)

There is also a tool called [LinqBridge][25] which will allow you to run Linq like queries in C# 2.0. 

## Tips and tricks using LINQ

[This question][26] has some tricky ways to use LINQ


  [1]: http://msdn.microsoft.com/en-us/netframework/aa904594.aspx
  [2]: http://msdn.microsoft.com/en-us/netframework/aa904594.aspx
  [3]: http://msdn.microsoft.com/en-us/library/bb397919.aspx
  [4]: http://msdn.microsoft.com/en-us/library/bb425822.aspx
  [5]: http://msdn.microsoft.com/en-us/library/bb387098.aspx
  [6]: http://msdn.microsoft.com/en-us/library/bb386964.aspx
  [7]: https://stackoverflow.com/questions/16322/all-about-linq#33588
  [8]: http://msdn.microsoft.com/en-us/library/bb399399.aspx
  [9]: http://blogs.microsoft.co.il/blogs/vardi/archive/2008/10/09/the-linq-list-projects.aspx
  [10]: https://stackoverflow.com/users/489/ch00k
  [11]: https://stackoverflow.com/questions/4432/csv-string-handling#4441
  [12]: https://stackoverflow.com/users/1/jeff-atwood
  [13]: https://stackoverflow.com/questions/9673/remove-duplicates-from-array#9685
  [14]: https://stackoverflow.com/questions/59/how-do-i-get-a-distinct-ordered-list-of-names-from-a-datatable-using-linq#62
  [15]: https://stackoverflow.com/users/1659/marxidad
  [16]: https://stackoverflow.com/questions/15486/sorting-an-ilist-in-c#15495
  [17]: https://stackoverflow.com/questions/185072/learning-linq-quicksort
  [18]: https://stackoverflow.com/questions/8050/beginners-guide-to-linq
  [19]: http://weblogs.asp.net/scottgu/archive/2007/05/19/using-linq-to-sql-part-1.aspx
  [20]: http://msdn.microsoft.com/en-us/library/bb308959.aspx
  [21]: https://stackoverflow.com/users/1758/ChrisAnnODell
  [22]: http://www.hookedonlinq.com/MainPage.ashx
  [23]: http://code.msdn.microsoft.com/101-LINQ-Samples-3fb9811b
  [24]: http://www.linqpad.net/
  [25]: https://stackoverflow.com/questions/7652/querying-like-linq-when-you-dont-have-linq#7710
  [26]: https://stackoverflow.com/questions/28858/coolest-c-linqlambdas-trick-youve-ever-pulled

Learning about LINQ

If I have a class that looks like:

    public class Item
    {
        public int ClientID { get; set; }
        public int ID { get; set; }
    }

And a collection of those items...

    List&lt;Item&gt; items = getItems();

How can I use LINQ to return the single &quot;Item&quot; object which has the highest ID?

If I do something like:

    items.Select(i =&gt; i.ID).Max(); 

I&#39;ll only get the highest ID, when what I actually want returned is the Item object itself which has the highest ID?  I want it to return a single &quot;Item&quot; object, not an int. 


How can I get LINQ to return the object which has the max value for a given property?

I have the following dictionary:

    Dictionary&lt;int,string&gt; dic = new Dictionary&lt;int,string&gt;();
    dic[1] = &quot;A&quot;;
    dic[2] = &quot;B&quot;;

I want to filter the dictionary&#39;s items and reassign the result to the same variable:

    dic = dic.Where (p =&gt; p.Key == 1);

How can I return the result as a dictionary from the same type [`&lt;int,string&gt;`] ?

I tried `ToDictionary`, but it doesn&#39;t work.



How can I filter a dictionary using LINQ and return it to a dictionary from the same type

I have a List(Of DateTime) items. How can I check if all the items are the same with a LINQ query? At any given time there could be 1, 2, 20, 50 or 100 items in the list.


Check if all items are the same in a List

From what I understand from the documentation of SelectMany, one could use it to produce a (flattened) sequence of a 1-many relationship.

I have following classes

      public class Customer
      {
        public int Id { get; set; }
        public string Name { get; set; }
      }
    
      class Order
      {
        public int Id { get; set; }
        public int CustomerId { get; set; }
        public string Description { get; set; }
      }


I then try to use them using the query expression syntax like so

      var customers = new Customer[]
      {
        new Customer() { Id=1, Name =&quot;A&quot;},
        new Customer() { Id=2, Name =&quot;B&quot;},
        new Customer() { Id=3, Name =&quot;C&quot;}
      };
    
      var orders = new Order[]
      {
        new Order { Id=1, CustomerId=1, Description=&quot;Order 1&quot;},
        new Order { Id=2, CustomerId=1, Description=&quot;Order 2&quot;},
        new Order { Id=3, CustomerId=1, Description=&quot;Order 3&quot;},
        new Order { Id=4, CustomerId=1, Description=&quot;Order 4&quot;},
        new Order { Id=5, CustomerId=2, Description=&quot;Order 5&quot;},
        new Order { Id=6, CustomerId=2, Description=&quot;Order 6&quot;},
        new Order { Id=7, CustomerId=3, Description=&quot;Order 7&quot;},
        new Order { Id=8, CustomerId=3, Description=&quot;Order 8&quot;},
        new Order { Id=9, CustomerId=3, Description=&quot;Order 9&quot;}
      };
    
      var customerOrders = from c in customers
                           from o in orders
                           where o.CustomerId == c.Id
                           select new 
                                  { 
                                     CustomerId = c.Id
                                     , OrderDescription = o.Description 
                                  };
    
      foreach (var item in customerOrders)
        Console.WriteLine(item.CustomerId + &quot;: &quot; + item.OrderDescription);


This gives to what I need.

    1: Order 1
    1: Order 2
    1: Order 3
    1: Order 4
    2: Order 5
    2: Order 6
    3: Order 7
    3: Order 8
    3: Order 9

I assume this translates to using the SelectMany method when not using the query expression syntax?

Either ways, I&#39;m trying to wrap my head around using SelectMany. So even if my above query does not translate to SelectMany, given the two classes and mock data, could someone provide me with a linq query that uses SelectMany?


Linq - SelectMany Confusion

I have an List&lt;T&gt; and I&#39;d like to wrap it into an IQueryable&lt;T&gt;.

Is this possible?

IList&lt;T&gt; to IQueryable&lt;T&gt;

With extension methods, we can write handy LINQ operators which solve generic problems.

I want to hear which methods or overloads you are missing in the `System.Linq` namespace and how you implemented them.

Clean and elegant implementations, maybe using existing methods, are preferred.


What&#39;s your favorite LINQ to Objects operator which is not built-in?

I&#39;m using LINQPad to create LINQ queries in an application I&#39;m bulding.

I noticed that in the downloaded **LINQ in Action** samples, e.g. example 4.04, intellisense shows a class &quot;Books&quot; but I don&#39;t see any **references** or &quot;**using**&quot; statements in the LINQPad tool, here is the sample:

    List&lt;Book&gt; books = new List&lt;Book&gt;() {
      new Book { Title=&quot;LINQ in Action&quot; },
      new Book { Title=&quot;LINQ for Fun&quot; },
      new Book { Title=&quot;Extreme LINQ&quot; } };
    
    var titles =
      books
        .Where(book =&gt; book.Title.Contains(&quot;Action&quot;))
        .Select(book =&gt; book.Title);
    
    titles.Dump();

In &quot;LinqBooks.Common, Business Objects, **Book.linq**&quot; is where the class seems to be defined:

    public class Book
    {
      public IEnumerable&lt;Author&gt; Authors {get; set;}
      public String Isbn {get; set;}
      public String Notes {get; set;}
      public Int32 PageCount {get; set;}
      public Decimal Price {get; set;}
      public DateTime PublicationDate {get; set;}
      public Publisher Publisher {get; set;}
      public IEnumerable&lt;Review&gt; Reviews {get; set;}
      public Subject Subject {get; set;}
      public String Summary {get; set;}
      public String Title {get; set;}
      public String Test {get; set;}
    
      public override String ToString()
      {
        return Title;
      }
    }

**But how does this work so that I can copy in my classes and use LINQPad to quickly build LINQ statements that I can then copy back into my application?**


How does LINQPad reference other classes, e.g. Books in the LINQ in Action samples

    public class ClassA
    {
         public string MyString {get; set;}
    }

    public class ClassB
    {
         public List&lt;ClassA&gt; MyObjects {get; set;}
    }

    List&lt;ClassB&gt; classBList = new List&lt;ClassB&gt;();
    var results = (from i in classBList select i.MyObjects).Distinct();

I want a distinct list of all the `ClassA` objects in the `classBList`.  How do I go about this using **LINQ**? I&#39;m thinking about a nested query, but couldn&#39;t quite figure it out.  Any help is very appreciated.

Using LINQ, select list of objects inside another list of objects

I would like to be able to fusion an `IEnumerable&lt;IEnumerable&lt;T&gt;&gt;` into `IEnumerable&lt;T&gt;` (i.e. merge all individual collections into one). The `Union` operators only applies to two collections. Any idea?

How to merge a collection of collections in Linq

Is there a way in Linq to do an OrderBy against a set of values (strings in this case) without knowing the order of the values?

Consider this data:

    A
    B
    A
    C
    B
    C
    D
    E

And these variables:

string firstPref, secondPref, thirdPref;

When the values are set like so:

    firstPref = &#39;A&#39;;
    secondPref = &#39;B&#39;;
    thirdPref = &#39;C&#39;;

Is it possible to order the data like so:

    A
    A
    B
    B
    C
    C
    D
    E

Linq OrderBy against specific values

Just a little niggle about LINQ syntax. I&#39;m flattening an `IEnumerable&lt;IEnumerable&lt;T&gt;&gt;` with `SelectMany(x =&gt; x)`.

My problem is with the lambda expression `x =&gt; x`. It looks a bit ugly. Is there some static &#39;identity function&#39; object that I can use instead of `x =&gt; x`? Something like `SelectMany(IdentityFunction)`?


All Linq to-Objects Solutions on Gang of Coders

Total of 18 Linq to-Objects Solutions

Dynamic LINQ OrderBy on IEnumerable<T> / IQueryable<T>