C# Language
Fonctionnalités C # 3.0

Remarques

Variables typées implicitement (var)

Le mot-clé var permet à un programmeur de taper implicitement une variable au moment de la compilation. var déclarations var ont le même type que les variables explicitement déclarées.

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

Les types des variables ci-dessus sont respectivement int , double , StringBuilder et un type anonyme.

Il est important de noter qu'une variable var n'est pas typée dynamiquement. SquaredNumber = Builder n'est pas valide puisque vous essayez de définir un int sur une instance de StringBuilder

Requêtes linguistiques intégrées (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

Exemple d'article de Wikipédia sur C # 3.0, sous-section LINQ

L'exemple 1 utilise une syntaxe de requête conçue pour ressembler aux requêtes 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

Exemple d'article de Wikipédia sur C # 3.0, sous-section LINQ

L'exemple 2 utilise la syntaxe de la méthode pour obtenir le même résultat que l'exemple 1.

Il est important de noter que, en C #, la syntaxe de requête LINQ est un sucre syntaxique pour la syntaxe de la méthode LINQ. Le compilateur traduit les requêtes en appels de méthode au moment de la compilation. Certaines requêtes doivent être exprimées dans la syntaxe de la méthode. De MSDN - "Par exemple, vous devez utiliser un appel de méthode pour exprimer une requête qui récupère le nombre d'éléments correspondant à une condition spécifiée."

Expression Lambda

Lambda Expresions est une extension de méthodes anonymes qui permettent des paramètres et des valeurs de retour implicitement typés. Leur syntaxe est moins verbeuse que les méthodes anonymes et suit un style de programmation fonctionnel.

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

Le code ci-dessus affichera la somme des carrés des nombres 1 à 10 sur la console.

La première expression lambda place les nombres dans la liste. Comme il n'y a que 1 paramètre, la parenthèse peut être omise. Vous pouvez inclure des parenthèses si vous le souhaitez:

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

ou tapez explicitement le paramètre mais les parenthèses sont nécessaires:

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

Le corps lambda est une expression et a un retour implicite. Vous pouvez également utiliser un corps de déclaration si vous le souhaitez. Ceci est utile pour les lambda plus complexes.

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

La méthode select renvoie un nouveau IEnumerable avec les valeurs calculées.

La seconde expression lambda additionne les nombres dans la liste renvoyés par la méthode select. Les parenthèses sont nécessaires car il y a plusieurs paramètres. Les types de paramètres sont explicitement tapés, mais cela n'est pas nécessaire. La méthode ci-dessous est équivalente.

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

Comme celui-ci:

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

Types anonymes

Les types anonymes offrent un moyen pratique d'encapsuler un ensemble de propriétés en lecture seule dans un objet unique sans avoir à définir explicitement un type en premier. Le nom de type est généré par le compilateur et n'est pas disponible au niveau du code source. Le type de chaque propriété est déduit par le compilateur.

Vous pouvez créer des types anonymes en utilisant le new mot-clé suivi d'une accolade ( { ) . À l'intérieur des accolades, vous pouvez définir des propriétés comme sur le code ci-dessous.

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

Il est également possible de créer un tableau de types anonymes. Voir le code ci-dessous:

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

Ou utilisez-le avec les requêtes LINQ:

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