C# Language
Características de C # 3.0

Observaciones

Variables implícitamente escritas (var)

La palabra clave var permite que un programador escriba implícitamente una variable en el momento de la compilación. var declaraciones var tienen el mismo tipo que las variables declaradas explícitamente.

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

Los tipos de las variables anteriores son int , double , StringBuilder y un tipo anónimo, respectivamente.

Es importante tener en cuenta que una variable var no se escribe dinámicamente. SquaredNumber = Builder no es válido porque está intentando establecer un int en una instancia de StringBuilder

Consultas integradas de idiomas (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

Ejemplo del artículo de wikipedia sobre la sub-sección LINQ de C # 3.0

El ejemplo 1 usa una sintaxis de consulta que fue diseñada para verse similar a las consultas 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

Ejemplo del artículo de wikipedia sobre la sub-sección LINQ de C # 3.0

El ejemplo 2 usa la sintaxis del método para lograr el mismo resultado que el ejemplo 1.

Es importante tener en cuenta que, en C #, la sintaxis de consulta LINQ es azúcar sintáctica para la sintaxis del método LINQ. El compilador traduce las consultas en llamadas de método en tiempo de compilación. Algunas consultas deben expresarse en la sintaxis del método. De MSDN : "Por ejemplo, debe usar una llamada de método para expresar una consulta que recupera el número de elementos que coinciden con una condición específica".

Expresiones lambda

Lambda Expresions es una extensión de métodos anónimos que permiten parámetros tipificados implícitamente y valores de retorno. Su sintaxis es menos detallada que los métodos anónimos y sigue un estilo de programación funcional.

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

El código anterior generará la suma de los cuadrados de los números del 1 al 10 en la consola.

La primera expresión lambda cuadra los números de la lista. Dado que solo hay 1 parámetro, el paréntesis puede omitirse. Puede incluir paréntesis si lo desea:

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

o escriba explícitamente el parámetro pero luego se requieren paréntesis:

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

El cuerpo lambda es una expresión y tiene un retorno implícito. Puedes usar un cuerpo de declaración si lo deseas también. Esto es útil para las lambdas más complejas.

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

El método de selección devuelve un nuevo IEnumerable con los valores calculados.

La segunda expresión lambda suma los números en la lista devueltos por el método de selección. Se requieren paréntesis ya que hay múltiples parámetros. Los tipos de parámetros se escriben explícitamente, pero esto no es necesario. El siguiente método es equivalente.

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

Como es este:

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

Tipos anónimos

Los tipos anónimos proporcionan una manera conveniente de encapsular un conjunto de propiedades de solo lectura en un solo objeto sin tener que definir explícitamente un tipo primero. El nombre del tipo lo genera el compilador y no está disponible en el nivel del código fuente. El tipo de cada propiedad es inferido por el compilador.

Puede hacer tipos anónimos utilizando la new palabra clave seguida de una llave ( { ) . Dentro de las llaves, puede definir propiedades como en el código a continuación.

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

También es posible crear una matriz de tipos anónimos. Ver código a continuación:

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

O usarlo con las consultas LINQ:

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