Tcpip Server Asynchronous Socket Programming Lập Trình Mạng

Trường Đại học Công Thương TP.HCM Khoa Công nghệ thơng tin

BÁO CÁO MƠN HỌC

LẬP TRÌNH MẠNG

“TCPIP Server Asynchronous Socket Programming”

Giảng viên hướng dẫn Nhóm thực hiện
ThS Hồ Nhựt Minh 07

LẬP TRÌNH MẠNG ĐỀ TÀI 03

BỘ CÔNG THƯƠNG
TRƯỜNG ĐẠI HỌC CÔNG THƯƠNG TP.HCM

KHOA CÔNG NGHỆ THÔNG TIN


ĐỀ TÀI 3:

TCPIP Server Asynchronous Socket
Programming

DANH SÁCH THÀNH VIÊN NHÓM 7

Họ và Tên MSSV

Quách Vũ Thường 2033207469

Huỳnh Trần Đức Thắng 2033207466

Nguyễn Anh Tuấn 2033207472

Nguyễn Văn Linh 2033204745

Đoàn Đặng Anh Khoa 2033207506

GVHD: Ths. Hồ Nhựt Minh
Thành phố Hồ Chí Minh, tháng 03 năm 2023

LẬP TRÌNH MẠNG ĐỀ TÀI 03

Mục lục

LỜI NÓI ĐẦU........................................................................................................................... 1
PHẦN 1: CƠ SỞ LÝ THUYẾT............................................................................................... 2
1.1. Lập trình đồng bộ (Synchronous Programming):............................................................ 2
1.2. Lập trình bất đồng bộ: ..................................................................................................... 2
1.3. So sánh lập trình đồng bộ và lập trình bất đồng bộ: ........................................................ 4
1.4. Lập trình bất đồng bộ trong C#.Net: ............................................................................... 6
1.5. Lập trình bất đồng bộ mơ hình TAP với từ khóa async và await trong C#.Net:............. 8
1.6. Lập trình Socket bất đồng bộ TCPIP Server với từ khóa async _await trong C#: ........ 11
PHẦN 2: PHÂN TÍCH VIDEO: 03 TCPIP SERVER ASYNCHRONOUS SOCKET
PROGRAMMING WITH ASYNC _ AWAIT KEYWORDS IN C# ................................ 13
2.1. Section Intro Asynchronous socket programming with async await in C# .Net:.......... 13
2.2. Example Disadvantage of synchronous IO in C# .Net:................................................. 14
2.3. Accepting a TCPClient Connection Asynchronously with await keyword in C#:........ 17
2.4. Demo Accept TCPClient Asynchronously:................................................................... 18
2.5. Continuously Accept Client Connections, Exception Handling in C# async Method: . 20
2.6. Use System.Net.Socket.NetworkStream _ StreamReader to read data from client: ..... 21

2.7. Demo Read Data On Network Stream and Endless Accept async in C#.Net: .............. 23
2.8. How to Handle Multiple Network Clients on Server in C# .Net:.................................. 24
2.9. Demo Send Data to Multiple Network Clients from List at Once, SendAll Method:... 27
2.10. How to Stop Listening for New Connections and Disconnect Client Sockets Properly:

28
2.11. Demo TcpListener.Stop and TcpClient.Close Calls to Stop Server:............................. 28
2.12. Section Summary TCPIP Server Side Asynchronous Socket Programming in C# .Net:

29
TÀI LIỆU THAM KHẢO...................................................................................................... 30

NHÓM 07 i

LẬP TRÌNH MẠNG ĐỀ TÀI 03

LỜI NĨI ĐẦU

Trong lập trình socket, sử dụng mơ hình bất đồng bộ (asynchronous programming)
có nhiều lợi ích. Đầu tiên, khi sử dụng mơ hình bất đồng bộ, chương trình có thể tiếp
tục thực hiện các tác vụ khác trong khi đang chờ đợi phản hồi từ socket, giúp tăng hiệu
quả và thời gian đáp ứng của ứng dụng. Thứ hai, mơ hình bất đồng bộ cho phép xử lý
đồng thời nhiều kết nối cùng lúc, do đó giảm thời gian chờ đợi của người dùng và cải
thiện trải nghiệm người dùng. Cuối cùng, mơ hình bất đồng bộ cũng giúp giảm tải cho
máy chủ khi nhiều yêu cầu đến cùng lúc, do đó tăng khả năng chịu tải của hệ thống.

Vì những lý do này, mơ hình bất đồng bộ đã trở thành một lựa chọn phổ biến trong
lập trình socket và được sử dụng rộng rãi trong các ứng dụng mạng hiện đại.

NHÓM 07 1

LẬP TRÌNH MẠNG ĐỀ TÀI 03

PHẦN 1: CƠ SỞ LÝ THUYẾT

1.1. Lập trình đồng bộ (Synchronous Programming):

Lập trình đồng bộ (synchronous) là cách lập trình mà các hoạt động của chương trình
sẽ được thực hiện tuần tự.

Trong mơ hình lập trình quen thuộc của chúng ta, các cơng việc được thực hiện theo
trật tự thời gian. Công việc sắp xếp trước thực hiện xong mới đến lượt công việc tiếp
theo.

Giả sử, có ba cơng việc được sắp xếp theo trình tự T1, T2, T3; thời gian thực hiện T1
là t1 giây, với T2 là t2 giây, T3 là t3 giây.

Khi nhiệm vụ T1 đã được bắt đầu thực hiện thì phải chờ T1 kết thúc, T2 mới được
bắt đầu (sau t1 s). Một khi T2 bắt đầu thì phải chờ T2 kết thúc, T3 mới được bắt đầu
(sau t1 + t2 s). Tổng thời gian thực hiện của cả ba nhiệm vụ là t1 + t2 + t3 s.

Mơ hình lập trình theo đó các cơng việc bắt đầu và kết thúc theo đúng trình tự thời
gian như trên được gọi là lập trình đồng bộ.

1.2. Lập trình bất đồng bộ (asynchronous programming):

Lập trình bất đồng bộ là cách lập trình cho phép các hoạt động thực hiện khơng theo
tuần tự. Có thể các đoạn code ở dưới chạy trước đoạn code viết ở phía trên (bất đồng
bộ), các hoạt động khơng phải đợi lẫn nhau. Bởi vì có nhiều threads nên khi xử lý các
hoạt động có thời gian dài thì main thread (UI) vẫn có thể hoạt động do các thread là

riêng biệt.

NHÓM 07 2

LẬP TRÌNH MẠNG ĐỀ TÀI 03

Giả sử (vẫn 3 nhiệm vụ T1, T2, T3 như trên) bây giờ chúng ta không chờ T1 kết thúc
mà bắt đầu luôn T2. Ngay sau khi bắt đầu T2 chúng ta bắt đầu ln T3.

Trong mơ hình này, nhiệm vụ sau không phải chờ nhiệm vụ trước kết thúc nữa. Tổng
thời gian thực hiện của ba nhiệm vụ không phải là t1+t2+t3 nữa mà nhỉnh hơn thời gian
thực hiện nhiệm vụ dài nhất. Rõ ràng mơ hình này có lợi thế hơn về thời gian thực hiện.

Mơ hình trong đó các nhiệm vụ khơng phải tuân thủ theo trình tự thời gian như trên
được gọi là mơ hình bất đồng bộ (asynchronous). Như vậy mơ hình bất đồng bộ cũng
cho phép thực hiện song song nhiều nhiệm vụ cùng lúc.

Trong lập trình socket, mơ hình bất đồng bộ được sử dụng rất phổ biến ở cả client và
server. Đối với server , mơ hình này cho phép xử lý đồng thời nhiều client và phát huy
tốt khả năng xử lý song song của server. Đối với client, nó giúp chương trình không bị
treo giao diện khi thực hiện các nhiệm vụ kéo dài.

Trước khi Asynchronous programing ra đời ở những phiên bản cũ hơn của .Net,
chúng ta có cơng nghệ lập trình đa luồng (multiple thread). Đây là hai khái niệm và mơ
hình khác nhau, mặc dù cùng hướng tới mục tiêu tương tự. Lập trình đa luồng là kỹ thuật
cho phép chương trình thực hiện nhiều luồng (thread) cùng một lúc, mỗi luồng thực hiện
một tác vụ riêng biệt. Các luồng sẽ chia sẻ tài nguyên của chương trình như bộ nhớ,
CPU, và các thiết bị nhập xuất. Lập trình đa luồng được sử dụng để tăng tốc độ thực thi
chương trình bằng cách sử dụng đồng thời nhiều CPU hoặc nhân của CPU để thực hiện
các tác vụ đồng thời. Trong khi đó, lập trình bất đồng bộ khơng phải là lập trình đa

luồng. Thay vì sử dụng nhiều luồng, lập trình bất đồng bộ cho phép các tác vụ đơn lẻ

NHÓM 07 3

LẬP TRÌNH MẠNG ĐỀ TÀI 03

(single-threaded) thực hiện đồng thời và không chờ đợi các tác vụ khác hoàn thành trước
khi thực hiện tác vụ tiếp theo bằng cách sử dụng các hàm bất đồng bộ (asynchronous
functions) hoặc các gọi hệ thống không đồng bộ (asynchronous system calls), mỗi tác
vụ được thực hiện trên cùng một luồng. Kỹ thuật này thường được sử dụng trong các
ứng dụng web, khi cần xử lý các yêu cầu HTTP đến từ nhiều người dùng khác nhau
cùng một lúc, và trong các ứng dụng desktop khi cần tương tác với các tác vụ I/O như
đọc/ghi dữ liệu từ đĩa cứng.

1.3. So sánh lập trình đồng bộ và lập trình bất đồng bộ:

Ưu điểm của lập trình đồng bộ: Các hoạt động xảy ra tuần tự nên có thể dễ quản lý,
dễ debug và phát hiện vấn đề khi xảy ra lỗi.

NHÓM 07 4

LẬP TRÌNH MẠNG ĐỀ TÀI 03

Vấn đề: Nếu thời gian chạy các hoạt động đồng bộ xảy ra quá dài thì UI sẽ bị lock
(đứng chương trình) do UI và các hoạt động đồng bộ cùng thuộc về 1 thread.

Ví dụ: Đơn giản nhất là khi ta làm việc với api lấy danh sách users từ database hay
từ file. Trong trường hợp data quá lớn thì việc api này sẽ trả về rất lâu(thời gian chờ
lâu). Nếu ta lập trình đồng bộ (synchronous) thì chương trình sẽ bị đứng (block UI) do
ta phải đợi gọi xong api thì khi đó thread duy nhất UI mới được giải phóng và làm việc

khác.

Vậy thread là gì: như hình minh họa ở trên 1 process(hay cịn được hiểu là 1 chương
trình) sẽ bao gồm nhiều threads. Mỗi thread có thể thực hiện các hoạt động khác nhau.

Ví dụ: Khi ta mở 1 ứng dụng web nghe nhạc. Ta vừa có thể play nhạc, vừa có thể làm
các hành động khác: pause, next, back, view list songs... bởi vì mỗi hành động là một
thread(một luồng riêng biệt).

NHÓM 07 5

LẬP TRÌNH MẠNG ĐỀ TÀI 03

Ưu điểm của lập trình bất đồng bộ: Bởi vì khơng bị block thread và các hoạt động có
thể khơng phải đợi nhau nên khi xử lý các tác vụ có thời gian thực hiện lâu khơng bị
đứng chương trình, đem lại trải nghiệm người dùng tốt.

Vấn đề: Bởi vì các hoạt động thực hiện khơng theo thứ tự nên ta phải quản lý các
hành động này một cách cẩn thận. Ví dụ như khi bạn xử lý hành động submit 1 form,
đầu tiên phải validate dữ liệu, sau đó mới tới phần xử lý. Nếu như quản lý khơng tốt
phần bất đồng bộ có thể dẫn tới: Phần xử lý chạy trước cả phần validate dữ liệu ---> có
thể gây ra lỗi nghiêm trọng.

1.4. Lập trình bất đồng bộ trong C#.Net:

Lập trình bất đồng bộ thường được sử dụng trong các xử lý tiềm ẩn blocking, giống
như truy cập tới website, việc truy cập tài ngun trên web đơi lúc là chậm trễ. Ngồi ra
có một số xử lý khác nên được xây dựng bất động bộ như: Làm việc trên file, ảnh,..

Từ .Net Framework 4.5 và Windows Runtime sẽ có một số phương thức trong các

APIs hỗ trợ bất đồng bộ như ở dưới:

✓ Web access: HttpClient, SyndicationClient
✓ Working with files: StorageFile, StreamWriter, StreamReader, XmlReader
✓ Working with images: MediaCapture, BitmapEncoder, BitmapDecoder
✓ WCF programming: Synchronous and Asynchronous Operations

NHÓM 07 6

LẬP TRÌNH MẠNG ĐỀ TÀI 03

C# hỗ trợ nhiều mơ hình lập trình bất đồng bộ để giúp giải quyết các vấn đề về hiệu
suất và độ trễ trong các ứng dụng. Dưới đây là các mơ hình lập trình bất đồng bộ chính
trong C#:

Asynchronous Programming Model (APM): là mô hình kế thừa sử dụng giao diện
IAsyncResult để cung cấp hành vi không đồng bộ. Trong mẫu này, các thao tác không
đồng bộ yêu cầu Begin và End các phương thức (ví dụ: BeginWritevà EndWriteđể triển
khai thao tác ghi khơng đồng bộ). Đây là một mơ hình lập trình bất đồng bộ cổ điển.
Trong mơ hình này, bạn định nghĩa một hàm gọi lại (callback function) mà sẽ được gọi
khi tác vụ bất đồng bộ hoàn thành. Hàm gọi lại này được truyền vào phương thức bất
đồng bộ làm tham số.

Event-based Asynchronous Pattern (EAP): là mơ hình kế thừa dựa trên sự kiện để
cung cấp hành vi khơng đồng bộ. Nó u cầu một phương thức có Async hậu tố và một
hoặc nhiều sự kiện, loại ủy quyền trình xử lý sự kiện và EventArg loại có nguồn gốc.
Đây là một mơ hình lập trình bất đồng bộ chuẩn được định nghĩa bởi Microsoft. Trong
mơ hình này, bạn sử dụng các sự kiện để thơng báo về tiến trình của tác vụ bất đồng bộ.
Các sự kiện này được kích hoạt khi tác vụ bắt đầu, tiến trình thay đổi hoặc kết thúc. EAP
đã được giới thiệu trong .NET Framework 2.0.

Task-based Asynchronous Pattern (TAP): Đây là mơ hình lập trình bất đồng bộ
mới nhất được định nghĩa bởi Microsoft. Trong mơ hình này, bạn sử dụng đối tượng
Task để đại diện cho tác vụ bất đồng bộ và sử dụng từ khóa async và await để lập trình
bất đồng bộ. TAP đã được giới thiệu trong .NET Framework 4.

APM ra đời đầu cùng với những phiên bản .Net đầu tiên. EAP ra đời sau và hoạt
động dựa trên sự kiện. APM và EAP khơng được khuyến khích sử dụng nữa, TAP xuất
hiện gần đây nhất và thay đổi hoàn toàn cách lập trình bất đồng bộ. TAP được xây dựng
trên bộ thư viện TPL (Task Parallel Library, dùng cho xử lí song song).

Task-based Asynchronous Pattern (TAP) là một mơ hình lập trình bất đồng bộ
trong C# được sử dụng để thực hiện các tác vụ đồng thời mà khơng chặn luồng chính

NHĨM 07 7

LẬP TRÌNH MẠNG ĐỀ TÀI 03

của ứng dụng. TAP cho phép ta thực hiện các phương thức bất đồng bộ bằng cách sử
dụng từ khóa "async" và "await" trong C#.

1.5. Lập trình bất đồng bộ mơ hình TAP với từ khóa async và await
trong C#.Net:

Task-based Asynchronous Pattern (TAP) là một mô hình lập trình để thực hiện các
tác vụ bất đồng bộ trong .NET Framework và .NET Core. TAP giúp ta giải quyết các
vấn đề liên quan đến lập trình đa luồng, như sự cố xung đột giữa các luồng, tăng hiệu
suất ứng dụng và tăng khả năng phản hồi của ứng dụng.

Khi sử dụng TAP, chúng ta sẽ tạo ra một tác vụ Task để thực hiện công việc bất đồng

bộ. Tác vụ này sẽ chứa một hoặc nhiều cơng việc cần thực hiện, ví dụ như truy vấn cơ
sở dữ liệu, tải tệp từ internet, hoặc tính tốn phức tạp. Khi một phương thức được đánh
dấu với từ khóa "async", nó cho phép phương thức trả về một Task hoặc Task<T>. Khi
một phương thức trả về một Task, nó chỉ định rằng phương thức đó là bất đồng bộ và sẽ
trả về một kết quả trong tương lai.

Ta sử dụng từ khóa await để đợi tác vụ hồn thành mà khơng chặn luồng chính của
ứng dụng. Khi một phương thức được gọi và chứa từ khóa "await", nó cho phép chương
trình tiếp tục thực hiện các công việc khác trong khi chờ đợi tác vụ bất đồng bộ được
hoàn thành. Khi tác vụ được hồn thành, chương trình sẽ tiếp tục thực hiện các dòng
lệnh tiếp theo.

Tại thời điểm tác vụ được đợi, nó có thể hồn thành bất kỳ lúc nào và kết quả sẽ được
trả về cho phương thức gọi. Trong q trình đợi, luồng chính của ứng dụng có thể tiếp
tục thực hiện các tác vụ khác mà khơng bị chặn.

Các tác vụ có thể chạy trên các luồng khác nhau, tùy thuộc vào cách triển khai của
phương thức. Khi một tác vụ được hồn thành, kết quả của nó sẽ được trả về cho phương
thức gọi thông qua một đối tượng Task<TResult>. Ta có thể sử dụng kết quả này để
thực hiện các tác vụ tiếp theo hoặc hiển thị nó trên giao diện người dùng.

NHÓM 07 8

LẬP TRÌNH MẠNG ĐỀ TÀI 03

Điều này giúp cho chương trình khơng bị chặn trong khi đợi các tác vụ bất đồng bộ
hoàn thành và giúp cải thiện hiệu suất của ứng dụng. TAP cũng cho phép xử lý các ngoại
lệ được ném ra từ các tác vụ bất đồng bộ, giúp đơn giản hóa mã lỗi và làm cho mã dễ
đọc hơn.

Ví dụ về sử dụng phương thức bất đồng bộ:

NHÓM 07 9

LẬP TRÌNH MẠNG ĐỀ TÀI 03

Các số trong sơ đồ tương ứng với các bước sau, được bắt đầu khi một phương thức
gọi gọi phương thức bất đồng bộ:

1. Calling method gọi và chờ GetUrlContentLengthAsync phương thức bất đồng bộ.
2. GetUrlContentLengthAsync tạo một phiên bản HttpClient và gọi phương thức

bất đồng bộ GetStringAsync để tải xuống nội dung của trang web dưới dạng
chuỗi.
3. Một cái gì đó xảy ra trong GetStringAsync đó đình chỉ tiến trình của nó. Có lẽ nó
phải đợi một trang web tải xuống hoặc một số hoạt động chặn khác. Để tránh
chặn tài nguyên, GetStringAsync hãy nhường quyền kiểm soát cho người gọi nó,
GetUrlContentLengthAsync.
GetStringAsync trả về một Task<TResult>, ở đâu Tresult là một chuỗi và
GetUrlContentLengthAsync gán tác vụ cho getStringTask biến. Nhiệm vụ đại
diện cho quá trình đang diễn ra đối với lệnh gọi đến GetStringAsync, với cam kết
tạo ra một giá trị chuỗi thực tế khi cơng việc hồn tất.
4. Vì getStringTask chưa được chờ đợi, GetUrlContentLengthAsync nên có thể tiếp
tục với công việc khác mà không phụ thuộc vào kết quả cuối cùng từ
GetStringAsync. Cơng việc đó được thể hiện bằng một cuộc gọi đến phương thức
đồng bộ DoIndependentWork.
5. DoIndependentWork là một phương thức đồng bộ thực hiện công việc của nó và
trả về trình gọi của nó.
6. GetUrlContentLengthAsync đã hết cơng việc mà nó có thể thực hiện mà không
có kết quả từ getStringTask. GetUrlContentLengthAsync next muốn tính tốn và

trả về độ dài của chuỗi đã tải xuống, nhưng phương thức khơng thể tính giá trị đó
cho đến khi phương thức có chuỗi.

Do đó, GetUrlContentLengthAsync sử dụng toán tử đang chờ để tạm dừng tiến
trình của nó và nhường quyền kiểm soát cho phương thức được gọi là
GetUrlContentLengthAsync.

GetUrlContentLengthAsync trả về a Task<int>cho người gọi. Nhiệm vụ thể hiện
lời hứa tạo ra một kết quả số nguyên có độ dài của chuỗi đã tải xuống.

NHÓM 07 10

LẬP TRÌNH MẠNG ĐỀ TÀI 03

Bên trong phương thức gọi, mẫu xử lý vẫn tiếp tục. Người gọi có thể thực
hiệncơng việc khác không phụ thuộc vào kết quả từ
GetUrlContentLengthAsynctrước khi chờ kết quả đó hoặc người gọi có thể chờ
ngay lập tức. Phương thức gọi đang chờ GetUrlContentLengthAsyncvà
GetUrlContentLengthAsyncđang chờ GetStringAsync.

7. GetStringAsynchoàn thành và tạo ra một kết quả chuỗi. Kết quả chuỗi không
được trả về GetStringAsynctheo cách mà bạn có thể mong đợi. (Hãy nhớ rằng
phương thức đã trả về một tác vụ ở bước 3.) Thay vào đó, kết quả chuỗi được lưu
trữ trong tác vụ đại diện cho việc hoàn thành phương thức, getStringTask. Toán
tử chờ lấy kết quả từ getStringTask. Câu lệnh gán gán kết quả đã truy xuất cho
contents.

8. Khi GetUrlContentLengthAsynccó kết quả chuỗi, phương thức có thể tính tốn
độ dài của chuỗi. Sau đó, cơng việc của GetUrlContentLengthAsynccũng hồn
tất và trình xử lý sự kiện đang chờ có thể tiếp tục. Trong ví dụ đầy đủ ở cuối chủ

đề, bạn có thể xác nhận rằng trình xử lý sự kiện truy xuất và in giá trị của kết quả
độ dài. Nếu bạn chưa quen với lập trình không đồng bộ, hãy dành một phút để
xem xét sự khác biệt giữa hành vi đồng bộ và không đồng bộ. Phương thức đồng
bộ trả về khi cơng việc của nó hồn tất (bước 5), nhưng phương thức không đồng
bộ trả về giá trị tác vụ khi công việc của nó bị tạm dừng (bước 3 và 6). Khi
phương thức async cuối cùng hoàn thành cơng việc của nó, tác vụ được đánh dấu
là đã hoàn thành và kết quả, nếu có, được lưu trữ trong tác vụ.

1.6. Lập trình Socket bất đồng bộ TCPIP Server với từ khóa async
_await trong C#:

Mô hình bất đồng bộ là một phương pháp lập trình cho phép các hoạt động I/O
(input/output) được thực hiện mà khơng cần chờ đợi các hoạt động I/O hồn thành trước
khi thực hiện các hoạt động khác. Trong lập trình socket, mơ hình bất đồng bộ thường
được sử dụng để tối ưu hóa thời gian phản hồi của các ứng dụng socket.

NHÓM 07 11

LẬP TRÌNH MẠNG ĐỀ TÀI 03

Các ứng dụng socket truyền thống thường sử dụng mơ hình đồng bộ, trong đó các
hoạt động I/O được thực hiện theo thứ tự tuần tự, một sau một. Điều này có nghĩa là nếu
một hoạt động I/O mất nhiều thời gian để hồn thành, thì tất cả các hoạt động khác phải
đợi cho đến khi hoạt động đó hồn thành trước khi được thực hiện. Điều này dẫn đến
thời gian phản hồi chậm và hiệu suất kém.

Với mơ hình bất đồng bộ, các hoạt động đầu I/O ra được thực hiện độc lập với nhau,
mà không cần phải chờ đợi các hoạt động khác hoàn thành trước. Khi một hoạt động
đầu I/O ra được gọi, nó sẽ được thực hiện trong nền và ứng dụng tiếp tục thực hiện các
hoạt động khác. Khi hoạt động I/O hoàn thành, ứng dụng sẽ được thơng báo và có thể

tiếp tục thực hiện các hoạt động khác.

Mô hình bất đồng bộ có thể cải thiện hiệu suất và thời gian phản hồi của các ứng dụng
socket, đặc biệt là trong các ứng dụng có nhiều kết nối đồng thời. Nó cũng giúp tăng
khả năng chịu tải của các ứng dụng socket, cho phép chúng xử lý được nhiều kết nối
cùng lúc mà không ảnh hưởng đến hiệu suất của hệ thống.

Khi sử dụng mô hình bất đồng bộ, chương trình có thể tiếp tục thực hiện các tác vụ
khác trong khi đang chờ đợi phản hồi từ socket, giúp tăng hiệu quả và thời gian đáp ứng
của ứng dụng. Mơ hình bất đồng bộ cho phép xử lý đồng thời nhiều kết nối cùng lúc, do
đó giảm thời gian chờ đợi của người dùng và cải thiện trải nghiệm người dùng. Mơ hình
bất đồng bộ cũng giúp giảm tải cho máy chủ khi nhiều yêu cầu đến cùng lúc, do đó tăng
khả năng chịu tải của hệ thống.

NHÓM 07 12

LẬP TRÌNH MẠNG ĐỀ TÀI 03

PHẦN 2: PHÂN TÍCH VIDEO: 03 TCPIP SERVER
ASYNCHRONOUS SOCKET PROGRAMMING WITH

ASYNC _ AWAIT KEYWORDS IN C#

2.1. Section Intro Asynchronous socket programming with async
await in C# .Net:

Từ khóa async và await đã được giới thiệu trong .Net Framework 4.5.
Các phương pháp không chặn đặc biệt cũng được giới thiệu.
Các lớp trợ giúp socket: TCPListener, TCPClient.
StreamReader & StreamWriter với các luồng mạng.

Class library, tangible course takeaway.
Tạo 1 class: Trong solution add một new Project:

Chọn class libary (.Net Framework):

NHÓM 07 13

LẬP TRÌNH MẠNG ĐỀ TÀI 03

Kết nối thư viện với form:

2.2. Example Disadvantage of synchronous IO in C# .Net:

Trên visual studio 2019, sử dụng Windows Forms App (.Net Framework) và tiến
hành chọn Framework trên 4.5:

Tạo form với 1 nút button “Start” có chức năng khi nhấn vào chương trình mới bắt
đầu thực hiện:

NHĨM 07 14

LẬP TRÌNH MẠNG ĐỀ TÀI 03

Sử dụng đoạn code Server TCP ở bài trước:

Server đang tiến hành lắng nghe Client kết nối tới và in ra màn hình dịng lệnh “About
to accept incoming connection”.

NHÓM 07 15

LẬP TRÌNH MẠNG ĐỀ TÀI 03

Server lắng nghe và đợi để chấp nhận yêu cầu nếu có client kết nối vào:

Tuy nhiên, nếu như chưa có client nào kết nối hoặc q trình kết nối bị gián đoạn,
dẫn đến thời gian chờ quá lâu, thì chương trình sẽ bị đứng và khơng phản hồi. Vì chương
trình thực hiện bằng mơ hình đồng bộ nên các lệnh được thực thi tuần tự. Do đó, server
sẽ lắng nghe, đến khi nào có chấp nhận kết nối mới thực hiện các hành động khác, tất
cả các hoạt động khác sẽ bị block và phải đợi cho đến khi listenerSocket.Accept() đó
hồn thành trước khi được thực hiện.

NHĨM 07 16

LẬP TRÌNH MẠNG ĐỀ TÀI 03

Tiến hành cho client kết nối vào, server chấp nhận kết nối, chương trình phản hồi trở
lại và tiếp tục thực hiện các lệnh phía sau:

Như vậy, nếu sử dụng mơ hình đồng bộ trong lập trình socket thì trong quá trình nhận
kết nối từ client trên server, chương trình khơng thể làm bất cứ điều gì khác ngồi việc
chờ đợi dẫn đến chương trình bị đứng và các luồng khác bị block. Điều này dẫn đến thời
gian phản hồi chậm và hiệu suất kém. Do đó, để cải thiện hiệu suất và tối ưu hóa thời
gian phản hồi của các ứng dụng socket thì trong lập trình socket, sẽ sử dụng mơ hình bất
đồng bộ.

2.3. Accepting a TCPClient Connection Asynchronously with await
keyword in C#:

Sử dụng async và await để tiến hành lập trình sever theo mơ hình bất đồng bộ.

NHĨM 07 17