Artykuł ten jest wprowadzeniem do zapytań wykonanych przy użyciu języka LINQ. Język ten pozwala nam na swobodną pracę z kolekcjami, tj. ich edycję, filtrowanie czy przeszukiwanie. Takie operacje można z łatwością wykonywać pracując z bazami danych jednakże podstawowe operację dostarczane przez przez interfejsy w języku C# są raczej ubogie. Korzystając jednak z technologii .NET od wersji 3.5 można skorzystać ze wspomnianej wyżej technologii, tj. LINQ.

Przejdźmy do przykładów, które są zdecydowanie bardziej pomocne. Poniżej zostaną przedstawione operacje:

• prosty Select;
• Select wraz z klauzurą Where;
• tworzenie uporządkowanej listy;
• współpraca z typami niestandardowymi;
• przeszukiwanie List<T>;
• przeszukiwanie List<T> i zwrócenie pojedycznego wyniku.

Poniżej najprosty przykład użycia klauzuli Select:

using System;
using System.Linq;
namespace LINQtoObject
{
    class Program
    {
        static void Main(string[] args)
        {
            // tworzymy tablicę samochodów - to jest nasza kolekcja
            string[] cars = { "Audi", "Porsche", "Pagani", "BMW", "Nissan", "Lamborghini" };
            // używamy LINQ aby zwrócić wszystkie elementy naszej kolekcji
            var list = from c in cars
                       select c;
            // wypisanie w konsoli wszystkich elementów
            foreach (var item in list)
            {
                Console.WriteLine(item);
            }
            Console.ReadKey();
        }
    }
}

Następny przykład zapytania przygotowanego w LINQ będzie dodatkowo zawierał klauzulę Where. Zdefiniujemy tablicę naszych danych początkowych a kolejnym krokiem będzie zwrócenie danych zaczynających się od wskazanej litery:

using System;
using System.Linq;
namespace LINQtoObjectWhere
{
    class Program
    {
        static void Main(string[] args)
        {
            // tworzymy tablicę samochodów - to jest nasza kolekcja
            string[] cars = { "Audi", "Porsche", "Pagani", "BMW", "Nissan", "Lamborghini", "Mercedes",
            "Alfa Romeo", "Maserati", "Panoz", "Peugeot", "Pontiac"};
            // używamy LINQ aby zwrócić elementy naszej kolekcji, które zaczynają się od litery 'P'
            var list = from c in cars
                       where c.StartsWith("P")
                       select c;
            // wypisanie w konsoli wszystkich elementów
            foreach (var item in list)
            {
                Console.WriteLine(item);
            }
            Console.ReadKey();
        }
    }
}

Niewielka zmiana powyższego przykładu, w tym przypadku klauzula Where zostanie użyta do odnalezienia dokładnego dopasowania:

using System;
using System.Linq;
namespace LINQtoObjectWhereExact
{
    class Program
    {
        static void Main(string[] args)
        {
            // tworzymy tablicę samochodów -to jest nasza kolekcja
            string[] cars = { "Audi", "Porsche", "Pagani", "BMW", "Nissan", "Lamborghini", "Mercedes",
            "Alfa Romeo", "Maserati", "Panoz", "Peugeot", "Pontiac"};
            // używamy LINQ aby zwrócić elementy naszej kolekcji, które zaczynają się od litery 'P'
            var list = from c in cars
                       where c == "Maserati"
                       select c;
            // wypisanie w konsoli wszystkich elementów (tym razem mamy jedno dopasowanie)
            foreach (var item in list)
            {
                Console.WriteLine(item);
            }
            Console.ReadKey();
        }
    }
}

W poniższym przykładzie zwrócimy dane uporządkowane wg. liter alfabetu:

using System;
using System.Linq;
namespace LINQtoObjectOrderedList
{
    class Program
    {
        static void Main(string[] args)
        {
            // tworzymy tablicę samochodów - to jest nasza kolekcja
            string[] cars = { "Audi", "Porsche", "Pagani", "BMW", "Nissan", "Lamborghini", "Mercedes",
            "Alfa Romeo", "Maserati", "Panoz", "Peugeot", "Pontiac"};
            // używamy LINQ aby zwrócić uporządkowane dane z powyższej tablicy
            var list = from c in cars
                       orderby c ascending
                       select c;
            // wypisanie w konsoli wszystkich elementów (tym razem mamy jedno dopasowanie)
            foreach (var item in list)
            {
                Console.WriteLine(item);
            }
            Console.ReadKey();
        }
    }
}

W tym przykładzie zostanie utworzona typowana lista, dodamy kolejne dane a następnie użyjemy LINQ, aby zwrócić wybrane dane:

using System;
using System.Collections.Generic;
using System.Linq;
namespace LINQtoObjectCustomTypes
{
    class Program
    {
        static void Main(string[] args)
        {
            // tworzymy listę obiektów typu Car
            List<Car> list = new List<Car>();
            Car car1 = new Car();
            car1.Id = 1;
            car1.Brand = "Audi";
            car1.Model = "RS6";
            Car car2 = new Car();
            car2.Id = 2;
            car2.Brand = "BMW";
            car2.Model = "M3";
            Car car3 = new Car();
            car3.Id = 3;
            car3.Brand = "Pagani";
            car3.Model = "Zonda";
            Car car4 = new Car();
            car4.Id = 4;
            car4.Brand = "Nissan";
            car4.Model = "GTR";
            // wszystkie obiekty dodajemy do listy
            list.Add(car1);
            list.Add(car2);
            list.Add(car3);
            list.Add(car4);
            // A dla przypomnienia inny sposób dodawania danych do listy
            list.Add(new Car { Id = 5, Brand = "Pontiac", Model = "GTO" });
            // używamy LINQ aby zwrócić uporządkowane dane z powyższej listy
            // sortowanie odbywa się po marce
            var sortedList = from l in list
                             orderby l.Brand ascending
                             select l;
            // wypisanie w konsoli wszystkich elementów
            foreach (var item in sortedList)
            {
                Console.WriteLine(item.Brand + " " + item.Model);
            }
            Console.ReadKey();
        }
    }
    class Car
    {
        public int Id { get; set; }
        public string Brand { get; set; }
        public string Model { get; set; }
    }
}

W powyższym przykładzie została utworzona i wypełniona typowana lista. W poniższym przykładzie użyjemy klauzuli Where, aby zwrócić dane zaczynające się od wskazanej litery:

using System;
using System.Collections.Generic;
using System.Linq;
namespace LINQtoObjectSearchingListT
{
    class Program
    {
        static void Main(string[] args)
        {
            // tworzymy listę obiektów typu Car
            List<Car> list = new List<Car>();
            Car car1 = new Car();
            car1.Id = 1;
            car1.Brand = "Audi";
            car1.Model = "RS6";
            Car car2 = new Car();
            car2.Id = 2;
            car2.Brand = "BMW";
            car2.Model = "M3";
            Car car3 = new Car();
            car3.Id = 3;
            car3.Brand = "Pagani";
            car3.Model = "Zonda";
            Car car4 = new Car();
            car4.Id = 4;
            car4.Brand = "Nissan";
            car4.Model = "GTR";
            // wszystkie obiekty dodajemy do listy
            list.Add(car1);
            list.Add(car2);
            list.Add(car3);
            list.Add(car4);
            // A dla przypomnienia inny sposób dodawania danych do listy
            list.Add(new Car { Id = 5, Brand = "Pontiac", Model = "GTO" });
            // używamy LINQ aby zwrócić dane zaczynające się od litery P
            var searching = from l in list
                            where l.Brand.StartsWith("P")
                            select l;
            // wypisanie w konsoli wszystkich elementów
            foreach (var item in searching)
            {
                Console.WriteLine("Id: " + item.Id + ", " + item.Brand + " " + item.Model);
            }
            Console.ReadKey();
        }
    }
    class Car
    {
        public int Id { get; set; }
        public string Brand { get; set; }
        public string Model { get; set; }
    }
}

W poniższym przykładzie zwrócimy pojedynczy rezultat:

using System;
using System.Collections.Generic;
using System.Linq;
namespace LINQtoObjectSearchingListTSingleResult
{
    class Program
    {
        static void Main(string[] args)
        {
            // tworzymy listę obiektów typu Car
            List<Car> list = new List<Car>();
            // użyjemy skróconego zapisu z poprzedniego przykładu
            list.Add(new Car { Id = 1, Brand = "Audi", Model = "RS6" });
            list.Add(new Car { Id = 2, Brand = "BMW", Model = "M3" });
            list.Add(new Car { Id = 3, Brand = "Pagani", Model = "Zonda" });
            list.Add(new Car { Id = 4, Brand = "Nissan", Model = "GTR" });
            list.Add(new Car { Id = 5, Brand = "Pontiac", Model = "GTO" });
            // używamy LINQ aby zwrócić dokładnie jeden rekord
            var singleResult = from l in list
                               where l.Id == 5
                               select l;
            // wypisanie w konsoli wszystkich elementów (tym razem mamy jedno dopasowanie)
            foreach (var item in singleResult)
            {
                Console.WriteLine("Id: " + item.Id + ", " + item.Brand + " " + item.Model);
            }
            // inny sposób użycia LINQ, zwracamy konkretny typ
            var singleResult2 = (from l in list
                                 where l.Id.Equals(3)
                                 select l).Single<Car>();
            // wypisanie w konsoli znalezionego rezultatu
            Console.WriteLine("Id: " + singleResult2.Id + ", " + singleResult2.Brand + " " + singleResult2.Model);
            Console.ReadKey();
        }
    }
    class Car
    {
        public int Id { get; set; }
        public string Brand { get; set; }
        public string Model { get; set; }
    }
}