C# Language
C # 3.0-funktioner

Anmärkningar

Implicit typade variabler (var)

Det var nyckelordet tillåter en programmerare att implicit skriver en variabel vid kompileringen. var deklarationer har samma typ som uttryckligen deklarerade variabler.

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

Ovanstående variabler är int , double , StringBuilder respektive en anonym typ.

Det är viktigt att notera att en var variabeln inte är dynamiskt skrivit. SquaredNumber = Builder är inte giltig eftersom du försöker ställa en int till en instans av StringBuilder

Språkintegrerade frågor (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

Exempel från wikipedia-artikel om C # 3.0, LINQ-underavsnitt

Exempel 1 använder frågesyntax som utformades för att se ut som SQL-frågor.

//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

Exempel från wikipedia-artikel om C # 3.0, LINQ-underavsnitt

Exempel 2 använder metatsyntax för att uppnå samma resultat som exempel 1.

Det är viktigt att notera att i C # är LINQ-frågesyntax syntaktiskt socker för LINQ-metodsyntax. Kompilatorn översätter frågorna till metodsamtal vid sammanställningstid. Vissa frågor måste uttryckas i metatsyntax. Från MSDN - "Till exempel måste du använda ett metodsamtal för att uttrycka en fråga som hämtar antalet element som matchar ett angivet tillstånd."

Lambda-uttryck

Lambda-uttryck är en förlängning av anonyma metoder som möjliggör implicit skrivna parametrar och returvärden. Deras syntax är mindre ordbok än anonyma metoder och följer en funktionell programmeringsstil.

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

Ovanstående kod kommer att mata ut summan av rutorna med siffrorna 1 till 10 till konsolen.

Det första lambda-uttrycket kvadrerar siffrorna i listan. Eftersom det endast finns 1 parameterparentes kan utelämnas. Du kan inkludera parentes om du vill:

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

eller uttryckligen ange parametern men sedan krävs parentes:

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

Lambda-kroppen är ett uttryck och har en implicit återkomst. Du kan använda ett uttalande organ om du vill. Detta är användbart för mer komplexa lambdas.

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

Den valda metoden returnerar en ny IE-nummer med de beräknade värdena.

Det andra lambda-uttrycket summerar siffrorna i listan som returneras från den valda metoden. Parenteser krävs eftersom det finns flera parametrar. Parametrarnas typer är uttryckligen skrivna men detta är inte nödvändigt. Nedanstående metod är ekvivalent.

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

Som det här är:

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

Anonyma typer

Anonyma typer ger ett bekvämt sätt att kapsla in en uppsättning skrivskyddade egenskaper till ett enda objekt utan att behöva definiera en typ först. Typnamnet genereras av kompilatorn och är inte tillgängligt på källkodnivå. Typen för varje egenskap sluts av kompilatorn.

Du kan skapa anonyma typer genom att använda det new nyckelordet följt av en lockig stag ( { ) . Inuti de lockiga hängslen kan du definiera egenskaper som i koden nedan.

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

Det är också möjligt att skapa en mängd anonyma typer. Se koden nedan:

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

Eller använd den med LINQ-frågor:

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