1. Mục lục - dulieu.tailieuhoctap.vndulieu.tailieuhoctap.vn/books/cong-nghe-thong-tin/lap-trinh-ung-dung/... · phép các nhà phát triển xây dựng các ứng dụng hướng

Bài 1

GIỚI THIỆU TỔNG QUAN VỀ

WINDOWS COMMUNICATION FOUNDATION

1. Mục lục

2. Windows Communication Foundation (WCF) là gì? ........................................................................................ 2

3. Tại sao sử dụng WCF? ...................................................................................................................................... 2

4. Kiến trúc của WCF ............................................................................................................................................ 3 4.1 Các contracts (Các hiệp nghị) ....................................................................................................3

4.2 Runtime service (Dịch vụ thực thi) ...............................................................................................4

4.3 Message (Bản tin) .........................................................................................................................5

4.4 Host and activation (Chứa và kích hoạt) ......................................................................................5

5. Các tính năng của WCF ..................................................................................................................................... 6 5.1 Transaction (Giao dịch) ................................................................................................................6

5.2 Host (Chứa) ..................................................................................................................................6

5.3 Bảo mật .........................................................................................................................................6

6. Công cụ phát triển với WCF .............................................................................................................................. 7

7. Ví dụ đầu tiên với WCF ..................................................................................................................................... 7

8. Sử dụng công cụ WCF Test Client để debug dịch vụ WCF ............................................................................ 13

9. Tài liệu tham khảo ........................................................................................................................................... 15

Microsoft Vietnam – DPE Team | Bài 1: Giới thiệu tổng quan về WCF 2

Bài này giới thiệu tổng quan về công nghệ Windows Communication Foundation

(WCF). Phần đầu nói về những công nghệ đã được triển khai trên thế giới nhằm giải quyết vấn

đề liên lạc giữa máy tính với máy tinh và những khó khăn thách thức trong việc triển khai các

công nghệ trên. Từ đó dẫn đến sự ra đời của công nghệ nền tảng WCF, là nền tảng thống nhất

cho việc xây dựng nhanh các ứng dụng cần giao tiếp. Sau đó sẽ giới thiệu cơ bản về kiến trúc

của WCF, những thành phần hợp thành WCF. Phần cuối sẽ giới thiệu các công cụ cần thiết để

xây dựng ứng dụng với WCF cùng với một ví dụ đơn giản với WCF để học viên dễ hình dung.

2. Windows Communication Foundation (WCF) là gì?

WCF là công nghệ nền tảng nhằm thống nhất nhiều mô hình lập trình giao tiếp được hỗ

trợ trong .NET 2.0 thành một mô hình duy nhất. Vào tháng 11 năm 2005, .NET 2.0 được

Microsoft phát hành trong đó có cung cấp các hàm API riêng biệt cho các liên lạc dựa trên

SOAP để tối đa hoá sự làm việc giữa các nền tảng sử dụng Web Services, đồng thời .NET 2.0

còn cung cấp các API để tối ưu việc liên lạc dựa trên mã nhị phân giữa các ứng dụng chạy trên

hệ thống Windows gọi là .NET Remoting, các API cho các giao dịch phân tán, và API cho liên

lạc dị bộ. WCF thống nhất các API này thành một mô hình duy nhất nhằm đáp ứng mô hình lập

trình hướng dịch vụ.

WCF có thể sử dụng các bản tin SOAP giữa hai tiến trình, do đó làm cho các ứng dụng

dựa trên WCF có thể làm việc với các tiến trình khác thông qua việc giao tiếp sử dụng bản tin

SOAP. Khi một tiến trình WCF liên lạc với một tiến trình không là WCF, các bản tin SOAP

được mã hoá trên cơ sở XML, nhưng khi nó liên lạc với một tiến trình WCF khác, bản tin SOAP

có thể được tối ưu hoá dựa trên mã hoá nhị phân.

3. Tại sao sử dụng WCF?

Như phần trên đã trình bày, .NET 2.0 hỗ trợ rất nhiều phương pháp liên lạc giữa các ứng

dụng khác nhau nhằm vào các mục tiêu khác nhau. Các phương pháp liên lạc này khá phức tạp

và phải mất nhiều thời gian để làm chủ được công nghệ. Tuy nhiên kiến thức thu được từ việc

triển khai một phương pháp ít có khả năng dùng được khi làm việc với phương pháp khác.

Với việc ra đời của WCF, mọi phương pháp liên lạc trước kia đều có thể thực hiện trên

WCF. Do vậy nhà phát triển chỉ cần làm chủ được công nghệ WCF là có thể xây dựng các ứng

dụng một cách nhanh chóng.

WCF là một mô hình lập trình cho phép nhà phát triển xây dựng các giải pháp dịch vụ

đảm bảo tính ổn định, và bảo mật và thậm chí là đảm bảo giao dịch. Nó làm đơn giản hoá việc


phát triển các ứng dụng nối kết và đưa ra cho nhà phát triển những giá trị mà có thể họ chưa

nhận ra ngay, đó là cách tiếp cận phát triển hệ thống phân tán thống nhất, đơn giản, và quản lý

được.

Do WCF được xây dựng trên cơ sở của .NET Framework 2.0 CLR, nó là tập các lớp cho

phép các nhà phát triển xây dựng các ứng dụng hướng dịch vụ bằng môi trường lập trình quen

thuộc của họ như VB.NET hay C#

4. Kiến trúc của WCF

Hình sau mô tả các lớp chủ yếu trong kiến trúc của Windows Communication

Foundation (WCF)

Figure 1 Kiến trúc của WCF (hình ảnh từ www.microsoft.com)

4.1 Các contracts (Các hiệp nghị)

Các contract trong WCF cũng giống như các hợp đồng/hiệp định mà bạn ký trong đời

sống thật. Một hợp đồng bạn ký có thể chứa các thông tin như kiểu công việc bạn sẽ làm, và

những thông tin mà bạn muốn đưa ra cho các bên khác. WCF contract cũng chứa các thông tin

tương tự như vậy. Contract định nghĩa các đặc tả trong hệ thống bản tin.Thông thường có các

loại contract sau:


Contract dữ liệu mô tả các tham số cho các bản tin mà một dịch vụ có thể

tạo ra hay sử dụng. Các tham số bản tin được định nghĩa bằng các tài liệu sử dụng ngôn

ngữ đặc tả XML Schema (XSD), điều này cho phép các hệ thống hiểu XML có thể xử lý

tài liệu dễ dàng. Các dịch vụ khi liên lạc với nhau có thể không cần đồng ý với nhau về

các kiểu, nhưng cần đồng ý về contract dữ liệu, nghĩa là đồng ý về các tham số và các

kiểu trả về.

Contract bản tin định nghĩa các phần có trong bản tin sử dụng các giao

thức SOAP, và nó cho phép điều khiển sâu hơn tới các phần trong bản tin khi có yêu cầu

sự chính xác như vậy.

Contract dịch vụ đặc tả chi tiết các phương thức của dịch vụ, và được

phân phối như là một giao diện trong các ngôn ngữ lập trình như Visual Basic hay Visual

C#. Có thể hình dung về contract dịch vụ một cách gián tiếp như sau: „Đây là các kiểu dữ

liệu của các bản tin của tôi, đây là nơi tôi cung cấp, và đây là các giao thức mà tôi có thể

liên lạc”

Các chính sách và các kết nối (bindings) mô tả các điều kiện cần có để

giao tiếp với một dịch vụ. Các chính sách sẽ bao gồm cả các yêu cầu về bảo mật và các

điều kiện khác cần phải có khi kết nối với một dịch vụ.

4.2 Runtime service (Dịch vụ thực thi)

Lớp dịch vụ thực thi chứa các hành xử sẽ xảy ra trong quá trình thực hiện của dịch vụ,

nghĩa là các hành xử thực thi của dịch vụ. Ta sẽ thấy một số các hành xử như sau:

Throttling behavior: Điều khiển luồng nhằm quy định xem có bao nhiêu

bản tin được xử lý

Error behavior: Hành xử lỗi quy định những hành động khi lỗi xảy ra

trong hệ thống

Metadata behavior: Hành xử với các siêu dữ liệu quy định xem làm thế

nào và khi nào thì các siêu dữ liệu được đưa ra bên ngoài dịch vụ

Instance behavior: Hành xử thực thể quy định xem có bao nhiêu thực thể

của dịch vụ đó được chạy

Transaction behavior: Hành xử giao dịch cho phép việc rollback các

giao dịch nếu xảy ra lỗi


Message inspection: Kiểm tra bản tin đem lại cho dịch vụ khả năng kiểm

tra tất cả hay một số phần của bản tin

Dispatch behavior: Khi một bản tin được xử lý bởi nền tảng WCF, dịch

vụ Dispatch behavior xác định xem bản tin được xử lý như thế nào.

Concurrency behavior: Hành xử đồng thời xác định xem việc xử lý thế

nào với việc đa luồng của mỗi dịch vụ hay mỗi thực thể của dịch vụ. Hành xử này giúp

cho việc điều khiển số lượng luồng có thể truy nhập tới một thực thể của dịch vụ.

Parameter filtering: Khi một bản tin được đưa tới một dịch vụ, sẽ xảy ra

một số hành động dựa trên nội dung phần đầu đề của bản tin. Phần lọc tham số sẽ thực

hiện lọc các đầu đề bản tin và thực hiện các hành động đặt sẵn dựa trên việc lọc đầu đề

bản tin.

4.3 Message (Bản tin)

Lớp bản tin là tập hợp các kênh. Mỗi kênh là một thành phần xử lý bản tin theo một cách

nào đó. Một tập các kênh thường được gọi là ngăn xếp kênh. Các kênh làm việc trên bản tin và

trên đầu đề của bản tin. Lớp này khác với lớp thực thi dịch vụ chủ yếu bởi sự khác nhau trong

việc xử lý nội dung bản tin.

Có hai kênh khác nhau là kênh vận chuyển (transport channel) và kênh điều khiển

(control channel).

Kênh vận chuyển phụ trách việc đọc và ghi các bản tin từ mạng (network)

hoặc từ một số điểm giao dịch bên ngoài)

Kênh điều khiển thực hiện xử lý bản tin theo giao thức, thông thường làm

việc bằng cách đọc và ghi thêm các đầu đề cho bản tin.

4.4 Host and activation (Chứa và kích hoạt)

Nhìn một cách tổng thể thì một dịch vụ thực chất là một chương trình. Cũng giống như

các chương trình khác, một dịch vụ cần phải chạy trong một tệp thực thi. Dịch vụ này thường

được gọi là dịch vụ tự chứa.

Các dịch vụ còn có thể được chứa, hoặc chạy trong một tệp thực thi được quản lý bởi

một agent bên ngoài như IIS hay Windows Activation Services (WAS). WAS cho phép WCF

được kích hoạt một cách tự động khi phân phối tới một máy tính có chạy WAS.


5. Các tính năng của WCF

WCF có nhiều tính năng và sẽ được mô tả chi tiết trong toàn bộ khoá học. Mục này chỉ

nhằm mục đích thảo luận một số tính năng của WCF. Danh sách các tính năng ở đây không phải

là danh sách hoàn chỉnh, mà chỉ hy vọng là danh sách các tính năng “đỉnh” nhất.

5.1 Transaction (Giao dịch)

Một giao dịch là một đơn vị của công việc. Một giao dịch đảm bảo chắc chắn rằng mọi

thứ diễn ra trong giao dịch thành công hay thất bại đều là kết quả tổng thể. Ví dụ, nếu một giao

dịch chứa ba mục công việc cần thực hiện, trong quá trình thực hiện giao dịch, một trong số các

mục đó bị thất bại, khi đó cả ba mục sẽ là thất bại. Giao dịch chỉ thành công khi cả ba mục công

việc đều thành công. Giao dịch thường thấy trong các thao tác với cơ sở dữ liệu.

WCF cho phép đưa vào việc xử lý giao dịch như trên với các liên lạc. Nhà phát triển có

thể nhóm các liên lạc với nhau thành các giao dịch. Ở mức doanh nghiệp, tính năng này cho

phép bạn thực hiện các công việc giao dịch qua các nền tảng khác nhau.

5.2 Host (Chứa)

WCF cho phép các dịch vụ được chứa trong một số lớn các môi trường khác nhau, như

Windows NT Services, Windows Forms, và ứng dụng console, cũng như ở trên IIS (Internet

Information Server) và WAS (Windows Activation Services).

Chứa ứng dụng trên IIS còn có thêm các lợi điểm khác là dịch vụ có thể nhận các ưu

điểm của rất nhiều tính năng có sẵn trên IIS, ví dụ IIS có thể điều khiển một cách tự động việc

bắt đầu hay kết thúc một dịch vụ.

5.3 Bảo mật

Bảo mật là tính năng không thể thiếu trong WCF nói riêng và trong liên lạc nói chung.

Trong WCF, tất cả mọi thứ từ các bản tin tới các client hay server đều phải xác thực và WCF có

tính năng để đảm bảo rằng các bản tin không bị lẫn trong quá trình vận chuyển. WCF bao gồm

việc đảm bảo tính toàn vẹn và bảo mật của bản tin.

WCF còn cho phép bạn tích hợp ứng dụng của bạn với cơ sở hạ tầng bảo mật sẵn có, bao

gồm cả các chuẩn bên ngoài môi trường Windows bằng cách sử dụng các bản tin SOAP bảo

mật.


6. Công cụ phát triển với WCF

Để phát triển ứng dụng với WCF ta cần các phần mềm sau:

.NET Framework 3.5. Học viên có thể tải về bộ cài của .NET

Framework 3.5 tại trang web của Microsoft. Địa chỉ như sau:

http://www.microsoft.com/downloads/details.aspx?familyid=ab99342f-5d1a-413d-8319-

81da479ab0d7&displaylang=en

Microsoft Visual Studio 2008. Bản dùng thử có thể tải về ở đây:

http://msdn.microsoft.com/en-us/visualc/aa700831.aspx

Hoặc Microsoft Visual Studio Express Editions. Địa chỉ tải về:

http://www.microsoft.com/express/

7. Ví dụ đầu tiên với WCF

Xây dựng ứng dụng viết chữ Hello World ra màn hình sử dụng WCF. Các bước làm việc

như sau:

1. Mở Visual Studio 2008, chọn Create New Project, trong phần WCF chọn

WCF Service Library như hình dưới. Đặt tên project là HelloService.


Figure 2Tạo WCF project

2. Sau khi project được tạo ra, xoá 2 tệp IService1.cs và Service1.cs. Đồng

thời làm sạch tệp app.config thành như sau:

<?xml version="1.0" encoding="utf-8" ?>

<configuration>

<system.web>

<compilation debug="true" />

</system.web>

<system.serviceModel>

<services>

</services>

<behaviors>

</behaviors>

</system.serviceModel>

</configuration>


3. Kích chuột phải vào project HelloService, chọn “Add New Item”. Sau

đó chọn thêm một WCF Service, đặt tên nó là HelloWorld như hình dưới. Hệ thống sẽ

thêm vào 2 tệp cho bạn:

Figure 3Thêm HelloWorld service

a. Tệp IHelloWorld.cs chứa một giao diện gọi là IHelloWorld, đây là

contract cho dịch vụ của bạn. Thay hàm DoWork thành SayHello như sau:

[ServiceContract]

public interface IHelloWorld

{

[OperationContract]

string SayHello(string inputName);

}

b. Tệp HelloWorld.cs, chứa lớp gọi là HelloWorld, lớp này sẽ cài đặt

contract cho dịch vụ của bạn. Thay hàm DoWork thành SayHello như sau:

public class HelloWorld : IHelloWorld

{

#region IHelloWorld Members

public string SayHello(string inputName)


{

return "Chào bạn " + inputName;

}

#endregion

}

Khi thực hiện cài đặt một dịch vụ WCF, thông thường bạn định nghĩa phần giao

diện trước (các interface) sau đó mới thực hiện thông qua một lớp để cài đặt giao diện

đó. Bạn hoàn toàn có thể làm bằng tay để viết lại phần khai báo các phương thức đã có

trong giao diện. Tuy vậy, có một cách nhanh hơn giúp bạn khai báo các phương thức

cũng như thuộc tính của giao diện bằng Visual Studio. Cách làm như sau:

Bước 1. Mở file chứa class cần cài đặt. Di chuyển con trỏ tới tên giao diện như

hình dưới

Figure 4 Di chuyển con trỏ tới tên giao diện

Bước 2. Bấm chuột vào hình chữ nhật nhỏ dưới chữ IHelloWorld (giống smart

tag trong Microsoft Word), xem hình dưới

Figure 5 Kích hoạt SmartTag


Bước 3. Mở menu popup và chọn một trong 2 mục.

Figure 6 Chọn mục menu để cài đặt giao diện

Kết quả. Sau khi chọn một mục menu ta sẽ được kết quả như hình dưới.

Figure 7 Kết quả

Như các bạn đã thấy, sử dụng tính năng này của Visual Studio cho phép chúng ta

thực hiện tạo nhanh các khai báo cần thiết để cài đặt giao diện.

4. Vậy là chúng ta đã có một dịch vụ hoàn chỉnh. Bấm F5 để chạy. Visual

Studio sẽ tự động gọi chương trình WCF Test Client (là chương trình client để test dịch

vụ của WCF). Xem hình dưới.


Figure 8 WCF Test Client

5. Chuyển tới phương thức SayHello, đưa vào tham số, giả sử là tên của bạn,

sau đó bấm nút Invoke. Kết quả xem hình dưới.


Figure 9 Kết quả thực thi dịch vụ HelloWorld

8. Sử dụng công cụ WCF Test Client để debug dịch vụ WCF

Công cụ WCF Test Client có thể được kích hoạt theo 2 cách.

Cách thứ nhất như các bạn đã thấy ở ví dụ trên. Công cụ này được kích

hoạt một cách tự động khi ta thực hiện debug một WCF Service Library.

Cách thứ 2 là chạy trực tiếp và thêm vào các dịch vụ cần debug. Cách này

thông thường hay sử dụng để debug dịch vụ khi host dịch vụ bởi IIS. Công cụ WCF Test

Client có thể tìm thấy ở thư mục sau:

C:\Program Files\Microsoft Visual Studio 9.0\Common7\IDE\WcfTestClient.exe

Khi kích hoạt trực tiếp WCF Test Client, sẽ thấy màn hình khởi động như sau:


Figure 10 Màn hình khởi động của WCT Test Client

Bấm chuột phải vào My Service Projects, bạn có thể thêm vào các dịch vụ WCF để thực

hiện debug


Figure 11 Thêm một dịch vụ vào WCF Test Client

Màn hình dưới đây là ví dụ thêm vào một dịch vụ được host trên IIS

Figure 12 Thêm vào một dịch vụ được host trên IIS

9. Tài liệu tham khảo

1. Windows Communication Foundation (http://msdn.microsoft.com/en-

au/library/ms735119.aspx)

2. What Is Windows Communication Foundation?

(http://msdn.microsoft.com/en-us/library/ms731082.aspx)


3. Windows Communication Foundation

(http://en.wikipedia.org/wiki/Windows_Communication_Foundation)

4. Writing the WCF Hello World App (http://blah.winsmarts.com/2008-4-

Writing_the_WCF_Hello_World_App.aspx)

Bài 2

MÔ HÌNH LẬP TRÌNH VỚI


Mục lục

1 Mô hình lập trình WCF ..................................................................................................................................... 2 1.1 Sử dụng phương pháp hướng đối tượng hay hướng dịch vụ? .......................................................2 1.2 Service Model (Mô hình dịch vụ) .................................................................................................4 1.3 Các phương pháp lập trình với WCF ............................................................................................6

1.3.1 Declarative programming (Phương pháp khai báo) ..............................................................6

1.3.2 Explicit programming (Phương pháp lập trình trực tiếp) .....................................................7

1.3.3 Phương pháp sử dụng tập tin cấu hình ..................................................................................7

2 Xây dựng một dịch vụ WCF .............................................................................................................................. 9 2.1 Cài đặt WCF .................................................................................................................................9

2.1.1 .NET Framework 3.5 SP1 .....................................................................................................9

2.1.2 Visual Studio 2008 SP1 ........................................................................................................9

2.2 Tạo dịch vụ WCF đầu tiên của bạn...............................................................................................9 2.2.1 Tạo ứng dụng phía server .....................................................................................................9

2.2.2 Phát hành thông tin về dịch vụ ...........................................................................................18

2.2.3 Tạo ứng dụng phía client ....................................................................................................23

2.3 Cách khác để tạo tham chiếu ở client .........................................................................................25

3 Câu hỏi ôn tập .................................................................................................................................................. 27

4 Tài liệu tham khảo ........................................................................................................................................... 28

Microsoft Vietnam – DPE Team | Bài 2: Mô hình lập trình với WCF 2

Nhìn lướt qua thì thấy rằng WCF có vẻ rối rắm phức tạp. Tuy nhiên nếu bạn hiểu về WSDL (Web

Service Description Language) và về Web services (các dịch vụ web), thì việc nắm được các khái niệm

trong WCF rất đơn giản. Nhưng nếu không quen về các khái niệm trên, để hiểu được khái niệm trong

WCF thông qua bài trước quả là một việc hơi quá sức, do WCF có quá nhiều lớp và thành phần.

Tuy vậy, WCF hay ở chỗ là nó đem đến một mô hình lập trình và dịch vụ rất đơn giản. Mặc dù nền

tảng bên dưới cho WCF tương đối lớn, WCF được xây dựng trên cơ sở .NET Framework do đó bạn có

thể sử dụng ngôn ngữ lập trình và nền tảng quen thuộc để làm việc với nó. Thêm nữa, khi phát triển các

dịch vụ với WCF bạn chỉ cần biết cách sử dụng một phần của các lớp đó mà thôi. Cách tốt nhất để học

cách phát triển các dịch vụ với WCF là làm việc trực tiếp với nó. Bài này giới thiệu với các bạn mô hình

lập trình với WCF, đồng thời hướng dẫn các bạn xây dựng một dịch vụ WCF đầu tiên.

1 Mô hình lập trình WCF

1.1 Sử dụng phương pháp hướng đối tượng hay hướng dịch vụ?

Nếu các bạn đã học qua môn học về các phương pháp lập trình hẳn sẽ thấy có 2 phương pháp chính

là hướng thủ tục và hướng đối tượng. Và phương pháp hướng đối tượng trong thời gian gần đây được

phát triển rất mạnh và được hỗ trợ ngay trong các ngôn ngữ lập trình như C# hay VB.NET. Khi làm việc

với các dịch vụ web bạn đã làm quen với một phương pháp nữa là lập trình hướng dịch vụ (Service-

oriented programming). Microsoft đã cung cấp nhiều công cụ trên .NET Framework để hỗ trợ phương

pháp lập trình này thông qua các lớp trong không gian tên: System.Web.Services.

Như vậy khi làm việc với WCF bạn có hai lựa chọn là hướng đối tượng và hướng dịch vụ. Vậy ta

nên sử dụng phương pháp nào? Câu trả lời là dùng cả hai. Nói một cách đơn giản là phương pháp hướng

đối tượng được sử dụng để phát triển các ứng dụng trên desktop, còn phương pháp hướng dịch vụ được

sử dụng để kết nối các ứng dụng đó với nhau. Điều quan trọng ở đây là làm sao để hiểu được sự khác

nhau giữa hai phương pháp và hiểu được khi nào chúng được sử dụng và sử dụng như thế nào đồng thời

cũng phải hiểu về các lợi ích chúng cung cấp.

Về hướng đối tượng có thể hiểu như sau. Các ứng dụng hướng đối tượng là hai hay nhiều lớp phụ

thuộc lẫn nhau và chia sẻ chung các kiểu dữ liệu. Những lớp này liên lạc với nhau thông qua các lời gọi

các hàm mà lớp đối tượng cung cấp.

Các ứng dụng hướng dịch vụ là các chương trình không biết gì về nhau. Mỗi ứng dụng liên lạc với

ứng dụng khác thông qua các bản tin. Điểm đặc biệt là các bản tin này được gửi từ một ứng dụng sang

ứng dụng khác mà không quan tâm tới nền tảng mà dịch vụ đang chạy.

Khi phát triển các dịch vụ WCF, điều quan trọng là cần hiểu sự liên kết giữa hướng đối tượng và

hướng dịch vụ. Khi làm việc với .NET Framework bạn chắc chắn rất quen thuộc với thuật ngữ lớp (class)


và giao diện (interface). Các thuật ngữ này vẫn được sử dụng khi phát triển dịch vụ WCF. Các lớp và

giao diện là phần hướng đối tượng trong WCF, còn phần hướng dịch vụ trong WCF sẽ được thấy khi bạn

đưa vào các thuộc tính WCF để định nghĩa các thực thể.

Ví dụ, lớp sau đây định nghĩa một giao diện hướng đối tượng

public interface DichVuBanHang

{

decimal TinhGiaVanChuyen(string diachi, decimal trongluong)

{

// thực hiện tính toán

}

decimal TinhTienThue(decimal tongGiaTien)

{


}

}

Ta sẽ có phần hướng dịch vụ cho dịch vụ WCF khi thêm vào các thuộc tính cho giao diện ở trên

[ServiceContract]

public interface DichVuBanHang

{

[OperationContract]

decimal TinhGiaVanChuyen(string diachi, decimal trongluong)

{


}

[OperationContract]

decimal TinhTienThue(decimal tongGiaTien)

{


}

}

Như vậy là qua ví dụ trên các bạn có thể thấy mối liên kết giữa phương pháp hướng đối tượng và

hướng dịch vụ trong WCF. Các bạn chưa cần quan tâm tới các thuộc tính [ServiceContract] và

[OperationContract] vội, bởi vì những thuộc tính này, và còn nhiều thứ khác nữa sẽ được giới thiệu một

cách chi tiết khi thích hợp.


1.2 Service Model (Mô hình dịch vụ)

Nếu bạn đã từng làm việc với dịch vụ web, bạn sẽ thấy mô hình này quen thuộc với bạn theo một

cách nào đó. Khi bạn tạo một dịch vụ web, bạn thực sự tạo ra một dịch vụ (service). Dịch vụ web chứa

một tài liệu XML để mô tả tất cả mọi thứ cần biết về dịch vụ đó. Tài liệu này được mô tả bằng ngôn ngữ

Web Service Description Language (ngôn ngữ mô tả dịch vụ web). Nó chứa ba phần:

Service (dịch vụ): Chứa thông tin về vị trí của dịch vụ

Binding: Chứa thông tin về cách liên lạc với dịch vụ, như dịch vụ sử dụng giao thức gì,

vv.

PortType (kiểu cổng): Giải thích về dịch vụ sẽ làm gì

Mô hình dịch vụ trên WCF cũng tương tự như với mô hình dịch vụ web. Điểm khác biệt là ở cách

đặt tên. Trong WCF các phần không được gọi là service, binding, và portType mà được gọi tương ứng là

address (địa chỉ), binding, và contract.

Mô hình dịch vụ WCF được cung cấp trong không gian tên System.ServiceModel. Không gian tên

này chứa rất nhiều lớp, nhưng bạn hoàn toàn không cần biết toàn bộ chúng. Để sử dụng mô hình và xây

dựng dịch vụ, ta thường sử dụng một số lớp sau:

Lớp Mô tả

BasicHTTPBinding Là binding mà các điểm cuối dịch vụ có thể sử dụng để liên lạc

với các ứng dụng khách và dịch vụ web (ASMX)

NetMsmqBinding Là binding mà các điểm cuối dịch vụ có thể sử dụng để liên lạc

với các MSMQ khách và các dịch vụ khác

NetNamedPipeBinding Là binding mà các điểm cuối dịch vụ có thể sử dụng để liên lạc

với các ứng dụng khách/dịch vụ trên cùng một máy

NetTCPBinding Là binding mà các điểm cuối dịch vụ có thể sử dụng để liên lạc

với các ứng dụng khách/dịch vụ ở các máy khác nhau

WSHTTPBinding Là binding mà các điểm cuối dịch vụ có thể sử dụng để liên lạc

với các ứng dụng khách/dịch vụ sử dụng các giao dịch phân tán và

các phiên làm việc bảo mật và tin cậy được.

EndpointAddress Lớp biểu diễn địa chỉ duy nhất được cung cấp và truy xuất được


cho máy khách để liên lạc với điểm cuối dịch vụ

EndpointAddressBuilding Là phương pháp để tạo mới các địa chỉ đầu cuối với các giá trị

tham số xác định

ChannelFactory Là phương pháp trong đó các kiểu kênh khác nhau được tạo ra

và quản lý, và đưa tới cho các ứng dụng khách để gửi bản tin tới các

điểm cuối

Identity Cách mà một định danh được xác định, cho phép xác thực giữa

các điểm cuối khi trao đổi bản tin

MessageHeader Biểu diễn nội dung của một đầu đề bản tin SOAP

ServiceHost Phương pháp cung cấp vật chứa cho các dịch vụ

ReliableSession Cung cấp truy xuất tới các thuộc tính của thành phần binding

trong phiên làm việc tin cậy.

Để định nghĩa việc liên lạc của dịch vụ, ta thường hay sử dụng các lớp sau

Lớp Mô tả

AddressHeader Phần đầu đề chưa thông tin địa chỉ được sử dụng để xác định và

liên lạc với một điểm cuối

AddressHeaderCollection Một tập hợp các đầu đề địa chỉ

Binding Tập hợp các thành phần binding, mỗi binding định nghĩa cách

mà một điểm cuối liên lạc với thế giới bên ngoài

BindingContext Cung cấp địa chỉ và thông tin binding cần thiết cho việc xây

dựng kênh

BindingElement Biểu diễn một thành phần binding, được sử dụng để xây dựng

các binding

CustomBinding Sử dụng để định nghĩa và xây dựng một tuỳ biến binding từ một

tập các thành phần binding

Message Một đơn vị của liên lạc giữa các điểm cuối


MessageHeader Nội dung của đầu đề bản tin SOAP

MessageHeaders Tập hợp các đầu đề bản tin

1.3 Các phương pháp lập trình với WCF

Có một số phương pháp lập trình với WCF, mỗi phương pháp có ưu điểm và khuyết điểm riêng của

nó. Điều đặc biệt về WCF là luôn có hơn một cách để giải quyết một vấn đề trong WCF, và bạn không

nhất thiết phải chọn duy nhất một phương pháp nào. Trong thực tế, cách làm tốt nhất là tổ hợp các

phương pháp để có được sự linh hoạt và mềm dẻo cho dịch vụ của bạn.

Có ba phương pháp hay được sử dụng khi phát triển dịch vụ WCF như sau:

Phương pháp khai báo

Phương pháp lập trình trực tiếp

Phương pháp sử dụng tập tin cấu hình

1.3.1 Declarative programming (Phương pháp khai báo)

Lập trình khai báo đạt được thông qua các thuộc tính. Những thuộc tính này được sử dụng để định

nghĩa các contract và xác định hành xử của dịch vụ. Chúng được sử dụng để xác định thêm các tham số

để thay đổi các chi tiết của contract và hành xử dịch vụ.

Thuộc tính ServiceContract dùng để quy định là giao diện này định nghĩa các chức năng của

một dịch vụ. Thuộc tính OperationContract được sử dụng ở các hàm để quy định rằng hàm này

được khai báo là một phần của dịch vụ. Đó là tất cả những gì cần để tạo ra một dịch vụ WCF.

Thêm nữa, bạn không nhất thiết phải sử dụng các giao diện (interface) khi cài đặt một dịch vụ, điều

này cũng giống như việc bạn không cần phải sử dụng giao diện để định nghĩa một lớp. Tuy vậy bạn nhất

thiết phải quy định phần nào thuộc về dịch vụ. Bạn có thể định nghĩa những phần khác cần cho giao diện,

nhưng chỉ những hàm (phương thức) có gắn thuộc tính [OperationContract].

Ví dụ ta có một dịch vụ thực hiện phép tính cộng giữa 2 số nguyên AddInt và 2 số thực

AddDouble. Ta khai báo dịch vụ như sau:

[ServiceContract]

public interface ICalcService

{

[OperationContract]

int AddInt(int x, int y);


[OperationContract]

double AddDouble(double x, double y);

}

Như vậy dịch vụ của chúng ta sau khi khai báo sẽ có 2 phương thức (khai báo với thuộc tính

OperationContract) là AddInt và AddDouble. Tuy nhiên khi khai báo trong C#, việc đặt tên

AddInt và AddDouble, và có thể có một số hàm add cho các kiểu dữ liệu khác, có thể rút gọn lại

thành một tên hàm Add mà thôi. Nhưng các dịch vụ lại không cho phép đặt trùng tên hàm như thế.

Chúng ta có thể khai báo thêm với thuộc tính OperationContract để thực hiện, cách làm như sau:

[ServiceContract]

public interface ICalcService

{

[OperationContract(Name="AddInt")]

int Add(int x, int y);

[OperationContract(Name="AddDouble")]

double Add(double x, double y);

}

Các bạn có thể thấy là chúng ta sử dụng được phép nạp chồng tên trong C# và sử dụng thêm tham số

Name để quy định thêm tên hàm ở dịch vụ. Ngoài ưu điểm trong việc giải quyết nạp chồng tên hàm, ta

còn thấy một lợi ích khác nữa là, việc quy định tham số Name trong thuộc tính OperationContract

còn cho ta thêm linh hoạt trong việc đổi tên các hàm trong giao diện mà không làm thay đổi định nghĩa

dịch vụ, nghĩa là các ứng dụng khác sử dụng dịch vụ này không cần phải biên dịch lại.

1.3.2 Explicit programming (Phương pháp lập trình trực tiếp)

Là phương pháp lập trình hướng đối tượng, bạn làm việc trực tiếp với các lớp và giao diện cung cấp

bởi mô hình đối tượng của WCF. Làm việc trực tiếp với mô hình đối tượng cho phép nhà phát triển tính

linh hoạt cao hơn và khả năng điều khiển tốt hơn thông qua mã nguồn của họ. Thêm nữa nó cho phép

điều khiển sâu hơn rất nhiều so với phương pháp khai báo và phương pháp sử dụng tập tin cấu hình.

1.3.3 Phương pháp sử dụng tập tin cấu hình

Cũng giống như phương pháp khai báo, có rất nhiều thứ mà bạn có thể quy định liên quan đến hành

xử của một dịch vụ thông qua tập tin cấu hình của dịch vụ. Điều hay trong cách tiếp cận này là những

thay đổi ở tập tin cấu hình hoàn toàn không cần phải biên dịch lại dịch vụ mới sử dụng được.

Sau đây là ví dụ sử dụng tập tin cấu hình để định nghĩa dịch vụ tính toán trong ví dụ của phần

phương pháp khai báo.



<configuration>

<system.web>


</system.web>


<services>

<service

behaviorConfiguration="CalculationService.CalcServiceBehavior"

name="CalculationService.CalcService">

<endpoint address="" binding="wsHttpBinding"

contract="CalculationService.ICalcService">

<identity>

<dns value="localhost" />

</identity>

</endpoint>

<endpoint address="mex" binding="mexHttpBinding"

contract="IMetadataExchange" />

<host>

<baseAddresses>

<add baseAddress="http://localhost:8731/CalcService/" />

</baseAddresses>

</host>

</service>

</services>

<behaviors>

<serviceBehaviors>

<behavior name="CalculationService.CalcServiceBehavior">

<serviceMetadata httpGetEnabled="true" />

<serviceDebug includeExceptionDetailInFaults="false" />

</behavior>

</serviceBehaviors>

</behaviors>


</configuration>


2 Xây dựng một dịch vụ WCF

2.1 Cài đặt WCF

2.1.1 .NET Framework 3.5 SP1

Để xây dựng một dịch vụ WCF, đầu tiên bạn cần phải cài đặt .NET Framework 3.5 SP1. Thực ra chỉ

cần .NET Framework 3.0 là đủ, tuy nhiên .NET Framework 3.5 SP1 còn cung cấp thêm cho bạn nhiều

tính năng nữa, nên bạn nên cài .NET Framework 3.5 SP1. Bản cài đặt của framework được Microsoft

cung cấp ở trang web http://www.microsoft.com/downloads/details.aspx?familyid=ab99342f-5d1a-413d-

8319-81da479ab0d7&displaylang=en hoặc tại http://download.microsoft.com/download/2/0/e/20e90413-

712f-438c-988e-fdaa79a8ac3d/dotnetfx35.exe

2.1.2 Visual Studio 2008 SP1

Sau khi cài đặt .NET Framework 3.5 SP1, bạn thực hiện cài đặt Visual Studio 2008 bản Express

hoặc bản Professional tuỳ theo bạn có bản nào. Nếu kinh phí hạn hẹp, bạn có thể tải về bản Visual Studio

2008 Express Edition miễn phí trên trang web của Microsoft, link ở đây:

http://go.microsoft.com/?linkid=9350817

Giờ đây bạn đã sẵn sàng để tạo ra dịch vụ đầu tiên trên WCF

2.2 Tạo dịch vụ WCF đầu tiên của bạn

Bạn có thể hình dung ứng dụng chúng ta sẽ xây dựng như sau. Công ty Contoso cần xây dựng một

hệ thống quản lý các nhân viên của công ty. Ban đầu, chúng ta cần phải xây dựng một ứng dụng ở server

Cung cấp danh sách các nhân viên, và

Cho phép hỏi về ngày sinh của một nhân viên nào đó.

Sau đó cần một ứng dụng phía client để làm những việc sau

Hiển thị danh sách các nhân viên

Chọn một nhân viên và hiển thị ngày sinh của nhân viên đó.

2.2.1 Tạo ứng dụng phía server

Bước 1. Tạo ứng dụng

1. Mở Visual Studio 2008, chọn tạo mới C# Console Project đặt tên là StaffService, xem

Figure 1


Figure 1 Tạo mới project

2. Thêm tham chiếu tới System.ServiceModel.dll.


Figure 2 Tham chiếu tới ServiceModel

Bước 2. Tạo contract dịch vụ

1. Định nghĩa giao diện sẽ được sử dụng như là contract cho ứng dụng của chúng ta, thêm

vào thuộc tính ServiceContract cho giao diện đó

2. Định nghĩa 2 hàm như đoạn mã nguồn sau, các hàm này đóng vai trò là các contract

operations miêu tả chức năng của dịch vụ

[ServiceContract]

public interface IStaff

{

[OperationContract]

string DisplayStaff();

[OperationContract]

DateTime GetBirthday(int staffId);

}

Bước 3. Cài đặt dịch vụ

1. Định nghĩa lớp Staff để cài đặt giao diện IStaff

2. Thực hiện cài đặt cho 2 hàm được định nghĩa trong giao diện IStaff

using System;


namespace StaffService

{

public class Staff : IStaff

{

#region IStaff Members

public string DisplayStaff()

{

return "1. Lê Anh\n2. Trần Văn Bình\n3. Nguyễn Văn

Cương\n4.Đinh Văn Dũng";

}

public DateTime GetBirthday(int staffId)

{

switch (staffId)

{

case 1:

return new DateTime(1979, 1, 20);

case 2:


case 3:


case 4:


default:

return DateTime.Now;

}

}

#endregion

}

}

Bước 4. Tạo vật chứa dịch vụ

1. Thêm đoạn mã nguồn sau vào hàm main

ServiceHost sh = new ServiceHost(typeof(Staff));

try

{

sh.Open();

Console.WriteLine("Staff Service opened successfully");

Console.WriteLine("Press Enter to terminate Staff Service");


Console.ReadLine();

}

finally

{

sh.Close();

}

Bước 5. Tạo các cấu hình dịch vụ

1. Compile project của bạn, đảm bảo rằng không có lỗi xảy ra trong quá trình biên dịch

2. Mở trình soạn thảo dịch vụ, Service Configuration Editor và nạp tệp ứng dụng, bằng

cách trong Visual Studio 2008, chọn menu Tools, chọn lựa chọn WCF Service Configuration

Editor

3. Chọn New Config, đặt tên là Staff.Service

Figure 3 Tạo config cho service

4. Đặt contract dịch vụ là StaffService.IStaff


Figure 4 Đặt tên cho contract dịch vụ

5. Chọn cách liên lạc là HTTP


Figure 5 Chọn cách liên lạc

6. Tiếp theo chọn phương pháp làm việc là Advanced Web Services interoperability, và đặt

kiểu liên kết là Simplex Communication


Figure 6 Chọn Simplex communication

7. Đặt mặc định (trống) cho trường địa chỉ, và bấm Finish, bạn sẽ thấy kết quả sau


Figure 7 Kết qủa cấu hình dịch vụ

8. Giờ bạn bấm vào biểu tượng Host phía bên trái, sau đó chọn thêm mới địa chỉ cơ sở cho

dịch vụ của bạn, đặt địa chỉ là http://localhost:8000/StaffService

http://localhost:8000/StaffService


Figure 8 Thêm địa chỉ cơ sở

9. Mở rộng nút EndPoints, chọn điểm cuối, rồi đặt tên là ep1

Figure 9 Đặt tên cho điểm cuối

10. Kết thúc quá trình này bạn sẽ có tệp cấu hình như sau:

<?xml version="1.0" encoding="utf-8"?>

<configuration>


<services>

<service name="StaffService.Staff">


bindingConfiguration=""

name="ep1" contract="StaffService.IStaff" />

<host>

<baseAddresses>

<add

baseAddress="http://localhost:8000/StaffService" />

</baseAddresses>

</host>

</service>

</services>


</configuration>

2.2.2 Phát hành thông tin về dịch vụ

Để phát hành thông tin về dịch vụ cho các ứng dụng khác khai thác, ta cần theo các bước sau:

1. Mở rộng nút Advanced (bên trái), sau đó chọn nút Service Behaviors và bấm vào New

Service Behavior Configuration ở bên phải


Figure 10 Tạo mới cấu hình cho hành xử dịch vụ

2. Đặt tên là MetaDataBehavior, bấm Add để thêm thành phần hành xử, chọn

ServiceMetaData

Figure 11 Thêm hành sử siêu dữ liệu

3. Chọn nút serviceMetadata ở bên trái và nhấp vào giá trị HttpGetEnabled thành true là

HttpGetUrl là http://localhost:8000/StaffService


Figure 12 Đặt cấu hình cho serviceMetadata

4. Giờ bạn chọn nút StaffService.Staff và đặt Behavior Configuration với giá trị là

“MetaDataBehavior”

Figure 13 Đặt BehaviorConfiguration cho dịch vụ

5. Cuối cùng là tạo điểm cuối để các ứng dụng có thể kết nối tới dịch vụ để lấy các thông

tin về dịch vụ. Bấm chuột phải vào Endpoints vào chọn New Service Endpoint sau đó đặt cấu

hình như sau:

Name: ep2

Address: mex


Binding: mexHttpBinding

Contract: ImetaDataExchange

Figure 14 Cấu hình cho điểm cuối

6. Bấm menu Save bạn sẽ có tệp cấu hình như sau:

<?xml version="1.0" encoding="utf-8"?>

<configuration>


<behaviors>

<serviceBehaviors>

<behavior name="MetaDataBehavior">

<serviceMetadata httpGetEnabled="true"

httpGetUrl="http://localhost:8000/StaffService" />

</behavior>

</serviceBehaviors>

</behaviors>

<services>

<service behaviorConfiguration="MetaDataBehavior"

name="StaffService.Staff">



name="ep1" contract="StaffService.IStaff" />



name="ep2" contract="IMetadataExchange" />


<host>

<baseAddresses>

<add

baseAddress="http://localhost:8000/StaffService" />

</baseAddresses>

</host>

</service>

</services>


</configuration>

7. Giờ bạn có thể chạy dịch vụ. Sẽ không có lỗi gì xảy ra và bạn sẽ có màn hình như sau:

Figure 15 Thực hiện dịch vụ

8. Nếu sử dụng Internet Explorer truy xuất tới địa chỉ

http://localhost:8000/StaffService bạn sẽ thấy màn hình sau:


Figure 16 Sử dụng IE để xem dịch vụ

2.2.3 Tạo ứng dụng phía client

Phần này hướng dẫn các bạn tạo ứng dụng phía client để truy xuất các hàm do dịch vụ trên cung cấp.

Điểm hay trong WCF là bạn chỉ cần sử dụng một dòng mã nguồn để gọi đến dịch vụ StaffService, chỉ

một dòng mà thôi, những thứ khác được tạo ra tự động sử dụng công cụ svcutil.exe.

1. Mở console dòng lệnh và chuyển tới thư mục bạn muốn tạo các tệp, gõ vào lệnh sau và

bấm Enter:

Svcutil.exe http://localhost:8000/StaffService?wsdl

Bạn sẽ thấy kết quả sau:


Figure 17 Kết quả tạo ra khai báo dịch vụ

2. Tạo ra một console project mới đặt tên là StaffClient và thêm tham chiếu tới

System.ServiceModel. Thêm vào tệp vừa tạo ra là Staff.cs, đồng thời đổi tên tệp cấu hình thành

app.config và thêm vào project. Kết quả như sau:

Figure 18 Tạo client

3. Sau khi biên dịch và chạy chương trình bạn được kết quả sau:


Figure 19 Kết quả chạy chương trình

2.3 Cách khác để tạo tham chiếu ở client

Ngoài cách thực hiện bằng dòng lệnh như ở trên, ta hoàn toàn có thể sử dụng sự giúp đỡ của công cụ

Visual Studio để tạo ra tham chiếu dịch vụ phía client. Cách này thực hiện rất nhanh và rất tiện lợi. Cách

làm như sau:

Bước 1. Chọn chuột phải vào project cần thêm tham chiếu, ở đây là StaffClient, sau đó chọn menu

là Add Service Reference như hình sau:


Figure 20 Thêm tham chiếu dịch vụ

Bước 2. Gõ vào địa chỉ của dịch vụ cần thêm, sau đó bấm nút Go, phía dưới đặt tên cho tham chiếu

dịch vụ là StaffService như hình dưới.


Figure 21 Cấu hình các tham số cho tham chiếu dịch vụ

Sau bước này bạn hoàn toàn có thể sử dụng lớp StaffClient để cài đặt ứng dụng phía client.

3 Câu hỏi ôn tập

1. Liệt kê các mô hình lập trình với WCF

Có 2 mô hình lập trình chủ yếu với WCF là phương pháp hướng đối tượng và phương pháp

hướng dịch vụ. Phương pháp hướng đối tượng thông thường được sử dụng khi phát triển ứng

dụng ở desktop, còn phương pháp hướng dịch vụ được sử dụng để phát triển các dịch vụ phía

server. Mối liên kết giữa hai phương pháp này thông qua các lớp và giao diện (hướng đối tượng)

và các thuộc tính WCF trên các lớp hay giao diện đó (hướng dịch vụ)

2. Các phương pháp lập trình với WCF

Có 3 phương pháp lập trình với WCF là phương pháp khai báo, phương pháp hiển hiện, và

phương pháp sử dụng tệp tin cấu hình. Thông thường khi làm việc với WCF, ta không sử dụng


riêng biệt một phương pháp nào mà sử dụng kết hợp cả ba phương pháp để đạt được kết quả tốt

nhất.

4 Tài liệu tham khảo

1. Programming your first WCF service (URL:

http://www.myitblog.com/sundararajan/programming-your-first-wcf-service.html)

2. Your first WCF Service (URL: http://eng.ahmedelmalt.googlepages.com/wcf02.htm)

Bài 3 ADDRESSES (ĐỊA CHỈ) VÀ BINDINGS

Mục lục

1 Địa chỉ trong Windows Communication Foundation ........................................................................................ 2 1.1 Các kiểu địa chỉ ......................................................................................................................................... 2

1.1.1 Địa chỉ điểm cuối ............................................................................................................................... 2

1.1.2 Địa chỉ cơ sở ...................................................................................................................................... 2

1.1.3 Địa chỉ MEX ...................................................................................................................................... 3

1.2 Các định dạng địa chỉ ................................................................................................................................ 3 1.2.1 Địa chỉ HTTP ..................................................................................................................................... 3

1.2.2 Địa chỉ HTTPS .................................................................................................................................. 3

1.2.3 Địa chỉ TCP ....................................................................................................................................... 4

1.2.4 Địa chỉ MSMQ .................................................................................................................................. 4

1.2.5 Địa chỉ Ống đặt tên (Named Pipe) ..................................................................................................... 4

1.2.6 Địa chỉ IIS .......................................................................................................................................... 5

2 Lập trình với địa chỉ trong Windows Communication Foundation ................................................................... 5 2.1 Lớp EndpointAddress ................................................................................................................................ 5

2.1.1 Lớp EndpointIdentity ......................................................................................................................... 6

2.1.2 Tập hợp các đầu đề ............................................................................................................................ 7

2.2 Lập trình các địa chỉ .................................................................................................................................. 7 2.2.1 Lập trình các địa chỉ cơ sở ................................................................................................................. 7

2.2.2 Lập trình địa chỉ điểm cuối ................................................................................................................ 8

3 Giới thiệu về Bindings trong Windows Communication Foundation ............................................................... 8

4 Lập trình các Bindings ..................................................................................................................................... 10

5 Câu hỏi ôn tập .................................................................................................................................................. 11


Microsoft Vietnam – DPE Team |Bài 3: Address (Địa chỉ) và Bindings 2

Những bài trước chúng ta có nói qua khái niệm về những thành phần của điểm cuối, một trong những

thành phần được nhắc tới là các địa chỉ, cách chúng được sử dụng trong điểm cuối và vai trò quan trọng

của chúng trong liên lạc. Như đã biết, mọi điểm cuối đều cần có một địa chỉ để các chương trình khác có

thể liên lạc với nó. Thực chất một địa chỉ có ý nghĩa là khai báo “tôi đây” cho thế giới bên ngoài.

Ngoài ra trong bài này còn giới thiệu với các bạn về bindings trong Windows Communication

Foundation. Bindings cũng giống như các địa chỉ là một trong ba thành phần quan trọng định nghĩa ra

một điểm cuối. Các bindings quy định cách mà một điểm cuối liên lạc, đặc biệt là nó chỉ ra những yêu

cầu một máy khách cần thực hiện khi kết nối tới một điểm cuối.

1 Địa chỉ trong Windows Communication Foundation

Để dễ hình dung xem địa chỉ trong WCF như thế nào, ta lấy một ví dụ thực tế về địa chỉ như sau:

http://localhost:8080/DichVuNhanTin

Ở ví dụ trên, ta nhận thấy rằng địa chỉ gồm có 4 phần:

Giao thức vận chuyển, trong ví dụ trên là http:

Tên của máy thực hiện dịch vụ, trong ví dụ này là //localhost

Đường dẫn tới điểm cuối dịch vụ, trong ví dụ này là /DichVuNhanTin

Phần tuỳ chọn là cổng dịch vụ, trong ví dụ này là 8080. Nếu cổng không được chỉ ra thì giá trị

mặc định là cổng 80 cho giao thức http: hay cổng 443 cho giao thức https:

Để hiểu chi tiết về địa chỉ ta cần hiểu về các kiểu địa chỉ và các định dạng của địa chỉ.

1.1 Address types (Các kiểu địa chỉ)

Trong WCF có một số kiểu địa chỉ sau

1.1.1 Endpoint Address (Địa chỉ điểm cuối)

Địa chỉ điểm cuối giống như ở ví dụ trên, một địa chỉ điểm cuối quy định địa chỉ của một điểm cuối dịch

vụ cụ thể. Máy khách (chương trình khách) có thể truy nhật dịch vụ qua địa chỉ điểm cuối. Ví dụ qua địa

chỉ sau:


Khi máy khách truy nhập dịch vụ thông qua địa chỉ điểm cuối, máy khách có thể nói chuyện với dịch vụ

và mọi liên lạc từ dịch vụ và đến dịch vụ đều thực hiện thông qua địa chỉ này.

1.1.2 Base Address (Địa chỉ cơ sở)

Địa chỉ cơ sở cung cấp một cách để xác định một địa chỉ đơn nhất cho một dịch vụ và gán các địa chỉ

tương đối cho từng điểm cuối riêng lẻ. Ví dụ, giả sử bạn có một dịch vụ với ba điểm cuối, bạn có thể gán

cho dịch vụ đó một địa chỉ cơ sở như sau


Với địa chỉ cơ sở được gán cho dịch vụ, bạn có thể gán cho ba điểm cuối các địa chỉ tương đối sau

http://localhost:8080/DichVuNhanTin/8753




1.1.3 MEX Address (Địa chỉ MEX)

Địa chỉ MEX cho phép một máy khách thu thập các thông tin về một dịch vụ nào đó. MEX, nghĩa là

metadata exchange (trao đổi siêu dữ liệu), là một địa chỉ điểm cuối HTTP được sử dụng để lấy thông tin

về dịch vụ. Ví dụ địa chỉ sau là một địa chỉ MEX:

http://localhost:8080/DichVuNhanTin/mex

Thông tin về dịch vụ cung cấp cho máy khách thông qua địa chỉ MEX được lấy từ siêu dữ liệu của dịch

vụ. Siêu dữ liệu này chính là những mô tả về dịch vụ.

1.2 Address formattings (Các định dạng địa chỉ)

Các địa chỉ điểm cuối được định dạng trên cơ sở của việc lựa chọn cách vận chuyển được sử dụng trong

truyền thông. Như đã chỉ ra trong ví dụ đầu tiên của bài này, giao thức vận chuyển là một phần của địa

chỉ nhằm xác định và quyết định vận chuyển nào được sử dụng. Điểm nhấn ở đây là chính các nhà lập

trình có thể chọn địa chỉ và cách nó được phân phối. Tuy nhiên, điểm quan trọng cần nhớ là với bất kể

định dạng nào, máy khách cần phải có khả năng lấy được địa chỉ tới dịch vụ và sử dụng dịch vụ.

Khi phát triển một dịch vụ bạn cần lưu ý các điểm sau:

Môi trường chứa dịch vụ. Môi trường có thể bắt buộc hoặc đòi hỏi địa chỉ phải được định dạng

theo cách này hay cách khác.

Nơi địa chỉ được xác định. Bạn có các tuỳ chọn để lưu nó ở tệp cấu hình hoặc bạn có thể lưu luôn

trong mã nguồn của chương trình của bạn.

Phần này sẽ giới thiệu với bạn các định dạng địa chỉ khác nhau để bạn có thể hình dung về tính linh hoạt

và các tuỳ chọn có thể có khi phát triển và phân phối dịch vụ. Bạn sẽ thấy rằng các định dạng địa chỉ gần

như giống nhau. Phần lớn các định dạng địa chỉ chứa các phần sau:

Phương thức (scheme): xác định giao thức liên lạc

Tên miền: xác định tên máy chứa dịch vụ

Cổng: xác định cổng mà dịch vụ thực hiện, nếu không được quy định thì giá trị mặc định là 80

Đường dẫn: đường dẫn tới dịch vụ

Thực chất, để phân biệt các định dạng địa chỉ khác nhau, ta căn cứ vào scheme của địa chỉ.

1.2.1 HTTP Address (Địa chỉ HTTP)

Có lẽ định dạng địa chỉ hay dùng nhất là địa chỉ HTTP. Định dạng của địa chỉ HTTP như sau:

http://domainname|hostname [:8080]/path

Định dạng địa chỉ HTTP chứa bốn phần. Sau đây là ví dụ của một địa chỉ HTTP sử dụng cả bốn phần:


Ví dụ địa chỉ HTTP chứa nhiều đường dẫn

http://www.asp.net:8080/Hello/Web

1.2.2 HTTPS Address (Địa chỉ HTTPS)

Địa chỉ HTTPS giống như địa chỉ HTTP chỉ khác là nó quy định việc vận chuyển được bảo mật bằng

cách sử dụng SSL (Secure Socket Layer), và được quy định bằng https. Ngoài scheme là https, thì

địa chỉ HTTPS không khác gì với địa chỉ HTTP. Ví dụ một địa chỉ HTTPS như sau:

https://localhost:8080/DichVuNhanTin

Khi sử dụng HTTPS, bạn cần phải lấy một chứng nhận từ một nhà chứng nhận hợp lệ như Verisign hay

Thawte.


1.2.3 TCP Address (Địa chỉ TCP)

Định dạng của một địa chỉ TCP như sau:

net.tcp://localhost:8080/DichVuNhanTin

1.2.4 MSMQ Address (Địa chỉ MSMQ)

Định dạng của địa chỉ MSMQ hơi khác so với các địa chỉ khác. Định dạng như sau:

net.msmq://hostname / [private] /queue-name

Ví dụ một địa chỉ MSMQ như sau:

net.msmq://localhost/msmqshare/DichVuNhanTin

Khi sử dụng địa chỉ MSMQ, cần chỉ ra các phần sau địa chỉ MSMQ:

Scheme: Quy định giao thức MSMQ

HostName: là tên đầy đủ của máy thực hiện MSMQ hoặc localhost nếu MSMQ được cài ở máy

cục bộ.

[private]: Là phần tuỳ chọn, khi sử dụng nó chứa địa chỉ tới một hàng đợi đích là một hàng đợi

riêng. Giá trị này không cần xác định khi truy nhập hàng đợi công cộng.

Queue-name: Tên của hàng đợi MSMQ.

Figure 1 Cách làm việc với MSMQ

1.2.5 Named Pipe Address (Địa chỉ Ống đặt tên)

Định dạng của địa chỉ Named Pipe như sau:

net.pipe://localhost/dichvu

Trong định dạng địa chỉ này cần lưu ý hai điểm sau:

Trong định dạng này không có cổng, do địa chỉ Named Pipe không sử dụng cổng

Truyền thông sử dụng các ống đặt tên không thể “cross-machine”, nghĩa là không liên lạc với

máy khác.


1.2.6 IIS Address (Địa chỉ IIS)

Địa chỉ IIS cũng giống như địa chỉ MSMQ, hơi khác về định dạng một chút so với các định dạng khác.

Do địa chỉ IIS đòi hỏi phải có tên thư mục ảo cũng như tên tệp dịch vụ (.svc). Định dạng của địa chỉ IIS

như sau:

http://domainname|hostname

[:port]/VirtualDirectory/TênTệpDịchVụ.svc

Ví dụ một địa chỉ IIS như sau:

http://localhost/dichvu/DichVuNhanTin.svc

2 Lập trình với địa chỉ trong Windows Communication Foundation

Khi lập trình với các địa chỉ trong Windows Communication Foundation bạn có thêm sự linh hoạt trong

làm việc với các điểm cuối và dịch vụ bởi bạn hoàn toàn có thể lập trình để định nghĩa và xử lý các địa

chỉ cơ sở.

Như đã nói, trong thực tế, không mấy khi các nhà lập trình tạo ra các điểm cuối và các địa chỉ điểm cuối

thông qua mã nguồn do các địa chỉ và binding bạn sử dụng trong quá trình phát triển dịch vụ thường

không giống so với các địa chỉ và binding sẽ sử dụng khi phân phối dịch vụ. Thông thường là ta định

nghĩa các điểm cuối và các địa chỉ trong tệp tin cấu hình.

Vậy tại sao ta lại cần lập trình với các địa chỉ? Một trong những lợi điểm của Windows Communication

Foundation là tính linh hoạt, và có thể trong một lúc nào đó việc lập trình các địa chỉ là cần thiết. Phần

này sẽ giới thiệu với các bạn các mục sau:

Lớp EndpointAddress, cung cấp cho nhà phát triển cách để tạo ra một địa chỉ mạng duy nhất truy

nhập được bởi các máy khách, cho phép chúng liên lạc với dịch vụ của bạn.

Lập trình các địa chỉ điểm cuối.

2.1 Lớp EndpointAddress

Mục đích của lớp này nhằm cung cấp một địa chỉ mạng duy nhất mà một máy khách sử dụng để liên lạc

với một điểm cuối dịch vụ. EndpointAddress chứa một URI và các thuộc tính địa chỉ bao gồm:

Identity (Định danh)

Các thành phần WSDL

Optional header collection (Một tập hợp các tuỳ chọn đầu đề). Các tuỳ chọn đầu đề được sử dụng

để cung cấp them thông tin chi tiết hơn về cách đánh địa chỉ để định ra hoặc tương tác với điểm

cuối. Ví dụ chúng có thể được sử dụng để chỉ ra thực thể nào của một dịch vụ được sử dụng để

xử lý bản tin đến từ một người dùng nào đó khi có nhiều thực thể của dịch vụ.

Địa chỉ điểm cuối cho một dịch vụ có thể được xác định hoặc là sử dụng mã nguồn hoặc là được khai báo

thông qua tệp tin cấu hình.

Lớp EndpointAddress không cài đặt giao diện ISerializable, do đó nó không lưu lại được. Để

điểm cuối được đưa ra là một phần của contract dịch vụ, nó cần phải lưu lại được, và cần phải tương

thích với giao thức địa chỉ Web Service Addressing.

Ví dụ tạo một thực thể của EndpointAddress như sau:

EndpointAddress endpointAddress = new

EndpointAddress("http://localhost:8003/servicemodelsamples/service");


2.1.1 Lớp EndpointIdentity

Một trong các thuộc tính của lớp EndpointAddress là phần định danh (identity). Phần định danh này

được quy định bởi lớp EndpointIdentity. Đây là một lớp ảo để cài đặt một định danh cho phép xác

thực một điểm cuối bởi các máy khách khi trao đổi bản tin với điểm cuối đó. Ta có các kiểu định danh có

thể dùng trong xác thực như sau:

Tên Mô tả

DnsEndpointIdentity Quy định định danh DNS của máy chủ. Lớp này quy định định

danh cần thiết của máy chủ. Định danh này hợp lệ cho cách xác

thực chứng nhận X509 nếu chứng nhận của phía máy chủ chứa

một DNS với cùng giá trị. Trong trường hợp này, một máy khách

quy định DnsEndpointIdentity là “server1.microsoft.com” cho

chế độ xác thực Windows tương đương với xác định

SpnEndpointIdentity là “host/server1.microsoft.com”

RsaEndpointIdentity Quy định một định danh RSA cho điểm cuối dịch vụ. RSA là

thuật toán mã hoá sử dụng khoá công cộng được sử dụng cho việc

ký và mã hoá bản tin.

SpnEndpointIdentity Biểu diễn một tên cơ bản của dịch vụ (Service principal name –

SPN) cho một định danh khi binding sử dụng Kerberos.

Một SPN là một tên theo đó một máy khách có thể xác định ra

duy nhất một thực thể của một dịch vụ. Nếu bạn cài đặt nhiều

thực thể khác nhau của một dịch vụ trên các máy tính, mỗi thực

thể phải có SPN riêng của chúng. Một thực thể của dịch vụ có thể

có nhiều SPN nếu có nhiều tên mà máy khách có thể sử dụng để

xác thực.

UpnEndpointIdentity Biểu diễn một tên cơ bản người dùng (user principal name –

UPN) cho một định danh được sử dụng khi binding sử dụng chế

độ xác thực là SSPINegotiate. Đây là cách tiêu chuẩn để đăng

nhập vào một domain Windows. Định dạng là

[email protected] (cho địa chỉ email)

X509CertificateEndpointIdentity Biểu diễn định danh chứng nhận cho điểm cuối dịch vụ. Các máy

khách cố gắng để liên lạc với điểm cuối dịch vụ này nên xác thực

với dịch vụ dựa trên chứng nhận được cung cấp bởi định danh

của điểm cuối.

Thông thường không cần phải xác định định danh điểm cuối do kiểu xác thực ở máy khách xác định kiểu

định danh sử dụng. Tuy nhiên, bạn có thể thay đổi định danh dịch vụ mặc định bằng cách sử dụng thành

phần <identity> trong tệp cấu hình hoặc bằng cách thiết lập bằng lập trình qua mã nguồn.

Ví dụ sau tạo ra một định danh cho một điểm cuối bằng mã nguồn:

ServiceEndpoint sep = MyServiceHost.AddServiceEndPoint(typeof(IMyWCFService), new WSHttpBinding(), String.Empy); EndpointAddress ea = new EndpointAddress(new Uri(“http://localhost:8080/testservice/service”), EndpointIdentity.CreateDnsIdentity("BookOrder.com"));; sep.Address = ea;

Cấu hình cho định danh sử dụng tệp cấu hình như sau:


<?xml version="1.0" encoding="utf-8" ?> <configuration> <system.serviceModel> <services> <service behaviorConfiguration="CalculationService.CalcServiceBehavior" name="CalculationService.CalcService"> <endpoint address="" binding="wsHttpBinding" contract="CalculationService.ICalcService"> <identity> <dns value="localhost" /> </identity> </endpoint> <endpoint address="mex" binding="mexHttpBinding" contract="IMetadataExchange" /> <host> <baseAddresses> <add baseAddress="http://localhost:8731 /Calculation/CalcService/" /> </baseAddresses> </host> </service> </services> </system.serviceModel> </configuration>

2.1.2 Header collection (Tập hợp các đầu đề)

Tập hợp các headers (đầu đề) là một cách theo đó các thông tin thêm vào được cung cấp cho các địa chỉ

điểm cuối. Bước đầu tiên là tạo các đầu đề địa chỉ và thêm chúng vào một mảng:

AddressHeader ah1 = AddressHeader.CreateAddressHeader("service1", "http://localhost:8080/testservice /service", 1); AddressHeader ah2 = AddressHeader.CreateAddressHeader("service2", "http://localhost:8080/testservice /service", 2);

Sau khi các đầu đề địa chỉ được tạo ra, ta thêm các đầu đề này vào trong một mảng:

AddressHeader[] addressHeaders = new AddressHeader[2] { ah1, ah2 };

Khi tập hợp địa chỉ được tạo ra, tập hợp này có thể được thêm vào trong một thể hiện của lớp

EndpointAddress. Sử dụng ví dụ về EndpointAddress ở trên, mã nguồn sẽ được sửa lại như sau:

EndpointAddress ea = new

EndpointAddress("http://localhost:8080/testservice/service"), addressHeaders);

2.2 Lập trình với các địa chỉ (address)

2.2.1 Lập trình các địa chỉ cơ sở

Thông qua lớp ServiceHost, một địa chỉ cơ sở được xác định như ví dụ sau:

Uri ba = new Uri("http://localhost:8080/testservice"); ServiceHost sh = new ServiceHost(typeof(Service), ba));

Ví dụ trên là trong trường hợp dịch vụ được cung cấp thông qua một địa chỉ cơ sở đơn nhất. Tuy nhiên

trong thực tế, một dịch vụ thông thường có hơn một điểm cuối, và các điểm cuối này có thể sử dụng các

giao thức và vận chuyển khác nhau. May mắn là cấu tử của lớp ServiceHost chấp nhận nhiều hơn

một địa chỉ cơ sở như ví dụ sau:

Uri[] bas = new Uri[] {


new Uri("http://localhost:8080/testservice"), new Uri("net.tcp://localhost:8090/testservice") }; ServiceHost sh = new ServiceHost(typeof(Service), bas));

Sau khi tạo ra một thể hiện của lớp ServiceHost, ta cần gọi hàm Open để mở ra service và sử dụng.

2.2.2 Lập trình địa chỉ điểm cuối (endpoint address)

Sau khi định nghĩa địa chỉ cơ sở, bạn có thể định nghĩa các địa chỉ điểm cuối có thể là địa chỉ tuyệt đối

hoặc địa chỉ tương đối với địa chỉ cơ sở. Việc định nghĩa địa chỉ điểm cuối có thể thực hiện thông qua tệp

cấu hình hoặc bằng lập trình.

Bằng tệp tin cấu hình ta có thể định nghĩa một địa chỉ điểm cuối như sau:

<?xml version="1.0" encoding="utf-8" ?> <configuration> <system.serviceModel> <services> <service behaviorConfiguration="CalculationService.CalcServiceBehavior" name="CalculationService.CalcService"> <endpoint address="http://localhost:8731/CalcService/" binding="wsHttpBinding" contract="CalculationService.ICalcService"> </endpoint> </service> </services> </system.serviceModel> </configuration>

Trong trường hợp định nghĩa hai hay nhiều địa chỉ điểm cuối, ta có tệp tin cấu hình như sau:

<?xml version="1.0" encoding="utf-8" ?> <configuration> <system.serviceModel> <services> <service behaviorConfiguration="CalculationService.CalcServiceBehavior" name="CalculationService.CalcService"> <endpoint address="http://localhost:8731/CalcService/" binding="wsHttpBinding" contract="CalculationService.ICalcService"> </endpoint> <endpoint address="http://localhost:8731/MultService/" binding="wsHttpBinding" contract="CalculationService.ICalcService"> </endpoint> </service> </services> </system.serviceModel> </configuration>

Khi định nghĩa địa chỉ bởi lập trình, ta có thể định nghĩa như sau:

ServiceHost sh = new ServiceHost(typeof(), new WsHttpBinding(),String.Empty);

3 Giới thiệu về Bindings trong Windows Communication Foundation

Các bindings là phương pháp theo đó các chi tiết trong truyền thông được xác định để tạo kết nối tới

điểm cuối dịch vụ WCF. Các bindings trong WCF có thể thay đổi mức độ phức tạp. Các mức độ này có


thể từ đơn giản nhất cho tới cực kỳ phức tạp. Khi định nghĩa một binding, bạn cần chỉ ra các thông tin ở

trong các lĩnh vực sau:

Protocol (Giao thức): Định nghĩa các thông tin cần sử dụng trong binding ví như tính bảo mật,

khả năng thực hiện giao dịch, hoặc khả năng truyền bản tin một cách tin cậy.

Transport (Vận chuyển): Định nghĩa giao thức cơ bản được sử dụng trong truyền thông

Encoding (mã hoá): Định nghĩa việc mã hoá được sử dụng cho các bản tin trong quá trình liên

lạc.

Để sử dụng binding, cần thực hiện hai bước sau:

1. Chọn một binding từ danh sách định nghĩa trước của các bindings trong WCF mà bạn sẽ sử dụng

cho điểm cuối. Khi chọn một binding có sẵn, bạn có lựa chọn là giữ lại hoặc thay đổi các thuộc

tính của binding để phù hợp với yêu cầu của bạn.

2. Tạo một điểm cuối sử dụng binding mà bạn vừa chọn hoặc tạo ra.

Lợi điểm của WCF là nó định nghĩa một số các binding phù hợp với hầu hết các yêu cầu phát sinh trong

quá trình phát triển dịch vụ. Bạn có thể theo dõi danh sách các binding đó ở bảng sau. Giá trị ở trong

ngoặc đơn là các giá trị mặc định cho từng tính năng của binding cụ thể.

Binding Tính làm việc

liên môi

trường

Bảo mật Phiên Giao dịch

BasicHttpBinding Basic Profile

1.1

(none), Transport,

Message

(None) (None)

WSHttpBinding WS Transport,

(Message), Mixed

(None),Transport,

Reliable

(None), Yes

WSDualHttpBinding WS (Message) Reliable (none), Yes

WSFederationHttpBinding WS (Message) (None), Reliable (none), Yes

NetTcpBinding .NET (Transport),

Message

Reliable,

(Transport)

(none), Yes

NetNamedPipeBinding .NET (Transport) None, (Transport) (none), Yes

NetMsmqBinding .NET Message,

(Transport), Both

(None) (None), Yes

NetPeerTcpBinding Peer (Transport) (None) None

MsmqIntegrationBinding MSMQ (Transport) (None) (none), Yes

Trong bảng trên, các tính năng được định nghĩa như sau:

Tính làm việc liên môi trường: Định nghĩa giao thức hay công nghệ mà binding sẽ sử dụng để

đảm bảo việc trao đổi và sử dụng thông tin.

Bảo mật: Xác định cách bảo mật kênh trao đổi thông tin

Phiên: Xác định việc hỗ trợ contract phiên

Giao dịch: Xác định việc cho phép hay không các giao dịch (transaction)


Để xác định xem khi nào nên sử dụng binding nào, bạn nên theo sơ đồ dưới đây:

Figure 2 Nên sử dụng binding nào (ảnh từ blog của Dennis van der Stelt) Bạn nên tham khảo thêm bài viết ở trang web này

http://weblogs.asp.net/spano/archive/2007/10/02/choosing-the-right-wcf-binding.aspx để biết thêm các

thông tin khi lựa chọng binding phù hợp.

4 Lập trình các Bindings

Các binding cũng giống như các địa chỉ có thể được tạo ra bằng cách sử dụng tập tin cấu hình, hoặc sử

dụng lập trình. Ví dụ sau đây định nghĩa một BasicHttpBinding bằng cách sử dụng tệp tin cấu hình:

<?xml version="1.0" encoding="utf-8" ?> <configuration> <system.serviceModel> <bindings> <basicHttpBinding> <binding name = "basichttpbind" closeTimeout = "00:00:30" openTimeout = "00:00:30" sendTimeout = "00:00:30" receiveTimeout = "00:00:30"> </binding> </basicHttpBinding> </bindings> </system.serviceModel> </configuration>

Trong trường hợp lập trình, ta có thể thực hiện như sau:

Uri ba = new Uri("http://localhost:8080/WroxService"); BasicHttpBinding binding = new BasicHttpBinding(); binding.CloseTimeout = 30000; binding.OpenTimeout = 30000; binding.SendTimeout = 30000; binding.ReceiveTimeout = 30000;


ServiceHost host = new ServiceHost(serviceType, baseAddresses); sh.AddServiceEndpoint("", binding, ba);


1. Liệt kê các dạng địa chỉ được sử dụng trong WCF

Có các dạng địa chỉ sau:

Địa chỉ HTTP

Địa chỉ HTTPS

Địa chỉ TCP

Địa chỉ MSMQ

Địa chỉ Ống đặt tên

Địa chỉ IIS


1. Basic WCF programming (URL: http://msdn.microsoft.com/en-us/library/ms731067.aspx)

2. Lớp EndpointAddress (URL: http://msdn.microsoft.com/en-

us/library/system.servicemodel.endpointaddress.aspx)

3. WCF Binding decision (URL: http://bloggingabout.net/blogs/dennis/archive/2006/12/01/WCF-

Binding-decision-chart.aspx)

Bài 4

CONTRACTS TRONG


Mục lục

1 Contracts trong Windows Communication Foundation .................................................................................... 2 1.1 Service Contracts ..........................................................................................................................3

1.1.1 Thuộc tính ServiceContract ..................................................................................................5

1.1.2 Thuộc tính OperationContract ..............................................................................................6

1.2 Data Contracts ..............................................................................................................................8 1.2.1 Thuộc tính DataContract .......................................................................................................8

1.3 Message Contracts ........................................................................................................................9 1.3.1 Thuộc tính MessageContract ................................................................................................9

1.3.2 Thuộc tính MessageHeader ................................................................................................10

1.3.3 Thuộc tính MessageBodyMember ......................................................................................10

2 Lập trình với các contracts trong Windows Communication Foundation ....................................................... 10

3 Câu hỏi ôn tập .................................................................................................................................................. 17


Microsoft Vietnam – DPE Team | Bài 4: Contracts trong WCF 2

Trong các bài trước, chúng ta đã nói đến các địa chỉ (address) và bindings trong Windows

Communication Foundation. Bài này sẽ giới thiệu tới các bạn về thành phần thứ ba rất quan trọng của

WCF, đó là các contract (giao kèo). Nội dung của bài này sẽ tập trung vào thảo luận các loại contract,

một số ví dụ để định nghĩa contract và lập trình với contract.

Tất cả các ví dụ mà bạn đã thấy và làm việc ở các bài trước cho đến giờ đều sử dụng và cài đặt các

contract. Mặc dù đã làm việc với contract, nhưng chúng ta chưa nói một cách chi tiết về contract là gì, có

các loại contract nào và làm thế nào để làm việc với chúng. Trong bài này chúng ta sẽ thảo luận các vấn

đề trên theo thứ tự sau:

Các loại (kiểu) của contract trong WCF

Làm thế nào để định nghĩa các kiểu contract khác nhau

Ví dụ về các contract

1 Contracts trong Windows Communication Foundation

Các contract trong Windows Communication Foundation cung cấp khả năng làm việc đa môi trường khi

liên lạc với các máy khách. Các máy khách và dịch vụ thoả thuận với nhau về các contract như kiểu của

các hành động và các cấu trúc dữ liệu mà các bên sẽ sử dụng trong quá trình liên lạc qua lại với nhau.

Nếu không có contract thì không thể thực hiện liên lạc được do không có sự thoả thuận thống nhất giữa

các bên.

Khi định nghĩa một dịch vụ trong Windows Communication Foundation ta sử dụng ba kiểu contract cơ

bản sau:

Service Contract (Contract dịch vụ): Định nghĩa các phương thức của một dịch vụ, thực chất là

các hành động mà client có thể sử dụng ở các điểm cuối (endpoint)

Data Contract (Contract dữ liệu): Định nghĩa các kiểu dữ liệu được sử dụng ở các phương

thức của dịch vụ

Message Contract (Contract bản tin): Cung cấp khả năng để điều khiển các đầu đề bản tin

trong quá trình tạo ra các bản tin

Cũng giống như các thành phần khác trong WCF, các contract được định nghĩa sử dụng các khái niệm

mà bạn đã quen thuộc. Các contract được định nghĩa sử dụng các lớp và giao diện, bằng cách thêm vào

các thuộc tính mô tả (attribute) cho các lớp và giao diện đó.

Có thể hình dung mối liên hệ giữa các contract với .NET Framework CLR một cách gần đúng như sau:

Service Contracts: Cung cấp thông tin để thực hiện ánh xạ từ CLR sang WSDL (Ngôn ngữ mô

tả dịch vụ Web – Web Service Description Language)


Data Contracts: Cung cấp thông tin để thực hiện ánh xạ từ CLR sang XSD (Định nghĩa schema

XML – XML Schema Definition)

Message Contracts: Dùng để miêu tả cấu trúc của bản tin SOAP (Giao thức truy nhập đối tượng

đơn giản – Simple Object Access Protocol)

1.1 Service Contracts

Như đã nói ở phần trên, một contract dịch vụ định nghĩa các hành động hoặc phương thức có ở điểm cuối

dịch vụ và được đưa ra để máy khách có thể sử dụng. Nó còn định nghĩa một cách cơ bản các phép trao

đổi bản tin như việc bản tin sẽ thế nào trong yêu cầu/trả lời hay trong liên lạc đơn công hoặc song công.

Contract dịch vụ đưa ra một số thông tin cho các máy khách đủ để cho máy khách có thể biết được dịch

vụ này có thể cung cấp những gì. Những thông tin đó bao gồm:

Các kiểu dữ liệu trong bản tin

Vị trí của các phương thức – hành động

Thông tin về giao thức, định đạng lưu dữ liệu để đảm bảo cho liên lạc thành công

Nhóm các hành động

Mẫu trao đổi bản tin (Message exchange pattern – MEP)

Như trên đã nói, để định nghĩa contract dịch vụ, ta sử dụng các thuộc tính mô tả cho một lớp hay giao

diện. Thuộc tính mô tả một contract dịch vụ là ServiceContract. Ví dụ sau định nghĩa một giao

diện như là một contract dịch vụ:

[ServiceContract]

public interface IStaffInformation

{

}

Sau đó để định nghĩa các hành động (phương thức) cho dịch vụ ta sử dụng phần mô tả là

OperationContract cho các phương thức của giao diện như ví dụ dưới đây:

[OperationContract]

bool HasPerson(int staffId);

[OperationContract]

string GetPersonName(int staffId);

Gộp các phần lại ta sẽ được một định nghĩa hoàn chỉnh cho một contract dịch vụ:

[ServiceContract]



{

[OperationContract]


[OperationContract]


}

Sau khi có được định nghĩa cho dịch vụ, ta có thể cài đặt một lớp cho giao diện trên, trong đó định nghĩa

các hàm (phương thức) thực hiện theo logic của dịch vụ.

public class StaffInformation : IStaffInformation

{

public bool HasPerson(int staffId)

{

// Làm việc gì đó ở đây, và trả về kết quả

}

public string GetPersonName(int staffId)

{


}

}

Trong trường hợp bạn không muốn định nghĩa dịch vụ ở phần giao diện, bạn hoàn toàn có thể định nghĩa

dịch vụ ở trong lớp cài đặt dịch vụ đó như sau:

[ServiceContract]


{

[OperationContract]

public bool HasPerson(int staffId)

{


}

[OperationContract]

public string GetPersonName(int staffId)

{


}

}


Trong khi định nghĩa contract dịch vụ, chúng ta đã sử dụng hai lớp thuộc tính để mô tả là

ServiceContract và OperationContract. Hai thuộc tính này có rất nhiều tham số kèm theo,

tuy nhiên trong nhiều trường hợp, chúng ta hoàn toàn có thể sử dụng các giá trị mặc định của hai thuộc

tính này để định nghĩa contract dịch vụ. Trong một số trường hợp khi chúng ta muốn điều khiển sâu hơn

về các thông tin liên quan đến dịch vụ, ta có thể đưa thêm các tham số cho hai thuộc tính này.

1.1.1 Thuộc tính ServiceContract

Thuộc tính ServiceContract được áp dụng cho việc mô tả các giao diện hoặc các lớp để định nghĩa

một contract dịch vụ. Thuộc tính này có các tham số sau:

Tên tham số Mô tả

CallbackContract Thiết lập/Trả về kiểu của callback contract khi liên lạc ở chế độ song công. Khi

liên lạc giữa máy khách và dịch vụ được thiết lập, tham số này chỉ ra rằng máy

khách cần phải đợi lời gọi hàm từ phía dịch vụ thông qua kiểu của callback

contract đã định nghĩa. Ví dụ sau mô tả cách sử dụng tham số

CallbackContract

[ServiceContract(CallbackContract=typeof(IClientContract))]


{

....

}

Trong ví dụ trên, dịch vụ quy định callback contract phải có kiểu là

IClientContract

ConfigurationName Thiết lập/Trả về tên được sử dụng để xác định thành phần dịch vụ trong tệp tin

cấu hình. Ví dụ về việc sử dụng tham số ConfigurationName như sau:

[ServiceContract(ConfigurationName="DichVu")]


{

....

}

Và ở tệp tin cấu hình ta có phần định nghĩa thành phần dịch vụ với tên là

DichVu


<configuration>



<services>

<service name="DichVu">

</service>

</services>


</configuration>

Name Thiết lập/Trả về tên của thành phần <portType> trong WSDL. Giá trị mặc

định cho tham số này chính là tên của giao diện hay lớp có gắn thuộc tính

ServiceContract. Tham số này được sử dụng trong trường hợp ta muốn

thay đổi tên của thành phần <portType> hoặc muốn giữ nguyên tên của

thành phần <portType> nhưng lại đổi tên của giao diện hay lớp định nghĩa

dịch vụ.

Namespace Thiết lập/Trả về namespace (không gian tên) cho thành phần <portType>

trong WSDL. Giá trị mặc định cho tham số này là http://tempuri.org

ProtectionLevel Quy định yêu cầu về mức bảo vệ trong binding. Việc quy định này bao gồm quy

định về mã hoá, chữ ký điện tử tại các điểm cuối của dịch vụ

SessionMode Quy định kiểu hỗ trợ cho các phiên làm việc tin cậy mà một dịch vụ đòi hỏi

hoặc hỗ trợ. Ví dụ có thể định nghĩa đòi hỏi phải hỗ trợ phiên làm việc tin cậy

cho dịch vụ như sau:

[ServiceContract(SessionMode=SessionMode.Required)]


{

....

}

1.1.2 Thuộc tính OperationContract

Thuộc tính OperationContract được gắn với các phương thức trong các giao diện hay các lớp. Chỉ

các phương thức được gắn thuộc tính OperationContract mới được coi là phương thức của dịch vụ.

Các tham số có thể sử dụng cho thuộc tính này như sau:

Tên tham số Mô tả

Action Quy định hành động để chỉ ra một cách duy nhất phương thức này. WCF

phân phối các bản tin yêu cầu với các phương thức dựa trên các hành


động của chúng.

AsyncPattern Chỉ ra rằng phương thức được cài đặt hoặc có thể gọi theo cách dị bộ sử

dụng cặp phương thức bắt đầu bởi Begin và End

IsInitiating Quy định phương thức này có phải là phương thức để khởi tạo trong một

phiên hay không

IsOneWay Chỉ ra rằng phương thức này chỉ chứa một bản tin đầu vào duy nhất.

Phương thức không có bản tin trả về.

IsTerminating Quy định xem liệu WCF có kết thúc phiên làm việc hiện tại sau khi

phương thức này thực hiện xong hay không

Name Quy định tên cuối cùng của phương thức sẽ có trong dịch vụ. Giá trị mặc

định của tham số này là tên của phương thức

ProtectionLevel Quy định sự bảo vệ ở mức bản tin mà một phương thức yêu cầu khi thực

hiện

ReplyAction Quy định hành động của bản tin trả lời cho phương thức này

Ví dụ sau biểu diễn việc sử dụng các tham số của OperationContract để quy định thứ tự thực hiện của các

phương thức khi làm việc với dịch vụ. Theo ví dụ này, quy trình để máy khách liên lạc với dịch vụ như

sau.

1. Đầu tiên máy khách cần phải gọi hàm Login để đăng nhập

2. Sau đó gọi hàm HasPerson hoặc GetPersonName để lấy thông tin về nhân viên

3. Cuối cùng gọi hàm Logout để đăng xuất

[ServiceContract]


{

[OperationContract(IsInitiating=true, IsTerminating=false)]

void Login(string userName, string password);

[OperationContract]


[OperationContract]


[OperationContract(IsInitiating=false, IsTerminating=true)]

void Logout();


}

Nếu máy khách không thực hiện theo thứ tự trên thì dịch vụ sẽ báo lỗi và không thực hiện.

1.2 Data Contracts

Một cách đơn giản thì một contract dữ liệu mô tả dữ liệu cần trao đổi. Trước khi máy khách và dịch vụ

thực hiện liên lạc thì chúng phải đồng ý với nhau về kiểu dữ liệu trao đổi, đó là contract dữ liệu. Điều

quan trọng là khi thực hiện liên lạc, máy khách và dịch vụ hoàn toàn không cần phải chung nhau cùng

các kiểu dữ liệu mà chúng chỉ cần chung nhau các contract dữ liệu. Contract dữ liệu định nghĩa cách

serialized và deserialized cho từng tham số và kiểu trả về.

Quá trình serialization dữ liệu là quá trình chuyển một cấu trúc dữ liệu thành một định dạng có thể dùng

trong liên lạc hoặc gửi qua đường truyền. Ví dụ đọc dữ liệu từ cơ sở dữ liệu sau đó chuyển nó thành một

chuỗi các byte và gửi qua đường truyền.

Quá trình deserialization là quá trình ngược lại với quá trình serialization. Quá trình này nhận dữ liệu từ

đường truyền và chuyển ngược thành cấu trúc dữ liệu.

Để định nghĩa contract dữ liệu, ta sử dụng thuộc tính DataContract và DataMember.

1.2.1 Thuộc tính DataContract

Cũng giống như thuộc tính ServiceContract, thuộc tính DataContract được gắn vào các lớp để định nghĩa

contract dữ liệu. Ví dụ sau định nghĩa một contract dữ liệu

[DataContract]

public class Person

{

...

}

Sau khi định nghĩa contract dữ liệu, bạn có thể định nghĩa các thành viên của một contract dữ liệu.

Những thành viên này thực chất là các trường hay thuộc tính trong lớp của bạn. Ví dụ sau đây định nghĩa

một số thành viên trong contract dữ liệu.

[DataContract]

public class Person

{

[DataMember]

int StaffId;

[DataMember]

string FullName;

[DataMember]


int Age;

}

Sau khi định nghĩa xong contract dữ liệu và các thành viên có trong contract dữ liệu, ta có thể sử dụng

contract dữ liệu này trong khai báo phương thức của contract dịch vụ như sau:

[ServiceContract]


{

[OperationContract]

public void AddPerson(Person person);

}

1.3 Message Contracts

Contract bản tin cho phép bạn điều khiển toàn bộ định dạng của các bản tin SOAP. Trong phần lớn các

trường hợp, bạn không cần sử dụng mức điều khiển này, do các contract dữ liệu đã cho phép bạn điều

khiển theo yêu cầu. Tuy vậy, vẫn có một vài trường hợp bạn cần đến mức điều khiển bằng các contract

bản tin.

Có lẽ lý do lớn nhất khiến bạn cần tới contract bản tin là tính làm việc liên môi trường. Một contract bản

tin cung cấp các mức độ làm việc liên môi trường bạn cần khi liên lạc với các máy khách hoặc các hệ

thống khác sử dụng một schema hay WSDL nào đó.

Contract bản tin cho phép bạn có nhiều lựa chọn hơn trong việc định dạng các tham số trong các bản tin

SOAP ví như liệu thông tin có hay không có ở trong nội dung bản tin hay đầu đề bản tin. Để định nghĩa

contract bản tin, ta sử dụng các lớp thuộc tính mô tả sau: MessageContract, MessageHeader, và

MessageBodyMember cùng với các tham số tương ứng với từng lớp.

1.3.1 Thuộc tính MessageContract

Các contract bản tin được định nghĩa bằng cách gắn thuộc tính MessageContract vào các lớp. Sau

đó cần phải xác định rõ cho từng bản tin các thuộc tính MessageHeader và MessageBodyMember.

Ví dụ sau biểu diễn một contract bản tin đơn giản.

[MessageContract]

public class Person

{

[MessageHeader]

int StaffId;

[MessageBodyMember]

string FullName;

[MessageBodyMember]


int Age;

}

1.3.2 Thuộc tính MessageHeader

Thuộc tính MessageHeader được gắn với các trường hoặc thuộc tính của một kiểu. Những trường hay

thuộc tính này sau đó sẽ được ánh xạ thành các đầu đề bản tin SOAP.

1.3.3 Thuộc tính MessageBodyMember

Thuộc tính MessageBodyMember được gắn với các trường hoặc thuộc tính của một kiểu. Những

trường hay thuộc tính này sau đó sẽ được ánh xạ thành phần nội dung của bản tin SOAP.

2 Lập trình với các contracts trong Windows Communication

Foundation

Trong phần này chúng ta sẽ tạo ra một dịch vụ đơn giản để quản trị thông tin về nhân viên trong công ty.

Dịch vụ cho phép chúng ta:

1. Thêm mới một nhân viên vào cơ sở dữ liệu

2. Xoá một nhân viên khỏi cơ sở dữ liệu

3. Sửa thông tin về nhân viên trong cơ sở dữ liệu

4. Lấy thông tin về nhân viên

5. Lấy danh sách tất cả các nhân viên

Bước 1. Mở Visual Studio 2008, tạo một project mới với kiểu là WCF Service Library, đặt tên là

ContractSample


Figure 1 Tạo WCF service library

Bước 2. Xoá tệp tin IService1.cs và Service1.cs trong solution, sau đó chọn chuột phải vào project

ContractSample, chọn Add -> New Item và chọn WCF Service, đặt tên cho service này là

StaffInfomation, xem hình dưới.


Figure 2 Thêm mới dịch vụ StaffInformation

Bước 3. Mở tệp IStaffInformation, thêm vào đoạn mã nguồn sau:

using System.Runtime.Serialization;

using System.ServiceModel;

namespace ContractSample

{

// định nghĩa contract dữ liệu

[DataContract]

public class Person

{

[DataMember]

public int personId;

[DataMember]

public string FullName;

[DataMember]

public int Age;

}

// định nghĩa contract dịch vụ


[ServiceContract]


{

[OperationContract]

bool HasPerson(int personId);

[OperationContract]

Person GetPerson(int personId);

[OperationContract]

void AddPerson(Person person);

[OperationContract]

void EditPerson(int personId, Person person);

[OperationContract]

void DeletePerson(int personId);

[OperationContract]

Person[] GetAll();

}

}

Bước 4. Mở tệp StaffInformation.cs, thay toàn bộ mã nguồn trong tệp đó bằng đoạn mã nguồn sau:

using System.Collections.Generic;

using System.Linq;


namespace ContractSample

{


{

List<Person> personCollection = new List<Person>();

public bool HasPerson(int personId)

{

return personCollection.Any(x => x.personId == personId);

}

public Person GetPerson(int personId)

{

return personCollection.FirstOrDefault(x => x.personId ==

personId);

}


public void AddPerson(Person person)

{

personCollection.Add(person);

}

public Person[] GetAll()

{

return personCollection.ToArray();

}

public void EditPerson(int personId, Person person)

{

Person p = GetPerson(personId);

if (p != null)

{

p.FullName = person.FullName;

p.Age = person.Age;

}

}

public void DeletePerson(int personId)

{


if (p != null)

{

personCollection.Remove(p);

}

}

}

}

Bước 5. Sửa tệp tin cấu hình App.config, thay bằng cấu hình sau:


<configuration>

<system.web>


</system.web>


<services>

<service

behaviorConfiguration="ContractSample.StaffInformationBehavior"


name="ContractSample.StaffInformation">


contract="ContractSample.IStaffInformation">

<identity>

<dns value="localhost" />

</identity>

</endpoint>



<host>

<baseAddresses>

<add

baseAddress="http://localhost:8731/ContractSample/StaffInformation/" />

</baseAddresses>

</host>

</service>

</services>

<behaviors>

<serviceBehaviors>

<behavior name="ContractSample.StaffInformationBehavior">



</behavior>

</serviceBehaviors>

</behaviors>


</configuration>

Vậy là bạn đã có một dịch vụ quản trị thông tin về các nhân viên trong công ty. Bạn có thể sử dụng

chương trình WCF Test Client để thực hiện quản trị thông tin về nhân viên. Chi tiết về cách sử dụng

WCF Test Client, xem bài mở đầu. Ví dụ một phiên quản trị như sau:

1. Thêm mới nhân viên


Figure 3 Thêm mới một nhân viên

2. Lấy danh sách tất cả nhân viên

Figure 4 Lấy danh sách các nhân viên

3. Sửa thông tin một nhân viên


Figure 5 Sửa thông tin về nhân viên

4. Lấy thông tin về một nhân viên

Figure 6 Lấy thông tin về một nhân viên


1. Liệt kê các kiểu contract có trong WCF

Có các kiểu contract sau:

Service Contract

Data Contract


Message Contract

2. Để định nghĩa một service contract, cần phải làm những gì?

Để định nghĩa một service contract ta cần làm các bước sau:

Tạo một lớp (class) hoặc một giao diện (interface) để khai báo dịch vụ

Gắn cho lớp hoặc giao diện đó thuộc tính ServiceContract

Thêm vào thuộc tính OperationContract cho các phương thức cần có của dịch vụ


1. Introduction to Building Windows Communication Foundation Services (URL:

http://msdn.microsoft.com/en-us/library/aa480190.aspx)

2. WCF Essentials—Service Contract (URL: http://en.csharp-online.net/WCF_Essentials-

Service_Contract)

3. ServiceContractAttribute class (URL: http://msdn.microsoft.com/en-

us/library/system.servicemodel.servicecontractattribute.aspx)

4. DataContractAttribute class (URL: http://msdn.microsoft.com/en-

us/library/system.runtime.serialization.datacontractattribute.aspx)

5. MessageContractAttribute class (URL: http://msdn.microsoft.com/en-

us/library/system.servicemodel.messagecontractattribute.aspx)

Bài 5 CLIENTS TRONG WINDOWS COMMUNICATION FOUNDATION

Mục lục

1 Kiến trúc của client trong Windows Communication Foundation .................................................................... 2 1.1 Các đối tượng phía client ..............................................................................................................3

1.1.1 ICommunicationObject .........................................................................................................3

1.1.2 IExtensibleObject .................................................................................................................4

1.2 Các kênh client .............................................................................................................................4

1.2.1 IClientChannel ......................................................................................................................4

1.2.2 IContextChannel ...................................................................................................................4

1.3 Các Channel Factory.....................................................................................................................5

1.3.1 Constructor (Cấu tử) của ChannelFactory ............................................................................5

1.3.2 Các thuộc tính của ChannelFactory ......................................................................................5

1.3.3 Các phương thức của ChannelFactory ..................................................................................5

2 Các cách liên lạc của client ................................................................................................................................ 6 2.1 Một chiều (One-Way) ...................................................................................................................6

2.2 Yêu cầu-Trả lời (Request-Reply)..................................................................................................7

2.3 Song công (Duplex) ......................................................................................................................7

2.3.1 Phía dịch vụ ..........................................................................................................................7

2.3.2 Phía client .............................................................................................................................9

2.4 Dị bộ (Asynchronous).................................................................................................................10

2.4.1 Phía dịch vụ ........................................................................................................................11

2.4.2 Phía client ...........................................................................................................................12

3 Câu hỏi ôn tập .................................................................................................................................................. 13


Microsoft Vietnam – DPE Team | Bài 5: Clients trong WCF 2

Trong các bài trước, chúng ta đã tập trung phần lớn vào việc cài đặt dịch vụ với Windows

Communication Foundation. Hai bài trước chúng ta đã được giới thiệu về ba thành phần quan trọng để

xây dựng dịch vụ WCF là address (địa chỉ), bindings, và contracts. Bài này chúng ta tập trung về phía

client (máy khách, hay là các chương trình sử dụng dịch vụ WCF, ta gọi chung là client). Chúng ta sẽ

được giới thiệu các mục sau:

Kiến trúc của client

Các cách liên lạc của client

Viết mã nguồn cho client

Định nghĩa các bindings and endpoints (điểm cuối) cho client

1 Kiến trúc của client trong Windows Communication Foundation

Một client trong Windows Communication Foundation là một chương trình sử dụng các chức năng cung

cấp bởi một dịch vụ WCF. Chương trình client sẽ liên lạc với dịch vụ thông qua điểm cuối dịch vụ. Để

làm được việc này client cần phải biết một số thông tin về dịch vụ như địa chỉ của điểm cuối, binding mà

dịch vụ sử dụng, và contract dịch vụ. Các thành phần này đã được thảo luận ở các bài trước.

Một trong những thứ bạn có thể thấy trong kiến trúc của client là kênh thông tin được xây dựng dựa trên

các cấu hình binding, những cấu hình này được quy định trong tệp tin cấu hình. Những thông tin cấu hình

này chính là các thông tin đã được giới thiệu trong phần nói về bindings. Những bindings này cho phép

client và dịch vụ liên lạc với nhau một cách hiệu quả.

Điểm thứ hai bạn có thể thấy là cài đặt của giao diện IClientChannel. Giao diện này định nghĩa các

thao tác cho phép nhà phát triển điều khiển các chức năng của kênh, như đóng phiên làm việc của client

và huỷ một kênh (để thu hồi tài nguyên). Nó đưa ra các phương thức và hàm của lớp

System.ServiceModel.ChannelFactory.

Cuối cùng là bạn có thể thấy contract dịch vụ được tạo ra tự động, contract dịch vụ sẽ cung cấp tính năng

chuyển lời gọi hàm ở phía client thành các bản tin đi, và chuyển các bản tin tới thành thông tin mà

chương trình client có thể sử dụng dưới dạng giá trị trả về hay tham số đầu ra của hàm.

Các client liên lạc với điểm cuối dịch vụ thông qua một proxy, như hình dưới. Sự liên lạc được thực hiện

thông qua một kênh. Sau khi proxy và kênh được tạo ra, client có thể truy xuất các phương thức có ở

điểm cuối đó.

Figure 1 WCF Client Proxy


Có hai cách để tạo ra các client proxy:

Cách đầu tiên là tạo proxy từ mã nguồn được tạo ra tự động từ thông tin siêu dữ liệu. Siêu dữ liệu

này được cung cấp bởi dịch vụ. Việc tạo mã nguồn được thực hiện thông qua việc sử dụng công

cụ Svcutil.exe, công cụ này đi kèm với bộ cài Visual Studio 2008 hoặc có thể lấy được ở trên

trang web của Microsoft.

Cách thứ hai là tạo ra proxy thông qua mã nguồn sử dụng đối tượng ChannelFactory. Đối

tượng này được cung cấp từ lớp System.ServiceModel.ChannelFactory. Phương

pháp này cho phép nhà phát triển khả năng điều khiển nhiều hơn, ví dụ như tạo các kênh mới từ

một channel factory có sẵn.

1.1 Các đối tượng phía client

Một client trong Windows Communication Foundation phải chứa hai giao diện cơ sở là

ICommunicationObject và IExtensibleObject.

1.1.1 ICommunicationObject

Giao diện ICommunicationObject là một trong những thành phần lõi để định nghĩa chức năng liên

lạc. Nhiệm vụ của đối tượng này là định nghĩa contract cho trạng thái cơ bản của tất cả các đối tượng

trong hệ thống; ví dụ, trạng thái đối tượng liên lạc đóng hay mở, hoặc trong trạng thái đang mở hoặc

đang đóng. Những đối tượng này bao gồm các kênh, các đầu nghe (listeners), các dispatchers, factories,

và chứa dịch vụ (service host).

Một chuyển trạng thái là việc chuyển từ trạng thái này sang trạng thái khác; ví dụ kênh liên lạc chuyển từ

trạng thái “đang mở” sang trạng thái “mở”.

Giao diện này định nghĩa các phương thức cho việc khởi tạo chuyển trạng thái:

Open: Làm cho đối tượng liên lạc chuyển trạng thái từ “Created” sang “Opened”.

Close: Làm cho đối tượng liên lạc chuyển từ trạng thái hiện tại sang trang thái “Opened”.

Abort: Làm cho đối tượng liên lạc chuyển ngay lập tức từ trạng thái hiện tại sang trạng thái

“Closed”.

Ngoài các phương thức khởi tạo ở trên, giao diện ICommunicationObject còn định nghĩa các sự

kiện để thông báo việc thay đổi trạng thái:

Opening: Sự kiện này được kích hoạt khi đối tượng chuyển trạng thái từ Created sang

Opened, sự kiện này xảy ra khi hàm Open hoặc BeginOpen được gọi.

Closing: Sự kiện này được kích hoạt khi đối tượng chuyển trạng thái từ Opened sang Closed,

sự kiện này xảy ra khi hàm Close hoặc BeginClose được gọi.

Opened: Sự kiện này được kích hoạt khi đối tượng kết thúc việc chuyển trạng thái từ Opening

sang Opened

Closed: Sự kiện này được kích hoạt khi đối tượng kết thúc việc chuyển trạng thái từ Closing

sang Closed

Faulted: Sự kiện này được kích hoạt khi đối tượng chuyển sang trạng thái Faulted.

Ngoài ra còn có một tập phương thức dị bộ cho các phương thức Open và Close:

BeginOpen: Bắt đầu thao tác dị bộ để mở một đối tượng liên lạc

BeginClose: Bắt đầu thao tác dị bộ để đóng một đối tượng liên lạc

EndOpen: Hoàn tất thao tác dị bộ để mở một đối tượng liên lạc


EndClose: Hoàn tất thao tác dị bộ để đóng một đối tượng liên lạc

Giao diện ICommunicationObject có một thuộc tính trạng thái State, với kiểu là

CommunicationState, thuộc tính này được dùng để chỉ ra trạng thái hiện tại của đối tượng.

Khi một đối tượng cài đặt ICommunicationObject được khởi tạo, trạng thái mặc định là Created

chứ không phải là trạng thái Opened. Trong khi đang ở trạng thái Created, ta chỉ có thể thiết lập cấu

hình cho đối tượng ICommunicationObject chứ không thể dùng nó để gửi hay nhận bản tin. Để có

thể gửi hay nhận bản tin, đối tượng cần phải chuyển sang trạng thái Opened, nhưng khi ở trạng thái này,

ta không thể thiết lập cấu hình cho nó nữa.

Để chuyển đối tượng sang trạng thái Opened, ta gọi hàm Open. Đối tượng sẽ giữ trạng thái này cho tới

khi nó chuyển hoàn toàn sang trạng thái Closed. Hàm Close được dùng để chuyển đối tượng sang

trạng thái Closed, tuy nhiên nó đợi cho các thao tác hiện tại của đối tượng hoàn tất mới thực hiện

chuyển trạng thái. Hàm Abort thì không như vậy, nghĩa là những thao tác chưa hoàn tất sẽ bị huỷ bỏ, và

đối tượng được chuyển ngay sang trạng thái Closed.

1.1.2 IExtensibleObject

Giao diện IExtensibleObject cung cấp cách mở rộng cho client. Trong WCF, cách mở rộng đối

tượng được sử dụng để thêm các tính năng mới cho các lớp thực thi đã có, qua đó mở rộng các thành

phần hiện tại cũng như thêm mới các trạng thái cho một đối tượng.

Giao diện này được đưa ra duy nhất một thuộc tính để cung cấp tính năng này, Extensions, với kiểu

là IExtensionCollection. Thuộc tính này được sử dụng để trả về một tập hợp các đối tượng mở

rộng có thể được sử dụng để mở rộng các lớp thực thi đã có.

1.2 Các kênh client

Các client trong Windows Communication Foundation chứa hai giao diện cơ bản cho kênh, giao diện

IClientChannel và IContextChannel.

1.2.1 IClientChannel

Giao diện IClientChannel định nghĩa các thao tác được hỗ trợ bởi tất cả các kênh. Các kênh này

được tạo ra bởi lời gọi hàm ChannelFactory(TChannel).CreateChannel. Giao diện này chứa

các phương thức và thuộc tính có thể sử dụng để định nghĩa các hành xử kênh cho các yêu cầu bên ngoài

và hành xử kênh cho yêu cầu/trả lời của chương trình client.

Ví dụ, thuộc tính AllowInitializationUI có thể đươc sử dụng để báo cho WCF mở một kênh mà

không cần có lời gọi để mở nó.

1.2.2 IContextChannel

Giao diện IContextChannel định nghĩa trạng thái của phiên làm việc của một kênh. Những thông tin này

bao gồm SessionId, phiên Input và phiên Output, cùng với các điểm cuối cục bộ và từ xa đang được sử

dụng để liên lạc với client trong phiên làm việc. IContextChannel có các thuộc tính sau:

InputSession: Trả về phiên đầu vào cho kênh

OutputSession: Trả về phiên đầu ra cho kênh

LocalAddress: Trả về điểm cuối cục bộ cho kênh

RemoteAddress: Trả về địa chỉ từ xa nối với kênh

SessionId: Trả về định danh của phiên hiện tại

OperationTimeout: Trả về/thiết lập thời gian mà một thao tác phải hoàn thành. Nếu thao tác

không hoàn thành trong thời gian quy định, sẽ có exception (ngoại lệ) xảy ra.


AllowOutputBatching: Báo cho WCF lưu các bản tin trước khi chuyển chúng tới tầng vận

chuyển.

1.3 Các Channel Factory

Việc hiểu các đối tượng client và đối tượng kênh client rất quan trọng do chúng đều sử dụng đối tượng

ChannelFactory. Đối tượng ChannelFactory có trách nhiệm tạo và hỗ trợ các thực thi phía client.

Như đã nói ở phần đầu, bạn có thể tạo các client khi cần bằng cách sử dụng ChannelFactory hoặc sử

dụng công cụ svcutil.exe. Công cụ svcutil tự động tạo ra đoạn mã nguồn làm việc với ChannelFactory, để

tạo ra các kênh khi cần.

Đoạn mã nguồn sau mô tả việc sử dụng ChannelFactory để tạo ra một kênh cho mọt dịch vụ bằng cách

đưa vào tên contract dịch vụ:

EndpointAddress ea = new EndpointAddress("tcp.net://localhost:8000/WCFService"); BasicHttpBinding bb = new BasicHttpBinding(); IServiceClass client = ChannelFactory<IServiceClass>.CreateChannel(bb, ea);

client.PlaceOrder(Val1);

Lớp ChannelFactory bao gồm các thành phần quan trọng là các cấu tử (constructors), các thuộc tính,

và các phương thức.

1.3.1 Constructor (Cấu tử) của ChannelFactory

Lớp ChannelFactory có một cấu tử gọi là ChannelFactory. Nó được sử dụng để khởi tạo mới

một thể hiện của lớp ChannelFactory. Đoạn mã để tạo ra một thể hiện ChannelFactory như sau:

IServiceClass client = ChannelFactory<IServiceClass>.CreateChannel(bb, ea);

1.3.2 Các thuộc tính của ChannelFactory

Lớp ChannelFactory có các thuộc tính sau:

Credentials: Trả về các credential được sử dụng bởi client để liên lạc với điểm cuối dịch vụ

thông qua kênh được tạo ra bởi factory

Endpoint: Trả về điểm cuối mà kênh được tạo ra

State: Trả về trạng thái hiện tại của đối tượng liên lạc.

Việc sử dụng credential yêu cầu có tham chiếu tới không gian tên

System.ServiceModel.Description, thông qua việc sử dụng câu lệnh using:

using System.ServiceModel.Description;

Bạn có thể thiết lập credential cho client và dịch vụ cũng như cung cấp các credential cho việc xác thực ở

phía proxy. Ví dụ sau đây biểu diễn cách cung cấp credential cho xác thực phía proxy khi tạo một kênh:

TCP.ServiceClassClient("WSHttpBinding_IServiceClass"); ChannelFactory<TCP.IServiceClass> factory = new ChannelFactory<TCP.IServiceClass>("WSHttpBinding_IServiceClass"); TCP.IServiceClass channel = factory.CreateChannel(); ClientCredentials cc = new ClientCredentials(); cc.UserName.UserName = "scooter"; cc.UserName.Password = "wcfrocks"; factory.Credentials = cc;

1.3.3 Các phương thức của ChannelFactory

ChannelFactory có các phương thức sau:


Abort: Chuyển ngay lập tức trạng thái của đối tượng liên lạc từ trạng thái hiện tại sang trạng thái Closing

BeginClose: Bắt đầu thao tác dị bộ để đóng đối tượng liên lạc hiện tại

BeginOpen: Bắt đầu thao tác dị bộ để mở đối tượng liên lạc

Close: Chuyển trạng thái của đối tượng từ trạng thái hiện tại sang trạng thái Closed

EndClose: Kết thúc thao tác đóng dị bộ của đối tượng liên lạc hiện tại

EndOpen: Kết thúc thao tác mở dị bộ của đối tượng liên lạc hiện tại

Open: Chuyển trạng thái của đối tượng từ trạng thái Created sang trạng thái Opened

Ví dụ sau tạo ra một kênh rồi mở kênh để thực hiện liên lạc:

WCFClientApp.TCP.ServiceClassClient("WSHttpBinding_IServiceClass"); ChannelFactory<TCP.IServiceClass> factory = new ChannelFactory<TCP.IServiceClass>("WSHttpBinding_IServiceClass"); TCP.IServiceClass channel = factory.CreateChannel(); factory.Open(); channel.DoSomething();

Khi làm việc xong, bạn cần phải đóng channel factory bằng cách gọi hàm Close như sau

factory.Close();

2 Các cách liên lạc của client

2.1 Một chiều (One-Way)

Liên lạc một chiều là liên lạc chỉ theo một hướng duy nhất. Là hướng từ phía client tới dịch vụ. Không có

trả lời từ phía dịch vụ và client hoàn toàn không trông mong nhận được phản hồi. Theo cách này, client

gửi đi một bản tin và tiếp tục thao tác của mình.

Do không có phản hồi từ dịch vụ trong liên lạc một chiều, client sẽ không biết được liệu có lỗi xảy ra

trong quá trình liên lạc hay không, và nó cũng hoàn toàn không biết liệu yêu cầu có thành công hay

không. Để tạo ra dịch vụ cho liên lạc một chiều, ta đặt tham số IsOneWay của thuộc tính mô tả

OperationContract là True. Điều này sẽ thông báo cho dịch vụ biết là không cần có phản hồi.

Đoạn mã nguồn sau đây biểu diễn cách thiết lập một liên lạc một chiều, thao tác AddPerson,

EditPerson, và DeletePerson:

[ServiceContract] public interface IStaffInformation { [OperationContract] bool HasPerson(int personId); [OperationContract] Person GetPerson(int personId); [OperationContract] Person[] GetAll(); [OperationContract(IsOneWay=true] void AddPerson(Person person); [OperationContract(IsOneWay=true] void EditPerson(int personId, Person person); [OperationContract(IsOneWay=true] void DeletePerson(int personId); }


2.2 Yêu cầu-Trả lời (Request-Reply)

Liên lạc theo kiểu yêu cầu-trả lời thực hiện như sau: client gửi đi một bản tin cho dịch vụ, nó sẽ chờ để

nhận một phản hồi từ dịch vụ. Kiểu liên lạc này đồng thời còn có nghĩa là khi client gửi đi bản tin, nó sẽ

không thực hiện thao tác khác cho tới khi nó nhận được một phản hồi từ phía dịch vụ.

Trong Windows Communication Foundation, có hai cách để quy định kiểu liên lạc yêu cầu-trả lời. Cách

thứ nhất là đặt giá trị false cho tham số IsOneWay của OperationContract. Thực chất giá trị mặc

định của tham số IsOneWay là false, do vậy cách thứ hai để quy định kiểu liên lạc yêu cầu-trả lời là

không dùng tham số IsOneWay nữa. Do vậy các thao tác trên dịch vụ của WCF mặc định là liên lạc

kiểu hỏi-trả lời.

Ví dụ đoạn mã nguồn sau đây khai báo 4 thao tác theo kiểu yêu cầu-trả lời: HasPerson, GetPerson,

và GetAll:

[ServiceContract] public interface IStaffInformation { [OperationContract] bool HasPerson(int personId); [OperationContract] Person GetPerson(int personId); [OperationContract] Person[] GetAll(); [OperationContract(IsOneWay=true] void AddPerson(Person person); [OperationContract(IsOneWay=true] void EditPerson(int personId, Person person); [OperationContract(IsOneWay=true] void DeletePerson(int personId); }

Kiểu liên lạc hỏi-trả lời là kiểu liên lạc mặc định của WCF nên thông thường bạn cài đặt dịch vụ WCF

hay sử dụng dịch vụ WCF, bạn liên lạc theo kiểu hỏi-trả lời. Các ví dụ ở các bài trước đều theo kiểu làm

việc này. Hai kiểu liên lạc tiếp theo đây là liên lạc song công và liên lạc dị bộ bạn ít gặp hơn.

2.3 Song công (Duplex)

Liên lạc song công là khả năng mà cả client và dịch vụ đều có thể khởi tạo liên lạc, cũng như phản hồi

các bản tin đến; nói cách khác đây là liên lạc hai chiều. Với liên lạc song công, dịch vụ không chỉ có thể

trả lời các bản tin đến mà còn có thể khởi tạo liên lạc với client bằng cách gửi bản tin yêu cầu một phản

hồi từ phía client.

Để cấu hình một liên lạc song công, cần có thay đổi từ cả hai phía: dịch vụ và client.

2.3.1 Phía dịch vụ

Để thực hiện liên lạc song công, phía dịch vụ cần có hai giao diện. Mục tiêu của giao diện thứ nhất là sử

dụng trong liên lạc từ client tới dịch vụ, nghĩa là nó được sử dụng để nhận các bản tin từ phía client,

giống như các ví dụ từ trước tới nay. Giao diện thứ hai, còn gọi là callback interface, được sử dụng trong

liên lạc từ dịch vụ tới client để gửi bản tin từ phía dịch vụ tới client. Điều quan trọng là các thao tác ở

trong các giao diện phải được định nghĩa là các thao tác một chiều.

Ví dụ sau mô tả cách định nghĩa một contract dịch vụ song công. Bước đầu là định nghĩa giao diện cho

phía dịch vụ:

[ServiceContract(SessionMode = SessionMode.Required)] public interface IDuplexService


{ [OperationContract(IsOneWay = true)] void Add(int bignumber); [OperationContract(IsOneWay = true)] void Subtract(int bignumber); }

Bước tiếp theo là định nghĩa callback interface. Giao diện này được dùng để gửi các kết quả tới client:

public interface IDuplexServiceCallback { [OperationContract(IsOneWay = true)] void Calculate(int bignumber); }

Bước thứ 3 là đưa callback interface vào trong contract dịch vụ của giao diện đầu tiên. Việc này tạo ra

mối liên kết giữa hai giao diện:

[ServiceContract(SessionMode = SessionMode.Required, CallbackContract=typeof(IDuplexServiceCallback))] public interface IDuplexService { [OperationContract(IsOneWay = true)] void Add(int bignumber); [OperationContract(IsOneWay = true)] void Subtract(int bignumber); }

Cuối cùng là tạo ra một lớp để cài đặt contract dịch vụ song công. Để làm điều này, trước hết cần phải

thêm một quy định hành xử cho dịch vụ (ServiceBehavior) vào lớp cài đặt bằng cách sử dụng thuộc tính

mô tả ServiceBehavior, và đặt giá trị PerSession cho tham số InstanceContextMode cho

thuộc tính này.

[ServiceBehavior(InstanceContextMode=InstanceContextMode.PerSession)] public class DuplexService : IDuplexService { private int answer = 0; IDuplexServiceCallback Callback { get { return OperationContext.Current.GetCallbackChannel<IDuplexServiceCallback>(); } } public void Add(int bignumber) { answer += bignumber; Callback.Calculate(answer); } public void Subtract(int bignumber) { answer -= bignumber; Callback.Calculate(answer); } }


2.3.2 Phía client

Để thực hiện liên lạc song công, phía client cũng phải nhận một phần trách nhiệm trong việc cài đặt, và

cũng phải cài đặt một callback contract. Client thực hiện bằng cách cài đặt callback interface của duplex

contract:

public class ServiceCallback : IDuplexServiceCallback { private TextBox resultHolder; public ServiceCallback(TextBox textbox) { resultHolder = textbox; } #region IDuplexServiceCallback Members public void Calculate(int bignumber) { resultHolder.Text = bignumber.ToString(); } #endregion }

Bước cuối cùng cho client là tạo ra cách để xử lý bản tin ở callback interface. Điều này có thể thực hiện

bằng cách tạo ra một thể hiện của lớp InstanceContext trong lớp ở client:

InstanceContext ic = new InstanceContext(new ServiceCallback(resultText));

Sau khi có được một thể hiện của lớp InstanceContext, bạn có thể tạo client và thực hiện gọi hàm của

dịch vụ:

client = new DuplexServiceClient(ic); int value = Convert.ToInt32(inputText.Text); client.Add(value);

Sau đây là ví dụ hoàn chỉnh phía client để thực hiện liên lạc song công:

using System; using System.ServiceModel; using System.Windows.Forms; using DuplexClient.DService; namespace DuplexClient { public class ServiceCallback : IDuplexServiceCallback { private TextBox resultHolder; public ServiceCallback(TextBox textbox) { resultHolder = textbox; } #region IDuplexServiceCallback Members public void Calculate(int bignumber) { resultHolder.Text = bignumber.ToString(); } #endregion } public partial class MainForm : Form { DuplexServiceClient client;


public MainForm() { InitializeComponent(); InstanceContext ic = new InstanceContext(new ServiceCallback(resultText)); client = new DuplexServiceClient(ic); } private void buttonAdd_Click(object sender, EventArgs e) { int value = Convert.ToInt32(inputText.Text); client.Add(value); } private void buttonSubtract_Click(object sender, EventArgs e) { int value = Convert.ToInt32(inputText.Text); client.Subtract(value); } } }

Kết quả thực hiện như sau:

Figure 2 Thực hiện thao tác Add(100)

Figure 3 Thực hiện thao tác Subtract(300) từ giá trị hiện tại

2.4 Dị bộ (Asynchronous)

Liên lạc dị bộ được thực hiện bằng cách gọi các hàm dị bộ. Việc liên lạc dị bộ cho phép chương trình tiếp

tục thực hiện những việc khác trong khi hàm được gọi vẫn đang thực hiện.

Cũng giống như trong liên lạc song công, các thao tác dị bộ yêu cầu một số thay đổi về phía client và

dịch vụ.


2.4.1 Phía dịch vụ

Các thao tác dị bộ chia một thao tác ra thành hai thao tác rời nhau nhưng có liên quan tới nhau. Thao tác

đầu tiên là thao tác Begin (bắt đầu), thao tác này được client gọi tới khi bắt đầu thao tác xử lý. Trong thao

tác Begin, cần thêm 2 tham số cho thao tác này và giá trị trả về là một đối tượng

System.IAsyncResult.

Thao tác thứ hai bắt đầu với End, nhận một tham số là đối tượng System.IAsyncResult, và trả về

một giá trị. Thao tác End không cần phải có thuộc tính OperationContract.

Đoạn mã sau khai báo một dịch vụ với liên lạc dị bộ:

namespace AsyncService { [ServiceContract] public interface IAsynchronousService { [OperationContract(AsyncPattern=true)] IAsyncResult BeginAdd(int val1, int val2, AsyncCallback cb, object state); int EndAdd(IAsyncResult result); } }

Tiếp theo ta cài đặt một lớp cho khai báo dịch vụ ở trên:

[ServiceBehavior(ConcurrencyMode = ConcurrencyMode.Multiple)] public class AsynchronousService : IAsynchronousService { public IAsyncResult BeginAdd(int val1, int val2, AsyncCallback cb, object state) { MathAsyncResult asyncResult = new MathAsyncResult(cb, state); asyncResult.Value1 = val1; asyncResult.Value2 = val2; ThreadPool.QueueUserWorkItem(new WaitCallback((Callback)), asyncResult); return asyncResult; } public int EndAdd(IAsyncResult asyncResult) { int result = 0; using (MathAsyncResult mathAsyncResult = asyncResult as MathAsyncResult) { mathAsyncResult.AsyncWaitHandle.WaitOne(); result = mathAsyncResult.Result; } return result; } public int Add(int value1, int value2) { Thread.Sleep(1000); return value1 + value2; } private void Callback(object asyncResult)


{ MathAsyncResult mathAsyncResult = (MathAsyncResult)asyncResult; try { mathAsyncResult.Result = Add(

mathAsyncResult.Value1, mathAsyncResult.Value2); } finally { mathAsyncResult.OnCompleted(); } }

}

2.4.2 Phía client

Phía client của liên lạc dị bộ chỉ đơn giản là đưa vào tham số đúng và đảm bảo rằng giá trị trả về là kiểu

IAsyncResult. Để truy nhập các thao tác dị bộ của dịch vụ, client bắt đầu với việc gọi hàm Begin, trong

ví dụ sau là BeginAdd. Trong lời gọi hàm đó, client đưa vào một hàm callback để nhận giá trị trả về,

trong ví dụ là callbackAdd. Khi hàm callback được gọi, client gọi hàm End để lấy ra kết quả, trong ví dụ

là hàm EndAdd.

Mã nguồn hoàn chỉnh của phía client như sau:

using System; using System.ServiceModel; using System.Windows.Forms; using AsyncClient.AService; namespace AsyncClient { public partial class MainForm : Form { IAsynchronousService client; public MainForm() { InitializeComponent(); ChannelFactory<IAsynchronousService> factory = new ChannelFactory<IAsynchronousService>("AsynchronousService"); factory.Open(); client = factory.CreateChannel(); } private void buttonAdd_Click(object sender, EventArgs e) { int val1 = Convert.ToInt32(inputText1.Text); int val2 = Convert.ToInt32(inputText2.Text); client.BeginAdd(val1, val2, new AsyncCallback(OnEndAdd), null); resultText.Text = "Calculating ..."; } public void OnEndAdd(IAsyncResult asyncResult) { this.Invoke( new MethodInvoker(delegate() { resultText.Text = client.EndAdd(asyncResult).ToString(); })); }


} }

Kết quả thực hiện liên lạc dị bộ như sau:

Figure 4 Nhập dữ liệu cho client

Figure 5 Bắt đầu thực hiện hàm Add

Figure 6 Kết thúc thực hiện hàm Add, lấy kết quả trả về


1. Liệt kê các kiểu liên lạc có trong WCF

Có các kiểu liên lạc sau:

Liên lạc một chiều từ client tới dịch vụ

Liên lạc yêu cầu-trả lời

Liên lạc song công

Liên lạc dị bộ



1. Building Clients (URL: http://msdn.microsoft.com/en-us/library/ms730825.aspx)

2. Synchronous and Asynchronous Operations (URL: http://msdn.microsoft.com/en-

us/library/ms734701.aspx)

3. How to: Call WCF Service Operations Asynchronously (URL: http://msdn.microsoft.com/en-


Bài 6

SERVICES TRONG


Mục lục

1 Tổng quan .......................................................................................................................................................... 2

1.1 Các kiểu dịch vụ ...........................................................................................................................2

1.1.1 Typed Service (Định kiểu) ....................................................................................................2

1.1.2 Untyped service (Không định kiểu) ......................................................................................3

1.1.3 Typed message service (Bản tin định kiểu) ..........................................................................4

1.2 Các contract dịch vụ .....................................................................................................................5

1.3 Service Endpoints (Các điểm cuối dịch vụ) ..................................................................................5

1.3.1 Định nghĩa điểm cuối bằng mã nguồn ..................................................................................5

1.3.2 Định nghĩa điểm cuối bằng tệp tin cấu hình .........................................................................6

2 Các phép hành xử dịch vụ (Service behaviors) ................................................................................................. 7

2.1 Lớp thuộc tính ServiceBehavior ...................................................................................................8

2.2 Lớp thuộc tính OperationBehavior .............................................................................................10

3 Xử lý lỗi ........................................................................................................................................................... 10

3.1 Ví dụ xử lý lỗi sử dụng FaultContract ........................................................................................10

4 Câu hỏi ôn tập .................................................................................................................................................. 16


Microsoft Vietnam – DPE Team | Bài 6: Services trong WCF 2

Bài này sẽ tập trung vào các thành phần cho riêng phía dịch vụ của Windows Communication

Foundation. Thực chất trong các bài trước chúng ta đã nói tới các chủ đề và khái niệm có liên quan đến

dịch vụ và client, rất nhiều trong số chúng vẫn áp dụng được cho phía dịch vụ. Tuy vậy, vẫn còn có một

số khái niệm phía dịch vụ chưa được nhắc tới.

Bài này sẽ tập trung vào các vấn đề sau:

Tổng quan về các khái niệm phía dịch vụ của Windows Communication Foundation

Các phép hành xử (behaviors)

Xử lý lỗi

1 Tổng quan

1.1 Các kiểu dịch vụ

Có ba kiểu dịch vụ trong WCF là: Định kiểu, Không định kiểu, và Bản tin định kiểu. Sau đây chúng ta sẽ

xem xét chi tiết các kiểu dịch vụ của WCF.

1.1.1 Typed Service (Định kiểu)

Dịch vụ có định kiểu là loại dịnh vụ đơn giản nhất trong số ba kiểu dịch vụ. Tuy vậy nó cung cấp phần

lớn các tính năng cần thiết để bạn phát triển các dịch vụ WCF.

Một thuật ngữ hay dùng cho dịch vụ định kiểu là “mô hình tham số”, mô hình này định nghĩa một cách

chính xác kiểu dịch vụ này làm gì. Các dịch vụ định kiểu không giới hạn ở việc định kiểu của các tham

số hay kết quả trả về. Các dịnh vụ kiểu này có thể chấp nhận các kiểu đơn giản cũng như phức hợp. Tuy

nhiên khi truyền các tham số hay trả về giá trị kiểu phức hợp, ta cần phải định nghĩa data contract cho các

kiểu đó.

Dịch vụ định kiểu trong Windows Communication Foundation xử lý tất cả các bản tin, bạn không cần

phải làm việc trực tiếp ở mức bản tin. Ví dụ sau đây mô tả một dịch vụ định kiểu. Contract dịch vụ định

nghĩa 2 thao tác. Thao tác thứ nhất không cần tham số, thao tác thứ 2 chấp nhận 2 tham số kiểu là int (số

nguyên):

[ServiceContract]

public interface IService1

{

[OperationContract]

string SayHello();

[OperationContract]

string GetData(int firstValue, int secondValue);


}

Dịch vụ định kiểu còn hỗ trợ các kiểu tham số với từ khoá ref và out.

1.1.2 Untyped service (Không định kiểu)

Các dịch vụ không định kiểu hơi phức tạp hơn so với dịch vụ định kiểu do chúng làm việc trực tiếp với

bản tin. Trong kiểu dịch vụ này, bạn định nghĩa các bản tin và nội dung của chúng. Nghĩa là với kiểu dịch

vụ này, bạn làm việc ở mức bản tin, các đối tượng bản tin được chuyển qua lại giữa client và dịch vụ, và

dịch vụ có thể trả về một đối tượng bản tin nếu được yêu cầu. Hơn nữa, kiểu dịch vụ này cho bạn khả

năng truy nhập tới nội dung bản tin.

Ví dụ sau đây mô tả cách tạo ra dịch vụ không định kiểu, trong ví dụ này, thay vì gửi các kiểu là các tham

số, các đối tượng bản tin được chuyển qua lại giữa client và dịch vụ:

[ServiceContract]

public interface IServiceClass

{

[OperationContract]

string InitiateOrder();

[OperationContract]

BookOrder PlaceOrder(BookOrder request);

[OperationContract]

string FinalizeOrder();

}

[MessageContract]

public class BookOrder

{

private string isbn;

private int quantity;

private string ordernumber;

public BookOrder(BookOrder message)

{

isbn = message.isbn;

quantity = message.quantity;

}

[MessageHeader]

public string ISBN

{

get { return isbn; }

set { isbn = value; }

}


[MessageBodyMember]

public int Quantity

{

get { return quantity; }

set { quantity = value; }

}

[MessageBodyMember]

public string OrderNumber

{

get { return ordernumber; }

set { ordernumber = value; }

}

public class ServiceClass : IServiceClass

{

string IServiceClass.InitiateOrder()

{

return "Initiating Order...";

}

public BookOrder PlaceOrder(BookOrder request)

{

BookOrder response = new BookOrder(request);

response.OrderNumber = "12345678";

return response;

}

string IServiceClass.FinalizeOrder()

{

return "Order placed successfully.";

}

}

}

1.1.3 Typed message service (Bản tin định kiểu)

Trong một dịch vụ bản tin có định kiểu (typed message service) còn được gọi là “mô hình contract bản

tin” bạn định nghĩa các bản tin và nội dung của chúng. Ở đây, các bản tin được mô tả với thuộc tính

MessageContract, là các contract bản tin thường được sử dụng để định nghĩa các lớp bản tin. Các

bản tin này sẽ được sử dụng để gửi qua lại trong các thao tác của dịch vụ.

[ServiceContract]


public interface IBookOrder

{

[OperationContract]

void PlaceOrder(MyContract Contract);

}

[MessageContract]

public class MyContract

{

[MessageHeader]

string Title;

[MessageBodyMember]

decimal cost;

}

1.2 Các contract dịch vụ

Trong các bài trước các bạn đã biết cách để định nghĩa một contract dịch vụ, sử dụng thuộc tính

ServiceContract trên một lớp hay một giao diện. Một dịch vụ trong WCF thông thường chứa một

hay một vài các thao tác, các thao tác này được mô tả bởi lớp thuộc tính là OperationContract.

Những phương thức của một lớp (giao diện) không có thuộc tính OperationContract thì không

thuộc vào các thao tác của dịch vụ. Phía client sẽ không thể truy xuất tới các phương thức này. Điều này

cũng giống như việc sử dụng thuộc tính WebMethod để định nghĩa các phương thức trong dịch vụ web.

1.3 Service Endpoints (Các điểm cuối dịch vụ)

Các client chỉ có thể truy nhập tới dịch vụ và sử dụng các thao tác của dịch vụ thông qua các điểm cuối

dịch vụ. Điểm cuối dịch vụ có thể được định nghĩa thông qua mã nguồn hoặc thông qua tập tin cấu hình.

Một dịch vụ có thể có một hay nhiều điểm cuối, mỗi điểm cuối có một địa chỉ (address), một binding, và

một contract dịch vụ.

1.3.1 Định nghĩa điểm cuối bằng mã nguồn

Như đã nói ở trên, một điểm cuối dịch vụ cần có một địa chỉ, một binding, và một contract dịch vụ. Hai

dòng đầu của đoạn mã nguồn bên dưới dùng để định nghĩa các địa chỉ mà dịch vụ sẽ sử dụng. Dòng tiếp

tạo ra một đối tượng ServiceHost để chứa dịch vụ.

Uri bpa = new Uri("net.pipe://localhost/NetNamedPipeBinding");

Uri tcpa = new Uri("net.tcp://localhost:8000/TcpBinding");

ServiceHost sh = new ServiceHost(typeof(ServiceClass), bpa, tcpa);

NetNamedPipeBinding pb = new NetNamedPipeBinding();


NetTcpBinding tcpb = new NetTcpBinding();

ServiceMetadataBehavior behave = new ServiceMetadataBehavior();

sh.Description.Behaviors.Add(behave);

sh.AddServiceEndpoint(typeof(IMetadataExchange),

MetadataExchangeBindings.CreateMexTcpBinding(), "mex");

sh.AddServiceEndpoint(typeof(IMetadataExchange),

MetadataExchangeBindings.CreateMexNamedPipeBinding(), "mex");

sh.AddServiceEndpoint(typeof(IServiceClass), pb, bpa);

sh.AddServiceEndpoint(typeof(IServiceClass), tcpb, tcpa);

sh.Open();

1.3.2 Định nghĩa điểm cuối bằng tệp tin cấu hình

Sau đây là một ví dụ dùng tập tin cấu hình để định nghĩa điểm cuối.


<configuration>


<services>

<service name="WCFService.Service" behaviorConfiguration="Service1Behavior">

<host>

<baseAddresses>

<add baseAddress = "http://localhost:8731/Service/" />

<add baseAddress = "net.tcp://localhost:8731/Service/" />

</baseAddresses>

</host>

<endpoint address ="tcpmex" binding="mexTcpBinding"


<endpoint address ="" binding="wsHttpBinding" contract="TempWCF.IService1"

/>


contract="IMetadataExchange"/>

</service>

</services>

<behaviors>

<serviceBehaviors>

<behavior name="Service1Behavior">

<serviceMetadata httpGetEnabled="True"/>

</behavior>

</serviceBehaviors>

</behaviors>



</configuration>

2 Các phép hành xử dịch vụ (Service behaviors)

Contract dịch vụ định nghĩa các đầu vào, đầu ra, kiểu dữ liệu và các tính năng của một dịch vụ. Contract

dịch vụ kết hợp với các thông tin về địa chỉ và binding làm cho dịch vụ có thể truy nhập được bởi các

client. Tuy vậy với tất cả các thông tin và tính năng này, ta vẫn không điều khiển được các khía cạnh

khác của dịch vụ như việc điều khiển thực thi của dịch vụ hay điều khiển luồng hoặc các thực thể của

dịch vụ.

Câu trả lời ở đây là sử dụng các behavior (các hành xử). Các service behavior (hành xử dịch vụ) là các

đối tượng dùng để thay đổi và điều khiển đặc tính của các dịch vụ Windows Communication Foundation

trong khi thực thi. Khi cài đặt một contract dịch vụ, bạn có thể điều khiển nhiều đặc tính khi thực thi của

dịch vụ.

Có hai kiểu behavior trong Windows Communication Foundation: service behavior và operation

behavior (hành xử thao tác). Việc định nghĩa các behavior cũng giống như các đối tượng khác trong

WCF bằng cách sử dụng các lớp thuộc tính. Ta sử dụng lớp thuộc tính ServiceBehavior và

OperationBehavior để định nghĩa các behavior. Ví dụ sau đây sử dụng hai lớp thuộc tính này.

[ServiceContract]

public interface IServiceClass

{

[OperationContract]

int Add(int x, int y);

[OperationContract]

int Subtract(int x, int y);

}

[ServiceBehavior]

public class ServiceClass : IServiceClass

{

[OperationBehavior]

public int Add(int x, int y)

{

return x + y;

}

[OperationBehavior]


public int Subtract(int x, int y)

{

return x - y;

}

}

2.1 Lớp thuộc tính ServiceBehavior

Thuộc tính ServiceBehavior chỉ được áp dụng ở mức class. Tuy vậy nó có thể áp dụng cho cả các

giao diện và các lớp. Sử dụng các tham số của lớp thuộc tính ServiceBehavior ta có thể điều khiển

một số khía cạnh khác nhau của dịch vụ:

Tham số Mô tả

Concurrency Điều khiển xử lý luồng cho một đối tượng. Chỉ hợp lệ khi tham số

Instancing có giá trị không phải là PerCall

Instancing Điều khiển việc tạo mới đối tượng cũng như điều khiển thời gian sống của

đối tượng đó. Giá trị mặc định là PerCall, nghĩa là mỗi lần phương

thức được gọi thì tạo mới một đối tượng. Nói chung, trong các dịch vụ có

hỗ trợ phiên làm việc, các giá trị PerSession hay Shareable có thể

cho lại hiệu năng tốt hơn, tuy vậy lại tốn kém trong việc quản lý đồng bộ.

Throttling Có thể thiết đặt thông qua tập tin cấu hình để giới hạn số lượng đồng thời

các lời gọi, kết nối, tổng số thể hiện, và các thao tác đợi. Tham số này chỉ

có tác dụng khi việc điều khiển luồng cho phép nhiều lời gọi đồng thời.

Transaction Điều khiển các khía cạnh của một giao dịch như tự động hoàn thành, mức

cách li, và việc sử dụng lại các đối tượng.

Quản lý phiên Cung cấp khả năng tự động đóng một phiên hoặc nạp chồng các hành xử

mặc định

Service behavior được cấu hình thông qua thành phần <serviceBehaviors> trong tập tin cấu hình. Ví dụ

sau đây mô tả cách thiết lập behavior cho debug dịch vụ và siêu dữ liệu của dịch vụ:

<behaviors>

<serviceBehaviors>

<behavior name="serviceBehavior">

<serviceDebug includeExceptionDetailInFaults="true"/>


<serviceMetadata />

</behavior>

</serviceBehaviors>

</behaviors>

Để gắn một tập các behavior tới một dịch vụ, sử dụng thuộc tính behaviorConfiguration của thành phần

<service> như ví dụ sau:

<services>

<service behaviorConfiguration="TempWCFServiceBehavior"

name="TempWCF.ServiceClass">

...

</service>

</services>

<behaviors>

<serviceBehaviors>

<behavior name="TempWCFServiceBehavior">



</behavior>

</serviceBehaviors>

</behaviors>

Ngoài việc sử dụng tập tin cấu hình, bạn còn có thể sử dụng mã nguồn để định nghĩa các service

behavior:

ServiceHost host = new ServiceHost(typeof(ServiceClass));

ServiceMetadataBehavior mexBehavior =

host.Description.Behaviors.Find<ServiceMetadataBehavior>();

if (mexBehavior == null)

{

mexBehavior = new ServiceMetadataBehavior();

mexBehavior.HttpGetEnabled = true;

host.Description.Behaviors.Add(mexBehavior);

}

host.Open();


2.2 Lớp thuộc tính OperationBehavior

Sử dụng ServiceBehavior bạn có thể điều khiển các behavior ở mức dịch vụ, tuy nhiên bạn còn có

thể điều khiển các behavior ở mức các thao tác của dịch vụ sử dụng lớp thuộc tính

OperationBehavior. Sử dụng lớp thuộc tính này bạn có thể điều khiển các khía cạnh sau:

Điều khiển Mô tả

Transaction Cung cấp khả năng tự động hoàn thành với luồng giao dịch và các tuỳ

chọn cần thiết

Caller Identity Khi được hỗ trợ bởi binding, sẽ cung cấp khả năng thực thi dưới định

danh của hàm gọi (caller)

Việc sử dụng lại đối tượng Cung cấp khả năng nạp chồng chế độ InstanceMode của

ServiceBehavior

3 Xử lý lỗi

Windows Communication Foundation sử dụng hai hệ thống báo lỗi là các đối tượng Exception và các

bản tin lỗi SOAP. Trong các ứng dụng trên nền .NET Framework thì lỗi được biễu diễn dưới dạng các

đối tượng Exception hoặc lớp kế thừa của Exception. Trong các ứng dụng SOAP, thông tin về lỗi được

liên lạc bằng các bản tin lỗi SOAP. Do vậy, các lỗi (exception) ở trong WCF cần phải được chuyển về

dạng bản tin lỗi SOAP mới có thể gửi tới client.

Có hai kiểu lỗi SOAP có thể gửi trả lại phía client như sau:

Được khai báo: Những thao tác có khai báo lỗi sẽ được mô tả với thuộc tính

FaultContract. Việc mô tả bằng thuộc tính mô tả FaultContract nhằm mục đính đặc tả

kiểu của lỗi SOAP.

Không khai báo: Lỗi dạng này không được khai báo ở các thao tác trong dịch vụ

Khi xây dựng dịch vụ, ta nên khai báo các lỗi có thể xảy ra ở một thao tác sử dụng thuộc tính

FaultContract. Điều này cho phép đặc tả một cách chính thức tất cả các lỗi SOAP mà client có thể

nhận được khi sử dụng thao tác này. Để đảm bảo tính bảo mật, chỉ những thông tin mà client cần biết liên

quan tới lỗi thì mới nên trả về trong lỗi SOAP.

3.1 Ví dụ xử lý lỗi sử dụng FaultContract

Bước 1: Tạo một bản tin lỗi theo ý.


namespace FaultContractSample

{


/// <summary>

/// Đây là cấu trúc được sử dụng để định nghĩa một bản tin báo lỗi.

/// Lỗi chi tiết có thể xem ở thuộc tính Message của cấu trúc này.

/// </summary>

[DataContract]

public struct CustomFaultMsg

{

/// <summary>

/// Thuộc tính này được sử dụng để chứa thông tin chi tiết về lỗi xảy

ra.

/// Thông tin về lỗi sẽ được gửi từ dịch vụ tới client

/// </summary>

[DataMember]

public string Message { get; set; }

}

}

Bước 2: Gắn lỗi SOAP với một thao tác trong dịch vụ



/// <summary>

/// Định nghĩa thông tin về một nhân viên

/// </summary>

[DataContract]

public class Person

{

[DataMember]

public int PersonId;

[DataMember]


[DataMember]

public int Age;

}

[ServiceContract]



{

[OperationContract]


/// <summary>

/// Lấy về thông tin của một nhân viên.

/// Nếu có nhân viên với ID trùng với personId thì

/// trả về thông tin nhân viên đó.

/// Trong trường hợp không có nhân viên phù hợp thì báo lỗi bằng bản tin

lỗi

/// </summary>

/// <param name="personId">ID của nhân viên</param>

/// <returns>Thông tin của nhân viên</returns>

[OperationContract]

[FaultContract(typeof(CustomFaultMsg))]


[OperationContract]

Person[] GetAll();

[OperationContract]


/// <summary>

/// Sửa thông tin của một nhân viên.

/// Nếu có nhân viên với ID trùng với personId thì

/// cập nhật thông tin nhân viên đó.


lỗi

/// </summary>


/// <param name="person">Thông tin mới về nhân viên</param>

[OperationContract]



/// <summary>

/// Xoá thông tin một nhân viên

/// Nếu có nhân viên với ID trùng với personId thì xoá thông tin nhân

viên đó.



lỗi

/// </summary>


[OperationContract]



}

Bước 3: Kiểm tra điều kiện, báo lỗi khi cần:


using System.Linq;



{

readonly List<Person> personCollection = new List<Person>();


{

return personCollection.Any(x => x.PersonId == personId);

}


{

if (!HasPerson(personId))

{

var error = new CustomFaultMsg

{ Message = "Không có nhân viên nào với ID là : " + personId };

throw new FaultException<CustomFaultMsg>(error);

}

return personCollection.FirstOrDefault(x => x.PersonId == personId);

}


{

personCollection.Add(person);

}



{

return personCollection.ToArray();

}


{



p.Age = person.Age;

}


{


personCollection.Remove(p);

}

}

Bước 4: Xử lý lỗi phía client

private void buttonGetInformation_Click(object sender, EventArgs e)

{

var client = new StaffInformationClient();

try

{

Person p = client.GetPerson(Convert.ToInt32(textBoxID.Text));

dataGrid.DataSource = new[] { p };

}

catch (FaultException<CustomFaultMsg> ex)

{

MessageBox.Show(ex.Message, "Error");

}

}

Sau đây là một số kết quả khi thực hiện:


Figure 1 Những nhân viên có trong cơ sở dữ liệu

Figure 2 Thông tin về nhân viên có ID là 3


Figure 3 Báo lỗi khi lấy thông tin về nhân viên ID là 5


1. Làm thế nào để dịch vụ của WCF báo cho client biết là có lỗi nào đó xảy ra trong quá trình thực

hiện?

Trả lời: Có nhiều cách để báo cho client biết về lỗi xảy ra, thông thường ta sử dụng cách báo lỗi

bằng lớp thuộc tính mô tả FaultContract cho một thao tác có lỗi, đồng thời trong thao tác đó

throw một đối tượng Exception.


1. Discover Mighty Instance Management Techniques For Developing WCF Apps (URL:

http://msdn.microsoft.com/en-us/magazine/cc163590.aspx)

2. ServiceBehaviorAttribute Class (URL: http://msdn.microsoft.com/en-

us/library/system.servicemodel.servicebehaviorattribute.aspx)

3. Using the Fault Contracts (SOAP Faults) in WCF Programming (URL: http://www.c-

sharpcorner.com/UploadFile/SunilBabuYLV/SOAPFaultContract08262008093633AM/SOAPFa

ultContract.aspx)

Bài 7 SECURITY TRONG


Mục lục

1 Tổng quan về bảo mật ....................................................................................................................................... 2 1.1 Ích lợi từ bảo mật trong WCF .......................................................................................................2

1.1.1 Tích hợp với các kiến trúc bảo mật có sẵn ........................................................................................ 3

1.1.2 Tích hợp với mô hình xác thực có sẵn ............................................................................................... 3

1.1.3 Các chuẩn và tính interoperability (làm việc liên môi trường) .......................................................... 3

1.2 Các lĩnh vực bảo mật của WCF ....................................................................................................3 1.2.1 Transfer security ................................................................................................................................ 4

1.2.2 Các chế độ bảo mật vận chuyển và bản tin ........................................................................................ 4

1.2.3 Điều khiển truy nhập ......................................................................................................................... 4

1.2.4 Auditing ............................................................................................................................................. 4

2 Lập trình với bảo mật trong WCF ..................................................................................................................... 4 2.1 Đặt chế độ bảo mật .......................................................................................................................4 2.2 Chọn kiểu xác thực client .............................................................................................................6 2.3 Thiết lập các giá trị credentials cho dịch vụ .................................................................................6 2.4 Thiết lập các giá trị credentials cho client ....................................................................................7

3 Xây dựng ví dụ với bảo mật trong WCF ........................................................................................................... 8 3.1 Tạo dịch vụ WCF..........................................................................................................................8 3.2 Thêm chức năng cho dịch vụ ........................................................................................................9 3.3 Thiết lập dịch vụ WCF sử dụng wsHttpBinding với Windows Authentication và Message

Security ..................................................................................................................................................12 3.4 Tạo ứng dụng client ....................................................................................................................13 3.5 Thêm tham chiếu tới dịch vụ WCF cho client ............................................................................14 3.6 Thêm chức năng cho client .........................................................................................................14

4 Câu hỏi ôn tập .................................................................................................................................................. 15


Microsoft Vietnam – DPE Team | WCF – Bài 7: Security trong WCF 2

Các bài trước chúng ta đã biết qua về các thành phần tạo nên một dịch vụ trên Windows

Communication Foundation, đồng thời cũng biết cách xây dựng một client để sử dụng các dịch vụ đó.

Tuy vậy chúng ta chưa hề đề cập tới một vấn đề rất quan trọng trong truyền dữ liệu đó là việc đảm bảo an

toàn dữ liệu cũng như tính nhất quán của dữ liệu. Trong một môi trường phân tán, việc truyền và gửi dữ

liệu giữa client với dịch vụ cần phải được bảo vệ khỏi sự dòm ngó của những đối tượng không mong

muốn. Bạn cần phải đảm bảo chắc chắn rằng, dữ liệu chỉ trao đổi giữa các thành phần có đủ thẩm quyền

mà thôi.

Với yêu cầu trên, Windows Communication Foundation cung cấp cho bạn một nền tảng cho

phép bạn thực hiện trao đổi dữ liệu (bản tin) thông qua rất nhiều giao thức khác nhau, trong đó có cả các

giao thức hỗ trợ bảo mật để phù hợp với từng yêu cầu của bạn.

Bài này sẽ tập trung thảo luận về các khía cạnh khác nhau về bảo mật với Windows

Communication Foundation và cách khai thác chúng. Mặc dù lĩnh vực bảo mật thông tin là một lĩnh vực

rất lớn, trong bài này chúng ta chỉ tập trung vào khía cạnh bảo mật bản tin trong WCF mà thôi. Chúng ta

sẽ thảo luận những vấn đề sau:

Tổng quan về bảo mật với Windows Communication Foundation

Lập trình với bảo mật trong Windows Communication Foundation

1 Tổng quan về bảo mật

Như các bạn đã biết Windows Communication Foundation là một nền tảng lập trình phân tán dựa

trên cơ sở các bản tin SOAP. Do vậy cần phải đảm bảo tính bảo mật của các bản tin trao đổi giữa client

với dịch vụ để có thể bảo vệ được dữ liệu khỏi những đối tượng không mong muốn. Việc này có thể thực

hiện nhờ vào việc WCF hỗ trợ trao đổi các bản tin bảo mật (secure message) dựa trên kiến trúc bảo mật

nền tảng cũng như các chuẩn bảo mật cho các bản tin SOAP.

WCF sử dụng các khái niệm mà bạn đã quen khi bạn xây dựng các ứng dụng bảo mật phân tán

với các công nghệ có sẵn như HTTPS, Windows integrated security (bảo mật tích hợp với hệ điều hành

Windows), hoặc sử dụng username với password để xác thực người dùng. WCF không chỉ tích hợp với

nền tảng bảo mật có sẵn mà còn mở rộng mức độ hỗ trợ ra khỏi giới hạn của hệ điều hành Windows bằng

cách sử dụng các bản tin SOAP bảo mật.

1.1 Ích lợi từ bảo mật trong WCF

Do WCF là một nền tảng lập trình phân tán dựa trên các bản tin SOAP, với việc sử dụng WCF,

các ứng dụng bạn tạo ra có thể tạo và xử lý các bản tin từ một số không hạn chế các dịch vụ và client

khác. Trong các ứng dụng này, các bản tin có thể được truyền từ điểm này sang điểm khác, thông qua các

thiết bị như tường lửa, router, switch, hay qua Internet, và qua một loạt các điểm trung chuyển SOAP.

Điều này tạo ra không ít mối đe doạ tới an ninh của bản tin. Những ví dụ sau đây cho ta thấy một số các

mối đe doạ thường thấy khi trao đổi bản tin giữa các ứng dụng, những mối đe doạ này hoàn toàn có thể

loại bỏ được nhờ vào sử dụng tính năng bảo mật trong WCF:

Quan sát các bản tin trên mạng để lấy ra các thông tin nhạy cảm. Ví dụ ở máy

client thực hiện login vào một hệ thống sử dụng chế độ gửi tên tài khoản và mật khẩu dạng text

không mã hoá. Hacker hoàn toàn có thể bắt được bản tin đó và trích ra thông tin về tài khoản

cùng với mật khẩu.

Đóng giả một dịch vụ mà client không hề biết. Việc này cũng tương tự như web

phishing, nghĩa là làm giả một trang web giống như trang web mà người dùng quen thuộc (như

trang web yahoo hay trang web ngân hàng). Người dùng sẽ nhập thông tin về tài khoản cùng với

mật khẩu đề đăng nhập vào trang giả đó. Khi đó hacker sẽ có được các thông tin này.

Thay đổi nội dung bản tin. Hacker hoàn toàn có thể thay đổi nội dung của một

bản tin mà client lẫn dịch vụ không biết.

Etc.


Việc đảm bảo bảo mật cho các bản tin trao đổi giữa client với dịch vụ WCF cần phải chú trọng ở

những điểm sau:

Xác thực điểm cuối dịch vụ

Xác thực client

Tính nhất quán của bản tin

Tính bảo mật của bản tin

Phát hiện replay (hiện tượng lặp lại yêu cầu của client hoặc dịch vụ mà thực chất

client/dịch vụ không đưa ra)

1.1.1 Tích hợp với các kiến trúc bảo mật có sẵn

WCF hoàn toàn có thể làm việc với các giải pháp bảo mật có sẵn như Secure Sockets Layer

(SSL) hoặc giao thức Kerbeos. Ngoài ra nó cũng có thể làm việc với kiến trúc bảo mật đang sử dụng như

domain trên Windows sử dụng Active Directory. Ngoài việc hỗ trợ các giải pháp bảo mật thường thấy,

WCF còn tích hợp với các mô hình bảo mật sẵn có ở tầng vận chuyển và có thể chuyển hạ tầng sẵn có

sang các mô hình mới hơn dựa trên bảo mật các bản tin SOAP.

1.1.2 Tích hợp với mô hình xác thực có sẵn

Một phần quan trọng trong bất kỳ mô hình bảo mật truyền tin nào là khả năng xác định và xác

thực các thực thể trong quá trình trao đổi dữ liệu. Các thực thể trong quá trình này sử dụng các “định

danh điện tử”, hay còn gọi là credentials, để xác thực chúng với đối tượng đang trao đổi. Với sự phát

triển của các nền tảng phân tán, có rất nhiều cách để xác thực các credentials được tạo ra. Lấy ví dụ, trên

Internet cách thông dụng nhất là sử dụng tên tài khoản cùng với mật khẩu để xác thực người dùng. Trong

mạng intranet, mô hình thông dụng là sử dụng Kerberos domain controller để xác thực người dùng cùng

với dịch vụ. Do vậy với cùng một dịch vụ, ta có thể có các cách xác thực khác nhau cho dịch vụ đó tuỳ

thuộc vào việc dịch vụ đó được sử dụng ở môi trường nào. WCF hỗ trợ rất nhiều các mô hình xác thực

khác nhau:

Anonymous caller (Người gọi vô danh)

Username client credential

Certificate client credential

Windows (Kerberos và NT LanMan – NTML)

1.1.3 Các chuẩn và tính interoperability (làm việc liên môi trường)

Trong thế giới với nhiều nền tảng như hiện nay, các nền tảng tính toán/truyền thông phân tán cần

phải làm việc liên thông với các công nghệ khác nhau mà các nhà cung cấp hỗ trợ. Cũng vì vậy mà bảo

mật cũng cần phải làm việc liên môi trường (interoperable).

Để thực hiện các hệ thống bảo mật interoperable, các công ty sử dụng dịch vụ Web với một loạt

các chuẩn khác nhau. Về bảo mật thì có thể kể ra một số chuẩn như sau: WS-Security, SOAP Message

Security, WS-Trust, WS-SecureConversation, và WS-SecurityPolicy.

Với các dịch vụ WCF ta có thể sử dụng WSHttpBinding để hỗ trợ WS-Security 1.1 và WS-

SecureConversation.

1.2 Các lĩnh vực bảo mật của WCF

Bảo mật trong WCF chia ra thành ba vùng chức năng: transfer security (bảo mật truyền thông),

(access control) điều khiển truy nhập, và auditing (ghi vết).


1.2.1 Transfer security

Bảo mật truyền thông bao gồm ba chức năng chính: sự nhất quán, sự bảo mật, và sự xác thực. Sự

nhất quán là khả năng phát hiện liệu bản tin có bị thay đổi hay không. Sự bảo mật là khả năng giữ cho

bản tin không đọc được bởi những người không đủ thẩm quyền; điều này có được nhờ vào cryptography

(mã mật – mật mã). Sự xác thực là khả năng xác minh được một định danh có thực đúng hay không. Kết

hợp ba chức năng này cho ta đảm bảo rằng các bản tin được gửi đi một cách an toàn, đến đúng nơi cần

đến.

1.2.2 Các chế độ bảo mật vận chuyển và bản tin

Có hai phương pháp chính dùng để thực hiện bảo mật truyền thông trong WCF là chế độ bảo mật

ở tầng vận chuyển (transport security mode) và chế độ bảo mật ở bản tin (message security mode)

Transport security mode sử dụng các giao thức ở tầng vận chuyển như HTTPS

để đảm bảo bảo mật. Chế độ này có ưu điểm là được sử dụng rất nhiều ở các nền tảng khác nhau,

và độ phức tạp tính toán ít hơn. Tuy vậy nhược điểm là chỉ đảm bảo bảo mật các bản tin từ điểm-

tới-điểm.

Message security mode sử dụng chuẩn WS-Security để đảm bảo bảo mật. Do

bảo mật bản tin được áp dụng trực tiếp lên các bản tin SOAP và được chứa trong các vỏ

(envelope) SOAP, cùng với dữ liệu của chương trình, nó có ưu điểm là không phụ thuộc vào giao

thức vận chuyển, dễ mở rộng, đảm bảo bảo mật từ đầu cuối-tới-đầu cuối (thay vì điểm-tới-điểm).

Nhược điểm của nó là chậm hơn so với chế độ transport security do nó phải làm việc với XML

trong bản tin SOAP.

1.2.3 Điều khiển truy nhập

Điều khiển truy nhập còn được biết tới như là authorization (nhận thực). Authorization cho phép

những người dùng khác nhau có các quyền khác nhau để xem dữ liệu. Trong WCF, các tính năng điều

khiển truy nhập được cung cấp dựa vào sự tích hợp với CLR (common language runtime) thông qua lớp

thuộc tính PrincipalPermissionAttribute và qua một loạt các hàm API.

1.2.4 Auditing

Auditing là quá trình ghi lại các sự kiện bảo mật vào hệ thống log của hệ điều hành Windows

(Windows event log). Bạn có thể ghi lại các sự kiện có liên quan tới bảo mật như là xác thực lỗi hay

thành công. Bạn có thể xem thêm trong bài How to: Audit Windows Communication Foundation

Security Events

2 Lập trình với bảo mật trong WCF

Khi lập trình với tính năng bảo mật trong WCF bạn cần thực hiện 3 bước cơ bản sau: đặt chế độ

bảo mật, kiểu xác thực client (client credential type), và các giá trị credentials cho dịch vụ. Cũng như các

phần khác trong WCF, bạn hoàn toàn có thể thực hiện các bước này thông qua mã lập trình hoặc là sử

dụng tập tin cấu hình.

2.1 Đặt chế độ bảo mật

Các bước để đặt chế độ bảo mật như sau:

1. Chọn một trong các binding phù hợp với các yêu cầu của ứng dụng của bạn. Để

biết về các binding nào có thể chọn, bạn nên xem lại bài 3 về address với bindings. Mặc định thì

hầu hết các binding đều có tính năng bảo mật. Tuỳ thuộc vào bạn chọn binding nào, bạn sẽ làm

việc với giao thức vận chuyển tương ứng với binding đó. Ví dụ khi chọn binding là

WSHttpBinding thì sẽ sử dụng giao thức vận chuyển là HTTP; còn nếu sử dụng binding là

NetTcpBinding thì giao thức là TCP.

http://msdn.microsoft.com/en-us/library/ms734737.aspx



2. Chọn một trong các chế độ bảo mật cho binding đã chọn. Tuỳ theo bạn chọn

binding nào thì sẽ có các chế độ bảo mật tương ứng. Ví dụ, binding WSDualHttpBinding không

hỗ trợ bảo mật vận chuyển (transport security), tương tự như vậy các binding

MsmqIntegrationBinding và NetNamedPipeBinding không hỗ trợ bảo mật bản tin (message

security). Bảng dưới đây liệt kê các binding có thể sử dụng và các chế độ bảo mật binding đó hỗ

trợ. Chú ý: trong ngoặc kép là chế độ bảo mật mặc định.

Binding Bảo mật

BasicHttpBinding (none),

Transport, Message

WSHttpBinding Transport,

(Message), Mixed

WSDualHttpBindi

ng

(Message)

WSFederationHttp

Binding

(Message)

NetTcpBinding (Transport),

Message

NetNamedPipeBin

ding

(Transport)

NetMsmqBinding Message,

(Transport), Both

NetPeerTcpBindin

g

(Transport)

MsmqIntegrationB

inding

(Transport)

3. Nếu bạn quyết định sử dụng chế độ bảo mật vận chuyển (transport security) cho

HTTP (tức là sử dụng giao thức HTTPS), bạn cần phải cấu hình cho host một chứng nhận SSL

(SSL certificate) và cho phép SSL ở một cổng nào đó. Để có thêm thông tin bạn có thể xem thêm

ở trang MSDN của Microsoft, HTTP Transport Security.

Ví dụ sử dụng tập tin cấu hình để cấu hình cho chế độ bảo mật

<bindings> <wsHttpBinding> <binding name="wsHttpTransportSecurity"> <security mode="Transport"> <transport clientCredentialType="Windows" /> </security> </binding> </wsHttpBinding> <wsHttpBinding> <binding name="wsHttpMessageSecurity"> <security mode="Message"> <message clientCredentialType="UserName" /> </security> </binding>



</wsHttpBinding> <basicHttpBinding> <binding name="basicHttp"> <security mode="TransportWithMessageCredential"> <transport /> <message clientCredentialType="UserName" /> </security> </binding> </basicHttpBinding> </bindings>

Ví dụ sử dụng mã lập trình để thiết lập chế độ bảo mật:

WSHttpBinding messageSecureBinding = new WSHttpBinding(); messageSecureBinding.Name = "messageSecureBinding"; messageSecureBinding.Security.Mode = SecurityMode.Message; messageSecureBinding.Security.Message.ClientCredentialType =

MessageCredentialType.Windows; NetTcpBinding transportSecureBinding = new NetTcpBinding(); transportSecureBinding.Name = "transportSecureBinding"; transportSecureBinding.Security.Mode = SecurityMode.Transport; transportSecureBinding.Security.Transport.ClientCredentialType =

TcpClientCredentialType.Windows; BasicHttpBinding mixedSecureBinding = new BasicHttpBinding(); mixedSecureBinding.Name = "mixedSecureBinding"; mixedSecureBinding.Security.Mode =

BasicHttpSecurityMode.TransportWithMessageCredential; mixedSecureBinding.Security.Message.ClientCredentialType =

BasicHttpMessageCredentialType.UserName;

2.2 Chọn kiểu xác thực client

Các kiểu xác thực client được hỗ trợ bởi WCF như sau:

Windows

Certificate

Digest

Basic

UserName

NTLM

IssuedToken

Về cách thiết lập kiểu xác thực client, các bạn có thể xem ở ví dụ trên.

2.3 Thiết lập các giá trị credentials cho dịch vụ

Sau khi đã chọn kiểu xác thực client, bạn cần phải thiết lập giá trị credential thực cho dịch vụ và

client sử dụng. Ở phía dịch vụ, các credential được thiết lập sử dụng lớp ServiceCredentials và

được trả về từ thuộc tính Credentials của lớp ServiceHostBase.

Ví dụ sau đây thiết lập một chứng nhận cho credential phía dịch vụ:

// Create the binding for an endpoint. NetTcpBinding b = new NetTcpBinding();


b.Security.Mode = SecurityMode.Message; // Create the ServiceHost for a calculator. Uri baseUri = new Uri("net.tcp://MachineName/tcpBase"); Uri[] baseAddresses = new Uri[] { baseUri }; ServiceHost sh = new ServiceHost(typeof(Calculator), baseAddresses); // Add an endpoint using the binding and a new address. Type c = typeof(ICalculator); sh.AddServiceEndpoint(c, b, "MyEndpoint"); // Set a certificate as the credential for the service. sh.Credentials.ServiceCertificate.SetCertificate( StoreLocation.LocalMachine, StoreName.My, X509FindType.FindBySubjectName, "client.com"); try { sh.Open(); Console.WriteLine("Listening...."); Console.ReadLine(); sh.Close(); } catch (CommunicationException ce) { Console.WriteLine("A commmunication error occurred: {0}", ce.Message); Console.WriteLine(); } catch (System.Exception exc) { Console.WriteLine("An unforseen error occurred: {0}", exc.Message); Console.ReadLine();

}

2.4 Thiết lập các giá trị credentials cho client

Ở phía client, các giá trị credentials được thiết lập thông quá lớp ClientCredentials và

được trả về qua thuộc tính ClientCredentials của lớp ClientBase.

Ví dụ sau thiết lập một chứng nhận như là một credential phía client sử dụng giao thức TCP.

// Create a NetTcpBinding and set its security properties. The // security mode is Message, and the client must be authenticated with // Windows. Therefore the client must be on the same Windows domain. NetTcpBinding b = new NetTcpBinding(); b.Security.Mode = SecurityMode.Message; b.Security.Message.ClientCredentialType = MessageCredentialType.Windows; // Set a Type variable for use when constructing the endpoint. Type c = typeof(ICalculator); // Create a base address for the service. Uri tcpBaseAddress = new Uri("net.tcp://machineName.Domain.Contoso.com:8036/serviceName"); // The base address is in an array of URI objects. Uri[] baseAddresses = new Uri[] { tcpBaseAddress }; // Create the ServiceHost with type and base addresses. ServiceHost sh = new ServiceHost(typeof(CalculatorClient), baseAddresses);


// Add an endpoint to the service using the service type and binding. sh.AddServiceEndpoint(c, b, ""); sh.Open(); string address = sh.Description.Endpoints[0].ListenUri.AbsoluteUri; Console.WriteLine("Listening @ {0}", address); Console.WriteLine("Press enter to close the service");

Console.ReadLine();

3 Xây dựng ví dụ với bảo mật trong WCF

Trong ví dụ này chúng ta sẽ xây dựng một ví dụ sử dụng Windows Authentication qua binding

wsHttpBinding có sử dụng chế độ bảo mật vận chuyển (transport security). Mô hình này phù hợp với môi

trường intranet trong doanh nghiệp khi ta có một domain controller.

Các bước để xây dựng như sau:

Bước 1 – Tạo dịch vụ WCF

Bước 2 – Thiết lập cấu hình cho dịch vụ WCF sử dụng wsHttpBinding với

Windows Authentication và Message Security (bảo mật bản tin)

Bước 3 – Tạo client

Bước 4 – Thêm tham chiếu dịch vụ cho client

Bước 5 – Chạy thử client và dịch vụ

3.1 Tạo dịch vụ WCF

1. Mở Visual Studio, chọn menu File -> New Web Site

Figure 1 Tạo một Web Site mới 2. Trong hộp thoại New Web Site, ở phần Templates, chọn WCF Service, chọn

Location là Http

3. Đặt địa chỉ trang web là https://localhost/SecureContact, chọn OK


Figure 2 Tạo Web site với template là WCF Service, giao thức HTTPS

3.2 Thêm chức năng cho dịch vụ

1. Click chuột phải vào project SecureContact, chọn Menu Add New Item, sau đó

chọn thêm vào WCF Service, đặt tên là ContactService.svc

Figure 3 Thêm mới một dịch vụ WCF 2. Thêm vào đoạn mã sau để định nghĩa interface




/// <summary>

/// Định nghĩa thông tin về một nhân viên

/// </summary>

[DataContract]

public class Person

{

[DataMember]

public int PersonId;

[DataMember]


[DataMember]

public int Age;

}

[ServiceContract]

public interface IContactService

{

[OperationContract]


/// <summary>

/// Lấy về thông tin của một nhân viên.

/// Nếu có nhân viên với ID trùng với personId

/// thì trả về thông tin nhân viên đó.

/// Trong trường hợp không có nhân viên phù hợp thì báo lỗi bằng

bản tin lỗi

/// </summary>


/// <returns>Thông tin của nhân viên</returns>

[OperationContract]


[OperationContract]

Person[] GetAll();

[OperationContract]


/// <summary>

/// Sửa thông tin của một nhân viên.


/// thì cập nhật thông tin nhân viên đó.


bản tin lỗi

/// </summary>


/// <param name="person">Thông tin mới về nhân viên</param>

[OperationContract]


/// <summary>

/// Xoá thông tin một nhân viên


/// thì xoá thông tin nhân viên đó.


bản tin lỗi

/// </summary>



[OperationContract]


}

3. Thêm vào đoạn mã sau để định nghĩa phần cài đặt dịch vụ


using System.Linq;

public class ContactService : IContactService

{

private readonly List<Person> personCollection;

public ContactService()

{

personCollection = new List<Person>

{

new Person { PersonId = 0, FullName = "Trần Văn Anh", Age =

30 },

new Person { PersonId = 1, FullName = "Lý Đào", Age = 35 },

new Person { PersonId = 2, FullName = "Hoàng Văn Giáp", Age

= 28 },

new Person { PersonId = 3, FullName = "Nguyễn Quang Cường",

Age = 25 },

new Person { PersonId = 4, FullName = "Lê Thị Bảo", Age =

31 },

};

}


{

return this.personCollection.Any(x => x.PersonId ==

personId);

}


{

if (!this.HasPerson(personId))

{

return null;

}

return

this.personCollection.FirstOrDefault(x => x.PersonId ==

personId);

}


{

this.personCollection.Add(person);

}


{

return this.personCollection.ToArray();

}


{

Person p = this.GetPerson(personId);


p.Age = person.Age;

}



{

Person p = this.GetPerson(personId);

this.personCollection.Remove(p);

}

}

3.3 Thiết lập dịch vụ WCF sử dụng wsHttpBinding với Windows Authentication và Message Security

Để cấu hình cho dịch vụ WCF chấp nhận giao thức HTTPS, ta cần thiết lập tập tin cấu hình

(web.config) như sau:

<system.serviceModel> <services> <service behaviorConfiguration="ContactServiceBehavior"

name="ContactService"> <host> <baseAddresses> <add baseAddress="https://localhost/SecureContact"/> </baseAddresses> </host> <endpoint address="" binding="wsHttpBinding"

contract="IContactService"

bindingConfiguration="wsHttpSecureBinding"> <identity> <dns value="localhost"/> </identity> </endpoint> <endpoint address="mex" binding="mexHttpsBinding"

contract="IMetadataExchange"/> </service> </services> <behaviors> <serviceBehaviors> <behavior name="ContactServiceBehavior"> <serviceMetadata httpsGetEnabled="true"/> <serviceDebug includeExceptionDetailInFaults="false"/> </behavior> </serviceBehaviors> </behaviors> <bindings> <wsHttpBinding> <binding name="wsHttpSecureBinding"> <security mode="Transport"> <transport clientCredentialType="Windows"/> </security> </binding> </wsHttpBinding> </bindings> </system.serviceModel>

Đến thời điểm này bạn đã có một dịch vụ hoàn chỉnh. Mở trình duyệt Web và truy nhập tới địa

chỉ https://localhost/SecureContact/ContactService.svc bạn sẽ thấy màn hình sau:

https://localhost/SecureContact/ContactService.svc


Figure 4 Truy nhập bằng trình duyệt Web tới địa chỉ của dịch vụ

3.4 Tạo ứng dụng client

1. Click chuột phải vào solution hiện tại, chọn Add -> New Project

2. Trong hộp thoại Add New Project, chọn Windows Forms Application

3. Đặt tên project là SecureContactClient.

Figure 5 Tạo client


3.5 Thêm tham chiếu tới dịch vụ WCF cho client

1. Click chuột phải vào client project, chọn Add Service Reference

2. Trong hộp thoại Add Service Reference, đưa vào URL tới dịch vụ của bạn,

https://localhost/SecureContact/ContactService.svc

3. Trong trường Namespace, nhập vào SecureContactService, click OK

Figure 6 Thêm tham chiếu dịch vụ cho Client

3.6 Thêm chức năng cho client

Thêm vào trong form mặc định 2 Button và 1 DataGridView (xem chi tiết trong source code kèm

theo). Viết mã xử lý các sự kiện bấm nút:

private void buttonGetInformation_Click(object sender, EventArgs e) { var client = new ContactServiceClient(); try { Person p = client.GetPerson(Convert.ToInt32(this.textBoxID.Text)); this.dataGrid.DataSource = new[] { p }; } catch (Exception ex) { MessageBox.Show(ex.Message, "Error"); } }


private void buttonGetAll_Click(object sender, EventArgs e) { var client = new ContactServiceClient(); this.dataGrid.DataSource = client.GetAll(); }

Chạy ứng dụng Client và nhất nút Get All ta sẽ có kết quả sau:

Figure 7 Kết quả chạy client


1. Binding MsmqIntegrationBinding có hỗ trợ chế độ bảo mật bản tin không?

Trả lời: Không, Binding MsmqIntegrationBinding chỉ hỗ trợ chế độ bảo mật vận

chuyển.


1. Security Overview (URL: http://msdn.microsoft.com/en-


2. Programming Security (URL: http://msdn.microsoft.com/en-


3. Fundametals of WCF Security (URL:

http://www.devx.com/codemag/Article/33342/1954)

4. WCF Security Resources (URL:

http://blogs.msdn.com/jmeier/archive/2008/05/23/wcf-security-resources.aspx)

5. WCF Security Learning Guide (URL:

http://www.theserverside.net/tt/articles/showarticle.tss?id=WCFSecurityLearningGuide)

Bài 8 MỘT SỐ VÍ DỤ SỬ DỤNG WINDOWS COMMUNICATION FOUNDATION

Mục lục

1 Tạo dịch vụ WCF hỗ trợ làm việc với AJAX .................................................................................................... 2

1.1 Tạo ứng dụng web để quản lý nhân viên ......................................................................................2

1.2 Tạo dịch vụ quản lý nhân viên ......................................................................................................4

1.3 Thiết lập cấu hình để hỗ trợ AJAX ...............................................................................................7

1.4 Sử dụng các phương thức của dịch vụ WCF bằng AJAX ............................................................8

2 Tạo dịch vụ WCF làm việc với REST ............................................................................................................. 10

2.1 Xây dựng URI Template cho việc lấy dữ liệu (HTTP GET) ......................................................12

2.2 Xây dựng URI Template cho việc cập nhật dữ liệu (HTTP PUT) .............................................14

2.3 Xây dựng URI Template để xoá một nhân viên (HTTP DELETE)............................................15


Microsoft Vietnam | WCF – Bài 8: Một số ví dụ sử dụng WCF 2

Các bài trước chúng ta đã biết các thành phần cấu thành một dịch vụ trên WCF cũng như cách

xây dựng một dịch vụ WCF, đồng thời cũng đã được giới thiệu cách xây dựng chương trình ứng dụng để

sử dụng các dịch vụ WCF. Trong bài cuối cùng này, chúng ta sẽ được làm quen với một số ứng dụng của

dịch vụ WCF theo một số cách khác nhau:

Tạo ứng dụng trên Web sử dụng công nghệ AJAX làm việc với dịch vụ WCF

Tạo dịch vụ WCF làm việc với REST

1 Tạo dịch vụ WCF hỗ trợ làm việc với AJAX

Để phục vụ cho mục đích giới thiệu việc hỗ trợ của WCF trong làm việc với REST hay JSON,

đầu tiên chúng ta tạo ra một dịch vụ WCF có hỗ trợ tốt khi client là trình duyệt với AJAX. Mục tiêu ứng

dụng của chúng ta vẫn là ứng dụng quản lý nhân viên như trong các ví dụ ở các bài trước. Tóm tắt lại,

ứng dụng quản lý nhân viên đơn giản gồm có các mục sau:

Thêm mới một nhân viên

Sửa thông tin một nhân viên

Xoá một nhân viên

Lấy thông tin chi tiết của một nhân viên

Lấy danh sách các nhân viên

Tìm kiếm nhân viên

1.1 Tạo ứng dụng web để quản lý nhân viên

1. Mở Visual Studio, chọn File->New Web Site, sau cho chọn ASP.NET Web Site

2. Đặt tên Web site là HRManagement


Figure 1 Tạo một web site mới

Do phần client cho web site tương đối dài, nên các bạn xem trong phần source code ví dụ để tiếp

tục làm việc cho tiện. Ở đây, phần client sẽ có 3 trang.

Trang chủ: hiển thị toàn bộ nhân viên và các thông tin chi tiết của nhân viên đó

Trang soạn thảo: Sửa thông tin của nhân viên

Trang thêm mới: Thêm một nhân viên

Cả 3 trang này đều sử dụng một trang master gọi là Application.master. Khi mở solution kèm

theo bạn sẽ thấy web site project như sau:


Figure 2 Web site project

1.2 Tạo dịch vụ quản lý nhân viên

Để ứng dụng web của bạn làm việc với các dịch vụ WCF, bạn cần thực hiện các bước sau:

1. Click chuột phải vào HRManagement project, chọn Add New Item

2. Chọn Thêm AJAX-enabled WCF Service

3. Đặt tên cho dịch vụ của bạn là HRService.svc


Figure 3 Thêm mới dịch vụ WCF 4. Thêm đoạn mã sau đây để cài đặt dịch vụ

using System.Collections.Generic; using System.Linq; using System.Runtime.Serialization; using System.ServiceModel; using System.ServiceModel.Activation; [DataContract] public class PersonData { [DataMember] public int PersonId; [DataMember] public string FirstName; [DataMember] public string LastName; [DataMember] public string EmailAddress; [DataMember] public string Department; } [ServiceContract(Namespace = "urn:hr")] [AspNetCompatibilityRequirements(RequirementsMode =

AspNetCompatibilityRequirementsMode.Allowed)] public class HRService { [OperationContract] public IList<PersonData> GetAll()


{ using (var personCtx = new DataClassesDataContext()) { // Set up the query var persons = from p in personCtx.Persons orderby p.FirstName select new PersonData { PersonId = p.PersonId, FirstName = p.FirstName, LastName = p.LastName, EmailAddress = p.EmailAddress, Department = p.Department }; return persons.ToList(); } } [OperationContract] public PersonData GetPerson(int personId) { using (var personCtx = new DataClassesDataContext()) { // Set up the query var person = (from p in personCtx.Persons where p.PersonId == personId select new PersonData { PersonId = p.PersonId, FirstName = p.FirstName, LastName = p.LastName, EmailAddress =

p.EmailAddress, Department = p.Department }).Single(); return person; } } [OperationContract] public void UpdatePerson(int personId, PersonData newData) { using (var personCtx = new DataClassesDataContext()) { // Set up the query var person = personCtx.Persons.Single(p => p.PersonId ==

personId); if (person != null) { person.FirstName = newData.FirstName; person.LastName = newData.LastName; person.EmailAddress = newData.EmailAddress; person.Department = newData.Department; personCtx.SubmitChanges(); } }


} [OperationContract] public void AddPerson(PersonData p) { using (var personCtx = new DataClassesDataContext()) { var person = new Person { PersonId = p.PersonId, FirstName = p.FirstName, LastName = p.LastName, EmailAddress = p.EmailAddress, Department = p.Department }; personCtx.Persons.InsertOnSubmit(person); personCtx.SubmitChanges(); } } [OperationContract] public void DeletePerson(int personId) { using (var personCtx = new DataClassesDataContext()) { var person = personCtx.Persons.Single(p => p.PersonId ==

personId); if (person != null) { personCtx.Persons.DeleteOnSubmit(person); personCtx.SubmitChanges(); } } } }

5. Trong đoạn mã trên có 2 điểm cần chú ý:

a. Giống như các dịch vụ khác, khi định nghĩa kiểu dữ liệu của chúng ta,

chúng ta cần phải thêm vào data contract (trong trường hợp này là lớp PersonData

được thêm thuộc tính DataContract)

b. Khi làm việc với AJAX, ta nên đăng ký namespace của dịch vụ, sử dụng

tham số Namespace trong thuộc tính ServiceContract. Trong ví dụ này là [ServiceContract(Namespace = "urn:hr")]

1.3 Thiết lập cấu hình để hỗ trợ AJAX

Trong thực tế, khi bạn tạo ra một project ASP.NET Web Site và thêm vào dịch vụ WCF như

trên, Visual Studio sẽ tự động thêm vào các cấu hình cần thiết, bạn sẽ không cần làm gì mà đã có thể sử

dụng dịch vụ. Để chắc chắn, hay kiểm tra tệp tin cấu hình xem có giống như sau không:

<system.serviceModel> <behaviors> <endpointBehaviors>


<behavior name="HRServiceAspNetAjaxBehavior"> <enableWebScript/> </behavior> </endpointBehaviors> </behaviors> <serviceHostingEnvironment aspNetCompatibilityEnabled="true"/> <services> <service name="HRService"> <endpoint address=""

behaviorConfiguration="HRServiceAspNetAjaxBehavior"

binding="webHttpBinding" contract="HRService"/> </service> </services> </system.serviceModel>

1.4 Sử dụng các phương thức của dịch vụ WCF bằng AJAX

Để sử dụng các phương thức của dịch vụ WCF, đầu tiên bạn cần thêm vào một

ScriptManager trong trang aspx của bạn, sau đó thêm vào Services và trỏ tới dịch vụ bạn muốn

sử dụng, ví dụ trong trang default.aspx, bạn thêm vào ngay sau thẻ form như sau:

<asp:ScriptManager ID="ScriptManager1" runat="server"> <Services> <asp:ServiceReference Path="~/HRService.svc" /> </Services> </asp:ScriptManager>

Sau khi thêm vào tham chiếu dịch vụ WCF, bạn hoàn toàn có thể gọi các phương thức của dịch

vụ như sau:

function GetData() { var hrs = new hr.HRService(); hrs.GetAll(PersonsReturnedEventHandler, null, null); }

function PersonsReturnedEventHandler(value) { alert("Tong cong co " + value.length, " nhan vien"); }

Như vậy cách sử dụng dịch vụ WCF là:

Tạo một instace (thể hiện) của dịch vụ: var hrs = new hr.HRService();

Gọi hàm của dịch vụ đó: hrs.GetAll(...)

Như vậy chúng ta đã có một ứng dụng web tương đối hoàn chỉnh để quản lý nhân viên.

Trang chủ mặc định:


Figure 4 Trang chủ Xoá nhân viên


Figure 5 Xoá nhân viên

Sửa thông tin

Figure 6 Sửa thông tin về một nhân viên

2 Tạo dịch vụ WCF làm việc với REST

Dựa trên cơ sở project chúng ta đã xây dựng ở trên. Thêm vào một dịch vụ WCF như sau:

1. Click chuột phải vào project HRManagement, chọn Add New Item, sau đó chọn

thêm vào WCF Service

2. Đặt tên cho service là RESTHRService.svc


Figure 7 Thêm dịch vụ REST WCF 3. Sửa tập tin cấu hình như sau:

<system.serviceModel> <behaviors> <endpointBehaviors> <behavior name="AJAXFriendly"> <enableWebScript /> </behavior> <behavior name="RESTFriendly"> <webHttp /> </behavior> </endpointBehaviors> </behaviors> <serviceHostingEnvironment aspNetCompatibilityEnabled="true"/> <services> <service name="HRService"> <endpoint address="" behaviorConfiguration="AJAXFriendly" binding="webHttpBinding" contract="HRService" /> </service> <service name="RESTHRService"> <endpoint address="" behaviorConfiguration="RESTFriendly" binding="webHttpBinding" contract="IRESTHRService" /> </service> </services> </system.serviceModel>


4. Chúng ta vẫn sử dụng DataContract là PersonData. Thêm vào khai báo dịch

vụ IRESTHRService như sau:

[ServiceContract] public interface IRESTHRService { [OperationContract] IList<PersonData> GetAll(); [OperationContract] PersonData GetPerson(int personId); [OperationContract] void UpdatePerson(int personId, PersonData newData); [OperationContract] void AddPerson(PersonData p); [OperationContract] void DeletePerson(int personId);

}

2.1 Xây dựng URI Template cho việc lấy dữ liệu (HTTP GET)

Để thực hiện dịch vụ thông qua REST chúng ta cần đưa vào các verb tương ứng trong REST như

HTTP GET, POST, PUT, DELETE. Với verb HTTP GET chúng ta có thể đưa vào bằng cách thêm thuộc

tính WebGet cho các hàm trong dịch vụ, ví dụ như:

[OperationContract] [WebGet] PersonData GetPerson(int personId);

Giá trị trả về chúng ta có thể quy định là dạng XML hoặc cũng có thể là JSON. Ở đây ta quy

định giá trị trả về là dưới dạng XML như sau:

[OperationContract] [WebGet(ResponseFormat = WebMessageFormat.Xml)] PersonData GetPerson(int personId);

Ngoài ra khi trả về giá trị, dịch vụ của chúng ta cũng cần phải báo cho client biết là request có

thành công hay không. Việc trả về trạng thái lỗi được thực hiện thông qua

WebOperationContext.Current. Như vậy, phần cài đặt cho hàm GetPerson sẽ như sau:

public PersonData GetPerson(int personId) { var ctx = WebOperationContext.Current; try { using (var personCtx = new DataClassesDataContext()) { // Set up the query var person = personCtx.Persons.SingleOrDefault(p => p.PersonId ==

personId); if (person == null) { ctx.OutgoingResponse.SetStatusAsNotFound(); return null;


} var personData = new PersonData { PersonId = person.PersonId, FirstName = person.FirstName, LastName = person.LastName, EmailAddress = person.EmailAddress, Department = person.Department }; ctx.OutgoingResponse.StatusCode = System.Net.HttpStatusCode.OK; return personData; } } catch { ctx.OutgoingResponse.StatusCode =

System.Net.HttpStatusCode.BadRequest; return null; } }

Một trong những đặc điểm cơ bản của REST là chúng ta chỉ làm việc với các URI. Do đó để dịch

vụ của chúng ta theo đúng kiểu của REST, ta cần thêm tham số UriTemplate cho thuộc tính WebGet như

sau:

[OperationContract] [WebGet(UriTemplate = "person/{personId}", ResponseFormat =

WebMessageFormat.Xml)] PersonData GetPerson(int personId);

Khi đó giả sử dịch vụ của chúng ta ở tại địa chỉ sau:

http://wcf.contoso.com/HRManagement/RESTHRService.svc

Hàm GetPerson sẽ được kích hoạt với personId=31 tại địa chỉ sau:

http://wcf.contoso.com/HRManagement/RESTHRService.svc/person/31

Mở trình duyệt Internet Explorer vào địa chỉ trên ta có thể nhận được kết quả như sau:


Figure 8 Kết quả lấy thông tin một nhân viên

Trong trường hợp bạn sử dụng định dạng trả về là Json như sau:

[OperationContract] [WebGet(UriTemplate = "person/{personId}", ResponseFormat =

WebMessageFormat.Json)] PersonData GetPerson(int personId);

Khi đó truy xuất tới địa chỉ

http://wcf.contoso.com/HRManagement/RESTHRService.svc/person/31

sẽ cho ta kết quả như sau:

{"Department":"Human

Resources","EmailAddress":"[email protected]","FirstName":"Belinda",

"LastName":"Kalin","PersonId":31}

2.2 Xây dựng URI Template cho việc cập nhật dữ liệu (HTTP PUT)

Việc cập nhật dữ liệu bao gồm sửa một bản ghi (thông tin nhân viên) sẵn có hoặc thêm mới một

nhân viên. Việc này được thực hiện dựa vào verb HTTP PUT trong REST. Để mô tả một phương thức

trong dịch vụ WCF sẽ được kích hoạt bằng verb PUT, ta sử dụng thuộc tính mô tả là WebInvoke, với

tham số Method là PUT. Để chỉ ra ta sẽ cập nhật thông tin vào nhân viên nào, ta cũng sử dụng URI

Template như phần trên. Như vậy, hàm cập nhật (hoặc thêm mới) nhân viên sẽ được khai báo như sau:

[OperationContract] [WebInvoke(Method = "PUT", UriTemplate = "person/{personId}", RequestFormat = WebMessageFormat.Json)] void UpdatePerson(string personId, PersonData personData);

Mã nguồn cài đặt chi tiết cho hàm này như sau:

public void UpdatePerson(string personId, PersonData personData)


{ WebOperationContext ctx = WebOperationContext.Current; System.Net.HttpStatusCode status = System.Net.HttpStatusCode.OK; try { using (var dataContext = new DataClassesDataContext()) { Person person = dataContext.Persons.SingleOrDefault( prod => prod.PersonId == Convert.ToInt32(personId)); if (person == null) { person = new Person(); dataContext.Persons.InsertOnSubmit(person); status = System.Net.HttpStatusCode.Created; } person.FirstName = personData.FirstName; person.LastName = personData.LastName; person.Department = personData.Department; person.EmailAddress = personData.EmailAddress; dataContext.SubmitChanges(); ctx.OutgoingResponse.StatusCode = status; return; } } catch { ctx.OutgoingResponse.StatusCode =

System.Net.HttpStatusCode.BadRequest; return; } }

Trên trang web ta gọi hàm dịch vụ WCF như sau:

function updatePersonEventHandler(sender, args) { var url = "../RESTHRService.svc/person/" + args.PersonId; var proxy = new Sys.Net.WebServiceProxy(); proxy.restInvoke(url, "PUT", args, "GetData", updatePersonSucceeded, null, null); }

2.3 Xây dựng URI Template để xoá một nhân viên (HTTP DELETE)

Để ra lệnh xoá một resource (trong trường hợp này là nhân viên) bằng REST, chúng ta sử dụng

verb HTTP DELETE. Tương tự như phần cập nhật, chúng ta khai báo phương thức với thuộc tính mô tả

là WebInvoke với Method là DELETE:

[OperationContract] [WebInvoke(Method = "DELETE", UriTemplate = "person/{personId}")]


void DeletePerson(string personId);

Và mã nguồn cài đặt cho việc xoá nhân viên:

public void DeletePerson(string personId) { WebOperationContext ctx = WebOperationContext.Current; try { using (var dataContext = new DataClassesDataContext()) { Person person = dataContext.Persons.SingleOrDefault(

p => p.PersonId == Convert.ToInt32(personId)); if (person == null) { ctx.OutgoingResponse.StatusCode =

System.Net.HttpStatusCode.NotFound; return; } dataContext.Persons.DeleteOnSubmit(person); dataContext.SubmitChanges(); ctx.OutgoingResponse.StatusCode = System.Net.HttpStatusCode.OK; return; } } catch { ctx.OutgoingResponse.StatusCode =

System.Net.HttpStatusCode.BadRequest; return; } }

Phía client gọi hàm DeletePerson như sau:

function DeletePersonEventHandler(sender, args) { if (confirm("Do you want to delete person: " + args.FirstName + " " +

args.LastName)) { var url = "../RESTHRService.svc/person/" + args.PersonId; var proxy = new Sys.Net.WebServiceProxy(); proxy.restInvoke(url, "DELETE", null, "DeletePersonEventHandler", OnDeleted, null, null); } }


1. REST in WCF Blog Series Index (URL:

http://blogs.msdn.com/bags/archive/2008/08/05/rest-in-wcf-blog-series-index.aspx)

2. Using WebHttpBinding & JSON Support in WCF (URL:

http://spellcoder.com/blogs/bashmohandes/archive/2008/01/05/9423.aspx)

3. Consuming JSON data in .NET with WCF (URL:

http://www.codeproject.com/KB/WCF/consuming-json-wcf.aspx)

Documents

1. Mục lục - dulieu.tailieuhoctap.vndulieu.tailieuhoctap.vn/books/cong-nghe-thong-tin/lap-trinh-ung-dung/... · phép các nhà phát triển xây dựng các ứng dụng hướng