En System.Linq existen una serie de métodos de extensión que permiten hacer consultas sobre datos (sobre xml, bases de datos…).

Los siguientes son ejemplos de consultas sobre elementos en memoria:

IEnumerable<Person> list = lPerson.Where(p => p.firstName.StartsWith("A"));
int maxAge = lPerson.Max(p => p.age);
double avg = lPerson.Average(p => p.age);

Pero en LINQ existen lo que serían las sintaxis de expresiones para realizar este tipo de consultas. Estas son parecidas a las sentencias sql de toda la vida y empiezan siempre por from y acaban por select siguiendo una estructura como la que sigue:

from elementos_a_consultar in lista select elementos_devueltos

Un ejemplo:

IEnumerable<Person> list = from p in lPerson select p;

También podemos agregar clausulas where y orderby:

IEnumerable<Person> list = from p 
    in lPerson 
    where p.firstName.StartsWith("A")
    orderby p.age
    select p;

En el código de arriba el trozo from p in lPerson indica lanzar una consulta LINQ sobre la colección lPerson, y que usaremos el parámetro p para representar a cada elemento que consultamos. En realidad, el nombre del parámetro p es irrelevante - podría haberlo llamado o, x, person o de cualquier otra forma. El trozo select p nos indica que queremos devolver una secuencia IEnumerable de objetos Person como resultado de la consulta. Esto esto pasa porque la colección lPerson contiene objetos de tipo Person. Pero si quisieramos devolver los nombres sería algo así:

IEnumerable<string> list = from p 
    in lPerson 
    where p.firstName.StartsWith("A")
    orderby p.age
    select p.firstName;

También podemos consultar los elementos relacionados o ordendar descendentemente:

IEnumerable<string> categories = from c in Categories
	where c.Products.Count > 5
	orderby c.CategoryName descending
	select c.CategoryName;

Otro ejemplo sería el de devolver un objeto de una clase que no es la de los elementos de la lista:

class AlternatePerson {
	string nameAge { get; set; }
}
...
IEnumerable<AlternatePerson> friends = from p in lPeople
	where p.LastName.StartsWith("G")
	select new AlternatePerson {
		nameAge = p.FirstName + p.Age;
	}

Una de las principales características de la interface IEnumerable<T> es que los objetos que las implementen pueden retrasar su ejecución hasta el momento en que se introduzca en un bucle (esto es posible gracias al yield). LINQ usa esta ventaja, retrasando las consultas hasta la primera vez que se itere sobre el resultado. Si nunca se itera sobre una IEnumerable<T>, entonces, la consulta nunca es ejecutada. Pero si lo que queremos es ejecutar inmediatamente la consulta (utilizando toList o toArray) haremos:

List<Category> categories = (from c in db.Categories
	where c.CategoryName
	select c).ToList();

Si luego cambiasemos los datos de la lista inicial y volviesemos a iterarla, se volvería a ejecutar la query. Por ejemplo, en la siguiente aparece Juanjo en la segunda iteración:

var list = from l in lPerson select l; 
foreach (Person p in list)
    Console.WriteLine(p.firstName);
lPerson.Add(new Person() { firstName = "Juanjo", age = 32 });
foreach (Person p in list)
    Console.WriteLine(p.firstName);

var expensiveInStockProducts =
        from p in products
        where p.UnitsInStock > 0 && p.UnitPrice > 3.00M
        select p;

string[] digits = { "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine" };
var shortDigits = digits.Where((digit, index) => digit.Length < index);

int[] numbers = { 5, 4, 1};
var numsPlusOne =
        from n in numbers
        select n + 1;

Devolvería 6 5 2

int[] numbers = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };
string[] strings = { "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine" };
var textNums =
        from n in numbers
        select strings[n];
<code csharp>
Devolvería five, four, one...
 
==== Grouping ====
 
Coger una agrupación y el tipo de agrupación que es:
<code csharp>
var wordGroups =
                from w in words
                group w by w[0] into g
                select new { FirstLetter = g.Key, Words = g };

var customerOrderGroups =
                from c in customers
                select
                    new {c.CompanyName,
                         YearGroups =
                             from o in c.Orders
                             group o by o.OrderDate.Year into yg
                             select
                                 new {Year = yg.Key,
                                      MonthGroups =
                                          from o in yg
                                          group o by o.OrderDate.Month into mg
                                          select new { Month = mg.Key, Orders = mg }
                                     }
                        };

string[] words = { "aPPLE", "BlUeBeRrY", "cHeRry" };
var upperLowerWords =
        from w in words
        select new {Upper = w.ToUpper(), Lower = w.ToLower()};
foreach (var ul in upperLowerWords) {
        Console.WriteLine("Uppercase: {0}, Lowercase: {1}", ul.Upper, ul.Lower);

Otro…

var productInfos =
        from p in products
        select new {p.ProductName, p.Category, Price = p.UnitPrice};
 foreach (var productInfo in productInfos) {
        Console.WriteLine("{0} is in the category {1} and costs {2} per unit.", productInfo.ProductName, productInfo.Category, productInfo.Price);

Otro…

int[] numbers = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };
var numsInPlace = numbers.Select((num, index) => new {Num = num, InPlace = (num == index)});

Otro… con asignación

 var orders =
        from c in customers,
                o in c.Orders,
                total = o.Total
        where total >= 2000.0M
        select new {c.CustomerID, o.OrderID, total};

var orders =
        from c in customers
        where c.Region == "WA"
        from o in c.Orders
        where o.OrderDate >= cutoffDate
        select new {c.CustomerID, o.OrderID};

var sortedWords =
        from w in words
        orderby w.Length
        select w;

var reversedIDigits = (
        from d in digits
        where d[1] == 'i'
        select d)
        .Reverse();

int[] factors = { 2, 2, 3, 5, 5 };
int uniqueFactors = factors.Distinct().Count(); 

Devolvería 3

int oddNumbers = numbers.Count(n => n % 2 == 1); 

string[] words = { "cherry", "apple", "blueberry" };
double totalChars = words.Sum(w => w.Length);

var customerNames =
        from c in customers
        select c.CompanyName;
var productNames =
        from p in products
        select p.ProductName;
var allNames = customerNames.Concat(productNames);

Product product12 = (
        from p in products
        where p.ProductID == 12
        select p )
        .First();

int fourthLowNum = (
        from n in numbers
        where n < 5
        select n )
        .ElementAt(3);

Nuevas funciones Generación de los números de 100 a 150: from n in Sequence.Range(100, 50)

Repetición del número 7, 10 veces: var numbers = Sequence.Repeat(7, 10);

Función Distinct Coge sólo uno, esquivando los elementos duplicados var categoryNames = (

      from p in products
      select p.Category)
      .Distinct();

Función Union Une dos listas del mismo tipo var uniqueNumbers = numbersA.Union(numbersB);

Función Intersect Coge los elementos que se repiten en las dos listas var commonNumbers = numbersA.Intersect(numbersB);

Función Except Coge los elementos de la primera lista que no esten en la segunda IEnumerable<int> aOnlyNumbers = numbersA.Except(numbersB);

Función Take Coge los primeros valores var first3Numbers = numbers.Take(3);

var first3WAOrders = (

              from c in customers
              from o in c.Orders
              where c.Region == "WA"
              select new {c.CustomerID, o.OrderID, o.OrderDate} )
              .Take(3);

Función Skip Coge los últimos números saltandose los indicados var allButFirst4Numbers = numbers.Skip(4);

Combinación de skip y take query.Skip(30).Take(10)