C# Language
C # 3.0-Funktionen

Bemerkungen

Implizit typisierte Variablen (var)

Mit dem Schlüsselwort var kann ein Programmierer beim Kompilieren implizit eine Variable eingeben. var deklarationen haben den gleichen Typ wie explizit deklarierte Variablen.

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

Die Typen der obigen Variablen sind int , double , StringBuilder bzw. ein anonymer Typ.

Es ist wichtig zu beachten, dass eine var Variable nicht dynamisch typisiert wird. SquaredNumber = Builder ist ungültig, da Sie versuchen, ein int auf eine Instanz von StringBuilder

Sprachintegrierte Abfragen (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

Beispiel aus dem Wikipedia-Artikel zu C # 3.0, LINQ-Unterabschnitt

In Beispiel 1 wird eine Abfragesyntax verwendet, die ähnlich wie SQL-Abfragen aussehen sollte.

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

Beispiel aus dem Wikipedia-Artikel zu C # 3.0, LINQ-Unterabschnitt

In Beispiel 2 wird die Methodensyntax verwendet, um dasselbe Ergebnis wie in Beispiel 1 zu erzielen.

Beachten Sie, dass in C # die LINQ-Abfragesyntax syntaktischer Zucker für die LINQ-Methodensyntax ist. Der Compiler übersetzt die Abfragen zum Zeitpunkt des Kompilierens in Methodenaufrufe. Einige Abfragen müssen in Methodensyntax ausgedrückt werden. Aus MSDN - "Beispielsweise müssen Sie einen Methodenaufruf verwenden, um eine Abfrage auszudrücken, die die Anzahl der Elemente abruft, die einer angegebenen Bedingung entsprechen."

Lambda-Ausdrücke

Lambda-Ausdrücke sind eine Erweiterung anonymer Methoden , die implizit typisierte Parameter und Rückgabewerte zulassen. Ihre Syntax ist weniger ausführlich als anonyme Methoden und folgt einem funktionalen Programmierstil.

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

Der obige Code gibt die Summe der Quadrate der Zahlen 1 bis 10 an die Konsole aus.

Der erste Lambda-Ausdruck quadriert die Zahlen in der Liste. Da es nur 1 Parameter gibt, kann eine Klammer weggelassen werden. Sie können Klammern angeben, wenn Sie möchten:

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

oder geben Sie den Parameter explizit ein, aber dann sind Klammern erforderlich:

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

Der Lambda-Körper ist ein Ausdruck und hat eine implizite Rendite. Sie können auch einen Statement-Body verwenden, wenn Sie möchten. Dies ist nützlich für komplexere Lambdas.

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

Die select-Methode gibt ein neues IEnumerable mit den berechneten Werten zurück.

Der zweite Lambda-Ausdruck summiert die Zahlen in der Liste, die von der select-Methode zurückgegeben werden. Klammern sind erforderlich, da mehrere Parameter vorhanden sind. Die Typen der Parameter werden explizit angegeben, dies ist jedoch nicht erforderlich. Die untenstehende Methode ist gleichwertig.

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

Wie ist dieser hier:

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

Anonyme Typen

Anonyme Typen bieten eine bequeme Möglichkeit, einen Satz schreibgeschützter Eigenschaften in ein einzelnes Objekt zu kapseln, ohne zuerst einen Typ explizit definieren zu müssen. Der Typname wird vom Compiler generiert und ist auf Quellcodeebene nicht verfügbar. Der Typ jeder Eigenschaft wird vom Compiler abgeleitet.

Sie können anonyme Typen erstellen, indem Sie das new Schlüsselwort gefolgt von einer geschweiften Klammer ( { ) verwenden . In den geschweiften Klammern können Sie Eigenschaften wie im folgenden Code definieren.

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

Es ist auch möglich, ein Array anonymer Typen zu erstellen. Siehe Code unten:

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

Oder verwenden Sie es mit LINQ-Abfragen:

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