LINQ

var numbers = new List<int>() {1,2,3,4}; // list with 4 numbers

// query is defined but not evaluated
var query = from x in numbers
            select x;

numbers.Add(5); // add a 5th number

// now the query gets evaluated
Console.WriteLine(query.Count()); // 5

numbers.Add(6); // add a 6th number

Console.WriteLine(query.Count()); // 6

public static class EnumerableExtensions
{
   public static IEnumerable<T> Where<T>(this IEnumerable<T> source, Func<T, bool> predicate)
   {
      foreach (var element in source)
      {
        if (predicate(element)) yield return element;
      }
   }
}

var query =
   from e in employees
   where e.DepartmentId == 5
   select e;

var query = employees.Where(e => e.DepartmentId == 5).Select(e => e);

var query = Enumerable.Select(EnumerableExtensions.Where(employees, e => e.DepartmentId == 5), e => e);

from rangeVariable in dataSource
// ...

var queryResults =
   from c in customers
   from o in orders
   select new { c.Name, o.OrderId, o.Price };

var queryResults =
   from c in customers, o in orders
   select new { c.Name, o.OrderId, o.Price };

var queryResults =
   from c in customers
   from o in orders
   where o.Date > DateTime.Now - TimeSpan.FromDays(7)
   select new { c.Name, o.OrderId, o.Price };

var groupedEmployees =
   from e in Employees
   group e by e.Department; // group by department

var groupedEmployees =
   from e in Employees
   group e by new { e.Department , e.Age }; // group by department and age

var groupedEmployees =
   from e in Employees
   group e by e.Department into EmployeesByDepartment
   select new { Department = EmployeesByDepartment.Key, EmployeesByDepartment.Count() };

var groupedEmployees =
   from e in Employees
   orderby e.Age // order employees by age; youngest first
   thenby e.Name // order same-age employees by name; sort A-to-Z
   select e;

var groupedEmployees =
   from e in Employees
   orderby e.Age descending // oldest first
   thenby e.Name descending // sort Z-to-A
   select e;

var productCategories =
   from c in categories // outer datasource
   join p in products // inner datasource
   on c.CategoryId equals p.CategoryId // categories without products are ignored
   select new { c.CategoryName, p.ProductName };

var productCategories =
   from c in categories
   join p in products
   on c.CategoryId equals p.CategoryId
   into productsInCategory
   select new { c.CategoryName, Products = productsInCategory };

var productCategories =
   from c in categories
   join p in products
   on c.CategoryId equals p.CategoryId
   into productsInCategory
   from pic in productsInCategory.DefaultIfEmpty(
      new Product(CategoryId = 0, ProductId = 0, ProductName = String.Empty))
   select new { c.CategoryName, p.ProductName };

var ordersByProducts =
   from c in categories
   join p in products
   on c.CategoryId equals p.CategoryId
   into productsByCategory
   let ProductCount = productsByCategory.Count()
   orderby ProductCount
   select new { c.CategoryName, ProductCount };

bool containsAnyElements = Enumerable.Empty<int>().Any(); // false
bool containsSix = Enumerable.Range(1,10).Any(x => x == 6); // true

bool containsSix = Enumerable.Range(1,10).Contains(6); // true

IEnumerable<int> Numbers = Enumerable.Range(1,10).Skip(2).Take(5); // {3,4,5,6,7}

IEnumerable<int> MultipleNumbers = new List<int>() {0,1,2,3,2,1,4};
IEnumerable<int> DistinctNumbers = MultipleNumbers.Distinct(); // {0,1,2,3,4}

var NumberSet1 = {1,5,6,9};
var NumberSet2 = {4,5,7,11};

var union = NumberSet1.Union(NumberSet2); // 1,5,6,9,4,7,11
var intersect = NumberSet1.Intersect(NumberSet2); // 5
var except = NumberSet1.Except (NumberSet2); // 1,6,9

var nums = new[]{1,2,3,4,5};
var sum = nums.Aggregate( (a,b) => a + b); // sum = 1+2+3+4+5 = 15

class Book
{
   public string Title { get; set; }
   public List<Author> Authors { get; set; }
}
class Author
{
   public string Name { get; set; }
}
class Foo
{
   public IEnumerable<string> GetAuthorsFromBooks(IEnumerable<Book> books)
   {
      // Input-Monad:  Enumerable Book Author
      // Output-Monad: Enumerable Author
      return books.SelectMany( book => book.Authors);
   }
}

IEnumerable<string> GetFilesInSubdirectories(string rootDirectory)
{
   var directoryInfo = new DirectoryInfo(rootDirectory); // get the root directory
   return directoryInfo.GetDirectories() // get directories in the root directory
                       .SelectMany(dir => GetFilesInSubdirectories(dir.FullName)) // recursively flattening the hierarchy of directories
                       .Concat(directoryInfo.GetFiles().Select(file => file.FullName)); // get the file name for each file in the directories
}

public class Identity<T>
{
    public T Value { get; private set; }

    public Identity(T value)
    {
        Value = value;
    }
}

// Unit-Methode
// Konvertiert einen beliebigen Wert in eine Identität
public static Identity<T> ToIdentity<T>(this T value)
{
   return new Identity<T>(value);
}

// Bind-Methode
// Verknüpft Funktionen die eine Identität zurückgeben
public static Identity<B> Bind<A, B>(this Identity<A> m, Func<A, Identity<B>> f)
{
    return f(m.Value);
}

var hello = "Hello".ToIdentity().Bind(h => "Monad".ToIdentity().Bind( m => String.Format("{0} {1}!", h, m) ));

Console.WriteLine(hello.Value); // "Hello Monad!"

// SelectMany = Bind
public static Identity<B> SelectMany<A, B>(this Identity<A> m, Func<A, Identity<B>> f)
{
    return Bind(m, f);
    // alternativ mit aufgelöstem Bind():
    // return f(m.Value);
}

// Bind mit Funktionskomposition
public static Identity<C> SelectMany<A, B, C>(this Identity<A> m, Func<A, Identity<B>> f, Func<A, B, C> select)
{
    return select(m.Value, m.Bind(f).Value).ToIdentity();

    // alternativ mit aufgelöstem Bind():
    // return select(m.Value, f(m.Value).Value).ToIdentity();
}

var hello = from h in "Hello".ToIdentity()
            from m in "Monad".ToIdentity()
            select String.Format("{0} {1}!", h, m);

Console.WriteLine(hello.Value); // "Hello Monad!"

class Maybe<T>
{
    public readonly static Maybe<T> Nothing = new Maybe<T>();

    public T Value { get; private set; }

    public bool HasValue { get; private set; }

    Maybe()
    {
        HasValue = false;
    }

    public Maybe(T value)
    {
        Value = value;
        HasValue = true;
    }

    public override string ToString()
    {
        return (HasValue) ? Value.ToString() : String.Empty;
    }
}

public static Maybe<T> ToMaybe<T>(this T value)
{
    return new Maybe<T>(value);
}

private static Maybe<U> Bind<T, U>(this Maybe<T> m, Func<T, Maybe<U>> f)
{
    return (m.HasValue) ? f(m.Value) : Maybe<U>.Nothing;
}

public static Maybe<U> SelectMany<T, U>(this Maybe<T> m, Func<T, Maybe<U>> f)
{
    return Bind<T, U>(m, f);
}

public static Maybe<C> SelectMany<A, B, C>(this Maybe<A> m, Func<A, Maybe<B>> f, Func<A, B, C> select)
{
    return m.Bind(x => f(x).Bind(y => select(x,y).ToMaybe()));
}

// null-propagation of nullables
var r = from x in 5.ToMaybe()
        from y in Maybe<int>.Nothing
        select x + y;

Console.WriteLine(r.Value); // String.Empty

public interface Maybe<T>{}

public class Nothing<T> : Maybe<T>
{
    public override string ToString()
    {
        return String.Empty;
    }
}

public class Something<T> : Maybe<T>
{
    public T Value { get; private set; }

    public Something(T value)
    {
        Value = value;
    }

    public override string ToString()
    {
        return Value.ToString();
    }
}

public static Maybe<T> ToMaybe<T>(this T value)
{
    return new Something<T>(value);
}

private static Maybe<B> Bind<A, B>(this Maybe<A> m, Func<A, Maybe<B>> f)
{
    var some = m as Something<A>;
    return (some == null) ? new Nothing<B>() : f(some.Value);
}

public static Maybe<B> SelectMany<A, B>(this Maybe<A> m, Func<A, Maybe<B>> f)
{
    return Bind<A, B>(m, f);
}

public static Maybe<C> SelectMany<A, B, C>(this Maybe<A> m, Func<A, Maybe<B>> f, Func<A, B, C> select)
{
    return m.Bind(x => f(x).Bind(y => select(x,y).ToMaybe()));
}

var r = from x in 5.ToMaybe() // Something<int>
        from y in new Nothing<int>()
        select x + y;

Console.WriteLine(r); // String.Empty

public static class PersonExtensions
{
   public static IEnumerable<TPerson> FilterByBirthday<TPerson>(this IEnumerable<TPerson> persons) where TPerson : Person
   {
      return FilterByBirthday(persons, DateTime.Now);
   }

   public static IEnumerable<TPerson> FilterByBirthday<TPerson>(this IEnumerable<TPerson> persons, DateTime date) where TPerson : Person
   {
      var birthdayPersons = select p in persons
                            where p.Birthday.Day == date.Day
                            where p.Birthday.Month == date.Month
                            select p;

      // return the list of persons
      foreach(Person p in birthdayPersons)
         yield return p;
   }
}

personsToCongratulate = persons.FilterByBirthday();

public static class PersonExtensions
{
   public static IEnumerable<TPerson> Oldest<TPerson>(this IEnumerable<TPerson> source, Func<TPerson, Boolean> predicate) where TPerson : Person
   {
      // filter Persons for criteria
      var persons = from p in source
                    where predicate(p)
                    select p;

      // determine the age of the oldest persons
      int oldestAge = (from p in persons
                       orderby p.Age descending
                       select p.Age).First();

      // get the list of the oldest persons
      var oldestPersons = select p in persons
                          where p.Age == youngestAge
                          select p;

      // return the list of oldest persons
      foreach (Person p in oldestPersons)
         yield return p;
   }

   public static IEnumerable<TPerson> Oldest(this IEnumerable<TPerson> source) where TPerson : Person
   {
      return Oldest(source, x => true);
   }
}

oldestLivingPersons = persons.Oldest(p => p.Living == true);

    using System.Data.Linq.Mapping;

    [Table(Name = "Products")]
    class Product
    {
        [Column(Name = "id", IsPrimaryKey = true)]
        public int ID;

        [Column(Name = "Name")]
        public string Name;

        [Column(Name = "Ean")]
        public string EanCode;
    }

using System.Configuration;  // for ConfigurationManager
using System.Data;           // for all interface types
using System.Data.Common;    // for DbProviderFactories

class Foo()
{
   public static void Main() {
      // get connection settings from app.config
      var cs = ConfigurationManager.ConnectionStrings["MyConnectionString"];
      var factory = DbProviderFactories.GetFactory(cs.ProviderName);

      using(IDbConnection connection = new factory.CreateConnection(cs.ConnectionString))
      {
         connection.Open();

         DataContext db = new DataContext(connection);

         Table<Product> table = db.GetTable<Product>();

         var query = from p in table
                     where p.Name.StartsWith("A")
                     orderby p.ID
                     select p;

         foreach (var p in query)
            Console.WriteLine(p.Name);
      }
   }
}

  var query = products
                .Where(p => p.Name.StartsWith("A"))
                .OrderBy(p => p.ID);

  foreach (var product in query) {
      Console.WriteLine(product.Name);
  }

   Console.WriteLine(products.Single(p => p.ID == 1).Name);

XElement purchaseOrder = XElement.Load("purchase_order.xml");

IEnumerable<string> items =
   from item in purchaseOrder.Descendants("Item")
   select (string)item.Attribute("PartNumber");

foreach (var item in items)
{
   Console.WriteLine(partNumbers.ElementAt(i));
}
// Output:
// 872-AA
// 926-AA

XElement purchaseOrder = XElement.Load("purchase_order.xml");

IEnumerable<XElement> items =
   from item in purchaseOrder.Descendants("Item")
   where (int)item.Element("Quantity") * (decimal)item.Element("USPrice") > 100
   orderby (string)item.Element("PartNumber")
   select item;

foreach(var item in items)
{
   Console.WriteLine(item.Attribute("PartNumber").Value);
}
// Output:
// 872-AA

using System;
using System.Reactive.Subjects;
using System.Reactive.Linq;

class Program
{
    // Helper functions
    private static Func<int,bool> isEven = n => n%2 == 0;
    private static Func<int,bool> isOdd = n => !isEven(n);
    private static Func<int,bool> isDivisibleBy5 = n => n%5 == 0;

    static void Main()
    {
        var subject = new Subject<int>();
        using(subject.Where(isEven).Where(isDivisibleBy5).Subscribe(_ => Console.WriteLine("FizzBuzz")))
        using(subject.Where(isEven).Where(!isDivisibleBy5).Subscribe(_ => Console.WriteLine("Fizz")))
        using(subject.Where(isOdd).Where(isDivisibleBy5).Subscribe(_ => Console.WriteLine("Buzz")))
        using(subject.Where(isOdd).Where(!isDivisibleBy5).Subscribe(Console.WriteLine))
        {
            Observable.Range(1, 100).Subscribe(subject.OnNext);
        }
    }
}

using System;
using System.Text;
using System.Reactive.Linq;

class Program
{
    static string IntToFizzBuzz(int n)
    {
        return new StringBuilder(8)
            .Append((n % 2 == 0) ? "Fizz" : string.Empty)
            .Append((n % 5 == 0)? "Buzz" : string.Empty)
            .Append((n % 2 != 0 && n % 5 != 0)? n.ToString() : string.Empty)
            .ToString();
    }

    static void Main(string[] args)
    {
        var numbers = Observable.Range(1, 100);
        var fizzBuzz = from n in numbers select IntToFizzBuzz(n);
        fizzBuzz.Subscribe(Console.WriteLine);
    }
}