Luận văn Đồ án kỹ sư IITìm hiểu công nghệ LINQ và ứng dụng

Luận văn

Đồ án kỹ sư IITìm hiểu

công nghệ LINQ và ứng

dụng

Đồ án kỹ sư II

Tìm hiểu công nghệ LINQ và ứng dụng

Mục lục

I. Gi ớ i thi ệ u v ề LINQ......................................................................................................6

II. Gi ớ i thi ệ u v ề các truy v ấ n LINQ .................................................................................7

II.1 Ba ph ầ n c ủ a m ộ t bi ể u th ứ c LINQ .............................................................................7

II.2 Các d ữ li ệ u ngu ồ n. ....................................................................................................9

II.3 Truy v ấ n ..................................................................................................................1 0

II.3 Th ự c thi truy v ấ n.....................................................................................................1 0

II.4 Th ự c thi b ắ t bu ộ c t ứ c th ờ i.......................................................................................1 1

III. T ổ ng quan v ề thi ế t k ế O / R.........................................................................................1 1

III.1 M ở các O / R Designer ..........................................................................................1 2

III.2 C ấ u hình và t ạ o ra DataContext.............................................................................1 2

III.3 T ạ o t ổ ch ứ c các l ớ p mà c ơ s ở d ữ li ệ u b ản đồ để bàn và xem................................1 3

III.4 DataContext t ạ o ra ph ươ ng pháp g ọ i th ủ t ụ c l ư u tr ữ và các hàm..........................1 3

III.5 C ấ u hình m ột DataContext để s ử d ụ ng các th ủ t ụ c l ư u tr ữ d ữ li ệ u l ư u d ữ li ệ u gi ữ a

các l ớ p th ự c th ể và c ơ s ở d ữ li ệ u. ..................................................................................1 3

III.6 Th ừ a k ế và các O / R Designer..............................................................................1 3

IV. Các truy v ấ n LINQ to SQL. ....................................................................................1 3

IV.1 Tách r ời DataContext đã tạ o ra và các l ớ p th ự c th ể vào các namespaces khác

nhau ...............................................................................................................................1 4

IV.2 Làm th ế nào để : Ch ỉ đị nh l ư u tr ữ Th ự c hi ệ n th ủ t ụ c Update, Insert, và delete.....1 4

V. LINQ và các ki ểu có chung đặc điể m .......................................................................1 4

V.1 IEnumerable các bi ế n trong các câu truy v ấ n LINQ ..............................................1 5

V.2 Cho phép ch ươ ng trình biên d ị ch x ử lý các lo ạ i khai báo chung ...........................1 5

V.3 Ho ạt độ ng truy v ấ n c ơ b ả n......................................................................................1 6

V.3.1 Obtaining a Data Source..................................................................................1 6

V.3.2 Filtering( L ọ c)..................................................................................................1 7

V.3.3 Ordering (Th ứ t ự ) ............................................................................................1 7

V.3.4 Groupin g ..........................................................................................................1 7

V.3.5 Joining..............................................................................................................1 8

V.3.6 Selecting (Projections).....................................................................................1 9

V.4 Chuy ển đổ i d ữ li ệ u v ớ i LINQ.....................................................................................1 9

Sinh viên thực hiện Nguyễn Văn Thụy & Hoàng Mạnh Giỏi

Trang 1

Đồ án kỹ sư II

Tìm hiểu công nghệ LINQ và ứng dụng

V.4.1 Tham gia vào nhi ề u y ế u t ố đầ u vào xu ấ t ra m ộ t trình t ự .....................................2 0

V.4.2 L ự a ch ọ n m ộ t t ậ p h ợ p con c ủ a m ỗ i ph ầ n t ử ngu ồ n .............................................2 1

V.4.3 Chuy ển đổi các đố i t ượ ng trong b ộ nh ớ vào XML..............................................2 2

V.4.4 Th ự c hi ệ n các ho ạt độ ng trên các ph ầ n t ử ngu ồ n ................................................2 3

V.4.5 Lo ạ i các quan h ệ trong thao tác truy v ấ n.............................................................2 4

V.5.6 Truy v ấ n mà không chuy ể n hóa các ngu ồ n d ữ li ệ u .............................................2 4

V.5.7 Trình biên d ị ch ph ả i suy lu ậ n ra các lo ạ i thông tin .............................................2 5

V.6 Cú pháp truy v ấ n vs cú pháp ph ươ ng th ứ c .................................................................2 6

V.6.1 Toán t ử truy v ấ n chu ẩ n m ở r ộ ng các ph ươ ng th ứ c..............................................2 6

V.6.2 Bi ể u th ứ c Lambda................................................................................................2 8

V.7 Các đặ c tr ưng đượ c LINQ h ỗ tr ợ trong C#3.0 ...........................................................2 9

V.7.1 Bi ể u th ứ c truy v ấ n. ..............................................................................................2 9

V.7.2 Implicitly Typed Variables (var) .........................................................................3 0

V.7.3 Đố i t ượ ng, và t ậ p h ợ p các giá tr ị đầ u vào............................................................3 0

V.7.4 Các lo ạ i ch ưa xác đị nh.........................................................................................3 0

V.7.5 Các ph ươ ng th ứ c m ở r ộ ng ...................................................................................3 1

V.7.6 Các thu ộ c tính t ự độ ng thi hành...........................................................................3 1

V.8 Vi ế t câu truy v ấ n trong C# .........................................................................................3 1

V.8.1 Để thêm các d ữ li ệ u ngu ồ n ......................................................................................3 1

V.9 T ạ o các truy v ấ n..........................................................................................................3 2

V.9.1 Để t ạ o m ộ t truy v ấn đơ n gi ả n ..............................................................................3 2

V.9.2 Để th ự c hi ệ n các truy v ấ n ....................................................................................3 3

V.9.3 Để thêm m ột điề u ki ệ n l ọ c...................................................................................3 3

V.9.4 Ch ỉ nh s ử a truy v ấ n...............................................................................................3 3

V.9.5 Để nhóm các k ế t qu ả ...........................................................................................3 4

V.9.6 To order the groups by their key value................................................................3 4

V.9.7 Để gi ớ i thi ệ u m ột đị nh danh b ằ ng cách s ử d ụ ng let ............................................3 4

V.9.8 Để s ử d ụ ng cú pháp ph ươ ng th ứ c trong m ộ t bi ể u th ứ c truy v ấ n .........................3 5

V.9.9 Để chuy ển đổ i ho ặ c d ự án trong m ệnh đề select .................................................3 5

VI. LINQ to SQL...........................................................................................................3 6

VI.1 K ế t n ố i ...................................................................................................................3 7

Sinh viên thực hiện Nguyễn Văn Thụy & Hoàng Mạnh Giỏi

Trang 2

Đồ án kỹ sư II

Tìm hiểu công nghệ LINQ và ứng dụng

VI.2 Giao d ị ch ...............................................................................................................3 8

VI.3 L ệ nh SQL tr ự c ti ế p................................................................................................3 9

Các tham s ố ...................................................................................................................3 9

VI.4 Cách k ế t n ố i m ộ t c ơ s ở d ữ li ệ u (LINQ to SQL)....................................................3 9

VI.5 Cách t ạ o c ơ s ở d ữ li ệ u (LINQ to SQL) .................................................................4 1

VI.6 B ạ n có th ể làm gì v ớ i LINQ to SQL .....................................................................4 3

VI.6.1 L ự a ch ọ n(Select) ............................................................................................4 3

VI.6.2 Cách chèn hàng vào trong c ơ s ở d ữ li ệ u (LINQ to SQL) ..............................4 3

VI.6.3 Chèn m ộ t hàng vào c ơ s ở d ữ li ệ u ...................................................................4 4

VI.6.4 Cách c ậ p nh ậ t hàng trong c ơ s ở d ữ (LINQ to SQL) ......................................4 5

VI.6.5 C ậ p nh ậ t..............................................................................................................4 6

VI.7 Cách xóa hàng trong c ơ s ở d ữ li ệ u (LINQ to SQL )..........................................4 7

Xóa.................................................................................................................................5 0

VI.8 Quy trình l ư u tr ữ (LINQ to SQL)..........................................................................5 0

VI.8.1 Chèn, c ậ p nh ậ t và xóa các ho ạt độ ng c ủ a c ơ s ở d ữ li ệ u trong LINQ to SQ L ....5 1

VI.8.2 Cách g ử i nh ững thay đổi đế n c ơ s ở d ữ li ệ u (LINQ to SQL)..............................5 2

VI.8.3 T ạ o các l ớp LINQ to SQL đượ c ánh x ạ vào b ả ng c ơ s ở d ữ li ệ u or các khung

nhìn. ...............................................................................................................................5 4

VI.8.4 Để t ạ o các l ớp đượ c ánh x ạ vào d ữ li ệ u b ả ng ho ặ c các khung nhìn trong LINQ

to SQL............................................................................................................................5 4

VII. LINQ to XML .........................................................................................................5 5

VII.1 Đị nh n ghĩa............................................................................................................5 5

VII.2 Thêm vào trong khi l ặ p ........................................................................................5 6

VII.3 Xóa trong khi l ặ p..................................................................................................5 7

VII.4 T ạ i sao không th ể x ử lý LINQ t ự độ ng? .............................................................5 8

VII.5 Làm th ế nào để : vi ế t m ộ t ph ươ ng th ứ c axis LINQ to XML ................................5 9

VII.6 Cách t ạ o m ộ t tài li ệ u v ớ i Namespaces (LINQ to XML) (C#) .............................6 7

VII.7 Cách Stream XML Fragments t ừ m ộ t XmlReader ..............................................6 9

VII.8 Cách t ạ o m ộ t s ơ đồ (Tree) t ừ m ộ t XmlReader.....................................................7 1

VII.9 Thay đổ i cây XML tròn b ộ nh ớ trong so v ớ i Functional Construction (LINQ to

XML ).............................................................................................................................7 2

VII.10 Chuy ển đổ i thu ộ c tính vào các ph ầ n t ử ..............................................................7 3

Sinh viên thực hiện Nguyễn Văn Thụy & Hoàng Mạnh Giỏi

Trang 3

Đồ án kỹ sư II

Tìm hiểu công nghệ LINQ và ứng dụng

VII.10.1 Ch ỉ nh s ử a m ộ t cây XML.................................................................................7 3

VII.10.2 Cách ti ế p c ậ n Functional Construction ...........................................................7 3

VII.10.3 Removing Elements, Attributes, and Nodes from an XML Tree ...................7 4

Code...........................................................................................................................7 6

VII.10.4 Làm th ế nào để : L ọ c trên m ộ t Tùy ch ọ n Element. .........................................7 7

VII.10.5 Làm th ế nào để : Tìm m ột đơ n Descendant rõ Ph ươ ng th ứ c s ử d ụ ng. ............7 9

VII.10.6 Làm th ế nào để : Tìm t ấ t c ả các Nodes trong m ộ t Namespace........................7 9

VII.10.7 Làm th ế nào để : Tìm m ộ t ph ầ n t ử v ớ i ph ầ n t ử c ụ th ể .....................................8 0

VII.10.8 Làm th ế nào để : Tìm m ộ t Element v ớ i m ộ t thu ộ c tính c ụ th ể ........................8 1

VII.10.9 Làm th ế nào để : Tìm Descendants v ớ i m ộ t c ụ th ể Element namespace.........8 1

VII.10.10 Làm th ế nào để : T ạo văn bả n t ừ t ậ p tin XML...............................................8 2

VII.10.11 Làm th ế nào để : t ạ o ra h ệ đẳ ng c ấ p b ằ ng cách s ử d ụ ng nhóm. ....................8 3

VII.10.12 Làm th ế nào để : Join hai b ộ s ư u t ậ p. ............................................................8 3

VII.10.13 Làm th ế nào để : Load XML t ừ m ộ t t ệ p ........................................................8 5

VII.11 S ửa đổ i XML Trees............................................................................................8 5

VII.11.1 Làm th ế nào để : Vi ế t m ộ t truy v ấ n mà các ph ầ n t ử d ự a trên b ố i c ả nh ...........8 6

VII.11.2 Làm th ế nào để : Vi ế t truy v ấ n v ớ i l ọ c ph ứ c t ạ p..............................................8 8

VII.11.3 Làm th ế nào để : Truy v ấn LINQ để s ử d ụ ng XML xpath. .............................8 9

VII.11.4 Làm th ế nào để : X ắ p s ế p các ph ầ n t ử . ............................................................8 9

VII.11.5 Làm th ế nào để : x ắ p s ế p các ph ầ n t ử có nhi ề u khóa.......................................9 0

VII.11.6 Làm th ế nào để : X ắ p s ế p theo chính sách th ự c hi ệ n chuy ển đổ i c ủ a tài li ệ u

XML l ớ n. .......................................................................................................................9 0

VII.11.7 Làm th ế nào để :truy c ậ p lu ồ ng XML phân m ả nh v ới thông tin cho tiêu đề ...9 3

VII.12 So sánh các Xpath và LINQ to XML.................................................................9 6

VIII. LINQ to Objects...................................................................................................9 7

VIII.1 Làm th ế nào để : Truy v ấ n v ớ i m ộ t ArrayList LINQ ..........................................9 8

VIII.2 LINQ and Strings................................................................................................9 9

VIII.3 Làm th ế nào để: Đế m s ự xu ấ t hi ệ n c ủ a m ộ t t ừ trong m ộ t chu ỗ i (LINQ )...........9 9

VIII.4 Làm th ế nào để : Truy v ấn cho câu đó chứ a m ộ t b ộ t ừ . ....................................1 01

VIII.5 Làm th ế nào để : Truy v ấ n cho các ký t ự trong m ộ t String (LINQ)..................1 02

VIII.6 Làm th ế nào để : K ế t h ợ p LINQ truy v ấ n v ớ i các bi ể u th ứ c chính quy. ..........1 03

Sinh viên thực hiện Nguyễn Văn Thụy & Hoàng Mạnh Giỏi

Trang 4

Đồ án kỹ sư II

Tìm hiểu công nghệ LINQ và ứng dụng

VIII.7 Câu h ỏ i bán c ấ u trúc d ữ li ệ u ở đị nh d ạng văn bả n ...........................................1 04

VIII.7.1 Làm th ế nào để : Tìm các t ậ p khác bi ệ t gi ữ a hai danh sách (LINQ)..............1 05

VIII.7.2 Làm th ế nào để : S ắ p x ế p hay L ọ c d ữ li ệu Văn bả n b ở i b ấ t kì m ộ t t ừ ho ặ c m ộ t

tr ườ ng (LINQ) .............................................................................................................1 05

VIII.7.3 Làm th ế nào để : S ắ p x ế p l ạ i các tr ường được đị nh gi ớ i trong file ................1 06

VIII.8 Để t ạ o các t ệ p d ữ li ệ u .......................................................................................1 06

VIII.8.1 Làm th ế nào để : K ế t h ợ p và so sánh các t ậ p h ợ p chu ỗ i (LINQ) ...................1 07

VIII.8.2 Làm th ế nào để : L ấ y ra t ậ p h ợp đố i t ượ ng t ừ nhi ề u ngu ồ n (LINQ )..............1 08

VIII.8.3 Làm th ế nào để : Gia nh ậ p n ộ i dung t ừ các file không cùng d ạ ng .................1 10

VIII.8.4 Làm th ế nào để : Tách m ộ t file vào các file b ằ ng cách s ử d ụ ng các nhóm

(LINQ ).........................................................................................................................1 10

VIII.8.5 Làm th ế nào để : Tính toán giá tr ị c ủ a c ộ t trong m ột văn bả n c ủ a t ệ p CSV

(LINQ ).........................................................................................................................1 11

IX. LINQ to ADO.NE T ...............................................................................................1 13

X. LINQ to DataSe t ......................................................................................................1 14

X.1 T ổ ng quan v ề LINQ to DataSet ............................................................................1 15

X.2 Truy v ấ n các DataSet s ử d ụng LINQ để DataSe t .................................................1 16

X.3 Ứ ng d ụ ng N-tier và LINQ to DataSet ..................................................................1 17

X.4 Đang tả i d ữ li ệ u vào m ộ t DataSet.........................................................................1 18

X.5 Truy v ấ n các DataSet............................................................................................1 19

X.6 Để truy v ấ n trong LINQ to DataSet......................................................................1 20

Sinh viên thực hiện Nguyễn Văn Thụy & Hoàng Mạnh Giỏi

Trang 5

Đồ án kỹ sư II

Tìm hiểu công nghệ LINQ và ứng dụng

I. Giới thiệu về LINQ.

LINQ là viết tắt của từ Language – Integrated Query tạm dịch là ngôn ngữ tích

hợp truy vấn là một sự đổi mới trong Visual Studio 2008 và .NET Framework 3.5 là cầu

nối khoảng cách giữa thế giới của các đối tượng với thế giới của dữ liệu.

Theo truyền thống các câu truy vấn trên dữ liệu được thể hiện một cách dễ dàng

giống như các chuỗi kí tự đơn giản mà không cần đến kiểu kiểm tra tại thời điểm biên

dịch hoặc sự hỗ trợ của trình hỗ trợ trực quan. Hơn nữa bạn cần phải tìm hiểu một ngôn

ngữ truy vấn khác nhau cho mỗi loại dữ liệu liệu nguồn khác nhau như: Cở sở dữ liệu

SQL, tài liệu XML, các dịch vụ Web. LINQ làm cho một truy vấn một lớp đầu tiên xây

dựng trong ngôn ngữ C# và Visual Basic. Bạn viết một câu truy vấn dựa trên tập hợp các

đối tượng bằng cách sử dụng ngôn ngữ, các từ khóa các toán tử quen thuộc. Ví dụ minh

họa sau đây cho thấy một phần câu truy vấn được hoàn thành dựa trên cơ sở dữ liệu SQL

Server trong C# với đầy đủ loại kiểm tra và sự hỗ trợ của trình hỗ trợ trực quan.

Sinh viên thực hiện Nguyễn Văn Thụy & Hoàng Mạnh Giỏi

Trang 6

Đồ án kỹ sư II

Tìm hiểu công nghệ LINQ và ứng dụng

Trong Visual Studio 2008 bạn có thể viết các câu truy vấn LINQ trong Visual

Basic hoặc C# với cơ sở dữ liệu SQL Server, các tài liệu XML, ADO.NET Datasets và

bất kỳ tập đối tượng được hỗ trợ IEnumerable hoặc có đặc điểm chung giống giao diện

IEnumerable<T>. LINQ hỗ trợ cho các thực thể ADO.NET Framework và LINQ đang

được các nhà cung cấp hiện nay viết bởi bên thứ ba cho nhiều dịch vụ Web và các triển

khai dữ liệu khác. Bạn có thể sử dụng các truy vấn LINQ trong các dự án mới hoặc trong

các dự án hiện có. Một yêu cầu duy nhất là các dự án đó được xây dựng trên .NET

Framework 3.5.

II. Giới thiệu về các truy vấn LINQ.

Một câu truy vấn là một biêu thức gọi ra dữ liệu từ dữ liệu nguồn. Câu truy vấn

thường nói rõ trong ngôn ngữ truy vấn đữ được thiết kế cho mục dích riêng. Các ngôn

ngữ khác nhau đã được phát triển theo thời gian cho các loại dữ liệu ngồn, ví dụ như SQL

dành cho cơ sở dữ liệu quan hệ và XQuery dành cho XML. Vì vậy các nhà phát triển đã

tìm hiểu một ngôn ngữ truy vấn mới cho các loại dữ liệu nguồn hoặc các định dạng mà

họ phải hỗ trợ. LINQ đơn giản tình trạng này bằng cách cung cấp một mô hình nhất quán

để làm việc với các loại dữ liệu nguồn khác nhau và các định dạng. Trong một truy vấn

LINQ bạn phải luôn luôn làm việc với các đối tượng. Bạn sử dụng giống như truy vấn

mẫu cơ bản mã hóa và chuyển đổi dữ liệu trong các tài liệu XML, cơ sở dữ liệu SQL,

ADO.NET DataSet và cho bất kì một định đạng nào mà một nhà cung cấp LINQ có sẵn.

II.1 Ba phần của một biểu thức LINQ.

Tất cả các biểu thức LINQ làm việc theo ba thao tác.

1. Có được các dữ liệu nguồn.

2. Tạo các truy vấn.

3. Thực hiện các truy vấn.

Ví dụ trong mã nguồn sau đây cho thấy ba phần của một truy vấn hoạt động như thế

nào. Ví dụ sử dụng một mảng số nguyên như là một sự thay thế cho nguồn dữ liệu; tuy

Sinh viên thực hiện Nguyễn Văn Thụy & Hoàng Mạnh Giỏi

Trang 7

Đồ án kỹ sư II

Tìm hiểu công nghệ LINQ và ứng dụng

nhiên, trong cùng một khái niệm áp dụng cho các nguồn dữ liệu khác cũng có. Ví dụ này

sẽ được giới thiệu đến trong suốt phần còn lại của chủ đề này.

class IntroToLINQ

{

static void Main()

{

// The Three Parts of a LINQ Query:

// 1. Data source.

int[] numbers = new int[7] { 0, 1, 2, 3, 4, 5, 6 };

// 2. Query creation.

// numQuery is an IEnumerable<int>

var numQuery =

from num in numbers

where (num % 2) == 0

select num;

// 3. Query execution.

foreach (int num in numQuery)

{

Console.Write("{0,1} ", num);

}

Minh họa sau đây cho thấy các hoạt động truy vấn tìm kiếm được hoàn tất. Trong

LINQ việc thực hiện các truy vấn riêng biệt từ bản thân câu truy vấn. Nói cách khác bạn

không lấy ra bất kỳ dữ liệu nào bằng cách tạo ra một biến truy vấn.

Sinh viên thực hiện Nguyễn Văn Thụy & Hoàng Mạnh Giỏi

Trang 8

Đồ án kỹ sư II

Tìm hiểu công nghệ LINQ và ứng dụng

II.2 Các dữ liệu nguồn.

Trong ví dụ trước vì dữ liệu là một mảng, nó hoàn toàn hỗ trợ đặc điểm chung

giao diện IEnumerable <T>. Điều này có nghĩa thực tế nó có thể được truy vấn với

LINQ. Một truy vấn được thực hiện trong một câu lệnh foreach và foreach yêu cầu

IEnumerable hay IEnumerable(T). Loại có hỗ trợ IEnumerable(T) hoặc một giao diện

như IQueryable(T) được gọi là các loại queryable. Một loại queryable không yêu cầu

phải sửa đổi hay xử lý đặc biệt để phục vụ một LINQ nguồn dữ liệu. Nếu các nguồn dữ

liệu không phải là đã có trong bộ nhớ như là một loại queryable, một nhà cung cấp LINQ

phải đại diện cho nó như vậy. Ví dụ, LINQ to XML một tài liệu XML vào một queryable

XElement:

// Query execution.

foreach (int num in numQuery)

{

Console.Write("{0,1} ", num);

}

Với LINQ to SQL trước tiên bạn tạo một đối tượng quan hệ được ánh xạ vào lúc

thiết kế cái này được làm thủ công hoặc bằng cách sử dụng trình thiết kế đối tượng quan

hệ(O/R Designer). Bạn viết các câu truy vấn của bạn dựa trên đối tượng và thi hành

Sinh viên thực hiện Nguyễn Văn Thụy & Hoàng Mạnh Giỏi

Trang 9

Đồ án kỹ sư II

Tìm hiểu công nghệ LINQ và ứng dụng

LINQ to SQL để sử lý các giao tiếp với cơ sở dữ liệu. Trong ví dụ sau, Customer đại diện

cho một bảng trong cơ sở dữ liệu, và Table<Customer> hỗ trợ các đặc tính chung

IQueryable<T> mà được bắt đầu từ IEnumerable<T>.

// Create a data source from a SQL Server database.

// using System.Data.Linq;

DataContext db = new DataContext(@"c:\northwind\northwnd.mdf");

II.3 Truy vấn.

Truy vấn trong ví dụ trước trả về tất cả các số từ mảng số nguyên. Các biểu thức

truy vấn chứa ba mệnh đề: from, where, select.(Nếu bạn đang quen với SQL sắp đặt của

các mệnh đề là sai vị trí trong SQL). Mệnh đề from dùng để xác định nguồn dữ liệu,

mệnh đề where dùng để lọc dữ liệu, mệnh đề select dùng để chọn ra những phần tử được

trả về. các mệnh đề này và các mệnh đề truy vấn khác sẽ được thảo luận chi tiết trong

phần LINQ Query Expresstions(Hướng dẫn lập trình C#). Lúc này một điểm quan trọng

là trong LINQ, các biến truy vấn tựu nó không hành động và trả về không có dữ liệu. Nó

chỉ chứa đựng thông tin đó là yêu cầu từ kết quả trả về khi câu truy vấn được thực hiện

tại một số điểm sau.

II.3 Thực thi truy vấn.

Hoãn thực thi.

Cũng giống như trạng thái trước đây, biến truy vấn tự nó chỉ chứa các lệnh truy

vấn. Hiện nay sự thực thi của các truy vấn là hoãn lại đến tận khi bạn nhắc lại đối với

biến truy vấn trong câu lệnh foreach. Cái này làm cơ sở để quy cho hoãn thực thi và là cái

điển hình trong ví dụ sau:

// Query execution.

foreach (int num in numQuery)

{

Console.Write("{0,1} ", num);

}

Câu lệnh foreach là nơi các kết quả truy vấn được trả về ví dụ các truy vấn trước

đó biến num được lặp và nắm dữ mỗi giá trị trong trình tự trả về. Bởi các biến truy vấn tự

Sinh viên thực hiện Nguyễn Văn Thụy & Hoàng Mạnh Giỏi

Trang 10

Đồ án kỹ sư II

Tìm hiểu công nghệ LINQ và ứng dụng

nó không bao giờ chứa kết quả truy vấn, bạn có thể thực hiện nó thường xuyên như bạn

muốn. Ví dụ bạn dang có một cơ sở dữ liệu mà đang được cập nhập liên tục bởi một ứng

dụng riêng biệt. Trong ứng dụng của bạn, bạn có thể tạo một truy vấn để lấy ra dữ liệu

mới nhất và bạn có thể thi hành nó một cách liên tục tại một khoảng thời gian để lấy kết

quả mỗi lần.

II.4 Thực thi bắt buộc tức thời.

Truy vấn mà sự kết hợp thực hiện các chức năng trên một loạt các phần tử nguồn

đầu tiên phải lặp đi lặp lại trên những nhần tử. Ví dụ như các truy vấn Count, Max,

Average, và First. Những thực thi mà không có một câu lệnh foreach nào rõ ràng bởi vì

các truy vấn tự nó phải sử dụng foreach để trả về là một kết quả. Cũng lưu ý rằng các loại

truy vấn trả lại một giá trị, không phải là một tập IEnumerable. Các truy vấn sau đây sẽ

trả về một số lượng các số trong mảng nguồn:

var evenNumQuery =

from num in numbers

where (num % 2) == 0

select num;

int evenNumCount = evenNumQuery.Count();

List<int> numQuery2 =

(from num in numbers

where (num % 2) == 0

select num).ToList();

// or like this:

// numQuery3 is still an int[]

var numQuery3 =

(from num in numbers

where (num % 2) == 0

select num).ToArray();

III. Tổng quan về thiết kế O / R.

Thiết kế đối tượng quan hệ (O / R Designer) cung cấp một hình ảnh thiết kế trực

quan cho việc tạo LINQ to SQL để tổ chức các thực thể và sự kết hợp (các mối quan hệ)

dựa trên các đối tượng trong một cơ sở dữ liệu. Nói cách khác, các O / R được thiết kế sử

dụng để tạo ra một mô hình đối tượng trong một ứng dụng để ánh xạ các đối tượng trong

một cơ sở dữ liệu. Nó cũng tạo ra một mạnh kiểu rõ ràng DataContext được sử dụng để

Sinh viên thực hiện Nguyễn Văn Thụy & Hoàng Mạnh Giỏi

Trang 11

Đồ án kỹ sư II

Tìm hiểu công nghệ LINQ và ứng dụng

gửi và nhận dữ liệu giữa các lớp thực thể và cơ sở dữ liệu. O / R Designer cũng cung cấp

tính năng cho việc ánh xạ các thủ tục lưu trữ và các hàm để thục hiện các phương thức

trong DataContext trả về các dữ liệu và populating tổ chức các lớp thực thể. Cuối cùng, O

/ R Designer cung cấp khả năng thiết kế thừa kế các mối quan hệ giữa các lớp thực thể.

O / R Designer tạo ra những file có phần mở rông là .dbml cung cấp cho việc ánh

xạ giữa các lớp LINQ to SQL và các đối tượng dữ liệu. O / R Designer cũng tạo ra những

kiểu DataContext và tổ chức các lớp thực thể.

O / R Designer có hai khu vực riêng biệt trên bề mặt thiết kế: các thực thể trong

của sổ bên trái, và các phương thức trong cửa sổ bên phải. Cửa sổ các thực thể chính là

bề mặt thiết kế lớp thực thể, các sự kết hợp, và các bậc kế thừa. Các phương thức trong

của sổ bên phảilà bề mặt thiết kế có hiển thị DataContext các phương thức ánh xạ để lưu

trữ các thủ tục và hàm.

III.1 Mở các O / R Designer.

Bạn có thể mở các O / R bằng cách thêm một class mới vào dự án

O / R Designer là một cách dễ dàng đẻ ánh xạ các đối tượng bởi vì nó chỉ hỗ trợ

ánh xạ 1:1các mối quan hệ. Nói cách khác, một lớp thực thể có thể chỉ có một ánh xạ

1:1trong mối quan hệ với một cơ sở dữ liệu hoặc view. Ánh xạ phức tạp, chẳng hạn như

ánh xạ một lớp thực thể tham gia vào một bảng, hiện chưa hỗ trợ. Ngoài ra, các nhà thiết

kế là một sinh mã tự động một chiều. Điều này có nghĩa là chỉ thay đổi mà bạn thực hiện

để các nhà thiết kế bề mặt được phản ánh trong các tập tin code. Hướng dẫn để thay đổi

các tập tin code không được phản ánh trong O / R Designer. Bất kỳ thay đổi nào mà bạn

làm thủ công trong các tập tin mã được ghi đè khi thiết kế được lưu và code là tự phục

hồi.

III.2 Cấu hình và tạo ra DataContext

Sau khi bạn thêm một lớp LINQ cho SQL cho một mục dự án và mở O / R

Designer thiết kế, các thiết kế bề mặt trống rỗng đại diện một DataContext sẵn sàng để

được cấu hình. các DataContext được cấu hình kết nối với các thông tin được cung cấp

Sinh viên thực hiện Nguyễn Văn Thụy & Hoàng Mạnh Giỏi

Trang 12

Đồ án kỹ sư II

Tìm hiểu công nghệ LINQ và ứng dụng

bởi các phần tử đầu tiên được kéo vào cho việc thiết kế .. Vì vậy, các DataContext được

cấu hình bằng cách sử dụng kết nối thông tin từ các phần tử dầu tiên được kéo vào thiết

kế bề mặt thiết kế.

III.3 Tạo tổ chức các lớp mà cơ sở dữ liệu bản đồ để bàn và xem.

Bạn có thể tạo các lớp thực thể được ánh xạ từ các bảng và các view bằng cách

kéo thả các cơ sở dữ liệu và các view Server Explorer / Explorer Database lên các O / R

Designer. Như chỉ định trong phần trước của DataContext được cấu hình kết nối với các

thông tin được cung cấp bởi các phần tử đầu tiên được kéo thả vào bề mặt thiết kế. Nếu

một mục sau mà sử dụng một kết nối khác sẽ được thêm vào O / R Designer, bạn có thể

thay đổi kết nối cho các DataContext.

III.4 DataContext tạo ra phương pháp gọi thủ tục lưu trữ và các hàm.

Bạn có thể tạo DataContext chưa các phương thức mà gọi (được ánh xạ tới) các

thủ tục và các hàm lưu trữ bằng cách kéo chúng từ Server Explorer / Explorer Database

lên các O / R Designer. Các thủ tục lưu trữ và các hàm được đưa vào các O / R Designer

như phương thức của DataContext.

III.5 Cấu hình một DataContext để sử dụng các thủ tục lưu trữ dữ liệu lưu dữ liệu

giữa các lớp thực thể và cơ sở dữ liệu.

Như đã nêu trên, bạn có thể tạo DataContext chứa các phương thức gọi các thủ tục

lưu trữ và các hàm. Ngoài ra, bạn cũng có thể chỉ định các thủ tục lưu trữ được sử dụng

mặc định cho LINQ to SQL để thực hiện hành động insert, update, và delete.

III.6 Thừa kế và các O / R Designer

Giống như các đối tượng khác, các lớp LINQ to SQL có thể sử dụng được kế thừa

và thu được từ các lớp. Trong một cơ sở dữ liệu, các mối quan hệ thừa kế được tạo ra

trong một số cách. O / R Designer hỗ trợ các khái niệm về đơn-bảng kế thừa như nó

thường triển khai thực hiện trong các hệ thống.

IV. Các truy vấn LINQ to SQL.

Sinh viên thực hiện Nguyễn Văn Thụy & Hoàng Mạnh Giỏi

Trang 13

Đồ án kỹ sư II

Tìm hiểu công nghệ LINQ và ứng dụng

IV.1 Tách rời DataContext đã tạo ra và các lớp thực thể vào các namespaces

khác nhau

O / R Designer cung cấp cho các thuộc tính Context Namespace và Entity

Namespace trên DataContext. Những thuộc tính xác định tên DataContext và các lớp

thực thể đã được tạo ra. Theo mặc định, các thuộc tính là trống rỗng và các DataContext

và các lớp thực thể được tạo ra vào ứng dụng của namesapce. Để tạo ra các mã vào một

namespace khác các ứng dụng của namespace, nhập một giá trị vào trong thuộc tính

Context Namespace và / hoặc Entity Namespace.

IV.2 Làm thế nào để: Chỉ định lưu trữ Thực hiện thủ tục Update, Insert, và delete

Thủ tục lưu trữ có thể được đưa vào các O / R Designer và thực hiện như các

phương thức điển hình trong DataContext. Chúng cũng có thể được sử dụng để phủ quyết

các phương thức mặc định trong LINQ to SQLđể thực hiện hành vi thêm, cập nhật, và

xóa khi các thay đổi đều được lưu từ các thực thể để tổ chức một cơ sở dữ liệu (ví dụ, khi

gọi các phương thức SubmitChanges).

Nếu thủ tục lưu trữ của bạn trả về giá trị mà cần phải được gửi lại cho client (ví

dụ, giá trị tính toán trong thủ tục lưu trữ), tạo ra tham số của bạn được lưu trữ trong các

thủ tục. Nếu bạn không thể sử dụng tham số, viết một phần phương thức một phần của

việc triển khai thực hiện thay vì dựa vào các phủ quyết được tạo ra bởi các O / R

Designer. Các thành viên được ánh xạ để tạo ra các giá trị cho cơ sở dữ liệu cần phải

được thiết lập thích hợp cho các giá trị sau khi hoàn tất thành công của qua trình INSERT

hoặc UPDATE.

V. LINQ và các kiểu có chung đặc điểm

Các câu truy vấn LINQ được dựa trên các loại có chung đặc điểm, đã được giới thiệu

trong phiên bản 2.0 của. NET Framework. Bạn không cần phải có kiến thức đi vào tìm

hiểu sâu các đặc điểm chung trước khi bạn có thể bắt đầu viết truy vấn. Tuy nhiên, bạn có

thể muốn hiểu rõ hai khái niệm cơ bản:

Sinh viên thực hiện Nguyễn Văn Thụy & Hoàng Mạnh Giỏi

Trang 14

Đồ án kỹ sư II

Tìm hiểu công nghệ LINQ và ứng dụng

1. Khi bạn tạo một ví dụ của một tập hợp có chung đặc điểm như List(T), bạn thay thế

"T" với các loại đối tượng trong danh sách đó sẽ chứa. Ví dụ, một danh sách các

xâu kí tự được thể hiện như List<string> , và một danh sách Customer các đối

tượng khách hàng được thể hiện như List<Customer>. Một danh sách chung có

kiểu sinh động và cung cấp nhiều lợi ích hơn một tập hợp nó cất giữ các phần tử

của chúng như đối tượng. Nếu bạn cố gắng để thêm một Customer vào trong mộ

List<string> , bạn sẽ nhận được một lỗi tại thời gian biên soạn. Nó là một cách dễ

dàng để sử dụng chung các tập hợp vì bạn không có thể thực hiện các hoạt động đã

được phân loại.

2. IEnumerable (T) là giao diện cho phép tập hợp các lớp để liệt kê bằng cách sử

dụng câu lệnh foreach. Tập hợp chung các lớp hỗ trợ IEnumerable (T) cũng giống

như tập hợp các lớp không chung chẳng hạn như IEnumerable hỗ trợ ArrayList.

V.1 IEnumerable các biến trong các câu truy vấn LINQ

Các biến trong câu truy vấn LINQ có kiểu như IEnumerable (T) hoặc có kiểu bắt

nguồn từ một nguồn như IQueryable (T). Khi bạn xem một câu truy vấn có biến là kiểu

IEnumerable<Customer>, nó đơn giản là các thức truy vấn, khi nó được thực hiện, sẽ

tạo ra một trình tự không có gì hoặc nhiều đối tượng Customer.

IEnumerable<Customer> customerQuery =from cust in customers

where cust.City == "London"

select cust;

foreach (Customer customer in customerQuery)

{

Console.WriteLine(customer.LastName + ", " + customer.FirstName);

}

V.2 Cho phép chương trình biên dịch xử lý các loại khai báo chung

Nếu bạn thích, bạn có thể tránh cú pháp chung chung bằng cách sử dụng từ khóa

var. Các từ khóa var để hướng dẫn trình biên dịch nhận ra loại biến một truy vấn tìm

kiếm tại các nguồn dữ liệu được xác định trong mệnh đề from. Ví dụ sau cho cùng một

kết quả như đoạn mã được xây dựng phía trên.

var customerQuery2 =

from cust in customers

where cust.City == "London"

select cust;

Sinh viên thực hiện Nguyễn Văn Thụy & Hoàng Mạnh Giỏi

Trang 15

Đồ án kỹ sư II

Tìm hiểu công nghệ LINQ và ứng dụng

foreach(var customer in customerQuery2)

{

Console.WriteLine(customer.LastName + ", " + customer.FirstName);

}

Các từ khóa var rất hữu ích khi các loại của biến là rõ ràng hoặc khi nó không

phải là điều quan trọng để xác định rõ ràng các loại chung như là cái đó được tạo ra bằng

cách nhóm các truy vấn. Nói chung, chúng tôi đề nghị rằng nếu bạn sử dụng var, nhận

thấy rằng nó có thể làm cho mã của bạn khó khăn hơn cho những người khác đọc.

V.3 Hoạt động truy vấn cơ bản.

Chủ đề này cho một giới thiệu tóm tắt về truy vấn LINQ và một số biểu hiện của

các loại hình hoạt động điển hình mà bạn thực hiện trong một truy vấn.

Chú ý: Nếu bạn đã là quen thuộc với một truy vấn ngôn ngữ như SQL hay XQuery, bạn

có thể bỏ qua hầu hết các chủ đề này. Đọc về "mệnh đề from" trong phần kế tiếp để tìm

hiểu về trật tự của các mệnh đề trong biểu thức truy vấn LINQ.

V.3.1 Obtaining a Data Source

Lấy vật là một nguồn dữ liệu

Trong một truy vấn LINQ, bước đầu tiên là xác định nguồn dữ liệu. Trong C #

cũng như trong hầu hết các ngôn ngữ lập trình một biến phải được khai báo trước khi nó

có thể được sử dụng. Trong một truy vấn LINQ, mệnh đề from đứng đầu tiên để giới

thiệu các nguồn dữ liệu (customer) và nhiều biến (cust).

//queryAllCustomers is an IEnumerable<Customer>

var queryAllCustomers = from cust in customers

select cust;

Phạm vi biến giống như các biến lặp trong một vòng lặp foreach, ngoại trừ không có thực

sự một vòng lặp xảy ra trong một biểu thức truy vấn. Khi truy vấn được thi hành, trong

phạm vi biến sẽ phục vụ như là một tham chiếu lần lượt đến các các phần tử trong mỗi

customers. Bởi vì trình biên dịch có thể nhận ra các kiểu khác nhau của cuts, bạn không

thể xác định nó rõ ràng. Bổ sung phạm vi các biến có thể được giới thiệu bởi một mệnh

đề let.

Sinh viên thực hiện Nguyễn Văn Thụy & Hoàng Mạnh Giỏi

Trang 16

Đồ án kỹ sư II

Tìm hiểu công nghệ LINQ và ứng dụng

V.3.2 Filtering( Lọc)

Có lẽ các hành đọng truy vấn phổ biến nhất là một bộ lọc để áp dụng trong các

mẫu của một biểu thức logic Boolean. Các bộ lọc giúp các truy vấn trả về duy nhất các

phần tử cho các biểu thức là đúng. Kết quả là kết quả được sử dụng mệnh đề where. Các

bộ lọc có hiệu lực xác định các yếu tố đó để loại trừ từ các nguồn liên tục. Trong ví dụ

sau, chỉ những khách hàng có địa chỉ ở London sẽ được trả về.

var queryLondonCustomers = from cust in customers

where cust.City == "London"

select cust;

Bạn có thể sử dụng quen ngôn ngữ C# với các biểu thức logic AND và OR để vận

hành áp dụng như nhiều bộ lọc trong mệnh đề where. Ví dụ, chỉ trả về các khách hàng có

địa chỉ tại"London" và có tên là "Devon" bạn sẽ viết đoạn mã sau đây:

where cust.City=="London" && cust.Name == "Devon"

Để trả về khách hàng có địa chỉ ở London hay Paris, bạn sẽ viết mã sau:

where cust.City == "London" || cust.City == "Paris"

V.3.3 Ordering (Thứ tự)

Thường nó là thuận tiện để phân loại dữ liệu trả về. Mệnh đề orderby sẽ gây ra

các phần tử trong chuỗi trả về để được sắp xếp theo mặc định so sánh cho các loại đang

được sắp xếp. Ví dụ, sau đây truy vấn có thể được mở rộng để phân loại các kết quả dựa

trên thuộc tính Name. Bởi vì thuộc tính Name là một chuỗi, mặc định nó sẽ so sánh và

thực hiện sắp xếp theo thứ tự chữ cái từ A đến Z.

var queryLondonCustomers3 =

from cust in customers

where cust.City == "London"

orderby cust.Name ascending

select cust;

Để các kết quả trong thứ tự đảo ngược trật tự, từ A to Z, sử dụng mệnh đề

orderby ...descending.

V.3.4 Grouping

Mệnh đề group cho phép bạn nhóm các kết quả của bạn dựa trên một khóa mà bạn

chỉ định. Ví dụ, bạn có thể xác định rằng các kết quả cần được nhóm lại theo thuộc tính

Sinh viên thực hiện Nguyễn Văn Thụy & Hoàng Mạnh Giỏi

Trang 17

Đồ án kỹ sư II

Tìm hiểu công nghệ LINQ và ứng dụng

City để tất cả các khách hàng từ London, Paris hay cá nhân đang có trong nhóm. Trong

trường hợp này, cust.City chính là khóa.

Chú ý: Các kiểu rõ ràng đang có trong các ví dụ để minh họa các khái niệm. Bạn cũng có

thể sử dụng chính cho custQuery, group,cad customer để cho trình biên dịch xác định

chính xác loại.

// queryCustomersByCity is an IEnumerable<IGrouping<string, Customer>>

var queryCustomersByCity =

from cust in customers

group cust by cust.City;

// customerGroup is an IGrouping<string, Customer>

foreach (var customerGroup in queryCustomersByCity)

{

Console.WriteLine(customerGroup.Key);

foreach (Customer customer in customerGroup)

{

Console.WriteLine("

{0}", customer.Name);

}

Khi bạn kết thúc một truy vấn với mệnh đề group, các kết quả của bạn sẽ sẽ được

trả về một danh sách từ các danh sách. Mỗi phần tử trong danh sách là một đối tượng có

một Key thành viên và danh sách các phần tử đó là nhóm chứa khóa này. Khi bạn lặp qua

một truy vấn mà kết quả là một nhóm có trình tự, bạn cần phải sử dụng một vòng lặp

foreach. Nếu bạn cần phải tham khảo các kết quả thi hành của một nhóm, bạn có thể sử

dụng từ khóa into để tạo ra một định danh có thể được thêm vào câu truy vấn. Dưới đây

là những truy vấn trả lại chỉ những nhóm có chứa nhiều hơn hai khách hàng:

var custQuery =

from cust in customers

group cust by cust.City into custGroup

where custGroup.Count() > 2

orderby custGroup.Key

select custGroup;

V.3.5 Joining

Thao tác Join tạo ra sự kết hợp giữa nhiều sự kiện không được rõ ràng mô trong

nguồn dữ liệu. Ví dụ, bạn có thể thực hiện một thao tác để tìm tất cả các khách hàng ở

London những người đặt hàng các sản phẩm từ nhà cung cấp, họ đang ở Paris. Trong

LINQ mệnh đề Join luôn luôn tham gia các hoạt động dựa trên tập đối tượng thay vì các

bảng cơ sở dữ liệu. Trong LINQ bạn không sử dụng mệnh đề Join thường xuyên như

Sinh viên thực hiện Nguyễn Văn Thụy & Hoàng Mạnh Giỏi

Trang 18

Đồ án kỹ sư II

Tìm hiểu công nghệ LINQ và ứng dụng

bạn làm trong SQL bởi vì các khóa ngoại LINQ miêu tả trong mô hình như là thuộc tính

nắm giữ một tập các mục. Ví dụ, một đối tượng Customer có chứa một tập Order của

các đối tượng. Đúng hơn là biểu diễn một thao tác, bạn truy cập các thứ tự bằng cách sử

dụng dấu chấm:

from order in Customer.Orders...

V.3.6 Selecting (Projections)

Mệnh đề Select đưa ra các kết quả trả về của một câu truy vấn và xác định "hình

dạng" hoặc kiểu của mỗi kết quả trả về. Ví dụ, bạn có thể chỉ định cho dù kết quả của bạn

sẽ bao gồm tất cả các đối tượng Customer, chỉ cần một thành viên, một nhóm của các

thành viên, hoặc một số kết quả loại hoàn toàn khác nhau dựa trên tính toán hay một đối

tượng mới tạo ra. Khi mệnh đề Select đưa ra một cái gì đó khác là một bản sao của các

phần tử nguồn, thao tác được gọi là bản dự thảo. Việc sử dụng các bản dự thảo để chuyển

đổi dữ liệu là một khả năng của biểu thức truy vấn LINQ.

V.4 Chuyển đổi dữ liệu với LINQ

Ngôn ngữ-Integrated Query (LINQ) không phải là chỉ có truy lại dữ liệu. Nó cũng

là một công cụ mạnh mẽ cho việc chuyển dữ liệu. Bằng cách sử dụng một truy vấn

LINQ, bạn có thể sử dụng một chuỗi nguồn dữ liệu vào và sửa đổi nó trong nhiều cách để

tạo ra một chuỗi ra mới. Bạn có thể sửa đổi trình tự bản thân nó mà không sửa đổi các

phần tử bằng cách phân loại và gom nhóm. Nhưng có lẽ trong hầu hết các tính năng mạnh

mẽ của các câu truy vấn LINQ là khả năng tạo loại mới. Đây là hoàn hảo trong mệnh đề

select. Ví dụ, bạn có thể thực hiện các nhiệm vụ sau:

Hợp nhất nhiều dãy đầu vào thành một dãy đầu ra đơn lẻ để có một loại mới.

Tạo ra dãy các phần tử bao gồm chỉ một hoặc một vài thuộc tính của mỗi phần tử.

Tạo ra dãy các phần tử bao gồm các kết quả của sự thi hành trên các nguồn dữ

liệu.

Tạo ra dãy trong một định dạng khác nhau. Ví dụ, bạn có thể chuyển đổi những

hàng dữ liệu từ SQL hoặc văn bản vào file XML.

Sinh viên thực hiện Nguyễn Văn Thụy & Hoàng Mạnh Giỏi

Trang 19

Đồ án kỹ sư II

Tìm hiểu công nghệ LINQ và ứng dụng

Đây chỉ là một vài ví dụ. Tất nhiên, những sự chuyển đổi có thể được kết hợp theo

cách khác nhau trong cùng một truy vấn. Hơn nữa, trình tự ra của một chuỗi truy vấn này

có thể được sử dụng như là yếu tố đầu vào cho một chuỗi truy vấn mới.

V.4.1 Tham gia vào nhiều yếu tố đầu vào xuất ra một trình tự.

Bạn có thể sử dụng một truy vấn LINQ để tạo ra một trình tự đầu ra có chứa các

phần tử từ nhiều hơn một trình tự đầu vào. Ví dụ sau cho thấy làm thế nào để kết hợp hai

cấu trúc dữ liệu trong bộ nhớ, nhưng cùng một nguyên tắc có thể được áp dụng để kết

hợp các nguồn dữ liệu từ XML hoặc SQL hoặc DataSet. Ví dự sau cho thấy điều đó:

class Student

{

public string First { get; set; }

public string Last {get; set;}

public int ID { get; set; }

public string Street { get; set; }

public string City { get; set; }

public List<int> Scores;

}

class Teacher

{

public string First { get; set; }

public string Last { get; set; }

public int ID { get; set; }

public string City { get; set; }

}

Ví dụ sau cho thấy một câu truy vấn:

class DataTransformations

{

static void Main()

{

// Create the first data source.

List<Student> students = new List<Student>()

{

new Student {First="Svetlana",

Last="Omelchenko",

ID=111,

Street="123 Main Street",

City="Seattle",

Scores= new List<int> {97, 92, 81, 60}},

new Student {First="Claire",

Last="O’Donnell",

ID=112,

Street="124 Main Street",

City="Redmond",

Scores= new List<int> {75, 84, 91, 39}},

new Student {First="Sven",

Last="Mortensen",

ID=113,

Street="125 Main Street",

Sinh viên thực hiện Nguyễn Văn Thụy & Hoàng Mạnh Giỏi

Trang 20

Đồ án kỹ sư II

Tìm hiểu công nghệ LINQ và ứng dụng

City="Lake City",

Scores= new List<int> {88, 94, 65, 91}},

};

// Create the second data source.

List<Teacher> teachers = new List<Teacher>()

{

new Teacher {First="Ann", Last="Beebe", ID=945, City = "Seattle"},

new Teacher {First="Alex", Last="Robinson", ID=956, City = "Redmond"},

new Teacher {First="Michiyo", Last="Sato", ID=972, City = "Tacoma"}

};

// Create the query.

var peopleInSeattle = (from student in students

where student.City == "Seattle"

select student.Last)

.Concat(from teacher in teachers

where teacher.City == "Seattle"

select teacher.Last);

Console.WriteLine("The following students and teachers live in Seattle:");

// Execute the query.

foreach (var person in peopleInSeattle)

{

Console.WriteLine(person);

}

Console.WriteLine("Press any key to exit.");

Console.ReadKey();

}

/* Output:

The following students and teachers live in Seattle:

Omelchenko

Beebe

*/

V.4.2 Lựa chọn một tập hợp con của mỗi phần tử nguồn

Có hai cách chính để lựa chọn một nhóm của mỗi phần tử trong chuỗi nguồn:

1. Để chọn chỉ cần một thành viên của các phần tử nguồn nguyên tố, sử dụng thao

tác chấm. Trong ví dụ sau, giả định rằng một đối tượng Customer có chứa một số

thuộc tính public bao gồm một chuỗi có tên City. Khi thực hiện, truy vấn này sẽ cho

ra một trình tự các chuỗi đầu ra.

var query = from cust in Customers

select cust.City;

3. Để tạo các phần tử có chứa nhiều hơn một thuộc tính các phần tử nguồn, bạn có thể

sử dụng một đối tượng với một đối tượng có tên hoặc một loại vô danh. Ví dụ sau

cho thấy việc sử dụng một ẩn danh để đóng gói hai loại thuộc tính từ mỗi phần tử

Customer:

Sinh viên thực hiện Nguyễn Văn Thụy & Hoàng Mạnh Giỏi

Trang 21

Đồ án kỹ sư II

Tìm hiểu công nghệ LINQ và ứng dụng

var query = from cust in Customer

select new {Name = cust.Name, City = cust.City};

V.4.3 Chuyển đổi các đối tượng trong bộ nhớ vào XML

Các câu truy vấn LINQ làm cho nó dễ dàng chuyển hóa dữ liệu giữa câu trúc dữ

liệu trong bộ nhớ, cơ sở dữ liệu SQL, ADO.NET Datasets và luồng XML, hoặc các tài

liệu. Ví dụ sau cho thấy việc chuyển đổi dữ liệu trong bộ nhớ vào các phần tử trong

XML:

class XMLTransform

{

static void Main()

{

// Create the data source by using a collection initializer.

List<Student> students = new List<Student>()

{

new Student {First="Svetlana", Last="Omelchenko", ID=111, Scores = new

List<int>{97, 92, 81, 60}},

new Student {First="Claire", Last="O’Donnell", ID=112, Scores = new

List<int>{75, 84, 91, 39}},

new Student {First="Sven", Last="Mortensen", ID=113, Scores = new

List<int>{88, 94, 65, 91}},

};

// Create the query.

var studentsToXML = new XElement("Root",

from student in students

let x = String.Format("{0},{1},{2},{3}", student.Scores[0],

student.Scores[1], student.Scores[2], student.Scores[3])

select new XElement("student",

new XElement("First", student.First),

new XElement("Last", student.Last),

new XElement("Scores", x)

) // end "student"

); // end "Root"

// Execute the query.

Console.WriteLine(studentsToXML);

// Keep the console open in debug mode.

Console.WriteLine("Press any key to exit.");

Console.ReadKey();

}

Ta có kết quả là:

< Root>

<First>Svetlana</First>

<Last>Omelchenko</Last>

</student>

<First>Claire</First>

<Last>O'Donnell</Last>

Sinh viên thực hiện Nguyễn Văn Thụy & Hoàng Mạnh Giỏi

Trang 22

Đồ án kỹ sư II

Tìm hiểu công nghệ LINQ và ứng dụng

</student>

<Last>Mortensen</Last>

</student>

</Root>

V.4.4 Thực hiện các hoạt động trên các phần tử nguồn.

Một trình tự đầu ra có thể không chứa bất kỳ những phần tử hoặc thuộc tính của phần tử

từ trình tự nguồn. Đầu ra phải đượcthay thế được bởi chuỗi các giá trị được tính bằng

cách sử dụng các phần tử nguồn như đối số đầu vào. Dưới đây là những truy vấn đơn

giản, khi nó được thực hiện, kết quả đầu ra của một trình tự những chuỗi có giá trị đại

diện cho một tính toán dựa trên các nguồn trình tự các phần tử thuộc kiểu double.

Chú ý: Việc gọi các phương thức trong các biểu thức truy vấn không được hỗ trợ nếu

truy vấn sẽ được dịch sang một tên miền khác. Ví dụ, bạn không thể gọi phương thức C #

thông thường trong LINQ to SQL vì SQL Server không có ngữ cảnh cho nó. Tuy nhiên,

bạn có thể ánh xạ thành các thủ tục trong SQL và gọi các phương thức đó.

class FormatQuery

{

static void Main()

{

// Data source.

double[] radii = { 1, 2, 3 };

// Query.

IEnumerable<string> query =

from rad in radii

select String.Format("Area = {0}", (rad * rad) * 3.14);

// Query execution.

foreach (string s in query)

Console.WriteLine(s);

// Keep the console open in debug mode.

Console.WriteLine("Press any key to exit.");

Console.ReadKey();

}

/* Output:

Area = 3.14

Area = 12.56

Area = 28.26

*/

Sinh viên thực hiện Nguyễn Văn Thụy & Hoàng Mạnh Giỏi

Trang 23

Đồ án kỹ sư II

Tìm hiểu công nghệ LINQ và ứng dụng

V.4.5 Loại các quan hệ trong thao tác truy vấn.

Để viết truy vấn có hiệu quả, bạn nên hiểu loại của các biến trong một truy vấn

như thế nào để hoàn tất tất cả các thao tác liên quan đến nhau. Nếu bạn hiểu được những

mối quan hệ, bạn sẽ dễ dàng hơn để lĩnh hội các ví dụ LINQ và đoạn code ví dụ trong tài

liệu hướng dẫn. Hơn nữa, bạn sẽ hiểu những gì xảy ra đằng sau những hiện trường khi

các biến được hoàn toàn phân loại cách sử dụng từ khóa var.

Thao tác truy vấn LINQ được phân loại rõ ràng trong nguồn dữ liệu, trong chính

câu truy vấn, và trong thực thi truy vấn. Các loại của các biến trong truy vấn phải tương

thích với các phần tử trong dữ liệu nguồn và với các loại của biến lặp trong câu lệnh

foreach. Điều này đảm bảo rằng các loại lỗi đều bị bắt lại tại thời điểm biên dịch khi đó

người ta có thể sửa lỗi đó trước khi nó được đưa vào làm ứng dụng.

Để giải thích các loại các mối quan hệ, hầu hết các ví dụ mà làm được sử dụng

kiểu rõ ràng cho tất cả các biến. Cuối cùng ví dụ cho thấy như thế nào cùng áp dụng một

nguyên tắc ngay cả khi bạn sử dụng từ khóa var.

V.5.6 Truy vấn mà không chuyển hóa các nguồn dữ liệu

Thí dụ minh họa sau đây cho thấy một câu truy vấn LINQ tới các đối tượng để

hoạt động mà không thực hiện chuyển đổi trên dữ liệu. Nguồn chứa một trình tự của

những chuỗi và giá trị đầu ra là một trình tự các chuỗi.

1. Các loại đối số của các nguồn dữ liệu xác định rõ loại miền của biến.

Sinh viên thực hiện Nguyễn Văn Thụy & Hoàng Mạnh Giỏi

Trang 24

Đồ án kỹ sư II

Tìm hiểu công nghệ LINQ và ứng dụng

2. Câu lệnh select sẽ trả về thuộc tính Name thay vì hoàn thành đối tượng Customer. Bởi

vì Name vì là một chuỗi, các kiểu đối số của custNameQuery là chuỗi, không phải

Customer.

3. Bởi vì custNameQuery là một trình tự các chuỗi, biến của vòng lặp foreach cũng phải

là một chuỗi.

Thí dụ sau đây cho thấy một sự chuyển đổi hơi phức tạp hơn. Câu lệnh select trả về một

kiểu nặc danh loại mà chỉ cần lưu giữ được hai thành viên của các đối tượng Customer

gốc.

V.5.7 Trình biên dịch phải suy luận ra các loại thông tin

Mặc dù bạn nên tìm hiểu những loại các mối quan hệ trong một hoạt động truy vấn, bạn

không có tuỳ chọn để cho phép trình biên dịch làm tất cả các công việc cho bạn. Các từ

khóa var có thể được sử dụng cho bất kỳ biến cục bộ nào trong một thao tác truy vấn.

động. Thí dụ sau đây là ví dụ chính xác tương đương với ví dụ số 2 đã được thảo luận

phía trên. Sự khác nhau duy nhất là trình biên dịch sẽ được cung cấp kiểu rõ ràng cho mỗi

biến trong hoạt động truy vấn:

Sinh viên thực hiện Nguyễn Văn Thụy & Hoàng Mạnh Giỏi

Trang 25

Đồ án kỹ sư II

Tìm hiểu công nghệ LINQ và ứng dụng

V.6 Cú pháp truy vấn vs cú pháp phương thức.

Nói chung, chúng tôi khuyên bạn nên sử dụng cú pháp truy vấn vì nó thường là

đơn giản hơn và hay hơn; tuy nhiên ở đây không có sự khác biệt giữa cú pháp truy vấn và

cú pháp phương thứ. Ngoài ra, một số truy vấn, chẳng hạn như việc truy lục các phần tử

phù hợp với một điều kiện xác định, hầu hết các truy vấn trong LINQ giới thiệu trong tài

liệu hướng dẫn được viết thành văn bản là biểu thức truy vấn bằng cách sử dụng cú pháp

truy vấn có tính tuyên bố được giới thiệu trong C # 3.0. Tuy nhiên,.NET runtime ngôn

ngữ chung(CRL_Common Language Runtime) không có ý niệm của cú pháp truy vấn

trong chính nó. Vì vậy, tại thời điểm biên dịch, biểu thức truy vấn là thông dịch gì đó mà

CRL, không hiểu: gọi các phương thức. Các phương thức này được gọi là toán tử truy

vấn chuẩn, và chúng có các tên như Where, Select, GroupBy, Join, Max, Average và

như vậy trên. Bạn có thể gọi chúng trực tiếp bằng cách sử dụng cú pháp phương thức các

cú pháp truy vấn. Truy lục các phần tử có giá trị tối đa trong một mã nguồn trình tự, chỉ

có thể được thể hiện như các lần gọi phương thức. Các tài liệu tham khảo cho biểu thức

truy vấn chuẩn trong namespace System.Linq bởi hầu hết mọi người sử dụng cú pháp

phương thức. Vì vậy, ngay cả khi bắt đầu viết truy vấn LINQ, nó rất hữu ích để làm quen

với cách sử dụng cú pháp phương thức trong truy vấn và toán tử thức truy vấn.

V.6.1 Toán tử truy vấn chuẩn mở rộng các phương thức

Ví dụ sau cho thấy một cách dễ dàng biểu thức truy vấn và các ngữ nghĩa tương đương

truy vấn được viết như là một phương thức dựa trên truy vấn.

Sinh viên thực hiện Nguyễn Văn Thụy & Hoàng Mạnh Giỏi

Trang 26

Đồ án kỹ sư II

Tìm hiểu công nghệ LINQ và ứng dụng

class QueryVMethodSyntax

{

static void Main()

{

int[] numbers = { 5, 10, 8, 3, 6, 12};

//Query syntax:

IEnumerable<int> numQuery1 =

from num in numbers

where num % 2 == 0

orderby num

select num;

//Method syntax:

IEnumerable<int> numQuery2 = numbers.Where(num => num % 2 == 0).OrderBy(n =>

n);

foreach (int i in numQuery1)

{

Console.Write(i + " ");

}

Console.WriteLine(System.Environment.NewLine);

foreach (int i in numQuery2)

{

Console.Write(i + " ");

}

// Keep the console open in debug mode.

Console.WriteLine(System.Environment.NewLine);

Console.WriteLine("Press any key to exit");

Console.ReadKey();

}

/*

Output:

6 8 10 12

*/

Đầu ta từ hai ví dụ là giống hệt nhau. Bạn có thể thấy rằng các loại của biến truy

vấn biến là cùng một trong hai hình thức: IEnumerable (T).

Để tìm hiểu phương thức dựa trên câu truy vấn, hãy kiểm tra nó chặt chẽ hơn. Ở

bên phải của biểu thức, chú ý rằng chú ý rằng mệnh đề where giờ đây không còn được

thể hiện như là một phương thức dụ trên đối tượng numbers, mà là bạn sẽ gọi lại một loại

kiểu IEnumerable<int> . Nếu bạn là quen thuộc với giao diện IEnumerable (T), bạn biết

rằng nó không có một phương thức where. Tuy nhiên, nếu bạn gọi trình hỗ trợ thông

minh hoàn thành danh sách trong Visual Studio IDE, bạn sẽ thấy không chỉ là một

phương thức where, nhưng nhiều phương thức khác như: select, SelectMany, Join, và

Orderby. Đây là tất cả các toán tử truy vấn chuẩn.

Sinh viên thực hiện Nguyễn Văn Thụy & Hoàng Mạnh Giỏi

Trang 27

Đồ án kỹ sư II

Tìm hiểu công nghệ LINQ và ứng dụng

Mặc dù nó có vẻ như nếu giao diện IEnumerable (T) đã được định nghĩa lại để bổ

xung các phương thức này, trên thực tế cái này không phải là cách. Các toán tử truy vấn

chuẩn được thực hiện như là một loại phương thức mới được gọi là các phương thức mở

rộng. Các phương thức mở rộng " extend " một loại hiện có; chúng có thể được gọi là nếu

chúng đã được thể hiện các phương thức dựa trên kiểu. Toán tử truy vấn chuẩn mở rộng

interface IEnumerable (T) và đó là lý do tại sao, bạn có thể viết numbers.Where (...).

Để bắt đầu sử dụng LINQ, bạn phải chắc chắn rằng bạn thực sự hiểu tất cả về các

phương thức mở rộng là làm thế nào để đem chúng vào trong phạm vi ứng dụng của bạn

bằng cách sử dụng đúng hướng dẫn. Điều này được giải thích thêm trong phần làm thế

nào để: Tạo một dự án LINQ.

V.6.2 Biểu thức Lambda

Trong ví dụ trước, chú ý rằng các biểu thức điều kiện (num% 2 == 0) là thông qua

như là một trong những đối số của phương thức where: Where (num => num% 2 == 0).

Biểu thức trong ngoặc được được gọi là biểu thức lambda. Đó là một phương thức nặc

danh có thể chứa đựng những biểu thức và các phát biểu và có thể sử dụng để tạo một ủy

nhiệm chung hoặc một biểu thức cây. Trong C # => là toán tử lambda, được đọc như

"goes to". Các num bên trái của các toán tử là yếu tố đầu vào biến đó tương ứng với num

trong biểu thức truy vấn. Trình biên dịch có thể nhận kiểu num bởi vì nó biết rằng

numbers là một kiểu chung IEnumerable (T). Toán tử lambda chỉ giống như các biểu

thức trong cú pháp truy vấn hay trong biểu thức C # hoặc câu lệnh; nó có thể bao gồm cả

Sinh viên thực hiện Nguyễn Văn Thụy & Hoàng Mạnh Giỏi

Trang 28

Đồ án kỹ sư II

Tìm hiểu công nghệ LINQ và ứng dụng

các lần gọi phương thức và các phương thức logic phức tạp. The "trả về giá trị" chỉ là các

biểu thức kết quả.

Để bắt đầu sử dụng LINQ, bạn không sử dụng lambdas nhiều. Tuy nhiên, một số

truy vấn chỉ có thể được thể hiện trong cú pháp phương thức và một số yêu cầu của

những biểu thức lambda. Sau khi bạn trở nên quen thuộc với lambdas, bạn sẽ thấy rằng

nó là một công cụ mạnh mẽ và linh hoạt trong LINQ của bạn.

Trong doạn mã ví dụ trước, không phải phương thức OrderBy là dẫn chứng bằng

cách sử dụng dấu chấm để gọi tới where. Where đưa ra trình tự lọc, và sau đó Orderby

có tác dụng sắp xếp trình tự đó. Bởi vì các truy vấn trở trả về một IEnumerable, bạn

soạn chúng trong cú pháp phương thức xích các lần gọi phương thức lại với nhau. Đây là

những gì trình biên dịch làm ở dăng sau hiện trường khi bạn viết truy vấn bằng cách sử

dụng cú pháp truy vấn. Và bởi vì một truy vấn biến không lưu trữ các kết quả của câu

truy vấn, bạn có thể thay đổi nó hay sử dụng nó như là cơ sở cho một truy vấn mới bất kỳ

lúc nào, ngay cả sau khi nó đã được thực hiện.

V.7 Các đặc trưng được LINQ hỗ trợ trong C#3.0

Dưới đây là những phần giới thiệu những ngôn ngữ mới xây dựng trong C # 3.0.

Mặc dù các tính năng mới tất cả đều được sử dụng đến một mức độ với các truy vấn

LINQ, chúng không giới hạn đối với LINQ và có thể được sử dụng trong bối cảnh bất cứ

nơi bạn tìm thấy chúng hữu ích.

V.7.1 Biểu thức truy vấn.

Biểu thức truy vấn sử dụng cú pháo khai báo tương tự với SQL hay XQuery để

truy vấn trên tập hợp IEnumerable. Tại thời điểm biên dịch cú pháp truy vấn là phương

thức gọi đến một nhà cung cấp LINQ của việc triển khai thực hiện của toán tử truy vấn

chuẩn các phương thức mở rộng. Ứng dụng kiểm soát các toán tử biểu thức truy vấn

chuẩn trong namespace thích hợp với một chỉ dẫn using. Dưới đây là một biểu thức truy

vấn chuẩn làm cho một mảng các chuỗi, nhóm chúng theo ký tự đầu tiên trong chuỗi, và

phân loại chúng thành một nhóm.

var query = from str in stringArray

Sinh viên thực hiện Nguyễn Văn Thụy & Hoàng Mạnh Giỏi

Trang 29