Lambda-Ausdruck in LINQ-Anweisungen in C#

1. LINQ in C#
2. Syntax von LINQ in C#
3. Lambda-Ausdrücke in C#
4. Lambda-Ausdruck in LINQ

In diesem einfachen Artikel geht es um Lambda-Ausdrücke in LINQ Select-Abfragen. Dazu besprechen wir zunächst eine kurze Einführung in LINQ, seine Syntax und Lambda-Ausdrücke.

Außerdem erklären wir, wie wir Lambda-Ausdrücke in LINQ Select-Abfragen verwenden können.

LINQ in C#

LINQ ist ein Akronym für Language Integrated Query. Es ist ein einheitliches Format, um die Daten aus mehreren Datenquellen wie Objekten, XML, SQL-Datenservern, Datensätzen usw. abzufragen.

Die einzige Voraussetzung für diese Datenquelle ist, dass sie die Schnittstelle IEnumerable<T> implementiert.

LINQ bietet mehrere Vorteile:

1. LINQ bietet objektbasierte, sprachintegrierte Abfragen, unabhängig davon, woher die Daten stammen. Daher können wir Datenbanken, XML und Sammlungen mit LINQ abfragen.
2. Überprüfung der Syntax zur Kompilierzeit.
3. Sie können Sammlungen wie Arrays, aufzählbare Klassen usw. in der Muttersprache Ihrer Anwendung wie VB oder C# abfragen, ähnlich wie Sie eine Datenbank mit SQL abfragen würden.

Stellen Sie sich ein Szenario vor, in dem wir eine Liste mit Zahlen haben und Zahlen kleiner als 10 auswählen müssen. Dann kann uns die LINQ-Abfrage bei der Auswahl der Daten helfen.

Schauen wir uns das folgende Codesegment an:

using System;
using System.Collections.Generic;
using System.Linq;
namespace ConsoleApp6 {
  class Program {
    static void Main(string[] args) {
      List<int> listOfNumbers = new List<int>() { 16, 11, 2, 5, 9, 8, 7, 6, 1, 12 };
      var result = from l in listOfNumbers
          where l<10 select l;
      foreach (int i in result) Console.WriteLine(i);
    }
  }
}

Sie können der obigen LINQ-Abfrage entnehmen, dass dies der Abfragesyntax ähnelt, die wir zum Abfragen von Daten aus SQL-Datenbanken verwenden. Hier fragen wir Daten von einem lokalen Datenmember Liste ab.

Die Ausgabe des Codesegments lautet:

Syntax von LINQ in C#

Es gibt zwei Syntaxen von LINQ, die beim Programmieren mit LINQ verwendet werden:

1. Abfragesyntax
2. Methodensyntax

Abfragesyntax in LINQ

Die LINQ-Abfragesyntax umfasst eine Reihe von Abfrageschlüsselwörtern, die in .NET Framework Version 3.5 oder höher definiert sind. Dadurch können Programmierer oder Entwickler Befehle im SQL-Stil in Code (C# oder VB.NET) schreiben, ohne Anführungszeichen zu verwenden.

Sie wird auch als Abfrageausdruckssyntax bezeichnet.

Das Schlüsselwort from beginnt die LINQ-Abfragesyntax und endet mit dem Schlüsselwort Select oder GroupBy. Nach dem Schlüsselwort können Sie verschiedene Standardabfrageoperationen wie Filtern, Gruppieren usw. verwenden, um Ihre Anforderungen zu erfüllen.

Das folgende Beispiel verwendet die Abfragesyntax, um die Daten aus der Liste abzurufen:

using System;
using System.Linq;
using System.Collections.Generic;

class LinqExample {
  static public void Main() {
    List<string> myList = new List<string>() { "Cat", "Dog", "Tiger", "Wolf" };

    // Create LINQ Query
    var result = from a in myList select a;

    // Executing the query
    foreach (var r in result) {
      Console.WriteLine(r);
    }
  }
}

Dies erzeugt die folgende Ausgabe:

Methodensyntax in LINQ

Die Methodensyntax wird in LINQ verwendet, um die Erweiterungsmethoden der statischen Enumerable- oder Queryable-Klassen aufzurufen. Sie wird auch als Methodenerweiterungssyntax bezeichnet.

Der Compiler hingegen konvertiert die Abfragesyntax immer zur Kompilierzeit in die Methodensyntax. Es kann Standard-Abfrageoperatoren wie Select, Where, GroupBy, Join, Max usw. verwenden.

Sie können sie direkt aufrufen, ohne die Abfragesyntax zu verwenden.

Im folgenden Beispiel verwenden wir die Methodensyntax, um den Namen eines Tieres zu erhalten, dessen Namenslänge größer als 3 ist. Die Abfrage wird wie folgt gebildet:

var result = myList.Where(a => a.Length > 3);

Der vollständige Code für die Methodensyntax sieht folgendermaßen aus:

using System;
using System.Linq;
using System.Collections.Generic;

class LinqExample {
  static public void Main() {
    List<string> myList = new List<string>() { "Cat", "Dog", "Tiger", "Wolf" };

    // Create LINQ Query
    var result = myList.Where(a => a.Length > 3);

    // Executing the query
    foreach (var r in result) {
      Console.WriteLine(r);
    }
  }
}

Dies ergibt die folgende Ausgabe:

In der Methodensyntax bemerken Sie möglicherweise einen Ausdruck im Argument der Where-Funktion, der aus einem =>-Zeichen besteht. Dieses ungewöhnliche Ding ist als Lambda-Ausdruck bekannt.

Im nächsten Abschnitt werden wir den Lambda-Ausdruck und seine Verwendung mit LINQ-Abfragen erörtern.

Lambda-Ausdrücke in C#

In C# werden Lambda-Ausdrücke ähnlich wie anonyme Funktionen verwendet, mit der Ausnahme, dass Sie den Typ des eingegebenen Werts nicht angeben müssen, wenn Sie einen Lambda-Ausdruck verwenden, was ihn flexibler macht.

Alle Lambda-Ausdrücke verwenden den Lambda-Operator, dargestellt durch das Symbol =>. Die Eingabe befindet sich auf der linken Seite des Lambda-Ausdrucks und der Ausdruck auf der rechten Seite.

Lambda-Ausdrücke werden in zwei Formen eingeteilt:

1. Ausdruck Lambda
2. Anweisung Lambda

Ausdruck Lambda

Diese besteht aus einer Eingabeanweisung und einem auszuwertenden Ausdruck rechts vom Lambda-Symbol:

input statement => expression

Erklärung Lambda

Diese besteht aus einer Eingabeanweisung und einer Reihe von Anweisungen auf der rechten Seite des Lambda-Symbols:

input statements => { set of statements }

Angenommen, wir haben eine Liste-Datenstruktur, die aus einigen Zahlen besteht, und wir müssen den Würfel aller Listenzahlen auswerten. Dies kann sehr einfach mit dem Lambda-Ausdruck erfolgen.

Dies kann im folgenden Codesegment demonstriert werden:

using System;
using System.Collections.Generic;
using System.Linq;

namespace ConsoleApp6 {
  class Program {
    static void Main(string[] args) {
      List<int> listOfNumbers = new List<int>() { 16, 11, 2, 5, 9, 8, 7, 6, 1, 12 };
      var cubes = listOfNumbers.Select(a => a * a * a);

      // Display all the cubes
      Console.Write("Cubes of the List : ");
      foreach (var val in cubes) {
        Console.Write("{0} ", val);
      }
    }
  }
}

Sie können im obigen Codesegment sehen, dass wir mit der Funktion Select ein Element aus der Liste ausgewählt und dann mit dem Lambda-Ausdruck seinen Würfel erstellt haben.

Die Ausgabe des Segments sieht wie folgt aus:

Lambda-Ausdruck in LINQ

Lambda-Ausdruck und LINQ bieten eine Möglichkeit, die Daten aus jeder Datenquelle abzufragen. Hier sind einige Beispiele, in denen wir Daten mit der LINQ Lambda-Syntax abfragen.

Angenommen, wir haben eine benutzerdefinierte Klasse Student mit roll_num, name und marks als Eigenschaften. Wir werden einige Daten in der Schülerliste initialisieren und die Daten dann mit LINQ-Abfragen und Lambda-Ausdrücken abfragen.

class Student {
  private int roll_num;
  private string name;
  private int marks;

  public int Roll_num {
    get => roll_num;
    set => roll_num = value;
  }
  public string Name {
    get => name;
    set => name = value;
  }
  public int Marks {
    get => marks;
    set => marks = value;
  }
}

In unserer Main-Funktion erstellen wir eine Liste von Student-Klassen und fragen dann die Daten daraus ab:

static void Main(string[] args) {
  List<Student> students =
      new List<Student>() { new Student { Roll_num = 1, Name = "David", Marks = 65 },
                            new Student { Roll_num = 2, Name = "John", Marks = 90 },
                            new Student { Roll_num = 3, Name = "Dina", Marks = 87 },
                            new Student { Roll_num = 4, Name = "Leen", Marks = 43 },
                            new Student { Roll_num = 5, Name = "Krish", Marks = 57 } };
}

Angenommen, wir müssen nach dem Erstellen der Liste die Schüler mit Noten über 60 auswählen und dem Benutzer anzeigen. Dafür verwenden wir Lambda-Ausdrücke und LINQ-Abfragen.

Console.WriteLine("Through Lambda Expression");
IEnumerable<Student> sortedData = students.Where(x => x.Marks > 60);
foreach (var s in sortedData) Console.WriteLine(s.Roll_num + "  " + s.Name + "  " + s.Marks);

Console.WriteLine("Through LINQ query");
IEnumerable<Student> result = from s in students
    where s.Marks> 60 select s; foreach (var s in sortedData) Console.WriteLine(s.Roll_num + "  " + s.Name + "  " + s.Marks);

Beachten Sie, dass wir im obigen Codesegment dieselben Daten auf zwei verschiedene Arten ausgewählt haben. Beachten Sie, dass das Abfragen von Daten durch Lambda-Anweisungen sehr einfach ist und weniger Codierung erfordert als LINQ-Abfragen.

Die Ausgabe ist in beiden Fällen gleich:

Im vorherigen Beispiel haben wir alle Daten der Schüler angezeigt. Wenn wir den Namen solcher Schüler erhalten müssen, die mehr als 60 Punkte erzielt haben, lautet der Lambda-Ausdruck:

var stuNames = students.Where(x => x.Marks > 60).Select(x => x.Name);
foreach (var s in stuNames) Console.WriteLine(s);

Dadurch werden nur die Namen der Schüler zurückgegeben. Daher haben wir sie nicht in einem IEnumerable-Typ gespeichert.

Die Ausgabe wird sein:

Angenommen, wir möchten die Namen und Noten der Schüler, aber zuerst müssen wir sie nach ihren Noten sortieren. Zur Sortierung der Daten verwenden wir die Funktion OrderBy .

var stuNames = students.OrderBy(x => x.Marks).Select(x => new { x.Name, x.Marks });
foreach (var s in stuNames) Console.WriteLine(s.Name + "  " + s.Marks);

Die Ausgabe wird sein:

So können wir sehen, dass verschiedene Methoden Daten mithilfe von Lambda-Ausdrücken abfragen können. Lambda-Ausdrücke sind hilfreich, wenn Sie über große Datenmengen verfügen und nur minimale Codierungsschritte zum Abfragen oder Anwenden verschiedener Operationen auf die Daten erfordern.