LINQ - Kurzanleitung

Entwickler auf der ganzen Welt hatten immer Probleme beim Abfragen von Daten, da kein definierter Pfad vorhanden war und sie eine Vielzahl von Technologien wie SQL, Web Services, XQuery usw. beherrschen mussten.

LINQ (Language Integrated Query) wurde in Visual Studio 2008 eingeführt und von Anders Hejlsberg entworfen. Es ermöglicht das Schreiben von Abfragen auch ohne Kenntnisse von Abfragesprachen wie SQL, XML usw. LINQ-Abfragen können für verschiedene Datentypen geschrieben werden.

Beispiel einer LINQ-Abfrage

C #

using System;
using System.Linq;

class Program {
   static void Main() {
   
      string[] words = {"hello", "wonderful", "LINQ", "beautiful", "world"};
		
      //Get only short words
      var shortWords = from word in words where word.Length <= 5 select word;
	    
      //Print each word out
      foreach (var word in shortWords) {
         Console.WriteLine(word);
      }	 
		
      Console.ReadLine();
   }
}

VB

Module Module1
   Sub Main()
      Dim words As String() = {"hello", "wonderful", "LINQ", "beautiful", "world"}
     
      ' Get only short words
      Dim shortWords = From word In words _ Where word.Length <= 5 _ Select word
     
      ' Print each word out.
	  
      For Each word In shortWords
         Console.WriteLine(word)
      Next
	  
      Console.ReadLine()
   End Sub
End Module

Wenn der obige Code von C # oder VB kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

hello 
LINQ 
world

Syntax von LINQ

Es gibt zwei Syntaxen von LINQ. Dies sind die folgenden.

Lamda (Methode) -Syntax

var longWords = words.Where( w ⇒ w.length > 10);
Dim longWords = words.Where(Function(w) w.length > 10)

Abfragesyntax (Verständnis)

var longwords = from w in words where w.length > 10;
Dim longwords = from w in words where w.length > 10

Arten von LINQ

Die Arten von LINQ werden im Folgenden kurz erwähnt.

LINQ zu Objekten
LINQ zu XML (XLINQ)
LINQ zu DataSet
LINQ zu SQL (DLINQ)
LINQ zu Entitäten

Abgesehen von den oben genannten gibt es auch einen LINQ-Typ namens PLINQ, bei dem es sich um den parallelen LINQ von Microsoft handelt.

LINQ-Architektur in .NET

LINQ verfügt über eine dreischichtige Architektur, bei der die oberste Schicht aus den Spracherweiterungen und die unterste Schicht aus Datenquellen besteht, bei denen es sich normalerweise um Objekte handelt, die generische IEnumerable <T> - oder IQueryable <T> -Schnittstellen implementieren. Die Architektur ist unten dargestellt.

Abfrageausdrücke

Der Abfrageausdruck ist nichts anderes als eine LINQ-Abfrage, die in einer ähnlichen Form wie SQL mit Abfrageoperatoren wie Select, Where und OrderBy ausgedrückt wird. Abfrageausdrücke beginnen normalerweise mit dem Schlüsselwort "From".

Um auf Standard-LINQ-Abfrageoperatoren zuzugreifen, sollte der Namespace System.Query standardmäßig importiert werden. Diese Ausdrücke werden in einer deklarativen Abfragesyntax geschrieben, die C # 3.0 war.

Im Folgenden finden Sie ein Beispiel für eine vollständige Abfrageoperation, die aus der Erstellung von Datenquellen, der Definition von Abfrageausdrücken und der Ausführung von Abfragen besteht.

C #

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

namespace Operators {
   class LINQQueryExpressions {
      static void Main() {
      
         // Specify the data source.
         int[] scores = new int[] { 97, 92, 81, 60 };

         // Define the query expression.
         IEnumerable<int> scoreQuery = from score in scores where score > 80 select score;

         // Execute the query.
		 
         foreach (int i in scoreQuery) {
            Console.Write(i + " ");
         }
		 
         Console.ReadLine();
      }
   }
}

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

97 92 81

Erweiterungsmethoden

Mit .NET 3.5 eingeführt, werden Erweiterungsmethoden nur in statischen Klassen deklariert und ermöglichen die Aufnahme benutzerdefinierter Methoden in Objekte, um einige präzise Abfrageoperationen zum Erweitern einer Klasse auszuführen, ohne tatsächlich Mitglied dieser Klasse zu sein. Diese können auch überlastet werden.

Kurz gesagt, Erweiterungsmethoden werden verwendet, um Abfrageausdrücke in herkömmliche Methodenaufrufe (objektorientiert) zu übersetzen.

Unterschied zwischen LINQ und gespeicherter Prozedur

Es gibt eine Reihe von Unterschieden zwischen LINQ- und gespeicherten Prozeduren. Diese Unterschiede werden unten erwähnt.

Gespeicherte Prozeduren sind viel schneller als eine LINQ-Abfrage, da sie einem erwarteten Ausführungsplan folgen.
Es ist einfach, Laufzeitfehler beim Ausführen einer LINQ-Abfrage zu vermeiden, als im Vergleich zu einer gespeicherten Prozedur, da diese die Intellisense-Unterstützung von Visual Studio sowie eine vollständige Typprüfung während der Kompilierungszeit bietet.
LINQ ermöglicht das Debuggen mithilfe des .NET-Debuggers, der bei gespeicherten Prozeduren nicht vorhanden ist.
LINQ bietet Unterstützung für mehrere Datenbanken im Gegensatz zu gespeicherten Prozeduren, bei denen es wichtig ist, den Code für verschiedene Arten von Datenbanken neu zu schreiben.
Die Bereitstellung einer LINQ-basierten Lösung ist im Vergleich zur Bereitstellung einer Reihe gespeicherter Prozeduren einfach und unkompliziert.

Need For LINQ

Vor LINQ war es wichtig, C #, SQL und verschiedene APIs zu lernen, die beide miteinander verbinden, um eine vollständige Anwendung zu bilden. Da diese Datenquellen und Programmiersprachen einer Impedanzfehlanpassung ausgesetzt sind; Es besteht die Notwendigkeit einer kurzen Codierung.

Nachfolgend finden Sie ein Beispiel dafür, wie viele verschiedene Techniken von den Entwicklern beim Abfragen von Daten vor dem Aufkommen von LINQ verwendet wurden.

SqlConnection sqlConnection = new SqlConnection(connectString);
SqlConnection.Open();

System.Data.SqlClient.SqlCommand sqlCommand = new SqlCommand();
sqlCommand.Connection = sqlConnection;

sqlCommand.CommandText = "Select * from Customer";
return sqlCommand.ExecuteReader (CommandBehavior.CloseConnection)

Interessanterweise wird die Abfrage von den vorgestellten Codezeilen nur durch die letzten beiden definiert. Mit LINQ kann dieselbe Datenabfrage in kürzerer Zeit in einer lesbaren farbcodierten Form wie der folgenden geschrieben werden.

Northwind db = new Northwind(@"C:\Data\Northwnd.mdf");
var query = from c in db.Customers select c;

Vorteile von LINQ

LINQ bietet eine Reihe von Vorteilen, darunter vor allem die starke Ausdruckskraft, mit der Entwickler deklarativ ausdrücken können. Einige der anderen Vorteile von LINQ sind unten angegeben.

LINQ bietet Syntaxhervorhebungen, die sich als hilfreich erweisen, um Fehler während der Entwurfszeit herauszufinden.
LINQ bietet IntelliSense, was bedeutet, dass Sie einfach genauere Abfragen schreiben können.
Das Schreiben von Codes ist in LINQ sehr viel schneller und somit wird auch die Entwicklungszeit erheblich verkürzt.
LINQ erleichtert das Debuggen aufgrund seiner Integration in die C # -Sprache.
Das Anzeigen der Beziehung zwischen zwei Tabellen ist mit LINQ aufgrund seiner hierarchischen Funktion einfach. Dadurch können Abfragen erstellt werden, die mehrere Tabellen in kürzerer Zeit verbinden.
LINQ ermöglicht die Verwendung einer einzelnen LINQ-Syntax beim Abfragen vieler verschiedener Datenquellen. Dies liegt hauptsächlich an der einheitlichen Grundlage.
LINQ ist erweiterbar, dh es ist möglich, das Wissen über LINQ zum Abfragen neuer Datenquellentypen zu verwenden.
LINQ bietet die Möglichkeit, mehrere Datenquellen in einer einzigen Abfrage zusammenzuführen und komplexe Probleme in eine Reihe von kurzen Abfragen zu unterteilen, die leicht zu debuggen sind.
LINQ bietet eine einfache Transformation für die Konvertierung eines Datentyps in einen anderen, wie die Transformation von SQL-Daten in XML-Daten.

Bevor Sie mit LINQ-Programmen beginnen, sollten Sie zunächst die Nuancen beim Einrichten einer LINQ-Umgebung verstehen. LINQ benötigt ein .NET Framework, eine revolutionäre Plattform für eine Vielzahl von Anwendungen. Eine LINQ-Abfrage kann bequem entweder in C # oder Visual Basic geschrieben werden.

Microsoft bietet mithilfe von Visual Studio Tools für beide Sprachen an, z. B. C # und Visual Basic. Unsere Beispiele wurden alle in Visual Studio 2010 kompiliert und geschrieben. Die Visual Basic 2013 Edition steht jedoch auch zur Verfügung. Es ist die neueste Version und hat viele Ähnlichkeiten mit Visual Studio 2012.

Visual Studio 2010 unter Windows 7 installieren

Visual Studio kann entweder von einem Installationsmedium wie einer DVD installiert werden. Administratoranmeldeinformationen sind erforderlich, um Visual Basic 2010 erfolgreich auf Ihrem System zu installieren. Es ist wichtig, vor der Installation alle austauschbaren USB-Geräte vom System zu trennen, da sonst die Installation fehlschlagen kann. Einige der für die Installation erforderlichen Hardwareanforderungen sind die folgenden.

Hardware-Anforderungen

1,6 GHz oder mehr
1 GB RAM
3 GB (verfügbarer Festplattenspeicher)
Festplattenlaufwerk mit 5400 U / min
DirectX 9-kompatible Grafikkarte
DVD-ROM-Laufwerk

Installationsschritte

Step 1 - Klicken Sie nach dem Einlegen der DVD mit dem Visual Studio 2010-Paket zunächst auf Install or run program from your media wird in einem Popup-Fenster auf dem Bildschirm angezeigt.

Step 2- Jetzt für Visual Studio eingerichtet wird auf dem Bildschirm angezeigt. WählenInstall Microsoft Visual Studio 2010.

Step 3- Sobald Sie darauf klicken, wird der Vorgang gestartet und ein Einrichtungsfenster wird auf Ihrem Bildschirm angezeigt. Klicken Sie nach Abschluss des Ladens der Installationskomponenten, was einige Zeit in Anspruch nehmen wird, aufNext Taste, um zum nächsten Schritt zu gelangen.

Step 4 - Dies ist der letzte Schritt der Installation. Es wird eine Startseite angezeigt, auf der Sie einfach "Ich habe die Lizenzbedingungen gelesen und akzeptiere" auswählen und auf klicken Next Taste.

Step 5- Wählen Sie nun auf der Optionsseite auf Ihrem Bildschirm die zu installierenden Funktionen aus. Sie können entweder wählenFull oder CustomMöglichkeit. Wenn Sie weniger Speicherplatz als erforderlich haben, wie in den Speicherplatzanforderungen angegeben, wählen Sie Benutzerdefiniert.

Step 6- Wenn Sie die Option Benutzerdefiniert wählen, wird das folgende Fenster angezeigt. Wählen Sie die Funktionen aus, die Sie installieren möchten, und klicken Sie aufUpdate oder fahren Sie mit Schritt 7 fort. Es wird jedoch empfohlen, die benutzerdefinierte Option nicht zu verwenden, da Sie in Zukunft möglicherweise die von Ihnen ausgewählten Funktionen benötigen, um nicht über diese zu verfügen.

Step 7- Bald wird ein Popup-Fenster angezeigt und die Installation wird gestartet, was lange dauern kann. Denken Sie daran, dass hier alle Komponenten installiert werden.

Step 8- Schließlich können Sie in einem Fenster eine Meldung anzeigen, dass die Installation erfolgreich abgeschlossen wurde. KlickenFinish.

Schreiben eines C # -Programms mit LINQ in Visual Studio 2010

Starten Sie Visual Studio 2010 Ultimate Edition und wählen Sie im Menü Datei gefolgt von Neuem Projekt.
Ein neues Projektdialogfeld wird auf Ihrem Bildschirm angezeigt.
Wählen Sie nun Visual C # als Kategorie unter installierten Vorlagen und anschließend Konsolenanwendungsvorlage (siehe Abbildung unten).

Geben Sie Ihrem Projekt im unteren Namensfeld einen Namen und drücken Sie OK.
Das neue Projekt wird im Projektmappen-Explorer auf der rechten Seite eines neuen Dialogfelds auf Ihrem Bildschirm angezeigt.

Wählen Sie nun Program.cs aus dem Projektmappen-Explorer und Sie können den Code im Editorfenster anzeigen, das mit 'using System' beginnt.
Hier können Sie mit dem Codieren Ihres folgenden C # -Programms beginnen.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
			
namespace HelloWorld {
   class Program {
      static void Main(string[] args) {
      
         Console.WriteLine("Hello World")
         Console.ReadKey();
      } 		
   }
}

Drücken Sie die Taste F5 und führen Sie Ihr Projekt aus. Es wird dringend empfohlen, das Projekt durch Auswahl zu speichernFile → Save All bevor Sie das Projekt ausführen.

Schreiben eines VB-Programms mit LINQ in Visual Studio 2010

Starten Sie Visual Studio 2010 Ultimate Edition und wählen Sie im Menü Datei gefolgt von Neuem Projekt.
Ein neues Projektdialogfeld wird auf Ihrem Bildschirm angezeigt.
Wählen Sie nun Visual Basic als Kategorie unter installierten Vorlagen und anschließend Konsolenanwendungsvorlage.
Geben Sie Ihrem Projekt im unteren Namensfeld einen Namen und drücken Sie OK.
Sie erhalten einen Bildschirm mit Module1.vb. Schreiben Sie hier Ihren VB-Code mit LINQ.

Module Module1

   Sub Main()
      Console.WriteLine("Hello World")
      Console.ReadLine()
   End Sub
   
End Module

Drücken Sie die Taste F5 und führen Sie Ihr Projekt aus. Es wird dringend empfohlen, das Projekt durch Auswahl zu speichernFile → Save All bevor Sie das Projekt ausführen.

Wenn der obige Code von C # oder VB gecimpt und ausgeführt wird, wird das folgende Ergebnis erzeugt:

Hello World

Eine Reihe von Erweiterungsmethoden, die ein Abfragemuster bilden, werden als LINQ-Standardabfrageoperatoren bezeichnet. Als Bausteine für LINQ-Abfrageausdrücke bieten diese Operatoren eine Reihe von Abfragefunktionen wie Filtern, Sortieren, Projektieren, Aggregieren usw.

LINQ-Standardabfrageoperatoren können aufgrund ihrer Funktionalität in die folgenden eingeteilt werden.

Filteroperatoren
Operatoren beitreten
Projektionsoperationen
Sortieroperatoren
Gruppieren von Operatoren
Conversions
Concatenation
Aggregation
Quantifiziereroperationen
Partitionsoperationen
Generierungsvorgänge
Operationen einstellen
Equality
Elementoperatoren

Filteroperatoren

Das Filtern ist eine Operation zum Einschränken der Ergebnismenge, sodass nur Elemente ausgewählt werden, die eine bestimmte Bedingung erfüllen.

Beispiele anzeigen

Operator	Beschreibung	Syntax des C # -Abfrageausdrucks	Syntax für VB-Abfrageausdrücke
wo	Filtern Sie Werte basierend auf einer Prädikatfunktion	wo	Wo
OfType	Filtern Sie Werte basierend auf ihrer Fähigkeit, ein bestimmter Typ zu sein	Unzutreffend	Unzutreffend

Operatoren beitreten

Joining bezieht sich auf eine Operation, bei der Datenquellen mit schwer zu verfolgenden Beziehungen auf direkte Weise als Ziel ausgewählt werden.

Beispiele anzeigen

Operator	Beschreibung	Syntax des C # -Abfrageausdrucks	Syntax für VB-Abfrageausdrücke
Beitreten	Der Bediener verbindet zwei Sequenzen auf der Basis übereinstimmender Schlüssel	mitmachen… mit… am… gleich…	Von x In…, y In… Wobei xa = ya
GroupJoin	Verbinden Sie zwei Sequenzen und gruppieren Sie die passenden Elemente	mach mit… mit… am… gleich… mit…	Group Join… In… On…

Projektionsoperationen

Projektion ist eine Operation, bei der ein Objekt in eine völlig neue Form mit nur bestimmten Eigenschaften umgewandelt wird.

Beispiele anzeigen

Operator	Beschreibung	Syntax des C # -Abfrageausdrucks	Syntax für VB-Abfrageausdrücke
Wählen	Der Operator projiziert Werte auf Basis einer Transformationsfunktion	wählen	Wählen
SelectMany	Der Operator projiziert die Folgen von Werten, die auf einer Transformationsfunktion basieren, und glättet sie zu einer einzigen Folge	Verwenden Sie mehrere from-Klauseln	Verwenden Sie mehrere From-Klauseln

Sortieroperatoren

Eine Sortieroperation ermöglicht das Ordnen der Elemente einer Sequenz auf der Basis eines einzelnen oder mehrerer Attribute.

Beispiele anzeigen

Operator	Beschreibung	Syntax des C # -Abfrageausdrucks	Syntax für VB-Abfrageausdrücke
Sortieren nach	Der Operator sortiert die Werte in aufsteigender Reihenfolge	Sortieren nach	Sortieren nach
OrderByDescending	Der Operator sortiert die Werte in absteigender Reihenfolge	orderby ... absteigend	Bestellen nach ... absteigend
Dann durch	Führt eine sekundäre Sortierung in aufsteigender Reihenfolge aus	Sortieren nach …, …	Sortieren nach …, …
ThenByDescending	Führt eine sekundäre Sortierung in absteigender Reihenfolge aus	orderby…,… absteigend	Bestellen nach…,… absteigend
Umkehren	Führt eine Umkehrung der Reihenfolge der Elemente in einer Sammlung durch	Unzutreffend	Unzutreffend

Gruppieren von Operatoren

Die Operatoren ordnen Daten basierend auf einem gemeinsamen Attribut in einige Gruppen ein.

Beispiele anzeigen

Operator	Beschreibung	Syntax des C # -Abfrageausdrucks	Syntax für VB-Abfrageausdrücke
Gruppiere nach	Organisieren Sie eine Folge von Elementen in Gruppen und geben Sie sie als IEnumerable-Sammlung vom Typ IGrouping <Schlüssel, Element> zurück	Gruppe… von -oder- Gruppe… von… in…	Gruppe… von… in…
Nachschlagen	Führen Sie eine Gruppierungsoperation aus, bei der eine Folge von Schlüsselpaaren zurückgegeben wird	Unzutreffend	Unzutreffend

Konvertierungen

Die Operatoren ändern den Typ der Eingabeobjekte und werden in einer Vielzahl von Anwendungen verwendet.

Beispiele anzeigen

Operator	Beschreibung	Syntax des C # -Abfrageausdrucks	Syntax für VB-Abfrageausdrücke
AsEnumerable	Gibt die als IEnumerable <T> eingegebene Eingabe zurück	Unzutreffend	Unzutreffend
AsQueryable	Eine (generische) IEnumerable wird in eine (generische) IQueryable konvertiert	Unzutreffend	Unzutreffend
Besetzung	Führt das Casting von Elementen einer Sammlung in einen bestimmten Typ durch	Verwenden Sie eine explizit eingegebene Bereichsvariable. ZB: von string str in Worten	Von… als…
OfType	Filtert Werte auf der Grundlage ihrer, abhängig von ihrer Fähigkeit, auf einen bestimmten Typ umgewandelt zu werden	Unzutreffend	Unzutreffend
ToArray	Erzwingt die Ausführung von Abfragen und konvertiert eine Sammlung in ein Array	Unzutreffend	Unzutreffend
ToDictionary	Stellen Sie anhand einer Tastenauswahlfunktion Elemente in ein Dictionary <TKey, TValue> und erzwingen Sie die Ausführung einer LINQ-Abfrage	Unzutreffend	Unzutreffend
Auflisten	Erzwingt die Ausführung einer Abfrage durch Konvertieren einer Sammlung in eine Liste <T>	Unzutreffend	Unzutreffend
Nachschlagen	Erzwingt die Ausführung einer Abfrage und fügt Elemente auf der Grundlage einer Schlüsselauswahlfunktion in einen Lookup <TKey, TElement> ein	Unzutreffend	Unzutreffend

Verkettung

Führt eine Verkettung von zwei Sequenzen durch und ist dem Union-Operator in Bezug auf seine Funktionsweise ziemlich ähnlich, mit der Ausnahme, dass dadurch keine Duplikate entfernt werden.

Beispiele anzeigen

Operator	Beschreibung	Syntax des C # -Abfrageausdrucks	Syntax für VB-Abfrageausdrücke
Concat	Zwei Sequenzen werden zur Bildung einer einzigen Sequenz verkettet.	Unzutreffend	Unzutreffend

Anhäufung

Führt jede Art von gewünschter Aggregation durch und ermöglicht das Erstellen benutzerdefinierter Aggregationen in LINQ.

Beispiele anzeigen

Operator	Beschreibung	Syntax des C # -Abfrageausdrucks	Syntax für VB-Abfrageausdrücke
Aggregat	Arbeitet mit den Werten einer Sammlung, um eine benutzerdefinierte Aggregationsoperation auszuführen	Unzutreffend	Unzutreffend
Durchschnittlich	Der Durchschnittswert einer Sammlung von Werten wird berechnet	Unzutreffend	Aggregate… In… Into Average ()
Anzahl	Zählt die Elemente, die eine Prädikatfunktion innerhalb der Sammlung erfüllen	Unzutreffend	Aggregate… In… Into Count ()
LonCount	Zählt die Elemente, die eine Prädikatfunktion erfüllen, innerhalb einer riesigen Sammlung	Unzutreffend	Aggregieren… In… In LongCount ()
Max	Finden Sie den Maximalwert innerhalb einer Sammlung heraus	Unzutreffend	Aggregieren… In… In Max ()
Mindest	Finden Sie den Mindestwert heraus, der in einer Sammlung vorhanden ist	Unzutreffend	Aggregieren… In… In Min ()
Summe	Ermitteln Sie die Summe der Werte in einer Sammlung	Unzutreffend	Aggregieren… In… In Summe ()

Quantifiziereroperationen

Diese Operatoren geben einen booleschen Wert zurück, dh True oder False, wenn einige oder alle Elemente innerhalb einer Sequenz eine bestimmte Bedingung erfüllen.

Beispiele anzeigen

Operator	Beschreibung	Syntax des C # -Abfrageausdrucks	Syntax für VB-Abfrageausdrücke
Alle	Gibt den Wert 'True' zurück, wenn alle Elemente einer Sequenz eine Prädikatbedingung erfüllen	Unzutreffend	Aggregieren… In… In Alle (…)
Irgendein	Bestimmt durch Durchsuchen einer Sequenz, ob ein Element desselben eine bestimmte Bedingung erfüllt	Unzutreffend	Aggregate… In… Into Any ()
Enthält	Gibt einen 'True'-Wert zurück, wenn festgestellt wird, dass ein bestimmtes Element in einer Sequenz vorhanden ist, wenn die Sequenz dieses bestimmte Element nicht enthält, wird ein' false'-Wert zurückgegeben	Unzutreffend	Unzutreffend

Partitionsoperatoren

Teilen Sie eine Eingabesequenz in zwei separate Abschnitte, ohne die Elemente der Sequenz neu anzuordnen und dann eines davon zurückzugeben.

Beispiele anzeigen

Operator	Beschreibung	Syntax des C # -Abfrageausdrucks	Syntax für VB-Abfrageausdrücke
Überspringen	Überspringt eine bestimmte Anzahl von Elementen innerhalb einer Sequenz und gibt die verbleibenden zurück	Unzutreffend	Überspringen
Überspringen	Entspricht dem von Überspringen, mit der einzigen Ausnahme, dass die Anzahl der zu überspringenden Elemente durch eine Boolesche Bedingung angegeben wird	Unzutreffend	Überspringen während
Nehmen	Nehmen Sie eine bestimmte Anzahl von Elementen aus einer Sequenz und überspringen Sie die verbleibenden	Unzutreffend	Nehmen
TakeWhile	Entspricht der von Take, außer dass die Anzahl der zu nehmenden Elemente durch eine Boolesche Bedingung angegeben wird	Unzutreffend	Nehmen Sie während

Generierungsvorgänge

Eine neue Wertesequenz wird von Generationsoperatoren erstellt.

Beispiele anzeigen

Operator	Beschreibung	Syntax des C # -Abfrageausdrucks	Syntax für VB-Abfrageausdrücke
DefaultIfEmpty	Wenn Sie auf eine leere Sequenz angewendet werden, generieren Sie ein Standardelement innerhalb einer Sequenz	Unzutreffend	Unzutreffend
Leer	Gibt eine leere Folge von Werten zurück und ist der einfachste Generationsoperator	Unzutreffend	Unzutreffend
Angebot	Erzeugt eine Sammlung mit einer Folge von Ganzzahlen oder Zahlen	Unzutreffend	Unzutreffend
Wiederholen	Erzeugt eine Sequenz mit wiederholten Werten einer bestimmten Länge	Unzutreffend	Unzutreffend

Operationen einstellen

Es gibt vier Operatoren für die festgelegten Operationen, die jeweils ein Ergebnis liefern, das auf unterschiedlichen Kriterien basiert.

Beispiele anzeigen

Operator	Beschreibung	Syntax des C # -Abfrageausdrucks	Syntax für VB-Abfrageausdrücke
Deutlich	Erstellt eine Liste eindeutiger Werte aus einer Sammlung, indem gegebenenfalls doppelte Daten gefiltert werden	Unzutreffend	Deutlich
Außer	Vergleicht die Werte von zwei Sammlungen und gibt diejenigen aus einer Sammlung zurück, die sich nicht in der anderen Sammlung befinden	Unzutreffend	Unzutreffend
Sich schneiden	Gibt den Wertesatz zurück, der in zwei separaten Sammlungen als identisch befunden wurde	Unzutreffend	Unzutreffend
Union	Kombiniert den Inhalt zweier verschiedener Sammlungen zu einer einzigen Liste, auch ohne doppelten Inhalt	Unzutreffend	Unzutreffend

Gleichberechtigung

Vergleicht zwei Sätze (aufzählbar) und stellt fest, ob sie genau übereinstimmen oder nicht.

Beispiele anzeigen

Operator	Beschreibung	Syntax des C # -Abfrageausdrucks	Syntax für VB-Abfrageausdrücke
SequenceEqual	Ergibt einen Booleschen Wert, wenn festgestellt wird, dass zwei Sequenzen miteinander identisch sind	Unzutreffend	Unzutreffend

Elementoperatoren

Mit Ausnahme von DefaultIfEmpty geben alle übrigen acht Standardoperatoren für Abfrageelemente ein einzelnes Element aus einer Auflistung zurück.

Beispiele anzeigen

Operator	Beschreibung	Syntax des C # -Abfrageausdrucks	Syntax für VB-Abfrageausdrücke
ElementAt	Gibt ein Element zurück, das in einem bestimmten Index in einer Sammlung vorhanden ist	Unzutreffend	Unzutreffend
ElementAtOrDefault	Entspricht ElementAt, außer dass es auch einen Standardwert zurückgibt, falls der spezifische Index außerhalb des Bereichs liegt	Unzutreffend	Unzutreffend
Zuerst	Ruft das erste Element innerhalb einer Sammlung oder das erste Element ab, das eine bestimmte Bedingung erfüllt	Unzutreffend	Unzutreffend
FirstOrDefault	Entspricht First, mit der Ausnahme, dass auch ein Standardwert zurückgegeben wird, falls solche Elemente nicht vorhanden sind	Unzutreffend	Unzutreffend
Zuletzt	Ruft das letzte in einer Sammlung vorhandene Element oder das letzte Element ab, das eine bestimmte Bedingung erfüllt	Unzutreffend	Unzutreffend
LastOrDefault	Entspricht Last, mit der Ausnahme, dass auch ein Standardwert zurückgegeben wird, falls kein solches Element vorhanden ist	Unzutreffend	Unzutreffend
Single	Gibt das einzelne Element einer Sammlung oder das einzelne Element zurück, das eine bestimmte Bedingung erfüllt	Unzutreffend	Unzutreffend
SingleOrDefault	Entspricht Single, mit der Ausnahme, dass auch ein Standardwert zurückgegeben wird, wenn kein solches einzelnes Element vorhanden ist	Unzutreffend	Unzutreffend
DefaultIfEmpty	Gibt einen Standardwert zurück, wenn die Sammlung oder Liste leer oder null ist	Unzutreffend	Unzutreffend

LINQ to SQL bietet eine Infrastruktur (Laufzeit) für die Verwaltung relationaler Daten als Objekte. Es ist eine Komponente von Version 3.5 von .NET Framework und ermöglicht die Übersetzung sprachintegrierter Abfragen des Objektmodells in SQL. Diese Abfragen werden dann zum Zweck der Ausführung an die Datenbank gesendet. Nachdem die Ergebnisse aus der Datenbank abgerufen wurden, übersetzt LINQ to SQL sie erneut in Objekte.

Einführung von LINQ in SQL

Für die meisten ASP.NET-Entwickler ist LINQ to SQL (auch als DLINQ bekannt) ein elektrisierender Teil von Language Integrated Query, da dies das Abfragen von Daten in der SQL Server-Datenbank mithilfe üblicher LINQ-Ausdrücke ermöglicht. Es ermöglicht auch das Aktualisieren, Löschen und Einfügen von Daten. Der einzige Nachteil, unter dem es leidet, ist die Beschränkung auf die SQL Server-Datenbank. Es gibt jedoch viele Vorteile von LINQ to SQL gegenüber ADO.NET, wie z. B. reduzierte Komplexität, wenige Codierungszeilen und vieles mehr.

Das folgende Diagramm zeigt die Ausführungsarchitektur von LINQ to SQL.

Wie verwende ich LINQ to SQL?

Step 1- Stellen Sie eine neue „Datenverbindung“ mit dem Datenbankserver her. Anzeigen & arrar; Server Explorer & arrar; Datenverbindungen & arrar; Verbindung hinzufügen

Step 2 - Hinzufügen von LINQ zur SQL-Klassendatei

Step 3 - Wählen Sie Tabellen aus der Datenbank aus und ziehen Sie sie per Drag & Drop in die neue LINQ to SQL-Klassendatei.

Step 4 - Tabellen zur Klassendatei hinzugefügt.

Abfragen mit LINQ zu SQL

Die Regeln zum Ausführen einer Abfrage mit LINQ to SQL ähneln denen einer Standard-LINQ-Abfrage, dh die Abfrage wird entweder verzögert oder sofort ausgeführt. Es gibt verschiedene Komponenten, die bei der Ausführung einer Abfrage mit LINQ to SQL eine Rolle spielen. Dies sind die folgenden.

LINQ to SQL API - fordert die Ausführung von Abfragen im Namen einer Anwendung an und sendet sie an LINQ an SQL Provider.
LINQ to SQL Provider - konvertiert die Abfrage in Transact SQL (T-SQL) und sendet die neue Abfrage zur Ausführung an den ADO-Anbieter.
ADO Provider - Senden Sie nach Ausführung der Abfrage die Ergebnisse in Form eines DataReader an LINQ an SQL Provider, der sie wiederum in eine Form von Benutzerobjekt konvertiert.

Es ist zu beachten, dass vor dem Ausführen einer LINQ to SQL-Abfrage unbedingt eine Verbindung zur Datenquelle über die DataContext-Klasse hergestellt werden muss.

Einfügen, Aktualisieren und Löschen mit LINQ To SQL

Hinzufügen ODER Einfügen

using System;
using System.Linq;

namespace LINQtoSQL {
   class LinqToSQLCRUD {
      static void Main(string[] args) {
      
         string connectString = System.Configuration.ConfigurationManager.ConnectionStrings["LinqToSQLDBConnectionString"].ToString();

         LinqToSQLDataContext db = new LinqToSQLDataContext(connectString);           

         //Create new Employee
		 
         Employee newEmployee = new Employee();
         newEmployee.Name = "Michael";
         newEmployee.Email = "[email protected]";
         newEmployee.ContactNo = "343434343";
         newEmployee.DepartmentId = 3;
         newEmployee.Address = "Michael - USA";

         //Add new Employee to database
         db.Employees.InsertOnSubmit(newEmployee);

         //Save changes to Database.
         db.SubmitChanges();

         //Get new Inserted Employee            
         Employee insertedEmployee = db.Employees.FirstOrDefault(e ⇒e.Name.Equals("Michael"));

         Console.WriteLine("Employee Id = {0} , Name = {1}, Email = {2}, ContactNo = {3}, Address = {4}",
                          insertedEmployee.EmployeeId, insertedEmployee.Name, insertedEmployee.Email, 
                          insertedEmployee.ContactNo, insertedEmployee.Address);

         Console.WriteLine("\nPress any key to continue.");
         Console.ReadKey();
      }
   }
}

Module Module1

   Sub Main()
   
      Dim connectString As String = System.Configuration.ConfigurationManager.ConnectionStrings("LinqToSQLDBConnectionString").ToString()

      Dim db As New LinqToSQLDataContext(connectString)

      Dim newEmployee As New Employee()
	  
      newEmployee.Name = "Michael"
      newEmployee.Email = "[email protected]"
      newEmployee.ContactNo = "343434343"
      newEmployee.DepartmentId = 3
      newEmployee.Address = "Michael - USA"
     
      db.Employees.InsertOnSubmit(newEmployee)
     
      db.SubmitChanges()
     
      Dim insertedEmployee As Employee = db.Employees.FirstOrDefault(Function(e) e.Name.Equals("Michael"))

      Console.WriteLine("Employee Id = {0} , Name = {1}, Email = {2}, ContactNo = {3}, 
         Address = {4}", insertedEmployee.EmployeeId, insertedEmployee.Name,
         insertedEmployee.Email, insertedEmployee.ContactNo, insertedEmployee.Address)

      Console.WriteLine(vbLf & "Press any key to continue.")
      Console.ReadKey()
	 
   End Sub
  
End Module

Wenn der obige Code von C # oder VB kompiliert und ausgeführt wird, wird das folgende Ergebnis erzeugt:

Emplyee ID = 4, Name = Michael, Email = [email protected], ContactNo = 
343434343, Address = Michael - USA

Press any key to continue.

Aktualisieren

using System;
using System.Linq;

namespace LINQtoSQL {
   class LinqToSQLCRUD {
      static void Main(string[] args) {
      
         string connectString = System.Configuration.ConfigurationManager.ConnectionStrings["LinqToSQLDBConnectionString"].ToString();

         LinqToSQLDataContext db = new LinqToSQLDataContext(connectString);

         //Get Employee for update
         Employee employee = db.Employees.FirstOrDefault(e =>e.Name.Equals("Michael"));

         employee.Name = "George Michael";
         employee.Email = "[email protected]";
         employee.ContactNo = "99999999";
         employee.DepartmentId = 2;
         employee.Address = "Michael George - UK";

         //Save changes to Database.
         db.SubmitChanges();

         //Get Updated Employee            
         Employee updatedEmployee = db.Employees.FirstOrDefault(e ⇒e.Name.Equals("George Michael"));

         Console.WriteLine("Employee Id = {0} , Name = {1}, Email = {2}, ContactNo = {3}, Address = {4}",
                          updatedEmployee.EmployeeId, updatedEmployee.Name, updatedEmployee.Email, 
                          updatedEmployee.ContactNo, updatedEmployee.Address);

         Console.WriteLine("\nPress any key to continue.");
         Console.ReadKey();
      }
   }
}

Module Module1

   Sub Main()
  
      Dim connectString As String = System.Configuration.ConfigurationManager.ConnectionStrings("LinqToSQLDBConnectionString").ToString()

      Dim db As New LinqToSQLDataContext(connectString)

      Dim employee As Employee = db.Employees.FirstOrDefault(Function(e) e.Name.Equals("Michael"))

      employee.Name = "George Michael"
      employee.Email = "[email protected]"
      employee.ContactNo = "99999999"
      employee.DepartmentId = 2
      employee.Address = "Michael George - UK"

      db.SubmitChanges()
          
      Dim updatedEmployee As Employee = db.Employees.FirstOrDefault(Function(e) e.Name.Equals("George Michael"))

      Console.WriteLine("Employee Id = {0} , Name = {1}, Email = {2}, ContactNo = {3},
         Address = {4}", updatedEmployee.EmployeeId, updatedEmployee.Name, 
         updatedEmployee.Email, updatedEmployee.ContactNo, updatedEmployee.Address)

      Console.WriteLine(vbLf & "Press any key to continue.")
      Console.ReadKey()
	  
   End Sub
   
End Module

Wenn der obige Code von C # oder Vb kompiliert und ausgeführt wird, wird das folgende Ergebnis erzeugt:

Emplyee ID = 4, Name = George Michael, Email = [email protected], ContactNo = 
999999999, Address = Michael George - UK

Press any key to continue.

Löschen

using System;
using System.Linq;

namespace LINQtoSQL {
   class LinqToSQLCRUD {
      static void Main(string[] args) {
      
         string connectString = System.Configuration.ConfigurationManager.ConnectionStrings["LinqToSQLDBConnectionString"].ToString();

         LinqToSQLDataContext db = newLinqToSQLDataContext(connectString);

         //Get Employee to Delete
         Employee deleteEmployee = db.Employees.FirstOrDefault(e ⇒e.Name.Equals("George Michael"));

         //Delete Employee
         db.Employees.DeleteOnSubmit(deleteEmployee);

         //Save changes to Database.
         db.SubmitChanges();

         //Get All Employee from Database
         var employeeList = db.Employees;
         foreach (Employee employee in employeeList) {
            Console.WriteLine("Employee Id = {0} , Name = {1}, Email = {2}, ContactNo = {3}",
               employee.EmployeeId, employee.Name, employee.Email, employee.ContactNo);
         }            

         Console.WriteLine("\nPress any key to continue.");
         Console.ReadKey();
      }
   }
}

Module Module1

   Sub Main()
   
      Dim connectString As String = System.Configuration.ConfigurationManager.ConnectionStrings("LinqToSQLDBConnectionString").ToString()

      Dim db As New LinqToSQLDataContext(connectString)

      Dim deleteEmployee As Employee = db.Employees.FirstOrDefault(Function(e) e.Name.Equals("George Michael"))

      db.Employees.DeleteOnSubmit(deleteEmployee)

      db.SubmitChanges()

      Dim employeeList = db.Employees
	  
      For Each employee As Employee In employeeList
         Console.WriteLine("Employee Id = {0} , Name = {1}, Email = {2}, ContactNo = {3}",
            employee.EmployeeId, employee.Name, employee.Email, employee.ContactNo)
      Next 

      Console.WriteLine(vbLf & "Press any key to continue.")
      Console.ReadKey()
   End Sub
   
End Module

Wenn der obige Code von C # oder VB kompiliert und ausgeführt wird, wird das folgende Ergebnis erzeugt:

Emplyee ID = 1, Name = William, Email = [email protected], ContactNo = 999999999
Emplyee ID = 2, Name = Miley, Email = [email protected], ContactNo = 999999999
Emplyee ID = 3, Name = Benjamin, Email = [email protected], ContactNo = 

Press any key to continue.

LINQ to Objects bietet die Verwendung jeder LINQ-Abfrage, die IEnumerable <T> für den Zugriff auf speicherinterne Datensammlungen unterstützt, ohne dass ein LINQ-Provider (API) erforderlich ist, wie im Fall von LINQ to SQL oder LINQ to XML.

Einführung von LINQ in Objekte

Abfragen in LINQ to Objects geben Variablen vom Typ IEnumerable <T> zurück. Kurz gesagt, LINQ to Objects bietet einen neuen Ansatz für Sammlungen, da es früher wichtig war, lange Codierungen (für jede Schleife von großer Komplexität) zu schreiben, um Daten aus einer Sammlung abzurufen, die jetzt durch das Schreiben von deklarativem Code ersetzt wird, der die gewünschten Daten klar beschreibt das ist erforderlich, um abzurufen.

Es gibt auch viele Vorteile von LINQ to Objects gegenüber herkömmlichen foreach-Schleifen wie mehr Lesbarkeit, leistungsstarke Filterung, Gruppierungsfähigkeit, verbesserte Reihenfolge bei minimaler Anwendungscodierung. Solche LINQ-Abfragen sind auch kompakter und können ohne Änderungen oder mit nur geringen Änderungen auf andere Datenquellen übertragen werden.

Unten finden Sie ein einfaches Beispiel für LINQ to Objects -

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

namespace LINQtoObjects {
   class Program {
      static void Main(string[] args) {
      
         string[] tools = { "Tablesaw", "Bandsaw", "Planer", "Jointer", "Drill", "Sander" };
         var list = from t in tools select t;

         StringBuilder sb = new StringBuilder();

         foreach (string s in list) {
            sb.Append(s + Environment.NewLine);
         }
		 
         Console.WriteLine(sb.ToString(), "Tools");
         Console.ReadLine();
      }
   }
}

Im Beispiel wird ein Array von Zeichenfolgen (Werkzeugen) als Sammlung von Objekten verwendet, die mit LINQ to Objects abgefragt werden sollen.

Objects query is:
var list = from t in tools select t;

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Tablesaw
Bandsaw
Planer
Jointer
Drill
Sander

Abfragen in Speichersammlungen mit LINQ zu Objekten

C #

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

namespace LINQtoObjects {
   class Department {
      public int DepartmentId { get; set; }
      public string Name { get; set; }
   }

   class LinqToObjects {
      static void Main(string[] args) {
      
         List<Department> departments = new List<Department>();
			
         departments.Add(new Department { DepartmentId = 1, Name = "Account" });
         departments.Add(new Department { DepartmentId = 2, Name = "Sales" });
         departments.Add(new Department { DepartmentId = 3, Name = "Marketing" });

         var departmentList = from d in departments
                              select d;

         foreach (var dept in departmentList) {
            Console.WriteLine("Department Id = {0} , Department Name = {1}",
               dept.DepartmentId, dept.Name);
         }
		 
         Console.WriteLine("\nPress any key to continue.");
         Console.ReadKey();
      }
   }
}

VB

Imports System.Collections.Generic
Imports System.Linq

Module Module1

   Sub Main(ByVal args As String())

      Dim account As New Department With {.Name = "Account", .DepartmentId = 1}
      Dim sales As New Department With {.Name = "Sales", .DepartmentId = 2}
      Dim marketing As New Department With {.Name = "Marketing", .DepartmentId = 3}

      Dim departments As New System.Collections.Generic.List(Of Department)(New Department() {account, sales, marketing})

      Dim departmentList = From d In departments

      For Each dept In departmentList
         Console.WriteLine("Department Id = {0} , Department Name = {1}", dept.DepartmentId, dept.Name)
      Next

      Console.WriteLine(vbLf & "Press any key to continue.")
      Console.ReadKey()
   End Sub

   Class Department
      Public Property Name As String
      Public Property DepartmentId As Integer
   End Class
   
End Module

Wenn der obige Code von C # oder VB kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Department Id = 1, Department Name = Account
Department Id = 2, Department Name = Sales
Department Id = 3, Department Name = Marketing

Press any key to continue.

Ein Datensatz bietet eine äußerst nützliche Datendarstellung im Speicher und wird für eine Vielzahl von datenbasierten Anwendungen verwendet. LINQ to Dataset als eine der Technologien von LINQ to ADO.NET erleichtert die problemlose Durchführung von Abfragen der Daten eines Datasets und steigert die Produktivität.

Einführung von LINQ in den Datensatz

LINQ to Dataset hat den Entwicklern das Abfragen vereinfacht. Sie müssen keine Abfragen in einer bestimmten Abfragesprache schreiben, stattdessen können dieselben in der Programmiersprache geschrieben werden. LINQ to Dataset kann auch zum Abfragen verwendet werden, wenn Daten aus mehreren Datenquellen konsolidiert werden. Dies erfordert auch keinen LINQ-Anbieter wie LINQ to SQL und LINQ to XML für den Zugriff auf Daten aus Speichersammlungen.

Im Folgenden finden Sie ein einfaches Beispiel für eine LINQ to Dataset-Abfrage, bei der zuerst eine Datenquelle abgerufen und dann der Datensatz mit zwei Datentabellen gefüllt wird. Zwischen beiden Tabellen wird eine Beziehung hergestellt, und mithilfe der Join-Klausel wird eine LINQ-Abfrage für beide Tabellen erstellt. Schließlich wird jede Schleife verwendet, um die gewünschten Ergebnisse anzuzeigen.

C #

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace LINQtoDataset {
   class Program {
      static void Main(string[] args) {
      
         string connectString = System.Configuration.ConfigurationManager.ConnectionStrings["LinqToSQLDBConnectionString"].ToString();

         string sqlSelect = "SELECT * FROM Department;" + "SELECT * FROM Employee;";

         // Create the data adapter to retrieve data from the database
         SqlDataAdapter da = new SqlDataAdapter(sqlSelect, connectString);
        
         // Create table mappings
         da.TableMappings.Add("Table", "Department");
         da.TableMappings.Add("Table1", "Employee");

         // Create and fill the DataSet
         DataSet ds = new DataSet();
         da.Fill(ds);

         DataRelation dr = ds.Relations.Add("FK_Employee_Department",
                           ds.Tables["Department"].Columns["DepartmentId"],
                           ds.Tables["Employee"].Columns["DepartmentId"]);

         DataTable department = ds.Tables["Department"];
         DataTable employee = ds.Tables["Employee"];

         var query = from d in department.AsEnumerable()
                     join e in employee.AsEnumerable()
                     on d.Field<int>("DepartmentId") equals
                     e.Field<int>("DepartmentId")                        
                     select new {
                        EmployeeId = e.Field<int>("EmployeeId"),
                        Name = e.Field<string>("Name"),                            
                        DepartmentId = d.Field<int>("DepartmentId"),                            
                        DepartmentName = d.Field<string>("Name")
                     };

         foreach (var q in query) {
            Console.WriteLine("Employee Id = {0} , Name = {1} , Department Name = {2}",
               q.EmployeeId, q.Name, q.DepartmentName);
         }

         Console.WriteLine("\nPress any key to continue.");
         Console.ReadKey();
      }
   }
}

VB

Imports System.Data.SqlClient
Imports System.Linq

Module LinqToDataSet

   Sub Main()
   
      Dim connectString As String = System.Configuration.ConfigurationManager.ConnectionStrings("LinqToSQLDBConnectionString").ToString()

      Dim sqlSelect As String = "SELECT * FROM Department;" + "SELECT * FROM Employee;"
      Dim sqlCnn As SqlConnection = New SqlConnection(connectString)
      sqlCnn.Open()

      Dim da As New SqlDataAdapter
      da.SelectCommand = New SqlCommand(sqlSelect, sqlCnn)

      da.TableMappings.Add("Table", "Department")
      da.TableMappings.Add("Table1", "Employee")

      Dim ds As New DataSet()
      da.Fill(ds)

      Dim dr As DataRelation = ds.Relations.Add("FK_Employee_Department", ds.Tables("Department").Columns("DepartmentId"), ds.Tables("Employee").Columns("DepartmentId"))

      Dim department As DataTable = ds.Tables("Department")
      Dim employee As DataTable = ds.Tables("Employee")

      Dim query = From d In department.AsEnumerable()
                  Join e In employee.AsEnumerable() On d.Field(Of Integer)("DepartmentId") Equals
                  e.Field(Of Integer)("DepartmentId")
                  Select New Person With { _
                        .EmployeeId = e.Field(Of Integer)("EmployeeId"),
                        .EmployeeName = e.Field(Of String)("Name"),
                        .DepartmentId = d.Field(Of Integer)("DepartmentId"),
                        .DepartmentName = d.Field(Of String)("Name")
                  }

      For Each e In query
         Console.WriteLine("Employee Id = {0} , Name = {1} , Department Name = {2}", e.EmployeeId, e.EmployeeName, e.DepartmentName)
      Next

      Console.WriteLine(vbLf & "Press any key to continue.")
      Console.ReadKey()
	  
   End Sub
  
   Class Person
      Public Property EmployeeId As Integer
      Public Property EmployeeName As String
      Public Property DepartmentId As Integer
      Public Property DepartmentName As String
   End Class
   
End Module

Wenn der obige Code von C # oder VB kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Employee Id = 1, Name = William, Department Name = Account
Employee Id = 2, Name = Benjamin, Department Name = Account
Employee Id = 3, Name = Miley, Department Name = Sales

Press any key to continue.

Abfragen des Datensatzes mit LinQ zum Datensatz

Bevor Sie mit der Abfrage eines Datasets mit LINQ to Dataset beginnen, müssen Sie unbedingt Daten in ein Dataset laden. Dies erfolgt entweder mithilfe der DataAdapter-Klasse oder mithilfe von LINQ to SQL. Die Formulierung von Abfragen mit LINQ to Dataset ähnelt der Formulierung von Abfragen mit LINQ zusammen mit anderen LINQ-fähigen Datenquellen.

Abfrage mit einer Tabelle

In der folgenden Einzeltabellenabfrage werden alle Online-Bestellungen aus der SalesOrderHeaderTtable erfasst und anschließend die Auftrags-ID, das Bestelldatum sowie die Bestellnummer als Ausgabe angezeigt.

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace LinqToDataset {
   class SingleTable {
      static void Main(string[] args) {
      
         string connectString = System.Configuration.ConfigurationManager.ConnectionStrings["LinqToSQLDBConnectionString"].ToString();

         string sqlSelect = "SELECT * FROM Department;";

         // Create the data adapter to retrieve data from the database
         SqlDataAdapter da = new SqlDataAdapter(sqlSelect, connectString);

         // Create table mappings
         da.TableMappings.Add("Table", "Department");           

         // Create and fill the DataSet
         DataSet ds = new DataSet();
         da.Fill(ds);

         DataTable department = ds.Tables["Department"];            

         var query = from d in department.AsEnumerable()                        
         select new {
            DepartmentId = d.Field<int>("DepartmentId"),
            DepartmentName = d.Field<string>("Name")
         };

         foreach (var q in query) {
            Console.WriteLine("Department Id = {0} , Name = {1}",
               q.DepartmentId, q.DepartmentName);
         }

         Console.WriteLine("\nPress any key to continue.");
         Console.ReadKey();
      }
   }
}

Imports System.Data.SqlClient
Imports System.Linq

Module LinqToDataSet

   Sub Main()
   
      Dim connectString As String = System.Configuration.ConfigurationManager.ConnectionStrings("LinqToSQLDBConnectionString").ToString()

      Dim sqlSelect As String = "SELECT * FROM Department;"
      Dim sqlCnn As SqlConnection = New SqlConnection(connectString)
      sqlCnn.Open()

      Dim da As New SqlDataAdapter
      da.SelectCommand = New SqlCommand(sqlSelect, sqlCnn)

      da.TableMappings.Add("Table", "Department")
      Dim ds As New DataSet()
      da.Fill(ds)

      Dim department As DataTable = ds.Tables("Department")

      Dim query = From d In department.AsEnumerable()
      Select New DepartmentDetail With {
         .DepartmentId = d.Field(Of Integer)("DepartmentId"),
            .DepartmentName = d.Field(Of String)("Name")
      }

      For Each e In query
         Console.WriteLine("Department Id = {0} , Name = {1}", e.DepartmentId, e.DepartmentName)
      Next

      Console.WriteLine(vbLf & "Press any key to continue.")
      Console.ReadKey()
   End Sub

   Public Class DepartmentDetail
      Public Property DepartmentId As Integer
      Public Property DepartmentName As String
   End Class
   
End Module

Wenn der obige Code von C # oder VB kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Department Id = 1, Name = Account
Department Id = 2, Name = Sales
Department Id = 3, Name = Pre-Sales
Department Id = 4, Name = Marketing

Press any key to continue.

LINQ to XML bietet einfachen Zugriff auf alle LINQ-Funktionen wie Standard-Abfrageoperatoren, Programmierschnittstellen usw. LINQ to XML ist in das .NET Framework integriert und nutzt die .NET Framework-Funktionen wie Debugging, Überprüfung der Kompilierungszeit und starke Typisierung optimal und vieles mehr zu sagen.

Einführung von LINQ in XML

Während der Verwendung von LINQ to XML ist das Laden von XML-Dokumenten in den Speicher einfacher und das Abfragen und Ändern von Dokumenten einfacher. Es ist auch möglich, im Speicher vorhandene XML-Dokumente auf der Festplatte zu speichern und zu serialisieren. Ein Entwickler muss die etwas komplexe XML-Abfragesprache nicht mehr lernen.

LINQ to XML hat seine Leistung im System.Xml.Linq-Namespace. Dies hat alle 19 notwendigen Klassen, um mit XML zu arbeiten. Diese Klassen sind die folgenden.

XAttribute
XCData
XComment
XContainer
XDeclaration
XDocument
XDocumentType
XElement
XName
XNamespace
XNode
XNodeDocumentOrderComparer
XNodeEqualityComparer
XObject
XObjectChange
XObjectChangeEventArgs
XObjectEventHandler
XProcessingInstruction
XText

Lesen Sie eine XML-Datei mit LINQ

C #

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

namespace LINQtoXML {
   class ExampleOfXML {
      static void Main(string[] args) {
      
         string myXML = @"<Departments>
                       <Department>Account</Department>
                       <Department>Sales</Department>
                       <Department>Pre-Sales</Department>
                       <Department>Marketing</Department>
                       </Departments>";

         XDocument xdoc = new XDocument();
         xdoc = XDocument.Parse(myXML);

         var result = xdoc.Element("Departments").Descendants();

         foreach (XElement item in result) {
            Console.WriteLine("Department Name - " + item.Value);
         }

         Console.WriteLine("\nPress any key to continue.");
         Console.ReadKey();
      }
   }
}

VB

Imports System.Collections.Generic
Imports System.Linq
Imports System.Xml.Linq

Module Module1

   Sub Main(ByVal args As String())
   
      Dim myXML As String = "<Departments>" & vbCr & vbLf & 
                           "<Department>Account</Department>" & vbCr & vbLf & 
                           "<Department>Sales</Department>" & vbCr & vbLf & 
                           "<Department>Pre-Sales</Department>" & vbCr & vbLf & 
                           "<Department>Marketing</Department>" & vbCr & vbLf & 
                           "</Departments>"

      Dim xdoc As New XDocument()
      xdoc = XDocument.Parse(myXML)

      Dim result = xdoc.Element("Departments").Descendants()

      For Each item As XElement In result
         Console.WriteLine("Department Name - " + item.Value)
      Next

      Console.WriteLine(vbLf & "Press any key to continue.")
      Console.ReadKey()
	  
   End Sub
   
End Module

Wenn der obige Code von C # oder VB kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Department Name - Account
Department Name - Sales
Department Name - Pre-Sales
Department Name - Marketing

Press any key to continue.

Neuen Knoten hinzufügen

C #

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

namespace LINQtoXML {
   class ExampleOfXML {
      static void Main(string[] args) {
      
         string myXML = @"<Departments>
                       <Department>Account</Department>
                       <Department>Sales</Department>
                       <Department>Pre-Sales</Department>
                       <Department>Marketing</Department>
                       </Departments>";

         XDocument xdoc = new XDocument();
         xdoc = XDocument.Parse(myXML);

         //Add new Element
         xdoc.Element("Departments").Add(new XElement("Department", "Finance"));

         //Add new Element at First
         xdoc.Element("Departments").AddFirst(new XElement("Department", "Support"));

         var result = xdoc.Element("Departments").Descendants();

         foreach (XElement item in result) {
            Console.WriteLine("Department Name - " + item.Value);
         }

         Console.WriteLine("\nPress any key to continue.");
         Console.ReadKey();
      }
   }
}

VB

Imports System.Collections.Generic
Imports System.Linq
Imports System.Xml.Linq

Module Module1

   Sub Main(ByVal args As String())
   
      Dim myXML As String = "<Departments>" & vbCr & vbLf & 
     	                   "<Department>Account</Department>" & vbCr & vbLf & 
     	                   "<Department>Sales</Department>" & vbCr & vbLf & 
     	                   "<Department>Pre-Sales</Department>" & vbCr & vbLf & 
     	                   "<Department>Marketing</Department>" & vbCr & vbLf & 
     	                   "</Departments>"

      Dim xdoc As New XDocument()
      xdoc = XDocument.Parse(myXML)

      xdoc.Element("Departments").Add(New XElement("Department", "Finance"))
     
      xdoc.Element("Departments").AddFirst(New XElement("Department", "Support"))

      Dim result = xdoc.Element("Departments").Descendants()

      For Each item As XElement In result
         Console.WriteLine("Department Name - " + item.Value)
      Next

      Console.WriteLine(vbLf & "Press any key to continue.")
      Console.ReadKey()
	  
   End Sub
   
End Module

Wenn der obige Code von C # oder VB kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Department Name - Support
Department Name - Account
Department Name - Sales
Department Name - Pre-Sales
Department Name - Marketing
Department Name - Finance

Press any key to continue.

Bestimmten Knoten löschen

C #

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

namespace LINQtoXML {
   class ExampleOfXML {
      static void Main(string[] args) {
      
         string myXML = @"<Departments>
                       <Department>Support</Department>
                       <Department>Account</Department>
                       <Department>Sales</Department>
                       <Department>Pre-Sales</Department>
                       <Department>Marketing</Department>
                       <Department>Finance</Department>
                       </Departments>";

         XDocument xdoc = new XDocument();
         xdoc = XDocument.Parse(myXML);

         //Remove Sales Department
         xdoc.Descendants().Where(s =>s.Value == "Sales").Remove(); 

         var result = xdoc.Element("Departments").Descendants();

         foreach (XElement item in result) {
            Console.WriteLine("Department Name - " + item.Value);
         }

         Console.WriteLine("\nPress any key to continue.");
         Console.ReadKey();
      }
   }
}

VB

Imports System.Collections.Generic
Imports System.Linq
Imports System.Xml.Linq

Module Module1

   Sub Main(args As String())
   
      Dim myXML As String = "<Departments>" & vbCr & vbLf & 
     	                   "<Department>Support</Department>" & vbCr & vbLf & 
     	                   "<Department>Account</Department>" & vbCr & vbLf & 
     	                   "<Department>Sales</Department>" & vbCr & vbLf & 
     	                   "<Department>Pre-Sales</Department>" & vbCr & vbLf & 
     	                   "<Department>Marketing</Department>" & vbCr & vbLf & 
     	                   "<Department>Finance</Department>" & vbCr & vbLf & 
                           "</Departments>"

      Dim xdoc As New XDocument()
      xdoc = XDocument.Parse(myXML)
     
      xdoc.Descendants().Where(Function(s) s.Value = "Sales").Remove()

      Dim result = xdoc.Element("Departments").Descendants()

      For Each item As XElement In result
         Console.WriteLine("Department Name - " + item.Value)
      Next

      Console.WriteLine(vbLf & "Press any key to continue.")
      Console.ReadKey()
	  
   End Sub
   
End Module

Wenn der obige Code von C # oder VB kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Department Name - Support
Department Name - Account
Department Name - Pre-Sales
Department Name - Marketing
Department Name - Finance

Press any key to continue.

Als Teil des ADO.NET Entity Framework ist LINQ to Entities flexibler als LINQ to SQL, jedoch aufgrund seiner Komplexität und des Fehlens wichtiger Funktionen nicht sehr beliebt. Es gibt jedoch nicht die Einschränkungen von LINQ to SQL, die Datenabfragen nur in der SQL Server-Datenbank zulassen, da LINQ to Entities die Datenabfrage bei einer großen Anzahl von Datenanbietern wie Oracle, MySQL usw. erleichtert.

Darüber hinaus hat ASP.Net eine wichtige Unterstützung in dem Sinne erhalten, dass Benutzer eine Datenquellensteuerung zum Ausführen einer Abfrage über LINQ an Entitäten verwenden können und das Binden der Ergebnisse ohne zusätzliche Codierung erleichtern.

LINQ to Entities ist für diese Vorteile heutzutage zum Standardmechanismus für die Verwendung von LINQ in Datenbanken geworden. Mit LINQ to Entities ist es auch möglich, abgefragte Datendetails zu ändern und eine Stapelaktualisierung einfach durchzuführen. Das Faszinierendste an LINQ to Entities ist, dass es dieselbe Syntax wie SQL und sogar dieselbe Gruppe von Standardabfrageoperatoren wie Join, Select, OrderBy usw. hat.

Prozess zur Erstellung und Ausführung von LINQ to Entities-Abfragen

Bau eines ObjectQuery Instanz aus einem ObjectContext (Entitätsverbindung)
Erstellen einer Abfrage entweder in C # oder Visual Basic (VB) mithilfe der neu erstellten Instanz
Konvertierung von Standardabfrageoperatoren von LINQ sowie von LINQ-Ausdrücken in Befehlsbäume
Durch Ausführen der Abfrage werden alle aufgetretenen Ausnahmen direkt an den Client übergeben
Rückgabe aller Abfrageergebnisse an den Client

ObjectContext ist hier die primäre Klasse, die die Interaktion mit ermöglicht Entity Data Modeloder mit anderen Worten, fungiert als Brücke, die LINQ mit der Datenbank verbindet. Befehlsbäume sind hier Abfragedarstellung mit Kompatibilität mit dem Entity Framework.

Das Entity Framework hingegen ist es tatsächlich Object Relational MapperVon den Entwicklern allgemein als ORM abgekürzt, das die Generierung von Geschäftsobjekten sowie Entitäten gemäß den Datenbanktabellen durchführt und verschiedene grundlegende Vorgänge wie Erstellen, Aktualisieren, Löschen und Lesen erleichtert. Die folgende Abbildung zeigt das Entity Framework und seine Komponenten.

Beispiel für ADD, UPDATE und DELETE mit LINQ mit Entity Model

Fügen Sie zunächst das Entitätsmodell hinzu, indem Sie die folgenden Schritte ausführen.

Step 1- Klicken Sie mit der rechten Maustaste auf das Projekt und klicken Sie auf Neues Element hinzufügen. Das folgende Fenster wird geöffnet. Wählen Sie ADO.NET-Entitätsdatenmodell aus, geben Sie den Namen an und klicken Sie auf Hinzufügen.

Step 2 - Wählen Sie Generate from database.

Step 3 - Wählen Sie im Dropdown-Menü die Option Datenbankverbindung.

Step 4 - Wählen Sie alle Tabellen aus.

Schreiben Sie nun den folgenden Code.

using DataAccess;
using System;
using System.Linq;

namespace LINQTOSQLConsoleApp {
   public class LinqToEntityModel {
      static void Main(string[] args) {

         using (LinqToSQLDBEntities context = new LinqToSQLDBEntities()) {
            //Get the List of Departments from Database
            var departmentList = from d in context.Departments
            select d;

            foreach (var dept in departmentList) {
               Console.WriteLine("Department Id = {0} , Department Name = {1}",
                  dept.DepartmentId, dept.Name);
            }

            //Add new Department
            DataAccess.Department department = new DataAccess.Department();
            department.Name = "Support";

            context.Departments.Add(department);
            context.SaveChanges();

            Console.WriteLine("Department Name = Support is inserted in Database");

            //Update existing Department
            DataAccess.Department updateDepartment = context.Departments.FirstOrDefault(d ⇒d.DepartmentId == 1);
            updateDepartment.Name = "Account updated";
            context.SaveChanges();

            Console.WriteLine("Department Name = Account is updated in Database");

            //Delete existing Department
            DataAccess.Department deleteDepartment = context.Departments.FirstOrDefault(d ⇒d.DepartmentId == 3);
            context.Departments.Remove(deleteDepartment);
            context.SaveChanges();

            Console.WriteLine("Department Name = Pre-Sales is deleted in Database");

            //Get the Updated List of Departments from Database
            departmentList = from d in context.Departments
            select d;

            foreach (var dept in departmentList) {
               Console.WriteLine("Department Id = {0} , Department Name = {1}",
                  dept.DepartmentId, dept.Name);
            }
         }

         Console.WriteLine("\nPress any key to continue.");
         Console.ReadKey();
      }
   }
}

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Der Begriff 'Lambda-Ausdruck' hat seinen Namen von der 'Lambda'-Rechnung abgeleitet, die wiederum eine mathematische Notation ist, die zum Definieren von Funktionen verwendet wird. Lambda-Ausdrücke als ausführbarer Teil einer LINQ-Gleichung übersetzen die Logik zur Laufzeit so, dass sie bequem an die Datenquelle weitergegeben werden kann. Lambda-Ausdrücke sind jedoch nicht nur darauf beschränkt, nur in LINQ Anwendung zu finden.

Diese Ausdrücke werden durch die folgende Syntax ausgedrückt:

(Input parameters) ⇒ Expression or statement block

Hier ist ein Beispiel für einen Lambda-Ausdruck -

y ⇒ y * y

Der obige Ausdruck gibt einen Parameter mit dem Namen y an und dieser Wert von y wird quadriert. Es ist jedoch nicht möglich, einen Lambda-Ausdruck in dieser Form auszuführen. Ein Beispiel für einen Lambda-Ausdruck in C # ist unten gezeigt.

C #

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

namespace lambdaexample {
   class Program {

      delegate int del(int i);
      static void Main(string[] args) {

         del myDelegate = y ⇒ y * y;
         int j = myDelegate(5);
         Console.WriteLine(j);
         Console.ReadLine();
      }
   }
}

VB

Module Module1
   Private Delegate Function del(ByVal i As Integer) As Integer
   
   Sub Main(ByVal args As String())
   
      Dim myDelegate As del = Function(y) y * y
      Dim j As Integer = myDelegate(5)
      Console.WriteLine(j)
      Console.ReadLine()
	  
   End Sub
   
End Module

Wenn der obige Code von C # oder VB kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Ausdruck Lambda

Da sich der oben gezeigte Ausdruck in der Syntax des Lambda-Ausdrucks auf der rechten Seite befindet, werden diese auch als Ausdruck Lambda bezeichnet.

Async Lambdas

Der Lambda-Ausdruck, der durch Einbeziehen der asynchronen Verarbeitung unter Verwendung des asynchronen Schlüsselworts erstellt wird, wird als asynchrone Lambdas bezeichnet. Unten finden Sie ein Beispiel für asynchrones Lambda.

Func<Task<string>> getWordAsync = async()⇒ “hello”;

Lambda in Standard-Abfrageoperatoren

Ein Lambda-Ausdruck innerhalb eines Abfrageoperators wird bei Bedarf von demselben ausgewertet und arbeitet kontinuierlich an jedem der Elemente in der Eingabesequenz und nicht an der gesamten Sequenz. Entwickler können mit dem Lambda-Ausdruck ihre eigene Logik in die Standardabfrageoperatoren einspeisen. Im folgenden Beispiel hat der Entwickler den Operator 'Where' verwendet, um die ungeraden Werte aus der angegebenen Liste unter Verwendung eines Lambda-Ausdrucks zurückzugewinnen.

C #

//Get the average of the odd Fibonacci numbers in the series... 

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

namespace lambdaexample {
   class Program {     
      static void Main(string[] args) {
      
         int[] fibNum = { 1, 1, 2, 3, 5, 8, 13, 21, 34 };
         double averageValue = fibNum.Where(num ⇒ num % 2 == 1).Average();
         Console.WriteLine(averageValue);
         Console.ReadLine();
      }
   }
}

VB

Module Module1

   Sub Main()
   
      Dim fibNum As Integer() = {1, 1, 2, 3, 5, 8, 13, 21, 34}
      Dim averageValue As Double = fibNum.Where(Function(num) num Mod 2 = 1).Average()
	  
      Console.WriteLine(averageValue)
      Console.ReadLine()
	  
   End Sub
   
End Module

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

7.33333333333333

Typinferenz in Lambda

In C # wird die Typinferenz in einer Vielzahl von Situationen verwendet, und dies auch ohne explizite Angabe der Typen. Im Fall eines Lambda-Ausdrucks funktioniert die Typinferenz jedoch nur, wenn jeder Typ angegeben wurde, da der Compiler erfüllt sein muss. Betrachten wir das folgende Beispiel.

delegate int Transformer (int i);

Hier verwendet der Compiler die Typinferenz, um auf die Tatsache zurückzugreifen, dass x eine ganze Zahl ist, und dies erfolgt durch Untersuchen des Parametertyps des Transformators.

Variabler Bereich im Lambda-Ausdruck

Es gibt einige Regeln für die Verwendung des Variablenbereichs in einem Lambda-Ausdruck, z. B. Variablen, die innerhalb eines Lambda-Ausdrucks initiiert werden, sollen in einer äußeren Methode nicht sichtbar sein. Es gibt auch die Regel, dass eine erfasste Variable nicht durch Speicherbereinigung erfasst werden soll, es sei denn, der Delegat, der auf dieselbe Variable verweist, ist für die Speicherbereinigung berechtigt. Darüber hinaus gibt es eine Regel, die eine return-Anweisung innerhalb eines Lambda-Ausdrucks verbietet, um die Rückgabe einer einschließenden Methode zu bewirken.

Hier ist ein Beispiel, um den variablen Bereich im Lambda-Ausdruck zu demonstrieren.

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

namespace lambdaexample {
   class Program {
      delegate bool D();
      delegate bool D2(int i);

      class Test {
         D del;
         D2 del2;
			
         public void TestMethod(int input) {
            int j = 0;
            // Initialize the delegates with lambda expressions.
            // Note access to 2 outer variables.
            // del will be invoked within this method.
            del = () ⇒ { j = 10; return j > input; };

            // del2 will be invoked after TestMethod goes out of scope.
            del2 = (x) ⇒ { return x == j; };

            // Demonstrate value of j:            
            // The delegate has not been invoked yet.
            Console.WriteLine("j = {0}", j);        // Invoke the delegate.
            bool boolResult = del();
           
            Console.WriteLine("j = {0}. b = {1}", j, boolResult);
         }

         static void Main() {
            Test test = new Test();
            test.TestMethod(5);

            // Prove that del2 still has a copy of
            // local variable j from TestMethod.
            bool result = test.del2(10);
           
            Console.WriteLine(result);

            Console.ReadKey();
         }
      }
   }
}

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

j = 0
j = 10. b = True
True

Ausdrucksbaum

Lambda-Ausdrücke werden in verwendet Expression TreeBau ausgiebig. Ein Ausdrucksbaum gibt Code in einer Datenstruktur ab, die einem Baum ähnelt, in dem jeder Knoten selbst ein Ausdruck wie ein Methodenaufruf ist oder eine binäre Operation wie x <y sein kann. Unten finden Sie ein Beispiel für die Verwendung des Lambda-Ausdrucks zum Erstellen eines Ausdrucksbaums.

Aussage Lambda

Es gibt auch statement lambdasBestehend aus zwei oder drei Anweisungen, werden jedoch nicht zur Erstellung von Ausdrucksbäumen verwendet. Eine return-Anweisung muss in eine Lambda-Anweisung geschrieben werden.

Syntax der Anweisung Lambda

(params)⇒ {statements}

Beispiel einer Aussage Lambda

using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Linq.Expressions;

namespace lambdaexample {
   class Program {
      static void Main(string[] args) {
         int[] source = new[] { 3, 8, 4, 6, 1, 7, 9, 2, 4, 8 };

         foreach (int i in source.Where(x ⇒ 
            {
               if (x <= 3)
                  return true;
               else if (x >= 7)
                  return true;
               return false;
            }
         ))
        Console.WriteLine(i);
        Console.ReadLine();
      }
   }
}

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Lambdas werden als Argumente in LINQ-Abfragen verwendet, die auf Methoden basieren, und dürfen niemals einen Platz auf der linken Seite von Operatoren wie haben is oder asgenau wie anonyme Methoden. Obwohl Lambda-Ausdrücke sehr anonymen Methoden ähneln, dürfen diese keinesfalls nur als Delegaten verwendet werden.

Punkte, die Sie bei der Verwendung von Lambda-Ausdrücken beachten sollten

Ein Lambda-Ausdruck kann einen Wert zurückgeben und Parameter enthalten.
Parameter können auf vielfältige Weise mit einem Lambda-Ausdruck definiert werden.
Wenn ein Lambda-Ausdruck eine einzelne Anweisung enthält, sind keine geschweiften Klammern erforderlich, während bei mehreren Anweisungen geschweifte Klammern sowie der Rückgabewert für das Schreiben unerlässlich sind.
Mit Lambda-Ausdrücken ist es möglich, auf Variablen zuzugreifen, die außerhalb des Lambda-Ausdrucksblocks vorhanden sind, und zwar über ein Merkmal, das als Abschluss bezeichnet wird. Die Verwendung des Verschlusses sollte vorsichtig erfolgen, um Probleme zu vermeiden.
Es ist unmöglich, unsicheren Code in einem Lambda-Ausdruck auszuführen.
Lambda-Ausdrücke dürfen nicht auf der linken Seite des Bedieners verwendet werden.

Als eine Reihe von .NET Framework-Erweiterungen ist LINQ der bevorzugte Mechanismus für den Datenzugriff von ASP.NET-Entwicklern. ASP.NET 3.5 verfügt über ein integriertes Tool LINQDataSource-Steuerelement, mit dem LINQ problemlos in ASP.NET verwendet werden kann. ASP.NET verwendet das oben genannte Steuerelement als Datenquelle. Projekte im realen Leben umfassen hauptsächlich Websites oder Windows-Anwendungen. Um das Konzept von LINQ mit ASP.NET besser zu verstehen, erstellen wir zunächst eine ASP.NET-Website, die die LINQ-Funktionen verwendet.

Dazu ist es wichtig, Visual Studio und .NET Framework auf Ihrem System zu installieren. Gehen Sie nach dem Öffnen von Visual Studio zu Datei → Neu → Website. Ein Popup-Fenster wird geöffnet (siehe Abbildung unten).

Unter den Vorlagen auf der linken Seite gibt es nun zwei Sprachoptionen zum Erstellen der Website. WählenVisual C# und auswählen ASP.NET Empty Web Site.

Wählen Sie den Ordner aus, in dem Sie eine neue Website auf Ihrem System speichern möchten. Dann drückenOK und so weiter Solution Explorerwird auf Ihrem Bildschirm mit allen Webdateien angezeigt. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf Default.aspx und wählen Sie Im Browser anzeigen, um die Standard-ASP.NET-Website im Browser anzuzeigen. Bald wird Ihre neue ASP.NET-Website im Webbrowser geöffnet, wie im folgenden Screenshot gezeigt.

.aspx ist in der Tat die wichtigste Dateierweiterung, die auf ASP.NET-Websites verwendet wird. Visual Studio erstellt standardmäßig alle erforderlichen Seiten für eine einfache Website wieHome page und About UsSeite, auf der Sie Ihre Inhalte bequem platzieren können. Der Code für die Website wird hier automatisch generiert und kann auch angezeigt werden.

LINQDataSource-Steuerelement

Es ist möglich zu UPDATE, INSERT und DELETEDaten auf den Seiten der ASP.NET-Website mit Hilfe des LINQDataSource-Steuerelements. Die Angabe von SQL-Befehlen ist absolut nicht erforderlich, da das LINQDataSource-Steuerelement dynamisch erstellte Befehle für solche Vorgänge verwendet.

Mit dem Steuerelement kann ein Benutzer LINQ auf einer ASP.NET-Webseite bequem über die Eigenschafteneinstellung im Markup-Text verwenden. LINQDataSource ist dem von Steuerelementen wie sehr ähnlichSqlDataSource ebenso gut wie ObjectDataSourceDies kann zum Binden anderer auf einer Seite vorhandener ASP.NET-Steuerelemente an eine Datenquelle verwendet werden. Also müssen wir eine habendatabase um die verschiedenen Funktionen zu erläutern, die vom LINQDataSource-Steuerelement aufgerufen werden.

Bevor Sie mit der Erläuterung der Verwendung des Steuerelements im ASP.NET-Webseitenformular beginnen, müssen Sie unbedingt die Microsoft Visual Studio Toolbox öffnen und das LINQDataSource-Steuerelement wie in der folgenden Abbildung auf die ASPX-Seite der ASP.NET-Website ziehen und dort ablegen.

Der nächste Schritt besteht darin, LINQDataSource zu konfigurieren, indem alle Spalten für den Mitarbeiterdatensatz ausgewählt werden.

Fügen Sie nun der ASPX-Seite ein GridView-Steuerelement hinzu und konfigurieren Sie es wie in der folgenden Abbildung gezeigt. Das GridView-Steuerelement ist leistungsstark und bietet Flexibilität beim Arbeiten mit den Daten. Bald nach der Konfiguration des Steuerelements wird es im Browser angezeigt.

Die Codierung, die jetzt auf Ihrem Bildschirm für die ASPX-Seite angezeigt werden kann, lautet:

<!DOCTYPE html>

<html>
   <head runat = "server">
      <title></title>
   </head>

   <body>
      <form id = "form1" runat = "server">
         <div>
            <asp:GridView ID = "GridView1" runat = "server" AutoGenerateColumns = "False"
			
               DataKeyNames = "ContactID" DataSourceID = "LINQDataSource1">
               <Columns>
			   
                  <asp:BoundField DataField = "ContactID" HeaderText = "ContactID"
                     InsertVisible = "False" ReadOnly="True" SortExpression = "ContactID" />
                  <asp:CheckBoxField DataField = "NameStyle" HeaderText = "NameStyle"
                     SortExpression = "NameStyle" />
                  <asp:BoundField DataField = "Title" HeaderText = "Title" SortExpression = "Title" />
                  <asp:BoundField DataField = "FirstName" HeaderText = "FirstName"
                     SortExpression="FirstName" />
                  <asp:BoundField DataField = "MiddleName" HeaderText = "MiddleName"
                     SortExpression = "MiddleName" />
                  <asp:BoundField DataField = "LastName" HeaderText = "LastName"
                     SortExpression = "LastName" />
                  <asp:BoundField DataField = "Suffix" HeaderText = "Suffix"
                     SortExpression = "Suffix" />
                  <asp:BoundField DataField = "EmailAddress" HeaderText = "EmailAddress"
                     SortExpression = "EmailAddress" />
               </Columns>

            </asp:GridView>

            <br />

         </div>

         <asp:LINQDataSource ID = "LINQDataSource1" runat = "server"

            ContextTypeName = "LINQWebApp1.AdventureWorksDataContext" EntityTypeName = ""
               TableName = "Contacts">

         </asp:LINQDataSource>
      </form>
   </body>
</html>

Hierbei ist zu beachten, dass die Eigenschaft ContextTypeName unbedingt auf die der Klasse festgelegt werden muss, die die Datenbank darstellt. Hier wird es beispielsweise als LINQWebApp1.AdventureWorksDataContext angegeben, da diese Aktion die erforderliche Verbindung zwischen LINQDataSource und der Datenbank herstellt.

INSERT-, UPDATE- und DELETE-Daten in ASP.NET Page mithilfe von LINQ

Nachdem Sie alle oben genannten Schritte sorgfältig ausgeführt haben, wählen Sie die LINQDataSource Tasks von dem LINQDataSource Control und wählen Sie alle drei Felder aus, um das Einfügen zu aktivieren, das Aktualisieren zu aktivieren und das Löschen zu aktivieren, wie im folgenden Screenshot gezeigt.

Bald wird das deklarative Markup wie folgt auf Ihrem Bildschirm angezeigt.

<asp:LINQDataSource 
   ContextTypeName = "LINQWebApp1.AdventureWorksDataContext" 
   TableName = "Contacts" 
   EnableUpdate = "true" 
   EnableInsert = "true" 
   EnableDelete = "true" 
   ID = "LINQDataSource1" 
   runat = "server">
</asp:LINQDataSource>

Da es jetzt mehrere Zeilen und Spalten gibt, ist es besser, ein weiteres Steuerelement in Ihrem ASPX-Formular hinzuzufügen, das als Detailansicht oder Master-Steuerelement unter dem Steuerelement "Rasteransicht" bezeichnet wird, um nur die Details einer ausgewählten Zeile des Rasters anzuzeigen. Wählen Sie die Aufgaben "Detailansicht" aus dem Steuerelement "Detailansicht" und aktivieren Sie die Kontrollkästchen wie unten gezeigt.

Speichern Sie jetzt einfach die Änderungen und drücken Sie Strg + F5, um die Seite in Ihrem Browser anzuzeigen, auf der Sie jetzt alle Datensätze in der Detailansicht löschen, aktualisieren und einfügen können.