LINQ - Szybki przewodnik

Deweloperzy na całym świecie zawsze napotykali problemy z odpytywaniem danych z powodu braku zdefiniowanej ścieżki i konieczności opanowania wielu technologii, takich jak SQL, usługi sieciowe, XQuery itp.

Wprowadzony w Visual Studio 2008 i zaprojektowany przez Andersa Hejlsberga, LINQ (Language Integrated Query) umożliwia pisanie zapytań nawet bez znajomości języków zapytań, takich jak SQL, XML itp. Zapytania LINQ można pisać dla różnych typów danych.

Przykład zapytania LINQ

DO#

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

Gdy powyższy kod C # lub VB jest kompilowany i wykonywany, daje następujący wynik -

hello 
LINQ 
world

Składnia LINQ

Istnieją dwie składnie LINQ. Oto poniższe.

Składnia Lamda (metoda)

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

Składnia zapytania (rozumienie)

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

Rodzaje LINQ

Rodzaje LINQ są wymienione poniżej w skrócie.

• LINQ to Objects
• LINQ to XML (XLINQ)
• LINQ to DataSet
• LINQ to SQL (DLINQ)
• LINQ to Entities

Oprócz powyższego istnieje również typ LINQ o nazwie PLINQ, który jest równoległym LINQ firmy Microsoft.

Architektura LINQ w .NET

LINQ ma architekturę 3-warstwową, w której najwyższa warstwa składa się z rozszerzeń języka, a dolna warstwa składa się ze źródeł danych, które są zwykle obiektami implementującymi interfejsy generyczne IEnumerable <T> lub IQueryable <T>. Architekturę przedstawiono poniżej.

Wyrażenia zapytania

Wyrażenie zapytania to nic innego jak zapytanie LINQ, wyrażone w formie podobnej do tej z SQL z operatorami zapytań, takimi jak Select, Where i OrderBy. Wyrażenia zapytania zwykle zaczynają się od słowa kluczowego „Od”.

Aby uzyskać dostęp do standardowych operatorów zapytań LINQ, należy domyślnie zaimportować przestrzeń nazw System.Query. Te wyrażenia są zapisywane w deklaratywnej składni zapytania, która była C # 3,0.

Poniżej znajduje się przykład pokazujący pełną operację zapytania, która składa się z utworzenia źródła danych, definicji wyrażenia zapytania i wykonania zapytania.

DO#

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

Kiedy powyższy kod jest kompilowany i wykonywany, daje następujący wynik -

97 92 81

Metody rozszerzeń

Wprowadzone w .NET 3.5 metody rozszerzające są zadeklarowane tylko w klasach statycznych i umożliwiają dołączanie niestandardowych metod do obiektów w celu wykonania pewnych precyzyjnych operacji zapytań w celu rozszerzenia klasy, nie będąc rzeczywistym członkiem tej klasy. Te również mogą być przeciążone.

W skrócie, metody rozszerzające służą do tłumaczenia wyrażeń zapytań na tradycyjne wywołania metod (zorientowane obiektowo).

Różnica między LINQ i procedurą składowaną

Istnieje szereg różnic między procedurami LINQ i składowanymi. Te różnice opisano poniżej.

• Procedury składowane są znacznie szybsze niż zapytanie LINQ, ponieważ są zgodne z oczekiwanym planem wykonania.

• Łatwo jest uniknąć błędów czasu wykonywania podczas wykonywania zapytania LINQ niż w porównaniu z procedurą składowaną, ponieważ ta pierwsza obsługuje technologię Visual Studio Intellisense, a także sprawdzanie pełnego typu podczas kompilacji.

• LINQ umożliwia debugowanie przy użyciu debugera .NET, czego nie ma w przypadku procedur składowanych.

• LINQ oferuje obsługę wielu baz danych w przeciwieństwie do procedur składowanych, w których konieczne jest ponowne napisanie kodu dla różnych typów baz danych.

• Wdrożenie rozwiązania opartego na LINQ jest łatwe i proste w porównaniu z wdrożeniem zestawu procedur składowanych.

Potrzebujesz LINQ

Przed LINQ konieczne było nauczenie się C #, języka SQL i różnych interfejsów API, które łączą oba, tworząc kompletną aplikację. Ponieważ te źródła danych i języki programowania napotykają niedopasowanie impedancji; odczuwa się potrzebę krótkiego kodowania.

Poniżej znajduje się przykład tego, jak wiele różnych technik było używanych przez programistów podczas wykonywania zapytań dotyczących danych przed pojawieniem się LINQ.

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)

Co ciekawe, spośród przedstawionych linii kodu zapytanie jest definiowane tylko przez dwie ostatnie. Korzystając z LINQ, to samo zapytanie o dane można zapisać w czytelnej formie oznaczonej kolorami, podobnie jak poniższa wspomniana poniżej, która również w bardzo krótszym czasie.

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

Zalety LINQ

LINQ oferuje wiele zalet, a wśród nich najważniejsza jest jego potężna ekspresja, która umożliwia programistom wyrażanie deklaratywne. Niektóre z innych zalet LINQ podano poniżej.

• LINQ oferuje podświetlanie składni, które okazuje się pomocne w znajdowaniu błędów w czasie projektowania.

• LINQ oferuje IntelliSense, co oznacza łatwe pisanie dokładniejszych zapytań.

• Pisanie kodów w LINQ jest znacznie szybsze, a zatem czas programowania również ulega znacznemu skróceniu.

• LINQ ułatwia debugowanie dzięki integracji w języku C #.

• Przeglądanie relacji między dwiema tabelami jest łatwe dzięki LINQ ze względu na jego hierarchiczną funkcję, a to umożliwia komponowanie zapytań łączących wiele tabel w krótszym czasie.

• LINQ umożliwia użycie pojedynczej składni LINQ podczas wykonywania zapytań w wielu różnych źródłach danych, a dzieje się tak głównie ze względu na jego jednoczącą podstawę.

• LINQ jest rozszerzalny, co oznacza, że ​​można używać wiedzy o LINQ do wykonywania zapytań o nowe typy źródeł danych.

• LINQ oferuje możliwość łączenia kilku źródeł danych w jednym zapytaniu, a także dzielenia złożonych problemów na zestaw krótkich zapytań, które są łatwe do debugowania.

• LINQ oferuje łatwą transformację do konwersji jednego typu danych na inny, na przykład przekształcanie danych SQL na dane XML.

Przed rozpoczęciem pracy z programami LINQ najlepiej jest najpierw zrozumieć niuanse związane z konfigurowaniem środowiska LINQ. LINQ potrzebuje frameworku .NET, rewolucyjnej platformy do obsługi różnorodnych aplikacji. Zapytanie LINQ można wygodnie napisać w języku C # lub Visual Basic.

Microsoft oferuje narzędzia dla obu tych języków, tj. C # i Visual Basic za pomocą Visual Studio. Wszystkie nasze przykłady zostały skompilowane i napisane w programie Visual Studio 2010. Jednak wersja Visual Basic 2013 jest również dostępna do użytku. Jest to najnowsza wersja i ma wiele podobieństw do programu Visual Studio 2012.

Pobieranie programu Visual Studio 2010 w systemie Windows 7

Program Visual Studio można zainstalować z nośnika instalacyjnego, takiego jak dysk DVD. Poświadczenia administratora są wymagane, aby pomyślnie zainstalować program Visual Basic 2010 w systemie. Ważne jest, aby odłączyć wszystkie wymienne USB od systemu przed instalacją, w przeciwnym razie instalacja może się nie powieść. Niektóre z wymagań sprzętowych niezbędnych do instalacji są następujące.

Wymagania sprzętowe

• 1,6 GHz lub więcej
• 1 GB pamięci RAM
• 3 GB (dostępne miejsce na dysku twardym)
• Dysk twardy 5400 obr./min
• Karta graficzna zgodna z DirectX 9
• Napęd DVD-ROM

Kroki instalacji

Step 1 - Najpierw po włożeniu dysku DVD z pakietem Visual Studio 2010 kliknij Install or run program from your media pojawiające się w wyskakującym okienku na ekranie.

Step 2- Teraz skonfigurowany dla programu Visual Studio pojawi się na ekranie. WybieraćInstall Microsoft Visual Studio 2010.

Step 3- Jak tylko klikniesz, proces zostanie zainicjowany i na ekranie pojawi się okno konfiguracji. Po zakończeniu ładowania komponentów instalacji, co zajmie trochę czasu, kliknijNext aby przejść do następnego kroku.

Step 4 - To jest ostatni etap instalacji. Pojawi się strona startowa, na której wystarczy wybrać opcję „Przeczytałem i akceptuję warunki licencji” i kliknąć Next przycisk.

Step 5- Teraz wybierz funkcje do zainstalowania ze strony opcji wyświetlanej na ekranie. Możesz wybraćFull lub Customopcja. Jeśli masz mniej miejsca na dysku, niż jest to wymagane pokazane w wymaganiach dotyczących miejsca na dysku, przejdź do opcji Niestandardowe.

Step 6- Po wybraniu opcji Niestandardowe pojawi się następujące okno. Wybierz funkcje, które chcesz zainstalować, i kliknijUpdate lub w innym przypadku przejdź do kroku 7. Jednak zaleca się rezygnację z opcji niestandardowej, ponieważ w przyszłości możesz potrzebować funkcji, których nie chcesz mieć.

Step 7- Wkrótce pojawi się wyskakujące okienko i rozpocznie się instalacja, która może zająć dużo czasu. Pamiętaj, że dotyczy to instalacji wszystkich komponentów.

Step 8- Na koniec będziesz mógł zobaczyć komunikat w oknie, że instalacja została zakończona pomyślnie. KliknijFinish.

Pisanie programu w języku C # przy użyciu LINQ w programie Visual Studio 2010

• Uruchom wersję Visual Studio 2010 Ultimate i wybierz z menu Plik, a następnie Nowy projekt.

• Na ekranie pojawi się nowe okno dialogowe projektu.

• Teraz wybierz Visual C # jako kategorię pod zainstalowanymi szablonami, a następnie wybierz szablon aplikacji konsoli, jak pokazano na poniższym rysunku.

• Nadaj projektowi nazwę w dolnym polu nazwy i naciśnij OK.

• Nowy projekt pojawi się w Eksploratorze rozwiązań po prawej stronie nowego okna dialogowego na ekranie.

• Teraz wybierz Program.cs z Eksploratora rozwiązań i możesz wyświetlić kod w oknie edytora, które zaczyna się od „using System”.

• Tutaj możesz rozpocząć kodowanie następującego programu C #.

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

• Naciśnij klawisz F5 i uruchom projekt. Zdecydowanie zaleca się zapisanie projektu, wybierającFile → Save All przed uruchomieniem projektu.

Pisanie programu VB przy użyciu LINQ w Visual Studio 2010

• Uruchom wersję Visual Studio 2010 Ultimate i wybierz z menu Plik, a następnie Nowy projekt.

• Na ekranie pojawi się nowe okno dialogowe projektu.

• Teraz wybierz Visual Basic jako kategorię pod zainstalowanymi szablonami, a następnie wybierz szablon aplikacji konsoli.

• Nadaj projektowi nazwę w dolnym polu nazwy i naciśnij OK.

• Otrzymasz ekran z Module1.vb. Zacznij pisać swój kod VB tutaj, używając LINQ.

Module Module1

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

• Naciśnij klawisz F5 i uruchom projekt. Zdecydowanie zaleca się zapisanie projektu, wybierającFile → Save All przed uruchomieniem projektu.

Gdy powyższy kod C # lub VB jest kopiowany i uruchamiany, daje następujący wynik -

Hello World

Zestaw metod rozszerzających tworzących wzorzec zapytania jest znany jako standardowe operatory zapytań LINQ. Jako bloki konstrukcyjne wyrażeń zapytań LINQ, te operatory oferują szereg możliwości zapytań, takich jak filtrowanie, sortowanie, projekcja, agregacja itp.

Standardowe operatory zapytań LINQ można podzielić na następujące na podstawie ich funkcjonalności.

• Operatory filtrowania
• Dołącz do operatorów
• Operacje projekcyjne
• Sortowanie Operatory
• Operatory grupowania
• Conversions
• Concatenation
• Aggregation
• Operacje kwantyfikatora
• Operacje na partycjach
• Operacje generacji
• Operacje na zbiorach
• Equality
• Operatory elementów

Operatory filtrowania

Filtrowanie to operacja mająca na celu ograniczenie zbioru wyników tak, aby zawierał tylko wybrane elementy spełniające określony warunek.

Pokaż przykłady

Operator	Opis	Składnia wyrażenia zapytania w języku C #	Składnia wyrażenia zapytania VB
gdzie	Filtruj wartości na podstawie funkcji predykatu	gdzie	Gdzie
OfType	Filtruj wartości na podstawie ich zdolności do bycia określonym typem	Nie dotyczy	Nie dotyczy

Dołącz do operatorów

Łączenie odnosi się do operacji, w której celem są źródła danych, w których trudno jest bezpośrednio śledzić relacje między sobą.

Pokaż przykłady

Operator	Opis	Składnia wyrażenia zapytania w języku C #	Składnia wyrażenia zapytania VB
Przystąp	Operator łączy dwie sekwencje na podstawie pasujących kluczy	dołącz… w… dnia… równa się…	Od x W…, y W… Gdzie xa = ya
GroupJoin	Połącz dwie sekwencje i zgrupuj pasujące elementy	dołącz… w… na… równa się… w…	Dołącz do grupy… w… w dniu…

Operacje projekcyjne

Projekcja to operacja, w której obiekt zostaje przekształcony w zupełnie nową formę o określonych właściwościach.

Pokaż przykłady

Operator	Opis	Składnia wyrażenia zapytania w języku C #	Składnia wyrażenia zapytania VB
Wybierz	Operator rzutuje wartości na podstawie funkcji transformacji	Wybierz	Wybierz
Wybierz wiele	Operator projektuje sekwencje wartości, które są oparte na funkcji transformacji, a także spłaszcza je w jedną sekwencję	Użyj wielu klauzul from	Użyj wielu klauzul From

Sortowanie Operatory

Operacja sortowania umożliwia uporządkowanie elementów sekwencji na podstawie jednego lub większej liczby atrybutów.

Pokaż przykłady

Operator	Opis	Składnia wyrażenia zapytania w języku C #	Składnia wyrażenia zapytania VB
Zamów przez	Operator sortuje wartości w kolejności rosnącej	Zamów przez	Zamów przez
OrderByDescending	Operator sortuje wartości w porządku malejącym	kolejność ... malejąco	Sortuj według ... Malejąco
Następnie przez	Wykonuje dodatkowe sortowanie w kolejności rosnącej	Zamów przez …, …	Zamów przez …, …
ThenByDescending	Wykonuje dodatkowe sortowanie w kolejności malejącej	w kolejności…,… malejąco	Uporządkuj według…,… Malejąco
Odwrócić	Wykonuje odwrócenie kolejności elementów w kolekcji	Nie dotyczy	Nie dotyczy

Operatory grupowania

Operatorzy umieszczają dane w niektórych grupach na podstawie wspólnego atrybutu wspólnego.

Pokaż przykłady

Operator	Opis	Składnia wyrażenia zapytania w języku C #	Składnia wyrażenia zapytania VB
Grupuj według	Organizuj sekwencję elementów w grupach i zwracaj je jako kolekcję IEnumerable typu IGrouping <key, element>	grupować… przez -lub- grupować… przez… do…	Grupuj… Przez… W…
ToLookup	Wykonaj operację grupowania, w której zwracana jest sekwencja par kluczy	Nie dotyczy	Nie dotyczy

Konwersje

Operatory zmieniają typ obiektów wejściowych i są wykorzystywane w różnorodnych zastosowaniach.

Pokaż przykłady

Operator	Opis	Składnia wyrażenia zapytania w języku C #	Składnia wyrażenia zapytania VB
AsEnumerable	Zwraca dane wejściowe wpisane jako IEnumerable <T>	Nie dotyczy	Nie dotyczy
AsQueryable	(Generic) IEnumerable jest konwertowany na (ogólny) IQueryable	Nie dotyczy	Nie dotyczy
Odlew	Wykonuje rzutowanie elementów kolekcji do określonego typu	Użyj jawnie wpisanej zmiennej zakresu. Np .: ze string str w słowach	Od… Jak…
OfType	Filtruje wartości na podstawie ich, w zależności od ich możliwości rzutowania na określony typ	Nie dotyczy	Nie dotyczy
ToArray	Wymusza wykonanie zapytania i wykonuje konwersję kolekcji na tablicę	Nie dotyczy	Nie dotyczy
ToDictionary	Na podstawie funkcji selektora kluczy ustawia elementy w Dictionary <TKey, TValue> i wymusza wykonanie zapytania LINQ	Nie dotyczy	Nie dotyczy
Notować	Wymusza wykonanie zapytania, konwertując kolekcję na List <T>	Nie dotyczy	Nie dotyczy
ToLookup	Wymusza wykonanie zapytania i umieszcza elementy w Lookup <TKey, TElement> na podstawie funkcji selektora kluczy	Nie dotyczy	Nie dotyczy

Powiązanie

Wykonuje konkatenację dwóch sekwencji i jest dość podobny do operatora Unii pod względem działania z wyjątkiem faktu, że nie usuwa to duplikatów.

Pokaż przykłady

Operator	Opis	Składnia wyrażenia zapytania w języku C #	Składnia wyrażenia zapytania VB
Concat	Dwie sekwencje są łączone w celu utworzenia jednej jednej sekwencji.	Nie dotyczy	Nie dotyczy

Zbiór

Wykonuje dowolny typ żądanej agregacji i umożliwia tworzenie niestandardowych agregacji w LINQ.

Pokaż przykłady

Operator	Opis	Składnia wyrażenia zapytania w języku C #	Składnia wyrażenia zapytania VB
Agregat	Działa na wartościach kolekcji w celu wykonania niestandardowej operacji agregacji	Nie dotyczy	Nie dotyczy
Średni	Obliczana jest średnia wartość zbioru wartości	Nie dotyczy	Aggregate… In… Into Average ()
Liczyć	Zlicza elementy spełniające funkcję predykatu w kolekcji	Nie dotyczy	Aggregate… In… Into Count ()
LonCount	Zlicza elementy spełniające funkcję predykatu w ogromnej kolekcji	Nie dotyczy	Agreguj… w… w LongCount ()
Maks	Sprawdź maksymalną wartość w kolekcji	Nie dotyczy	Agreguj… In… Into Max ()
Min	Sprawdź minimalną wartość istniejącą w kolekcji	Nie dotyczy	Aggregate… In… Into Min ()
Suma	Sprawdź sumę wartości w kolekcji	Nie dotyczy	Agreguj… w… w sumę ()

Operacje kwantyfikatora

Te operatory zwracają wartość logiczną, tj. True lub False, gdy niektóre lub wszystkie elementy w sekwencji spełniają określony warunek.

Pokaż przykłady

Operator	Opis	Składnia wyrażenia zapytania w języku C #	Składnia wyrażenia zapytania VB
Wszystko	Zwraca wartość „True”, jeśli wszystkie elementy sekwencji spełniają warunek predykatu	Nie dotyczy	Agreguj… w… we wszystko (…)
Każdy	Określa, przeszukując sekwencję, która określa, czy dowolny element tego samego spełnia określony warunek	Nie dotyczy	Aggregate… In… Into Any ()
Zawiera	Zwraca wartość „True”, jeśli stwierdzi, że określony element występuje w sekwencji, jeśli sekwencja nie zawiera tego określonego elementu, zwracana jest wartość „false”	Nie dotyczy	Nie dotyczy

Operatory partycji

Podziel sekwencję wejściową na dwie oddzielne sekcje bez zmiany układu elementów sekwencji, a następnie zwracania jednego z nich.

Pokaż przykłady

Operator	Opis	Składnia wyrażenia zapytania w języku C #	Składnia wyrażenia zapytania VB
Pominąć	Pomija określoną liczbę elementów w sekwencji i zwraca pozostałe	Nie dotyczy	Pominąć
SkipWhile	Tak samo jak w przypadku Pomiń, z jedynym wyjątkiem, że liczba elementów do pominięcia jest określona przez warunek logiczny	Nie dotyczy	Pomiń podczas
Brać	Weź określoną liczbę elementów z sekwencji i pomiń pozostałe	Nie dotyczy	Brać
TakeWhile	To samo, co Take, z wyjątkiem faktu, że liczba elementów do wzięcia jest określona przez warunek logiczny	Nie dotyczy	Nie spiesz się

Operacje generacji

Operatorzy pokoleń tworzą nową sekwencję wartości.

Pokaż przykłady

Operator	Opis	Składnia wyrażenia zapytania w języku C #	Składnia wyrażenia zapytania VB
DefaultIfEmpty	Po zastosowaniu do pustej sekwencji generuje domyślny element w sekwencji	Nie dotyczy	Nie dotyczy
Pusty	Zwraca pustą sekwencję wartości i jest najprostszym operatorem generacyjnym	Nie dotyczy	Nie dotyczy
Zasięg	Generuje kolekcję zawierającą sekwencję liczb całkowitych lub liczb	Nie dotyczy	Nie dotyczy
Powtarzać	Generuje sekwencję zawierającą powtarzające się wartości o określonej długości	Nie dotyczy	Nie dotyczy

Operacje na zbiorach

Istnieją cztery operatory dla operacji na zbiorach, z których każdy daje wynik oparty na innych kryteriach.

Pokaż przykłady

Operator	Opis	Składnia wyrażenia zapytania w języku C #	Składnia wyrażenia zapytania VB
Odrębny	Tworzy listę unikatowych wartości z kolekcji, filtrując zduplikowane dane, jeśli istnieją	Nie dotyczy	Odrębny
Z wyjątkiem	Porównuje wartości dwóch kolekcji i zwraca te z jednej kolekcji, których nie ma w drugiej kolekcji	Nie dotyczy	Nie dotyczy
Krzyżować	Zwraca zestaw wartości znalezionych jako identyczne w dwóch oddzielnych kolekcjach	Nie dotyczy	Nie dotyczy
Unia	Łączy zawartość dwóch różnych kolekcji w jedną listę, która również nie zawiera powielonych treści	Nie dotyczy	Nie dotyczy

Równość

Porównuje dwa zdania (wyliczalne) i określa, czy są one dokładnym dopasowaniem, czy nie.

Pokaż przykłady

Operator	Opis	Składnia wyrażenia zapytania w języku C #	Składnia wyrażenia zapytania VB
SequenceEqual	Daje wartość logiczną, jeśli okaże się, że dwie sekwencje są identyczne	Nie dotyczy	Nie dotyczy

Operatory elementów

Z wyjątkiem DefaultIfEmpty, wszystkie pozostałe osiem standardowych operatorów elementów zapytania zwraca pojedynczy element z kolekcji.

Pokaż przykłady

Operator	Opis	Składnia wyrażenia zapytania w języku C #	Składnia wyrażenia zapytania VB
ElementAt	Zwraca element obecny w określonym indeksie w kolekcji	Nie dotyczy	Nie dotyczy
ElementAtOrDefault	To samo co ElementAt, z wyjątkiem tego, że zwraca również wartość domyślną w przypadku, gdy określony indeks jest poza zakresem	Nie dotyczy	Nie dotyczy
Pierwszy	Pobiera pierwszy element w kolekcji lub pierwszy element spełniający określony warunek	Nie dotyczy	Nie dotyczy
FirstOrDefault	To samo co First, z wyjątkiem faktu, że zwraca również wartość domyślną w przypadku, gdy nie ma takich elementów	Nie dotyczy	Nie dotyczy
Ostatni, ubiegły, zeszły	Pobiera ostatni element obecny w kolekcji lub ostatni element spełniający określony warunek	Nie dotyczy	Nie dotyczy
LastOrDefault	Tak samo jak Last, z wyjątkiem faktu, że zwraca również wartość domyślną w przypadku, gdy nie ma takiego elementu	Nie dotyczy	Nie dotyczy
Pojedynczy	Zwraca samotny element kolekcji lub samotny element, który spełnia określony warunek	Nie dotyczy	Nie dotyczy
SingleOrDefault	To samo co Single, z tą różnicą, że zwraca również wartość domyślną, jeśli nie ma takiego samotnego elementu	Nie dotyczy	Nie dotyczy
DefaultIfEmpty	Zwraca wartość domyślną, jeśli kolekcja lub lista jest pusta lub null	Nie dotyczy	Nie dotyczy

LINQ to SQL oferuje infrastrukturę (czas wykonywania) do zarządzania danymi relacyjnymi jako obiektami. Jest składnikiem wersji 3.5 programu .NET Framework i sprawnie tłumaczy zintegrowane językowo zapytania modelu obiektowego na SQL. Zapytania te są następnie przesyłane do bazy danych w celu wykonania. Po uzyskaniu wyników z bazy danych LINQ to SQL ponownie tłumaczy je na obiekty.

Wprowadzenie LINQ To SQL

Dla większości programistów ASP.NET LINQ to SQL (znany również jako DLINQ) jest elektryzującą częścią zapytania zintegrowanego z językiem, ponieważ umożliwia odpytywanie danych w bazie danych serwera SQL przy użyciu zwykłych wyrażeń LINQ. Pozwala również na aktualizację, usuwanie i wstawianie danych, ale jedyną wadą, na którą cierpi, jest ograniczenie do bazy danych serwera SQL. Jednak LINQ to SQL przez ADO.NET ma wiele zalet, takich jak mniejsza złożoność, kilka wierszy kodu i wiele innych.

Poniżej znajduje się diagram przedstawiający architekturę wykonywania LINQ to SQL.

Jak używać LINQ to SQL?

Step 1- Utwórz nowe „połączenie danych” z serwerem bazy danych. Wyświetl & arrar; Eksplorator serwera & arrar; Połączenia danych & arrar; Dodaj połączenie

Step 2 - Dodaj plik klasy LINQ To SQL

Step 3 - Wybierz tabele z bazy danych i przeciągnij i upuść do nowego pliku klasy LINQ to SQL.

Step 4 - Dodano tabele do pliku klasy.

Wykonywanie zapytań za pomocą LINQ to SQL

Zasady wykonywania zapytania za pomocą LINQ to SQL są podobne do reguł w przypadku standardowego zapytania LINQ, tj. Zapytanie jest wykonywane odroczone lub natychmiastowe. Istnieją różne składniki, które odgrywają rolę w wykonywaniu zapytania za pomocą LINQ to SQL, a są to następujące.

• LINQ to SQL API - żąda wykonania zapytania w imieniu aplikacji i wysyła je do LINQ to SQL Provider.

• LINQ to SQL Provider - konwertuje zapytanie do Transact SQL (T-SQL) i wysyła nowe zapytanie do ADO Provider w celu wykonania.

• ADO Provider - Po wykonaniu zapytania wyślij wyniki w postaci DataReadera do LINQ to SQL Provider, który z kolei przekształci je w postać obiektu użytkownika.

Należy zauważyć, że przed wykonaniem zapytania LINQ to SQL niezbędne jest połączenie się ze źródłem danych za pośrednictwem klasy DataContext.

Wstawianie, aktualizowanie i usuwanie za pomocą LINQ To SQL

Dodaj LUB Wstaw

C#

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

VB

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

Kiedy powyższy kod C # lub VB jest kompilowany i uruchamiany, daje następujący wynik -

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

Press any key to continue.

Aktualizacja

C#

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

VB

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

Gdy powyższy kod C # lub Vb jest kompilowany i uruchamiany, daje następujący wynik -

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

Press any key to continue.

Usunąć

C#

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

VB

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

Kiedy powyższy kod C # lub VB jest kompilowany i uruchamiany, daje następujący wynik -

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 oferuje użycie dowolnego zapytania LINQ obsługującego IEnumerable <T> do uzyskiwania dostępu do kolekcji danych w pamięci bez konieczności korzystania z dostawcy LINQ (API), tak jak w przypadku LINQ to SQL lub LINQ to XML.

Wprowadzenie LINQ to Objects

Zapytania w LINQ to Objects zwracają zmienne typu zwykle tylko IEnumerable <T>. Krótko mówiąc, LINQ to Objects oferuje świeże podejście do kolekcji, ponieważ wcześniej konieczne było napisanie długiego kodowania (dla wszystkich pętli o dużej złożoności) do pobierania danych z kolekcji, która jest teraz zastępowana pisaniem kodu deklaratywnego, który jasno opisuje żądane dane który jest wymagany do odzyskania.

LINQ to Objects ma również wiele zalet w porównaniu z tradycyjnymi pętlami foreach, takimi jak większa czytelność, zaawansowane filtrowanie, możliwość grupowania, ulepszone porządkowanie przy minimalnym kodowaniu aplikacji. Takie zapytania LINQ mają również bardziej zwarty charakter i można je przenosić do innych źródeł danych bez żadnych modyfikacji lub z niewielką modyfikacją.

Poniżej znajduje się prosty przykład 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();
      }
   }
}

W tym przykładzie tablica ciągów (narzędzi) jest używana jako kolekcja obiektów do odpytywania przy użyciu LINQ to Objects.

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

Kiedy powyższy kod jest kompilowany i wykonywany, daje następujący wynik -

Tablesaw
Bandsaw
Planer
Jointer
Drill
Sander

Wykonywanie zapytań w kolekcjach pamięci przy użyciu LINQ to Objects

DO#

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

Gdy powyższy kod C # lub VB jest kompilowany i wykonywany, daje następujący wynik -

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

Press any key to continue.

Zestaw danych oferuje niezwykle użyteczną reprezentację danych w pamięci i jest używany w różnorodnych aplikacjach opartych na danych. LINQ to Dataset jako jedna z technologii LINQ to ADO.NET ułatwia wykonywanie zapytań dotyczących danych zestawu danych w bezproblemowy sposób i zwiększa produktywność.

Wprowadzenie LINQ To Dataset

LINQ to Dataset uprościło zadanie wykonywania zapytań przez deweloperów. Nie muszą pisać zapytań w określonym języku zapytań, zamiast tego to samo można napisać w języku programowania. LINQ to Dataset jest również użyteczny do wykonywania zapytań, w których dane są konsolidowane z wielu źródeł danych. To również nie wymaga żadnego dostawcy LINQ, takiego jak LINQ to SQL i LINQ to XML do uzyskiwania dostępu do danych z kolekcji pamięci.

Poniżej znajduje się prosty przykład zapytania LINQ to Dataset, w którym najpierw uzyskuje się źródło danych, a następnie zestaw danych jest wypełniany dwiema tabelami danych. Relacja jest ustanawiana między obydwoma tabelami, a zapytanie LINQ jest tworzone dla obu tabel za pomocą klauzuli join. Wreszcie pętla foreach służy do wyświetlania żądanych wyników.

DO#

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

Gdy powyższy kod C # lub VB jest kompilowany i wykonywany, daje następujący wynik -

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.

Wykonywanie zapytań dotyczących zestawu danych za pomocą LinQ do zestawu danych

Przed rozpoczęciem wykonywania zapytań dotyczących zestawu danych za pomocą LINQ to Dataset ważne jest, aby załadować dane do zestawu danych i odbywa się to za pomocą klasy DataAdapter lub LINQ to SQL. Formułowanie zapytań przy użyciu LINQ to Dataset jest dość podobne do formułowania zapytań przy użyciu LINQ wraz z innymi źródłami danych z obsługą LINQ.

Zapytanie jednotabelowe

W poniższym zapytaniu z jedną tabelą wszystkie zamówienia online są zbierane z SalesOrderHeaderTtable, a następnie identyfikator zamówienia, data zamówienia oraz numer zamówienia są wyświetlane jako dane wyjściowe.

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

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;"
      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

Gdy powyższy kod C # lub VB jest kompilowany i wykonywany, daje następujący wynik -

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 oferuje łatwy dostęp do wszystkich funkcji LINQ, takich jak standardowe operatory zapytań, interfejs programistyczny itp. Zintegrowany z platformą .NET, LINQ to XML najlepiej wykorzystuje również funkcje platformy .NET, takie jak debugowanie, sprawdzanie w czasie kompilacji, silne pisanie i wiele więcej do powiedzenia.

Wprowadzenie LINQ to XML

Podczas korzystania z LINQ to XML ładowanie dokumentów XML do pamięci jest łatwe i łatwiejsze jest wykonywanie zapytań i modyfikowanie dokumentów. Możliwe jest również zapisywanie dokumentów XML istniejących w pamięci na dysk i ich serializowanie. Eliminuje to potrzebę uczenia się przez programistę języka zapytań XML, który jest dość złożony.

LINQ to XML ma swoją moc w przestrzeni nazw System.Xml.Linq. Zawiera wszystkie 19 klas niezbędnych do pracy z XML. Te klasy są następujące.

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

Przeczytaj plik XML za pomocą LINQ

DO#

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

Gdy powyższy kod C # lub VB jest kompilowany i wykonywany, daje następujący wynik -

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

Press any key to continue.

Dodaj nowy węzeł

DO#

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

Gdy powyższy kod C # lub VB jest kompilowany i wykonywany, daje następujący wynik -

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

Press any key to continue.

Usuwanie określonego węzła

DO#

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

Gdy powyższy kod C # lub VB jest kompilowany i wykonywany, daje następujący wynik -

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

Press any key to continue.

Będąc częścią ADO.NET Entity Framework, LINQ to Entities jest bardziej elastyczny niż LINQ to SQL, ale nie jest zbyt popularny ze względu na swoją złożoność i brak kluczowych funkcji. Jednak nie ma ograniczeń LINQ to SQL, które umożliwia wykonywanie zapytań o dane tylko w bazie danych SQL Server, ponieważ LINQ to Entities ułatwia wykonywanie zapytań o dane w dużej liczbie dostawców danych, takich jak Oracle, MySQL itp.

Co więcej, ma duże wsparcie ze strony ASP.Net w tym sensie, że użytkownicy mogą używać kontroli źródła danych do wykonywania zapytania za pośrednictwem LINQ to Entities i ułatwia wiązanie wyników bez konieczności dodatkowego kodowania.

Dzięki tym zaletom LINQ to Entities stało się obecnie standardowym mechanizmem użycia LINQ w bazach danych. Dzięki LINQ to Entities można również łatwo zmieniać szczegóły danych, których dotyczy zapytanie, i łatwo zatwierdzać aktualizację partii. Najbardziej intrygującym faktem dotyczącym LINQ to Entities jest to, że ma taką samą składnię jak SQL, a nawet ma tę samą grupę standardowych operatorów zapytań, takich jak Join, Select, OrderBy itp.

Proces tworzenia i wykonywania zapytań LINQ to Entities

• Budowa ObjectQuery wystąpienie z ObjectContext (Połączenie jednostki)

• Tworzenie zapytania w C # lub Visual Basic (VB) przy użyciu nowo utworzonego wystąpienia

• Konwersja standardowych operatorów zapytań LINQ, a także wyrażeń LINQ do drzew poleceń

• Wykonywanie zapytania i przekazywanie wszelkich wyjątków napotkanych bezpośrednio do klienta

• Zwrócenie klientowi wszystkich wyników zapytania

ObjectContext jest tutaj podstawową klasą, która umożliwia interakcję z Entity Data Modellub innymi słowy działa jak most, który łączy LINQ z bazą danych. Drzewa poleceń są tutaj reprezentacją zapytań ze zgodnością z platformą Entity.

Z drugiej strony Entity Framework jest w rzeczywistości Object Relational Mapperogólnie w skrócie ORM przez programistów, który generuje obiekty biznesowe, a także encje zgodnie z tabelami bazy danych i ułatwia różne podstawowe operacje, takie jak tworzenie, aktualizowanie, usuwanie i odczytywanie. Na poniższej ilustracji przedstawiono strukturę jednostki i jej składniki.

Przykład ADD, UPDATE i DELETE przy użyciu LINQ z Entity Model

Najpierw dodaj model jednostki, wykonując poniższe kroki.

Step 1- Kliknij prawym przyciskiem myszy projekt i kliknij dodaj nowy element, otworzy się okno, jak pokazano poniżej. Wybierz Entity Data Model ADO.NET, określ nazwę i kliknij Dodaj.

Step 2 - Wybierz Generate from database.

Step 3 - Z menu rozwijanego wybierz opcję Połączenie z bazą danych.

Step 4 - Zaznacz wszystkie tabele.

Teraz napisz następujący kod.

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

Kiedy powyższy kod jest kompilowany i wykonywany, daje następujący wynik -

Termin „wyrażenie lambda” wywodzi swoją nazwę od rachunku „lambda”, który z kolei jest zapisem matematycznym stosowanym do definiowania funkcji. Wyrażenia lambda jako część wykonywalna równania LINQ tłumaczą logikę w sposób w czasie wykonywania, dzięki czemu można ją wygodnie przekazać do źródła danych. Jednak wyrażenia lambda nie są ograniczone tylko do znajdowania aplikacji tylko w LINQ.

Te wyrażenia są wyrażane za pomocą następującej składni -

(Input parameters) ⇒ Expression or statement block

Oto przykład wyrażenia lambda -

y ⇒ y * y

Powyższe wyrażenie określa parametr o nazwie y, a wartość y jest podniesiona do kwadratu. Jednak nie można wykonać wyrażenia lambda w tej formie. Przykład wyrażenia lambda w C # pokazano poniżej.

DO#

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

Gdy powyższy kod C # lub VB jest kompilowany i wykonywany, daje następujący wynik -

25

Expression Lambda

Ponieważ wyrażenie w składni wyrażenia lambda pokazanego powyżej znajduje się po prawej stronie, są one również znane jako wyrażenie lambda.

Async Lambdas

Wyrażenie lambda utworzone przez włączenie przetwarzania asynchronicznego przy użyciu słowa kluczowego async jest znane jako async lambda. Poniżej znajduje się przykład asynchronicznej lambdy.

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

Lambda w standardowych operatorach zapytań

Wyrażenie lambda w operatorze zapytania jest oceniane przez to samo na żądanie i stale działa na każdym z elementów w sekwencji wejściowej, a nie na całej sekwencji. Wyrażenie Lambda umożliwia programistom podawanie własnej logiki do standardowych operatorów zapytań. W poniższym przykładzie deweloper użył operatora „Where”, aby odzyskać nieparzyste wartości z podanej listy, używając wyrażenia lambda.

DO#

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

Kiedy powyższy kod jest kompilowany i wykonywany, daje następujący wynik -

7.33333333333333

Wnioskowanie o typie w Lambda

W języku C # wnioskowanie o typie jest wygodnie używane w różnych sytuacjach, a także bez jawnego określania typów. Jednak w przypadku wyrażenia lambda wnioskowanie o typie będzie działać tylko wtedy, gdy każdy typ został określony, ponieważ kompilator musi być spełniony. Rozważmy następujący przykład.

delegate int Transformer (int i);

W tym przypadku kompilator wykorzystuje wnioskowanie o typie, aby skorzystać z faktu, że x jest liczbą całkowitą, a odbywa się to poprzez badanie typu parametru Transformera.

Zmienny zakres w wyrażeniu lambda

Istnieją pewne reguły dotyczące używania zakresu zmiennej w wyrażeniu lambda, na przykład zmienne inicjowane w wyrażeniu lambda nie mają być widoczne w metodzie zewnętrznej. Istnieje również reguła, że ​​przechwycona zmienna nie ma być zbierana bez pamięci, chyba że delegat odwołujący się do tego samego staje się kwalifikowalny do aktu czyszczenia pamięci. Ponadto istnieje reguła, która zabrania instrukcji return w wyrażeniu lambda, aby spowodować zwrócenie otaczającej metody.

Oto przykład pokazujący zakres zmiennych w wyrażeniu lambda.

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

Kiedy powyższy kod jest kompilowany i wykonywany, daje następujący wynik -

j = 0
j = 10. b = True
True

Drzewo wyrażeń

Wyrażenia lambda są używane w Expression Treeszeroko zakrojona budowa. Drzewo wyrażeń udostępnia kod w strukturze danych przypominającej drzewo, w którym każdy węzeł sam jest wyrażeniem, takim jak wywołanie metody, lub może być operacją binarną, taką jak x <y. Poniżej znajduje się przykład użycia wyrażenia lambda do budowy drzewa wyrażeń.

Oświadczenie Lambda

Jest również statement lambdasskładają się z dwóch lub trzech instrukcji, ale nie są używane w konstrukcji drzew wyrażeń. Instrukcja powrotu musi być zapisana w wyrażeniu lambda.

Składnia wyrażenia lambda

(params)⇒ {statements}

Przykład wyrażenia 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();
      }
   }
}

Kiedy powyższy kod jest kompilowany i wykonywany, daje następujący wynik -

3
8
1
7
9
2
8

Lambdy są używane jako argumenty w zapytaniach LINQ opartych na metodach i nigdy nie mogą mieć miejsca po lewej stronie operatorów, takich jak is lub aspodobnie jak metody anonimowe. Chociaż wyrażenia Lambda są bardzo podobnymi metodami anonimowymi, nie są one wcale ograniczone do używania tylko jako delegatów.

O czym należy pamiętać używając wyrażeń lambda

• Wyrażenie lambda może zwracać wartość i może mieć parametry.

• Parametry można definiować na wiele sposobów za pomocą wyrażenia lambda.

• Jeśli w wyrażeniu lambda znajduje się pojedyncza instrukcja, nie ma potrzeby stosowania nawiasów klamrowych, podczas gdy w przypadku wielu instrukcji niezbędne są nawiasy klamrowe oraz zwracana wartość.

• Dzięki wyrażeniom lambda możliwy jest dostęp do zmiennych znajdujących się poza blokiem wyrażenia lambda za pomocą funkcji znanej jako zamknięcie. Używanie zamknięcia powinno być wykonywane ostrożnie, aby uniknąć jakiegokolwiek problemu.

• Niemożliwe jest wykonanie niebezpiecznego kodu wewnątrz żadnego wyrażenia lambda.

• Wyrażenia lambda nie powinny być używane po lewej stronie operatora.

Jako zestaw rozszerzeń platformy .NET, LINQ jest preferowanym mechanizmem dostępu do danych przez programistów ASP.NET. ASP.NET 3.5 ma wbudowaną kontrolę narzędzia LINQDataSource, która umożliwia łatwe użycie LINQ w ASP.NET. ASP.NET wykorzystuje wyżej wymienioną kontrolkę jako źródło danych. Rzeczywiste projekty obejmują głównie witryny internetowe lub aplikacje Windows, więc aby lepiej zrozumieć koncepcję LINQ z ASP.NET, zacznijmy od stworzenia witryny ASP.NET, która korzysta z funkcji LINQ.

W tym celu konieczne jest zainstalowanie w systemie Visual Studio i .NET Framework. Po otwarciu programu Visual Studio przejdź do Plik → Nowy → Witryna internetowa. Otworzy się wyskakujące okienko, jak pokazano na poniższym rysunku.

Teraz pod szablonami po lewej stronie będą dostępne dwie opcje językowe do stworzenia strony internetowej. WybieraćVisual C# i wybierz ASP.NET Empty Web Site.

Wybierz folder, w którym chcesz zapisać nowy serwis WWW w swoim systemie. Następnie wciśnijOK i tak dalej Solution Explorerpojawia się na ekranie zawierającym wszystkie pliki internetowe. Kliknij prawym przyciskiem myszy Default.aspx w Eksploratorze rozwiązań i wybierz opcję Wyświetl w przeglądarce, aby wyświetlić w przeglądarce domyślną witrynę ASP.NET. Wkrótce Twoja nowa witryna ASP.NET zostanie otwarta w przeglądarce internetowej, jak pokazano na poniższym zrzucie ekranu.

.aspx jest w rzeczywistości głównym rozszerzeniem plików używanym w witrynach internetowych ASP.NET. Program Visual Studio domyślnie tworzy wszystkie niezbędne strony dla podstawowej witryny sieci Web, takiej jakHome page i About Usstronę, na której możesz wygodnie umieścić swoje treści. Kod strony internetowej jest generowany automatycznie tutaj i można go również wyświetlić.

Kontrolka LINQDataSource

Jest to możliwe UPDATE, INSERT i DELETEdane na stronach witryny ASP.NET za pomocą kontrolki LINQDataSource. Nie ma absolutnie potrzeby określania poleceń SQL, ponieważ formant LINQDataSource wykorzystuje dynamicznie tworzone polecenia do takich operacji.

Kontrolka umożliwia użytkownikowi wygodne korzystanie z LINQ na stronie sieci Web ASP.NET przez ustawienie właściwości w tekście znaczników. LINQDataSource jest bardzo podobny do kontrolek, takich jakSqlDataSource jak również ObjectDataSourceponieważ może być używany do wiązania innych formantów ASP.NET obecnych na stronie ze źródłem danych. Więc musimy miećdatabase aby wyjaśnić różne funkcje wywoływane przez kontrolkę LINQDataSource.

Przed przystąpieniem do objaśniania użycia formantu w formularzu strony internetowej ASP.NET, konieczne jest otwarcie Microsoft Visual Studio Toolbox i przeciągnięcie i upuszczenie kontrolki LINQDataSource na stronę .aspx witryny ASP.NET, jak na poniższym rysunku.

Następnym krokiem jest skonfigurowanie LINQDataSource przez wybranie wszystkich kolumn rekordu pracownika.

Teraz dodaj kontrolkę GridView do strony .aspx i skonfiguruj ją tak, jak pokazano na poniższym rysunku. Kontrolka GridView jest zaawansowana i zapewnia elastyczność pracy z danymi. Wkrótce po skonfigurowaniu sterowania pojawi się on w przeglądarce.

Kodowanie strony .aspx, które można teraz wyświetlić na ekranie, to -

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

W tym miejscu należy zauważyć, że konieczne jest ustawienie właściwości ContextTypeName na klasę reprezentującą bazę danych. Na przykład tutaj jest podany jako LINQWebApp1.AdventureWorksDataContext, ponieważ ta akcja utworzy wymagane połączenie między LINQDataSource a bazą danych.

WSTAW, AKTUALIZUJ i USUŃ dane na stronie ASP.NET przy użyciu LINQ

Po dokładnym wykonaniu wszystkich powyższych kroków wybierz plik LINQDataSource Tasks z LINQDataSource Control i wybierz wszystkie trzy pola do włączania wstawiania, włączania aktualizacji i włączania usuwania z tego samego, jak pokazano na poniższym zrzucie ekranu.

Wkrótce deklaratywny znacznik zostanie wyświetlony na ekranie jako następujący.

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

Ponieważ istnieje wiele wierszy i kolumn, lepiej jest dodać kolejną kontrolkę w formularzu .aspx o nazwie jako Widok szczegółów lub Kontrolka główna poniżej kontrolki Widok siatki, aby wyświetlić tylko szczegóły wybranego wiersza siatki. Wybierz Zadania widoku szczegółowego z kontrolki Widok szczegółowy i zaznacz pola wyboru, jak pokazano poniżej.

Teraz po prostu zapisz zmiany i naciśnij Ctrl + F5, aby wyświetlić stronę w przeglądarce, gdzie można teraz usunąć, zaktualizować, wstawić dowolny rekord w kontrolce widoku szczegółów.