C# Language
Funkcje C # 3.0

Uwagi

Zmienne niejawnie wpisane (var)

var kluczowe var pozwala programiście na niejawne wpisanie zmiennej w czasie kompilacji. Deklaracje var mają ten sam typ, co zmienne jawnie zadeklarowane.

var squaredNumber = 10 * 10;
var squaredNumberDouble = 10.0 * 10.0;
var builder = new StringBuilder();
var anonymousObject = new
{ 
    One = SquaredNumber,
    Two = SquaredNumberDouble,
    Three = Builder
}

Typami powyższych zmiennych są odpowiednio: int , double , StringBuilder i anonimowy.

Należy zauważyć, że zmienna var nie jest dynamicznie typowana. SquaredNumber = Builder jest niepoprawny, ponieważ próbujesz ustawić int dla instancji StringBuilder

Zintegrowane zapytania językowe (LINQ)

//Example 1
int[] array = { 1, 5, 2, 10, 7 };

// Select squares of all odd numbers in the array sorted in descending order
IEnumerable<int> query = from x in array
                         where x % 2 == 1
                         orderby x descending
                         select x * x;
// Result: 49, 25, 1

Przykład z artykułu w Wikipedii na temat C # 3.0, podsekcja LINQ

W przykładzie 1 użyto składni zapytań, która została zaprojektowana tak, aby wyglądać podobnie do zapytań SQL.

//Example 2
IEnumerable<int> query = array.Where(x => x % 2 == 1)
    .OrderByDescending(x => x)
    .Select(x => x * x);
// Result: 49, 25, 1 using 'array' as defined in previous example

Przykład z artykułu w Wikipedii na temat C # 3.0, podsekcja LINQ

W przykładzie 2 zastosowano składnię metody, aby osiągnąć taki sam wynik jak w przykładzie 1.

Należy zauważyć, że w języku C # składnia zapytania LINQ to cukier składniowy dla składni metody LINQ. Kompilator tłumaczy zapytania na wywołania metod w czasie kompilacji. Niektóre zapytania muszą być wyrażone w składni metody. Z MSDN - „Na przykład musisz użyć wywołania metody, aby wyrazić zapytanie, które pobiera liczbę elementów pasujących do określonego warunku”.

Wyrażenia lambda

Wyrażenia lambda są rozszerzeniem anonimowych metod, które pozwalają na niejawnie wpisane parametry i zwracane wartości. Ich składnia jest mniej szczegółowa niż anonimowe metody i jest zgodna z funkcjonalnym stylem programowania.

using System;
using System.Collections.Generic;
using System.Linq;
                    
public class Program
{
    public static void Main()
    {
        var numberList = new List<int> {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        var sumOfSquares = numberList.Select( number => number * number )
            .Aggregate( (int first, int second) => { return first + second; } );
        Console.WriteLine( sumOfSquares );
    }
}

Powyższy kod wyświetli w konsoli sumę kwadratów liczb od 1 do 10.

Pierwsze wyrażenie lambda jest kwadratem liczb na liście. Ponieważ istnieje tylko 1 parametr, nawiasy można pominąć. Możesz dołączyć nawias, jeśli chcesz:

.Select( (number) => number * number);

lub jawnie wpisz parametr, ale wymagane są nawiasy:

.Select( (int number) => number * number);

Ciało lambda jest wyrażeniem i ma ukryty zwrot. Możesz także użyć treści instrukcji, jeśli chcesz. Jest to przydatne w przypadku bardziej złożonych lambd.

.Select( number => { return number * number; } );

Metoda select zwraca nowy IEnumerable z obliczonymi wartościami.

Drugie wyrażenie lambda sumuje liczby na liście zwrócone z metody select. Nawiasy są wymagane, ponieważ istnieje wiele parametrów. Typy parametrów są jawnie wpisane, ale nie jest to konieczne. Poniższa metoda jest równoważna.

.Aggregate( (first, second) => { return first + second; } );

Jak to ten:

.Aggregate( (int first, int second) => first + second );

Anonimowe typy

Anonimowe typy zapewniają wygodny sposób enkapsulacji zestawu właściwości tylko do odczytu w jednym obiekcie bez konieczności wcześniejszego jawnego definiowania typu. Nazwa typu jest generowana przez kompilator i nie jest dostępna na poziomie kodu źródłowego. Typ każdej właściwości jest wyprowadzany przez kompilator.

Możesz tworzyć anonimowe typy, używając new słowa kluczowego, a następnie nawiasu klamrowego ( { ) . Wewnątrz nawiasów klamrowych możesz zdefiniować właściwości takie jak w kodzie poniżej.

var v = new { Amount = 108, Message = "Hello" };

Możliwe jest również utworzenie tablicy anonimowych typów. Zobacz kod poniżej:

var a = new[] { 
    new { 
        Fruit = "Apple", 
        Color = "Red" 
    },
    new {
        Fruit = "Banana",
        Color = "Yellow"
    }
};

Lub użyj go z zapytaniami LINQ:

var productQuery = from prod in products
                   select new { prod.Color, prod.Price };