C# Language
C # 3.0 Kenmerken

Opmerkingen

Impliciet getypte variabelen (var)

Met het sleutelwoord var kan een programmeur impliciet een variabele typen tijdens het compileren. var verklaringen zijn van hetzelfde type als expliciet gedeclareerde variabelen.

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

De typen van de bovenstaande variabelen zijn respectievelijk int , double , StringBuilder en anonymous.

Het is belangrijk op te merken dat een var variabele niet dynamisch wordt getypt. SquaredNumber = Builder is niet geldig omdat u probeert een int te stellen op een instantie van 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

Voorbeeld uit een wikipedia-artikel over C # 3.0, LINQ subsectie

Voorbeeld 1 gebruikt querysyntaxis die is ontworpen om te lijken op SQL-query's.

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

Voorbeeld uit een wikipedia-artikel over C # 3.0, LINQ subsectie

Voorbeeld 2 gebruikt de syntaxis van de methode om hetzelfde resultaat te bereiken als in voorbeeld 1.

Het is belangrijk op te merken dat in C # de syntaxis van de LINQ-query syntactische suiker is voor de syntaxis van de LINQ-methode. De compiler vertaalt de query's tijdens het compileren naar methodeaanroepen. Sommige vragen moeten worden uitgedrukt in syntaxis van de methode. Van MSDN - "U moet bijvoorbeeld een methode-aanroep gebruiken om een query uit te drukken die het aantal elementen ophaalt dat overeenkomt met een opgegeven voorwaarde."

Lambda-uitdrukkingen

Lambda-expressies zijn een uitbreiding van anonieme methoden die impliciet getypeerde parameters en retourwaarden mogelijk maken. Hun syntaxis is minder uitgebreid dan anonieme methoden en volgt een functionele programmeerstijl.

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

De bovenstaande code zal de som van de vierkanten van de nummers 1 tot en met 10 naar de console uitvoeren.

De eerste lambda-uitdrukking regelt de getallen in de lijst. Omdat er slechts 1 parameter tussen haakjes kan worden weggelaten. U kunt haakjes opnemen als u dat wilt:

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

of typ de parameter expliciet, maar haakjes zijn vereist:

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

Het lambda-lichaam is een uitdrukking en heeft een impliciete terugkeer. Je kunt ook een statement body gebruiken als je dat wilt. Dit is handig voor complexere lambdas.

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

De selectiemethode retourneert een nieuwe IEnumerable met de berekende waarden.

De tweede lambda-uitdrukking somt de getallen in de lijst op die zijn geretourneerd door de selectiemethode. Haakjes zijn vereist omdat er meerdere parameters zijn. De typen parameters worden expliciet getypt, maar dit is niet nodig. De onderstaande methode is equivalent.

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

Zoals deze:

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

Anonieme typen

Anonieme typen bieden een handige manier om een set alleen-lezen eigenschappen in een enkel object in te kapselen zonder eerst een type expliciet te definiëren. De typenaam wordt gegenereerd door de compiler en is niet beschikbaar op broncodeniveau. Het type van elke eigenschap wordt afgeleid door de compiler.

U kunt anonieme typen maken door het new trefwoord te gebruiken, gevolgd door een accolade ( { ) . Binnen de accolades kunt u eigenschappen definiëren zoals op onderstaande code.

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

Het is ook mogelijk om een reeks anonieme typen te maken. Zie onderstaande code:

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

Of gebruik het met LINQ-zoekopdrachten:

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