C# Language
C # 3.0 Caratteristiche

Osservazioni

Variabili implicitamente tipizzate (var)

La parola chiave var consente a un programmatore di digitare implicitamente una variabile in fase di compilazione. var dichiarazioni var hanno lo stesso tipo di variabili dichiarate esplicitamente.

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

I tipi delle variabili precedenti sono rispettivamente int , double , StringBuilder e un tipo anonimo.

È importante notare che una variabile var non viene digitata in modo dinamico. SquaredNumber = Builder non è valido poiché stai provando a impostare int su un'istanza di StringBuilder

Language Integrated Queries (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

Esempio tratto dall'articolo di Wikipedia su C # 3.0, sotto-sezione LINQ

L'esempio 1 utilizza la sintassi della query che è stata progettata per sembrare simile alle query 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

Esempio tratto dall'articolo di Wikipedia su C # 3.0, sotto-sezione LINQ

L'esempio 2 utilizza la sintassi del metodo per ottenere lo stesso risultato dell'esempio 1.

È importante notare che, in C #, la sintassi della query LINQ è zucchero sintattico per la sintassi del metodo LINQ. Il compilatore traduce le query in chiamate di metodo in fase di compilazione. Alcune query devono essere espresse nella sintassi del metodo. Da MSDN : "Ad esempio, è necessario utilizzare una chiamata al metodo per esprimere una query che recupera il numero di elementi che corrispondono a una condizione specificata."

Espressioni Lambda

Lambda Expresions è un'estensione di metodi anonimi che consentono parametri implicitamente tipizzati e valori di ritorno. La loro sintassi è meno prolissa di metodi anonimi e segue uno stile di programmazione funzionale.

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 );
    }
}

Il codice sopra mostrerà la somma dei quadrati dei numeri da 1 a 10 alla console.

La prima espressione lambda quadra i numeri nella lista. Poiché esiste solo una parentesi sui parametri, può essere omessa. Puoi includere le parentesi se lo desideri:

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

o digitare esplicitamente il parametro, ma sono necessarie le parentesi:

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

Il corpo lambda è un'espressione e ha un ritorno implicito. Puoi usare un corpo di statement anche se lo desideri. Questo è utile per lambda più complessi.

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

Il metodo select restituisce un nuovo IEnumerable con i valori calcolati.

La seconda espressione lambda somma i numeri nell'elenco restituito dal metodo select. Le parentesi sono obbligatorie in quanto vi sono più parametri. I tipi dei parametri sono digitati in modo esplicito ma non è necessario. Il metodo seguente è equivalente.

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

Come è questo:

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

Tipi anonimi

I tipi anonimi forniscono un modo conveniente per incapsulare un insieme di proprietà di sola lettura in un singolo oggetto senza dover prima definire esplicitamente un tipo. Il nome del tipo è generato dal compilatore e non è disponibile a livello di codice sorgente. Il tipo di ogni proprietà è dedotto dal compilatore.

È possibile creare tipi anonimi utilizzando la new parola chiave seguita da una parentesi graffa ( { ) . All'interno delle parentesi graffe, è possibile definire proprietà come nel codice sottostante.

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

È anche possibile creare una serie di tipi anonimi. Vedi il codice qui sotto:

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

O usalo con le query LINQ:

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