Báo cáo thực tập tốt nghiệp Hoàng Văn Vang _ Nguyễn Mạnh Dũng _ Xây dựng phần mềm lớp học ảo trong mạng Lan _Lop KHMT1K3

TRƯỜNG ĐẠI HỌC CÔNG NGHIỆP HÀ NỘI

KHOA CÔNG NGHỆ THÔNG TIN-------------------------------- ------------------------------

BÁO CÁO THỰC TẬP TỐT NGHIỆP

Đề tài:

XÂY DỰNG PHẦN MỀM LỚP HỌC ẢO TRONG MẠNG LAN

Nhóm sinh viên thực hiện: HOÀNG VĂN VANG

NGUYỄN MẠNH DŨNG

Lớp : ĐH- KHMT1K3

Giảng viên hướng dẫn: TH.S NGUYỄN TIẾN LỢI

Hà Nội, 05/2012

PHIẾU GIAO ĐỀ TÀI

Page | 2

NHẬN XÉT CỦA GIÁO VIÊN HƯỚNG DẪN

....................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................... ................................................................................................................................................................................................................................................................................................................................................................................................................................. ........................................................................................................................................... ........................................................................................................................................... ........................................................................................................................................... ........................................................................................................................................... .......................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................... ...................................................................................................................................................................................................................................................................................... ........................................................................................................................................... ........................................................................................................................................... ..................................................................................................................................

Hà Nội, ngày tháng năm 2012

Giảng viên

Page | 3

Th.S Nguyễn Tiến Lợi

LỜI NÓI ĐẦU

Công nghệ thông tin là ngành công nghiệp mũi nhọn của thế giới nói chung và của Việt Nam nói riêng, nó đã phát triển mạnh mẽ không ngừng trong những năm gần đây. Số lượng các trường học có đào tạo nghành CNTT ngày một tăng cao, cùng với đó là các trung tâm tin học mở ra ngày một nhiều. Và lẽ tự nhiên khi các trường, các trung tâm muốn có các phòng máy chất lượng thì họ cũng sẽ có nhu cầu sử dụng các hệ thống quản lý phòng máy đa năng, tiện dụng và thân thiện người sử dụng. Tại các phòng máy đó các giảng viên có thể dễ dàng truyền đạt kiến thức một cách sinh động, trực quan cho các học viên bằng cách sử dụng chức năng chia sẻ màn hình của phần mềm quản lý phòng máy, hoặc giảng viên có thể chỉ dẫn cho học viên trực tiếp trên màn hình của học viên chỉ bằng thao tác đơn giản giống như trực tiếp giảng viên ngồi tại máy của học viên …

Do đó việc xây dựng một phần mềm lớp học ảo trong mạng Lan là một việc rất cần thiết, nhằm hỗ trợ các giảng viên cũng như hỗ trợ các học viên có thể tiếp cận được với cách học tập trực quan dễ hiểu. Nhận thức được tầm quan trọng cũng như cấp thiết phải có một hệ thống quản lý các máy tính trong phòng học mạng Lan. Nhóm chúng em đã đăng ký đề tài “Xây dựng phần mềm lớp học ảo trong mạng Lan”. Với hi vọng phần mềm sẽ giải quyết được phần nào trong quá trình dạy và học trong phòng máy sử dụng mạng Lan. Và tiến xa hơn đó là một phần mềm đào tạo thông qua mạng Internet, ở đó cả học viên và giảng viên có thể truy cập từ bất kỳ máy tính nào được cài đặt phần mềm việc học tập và giảng dạy sẽ càng trở lên dễ dàng hơn.

Để hoàn thành báo cáo thực tập tốt nghiệp này, chúng em đã được sự giúp đỡ tận tình của giảng viên hướng dẫn - Th.S Nguyễn Tiến Lợi - Giảng viên khoa CNTT trường Đại Học Công Nghiệp Hà Nội, Thầy đã tận tình hướng dẫn, góp ý chỉnh sửa rất chi tiết cho bài báo cáo của chúng em. Chúng em xin chân thành gửi lời cảm ơn sâu sắc tới Thầy. Xin chúc Thầy và gia đình luôn mạnh khỏe và thạnh phúc.

Page | 4

TÓM TẮT NỘI DUNG BÁO CÁO THỰC TẬP TỐT NGHIỆP

1. Những nội dung sẽ được trình bày trong bài báo cáo.

Đề xuất xây dựng một phần mềm lớp học ảo trong mạng Lan có những chức năng chính sau đây.

Chia sẻ màn hình giảng dạy.

Chia sẻ tài liệu học tập.

Chat Message.

Điều khiển máy tính từ xa (Remote Desktop).

Hỗ trợ giảng viên một số chức năng và tiện ích khác.

Đưa ra các kiến thức, kỹ thuật cơ bản và quan trọng về lập trình mạng với Socket và .Net Remoting.

Nghiên cứu các lĩnh vực lập trình nâng cao như các hàm API, lập trình xử lý ảnh có ứng dụng cụ thể trong bài toán.

Báo cáo về quá trình để xây dựng các module chính của phần mềm, và sau đó tiến hành xây dựng một phần mềm hoàn thiện.

Đưa ra một phần mềm hoàn thiện và đánh giá về các kết quả thực nghiệm.

2. Cấu trúc của báo cáo.

Chương 1. Tổng quan về đề tài.

Chương 2. Lý thuyết cơ sở.

Chương 3. Ứng dụng phần mềm quản lý lớp học ảo.

Chương 4. Cài đặt và thử nghiệm.

Chương 5. Kết luận.

Tài liệu tham khảo và kiến nghị.

Page | 5

DANH SÁCH HÌNH ẢNH

Hình 2. 1: Chức năng của Socket..............................................................................................16

Hình 2. 2. Sơ đồ giao tiếp các máy tính khác nhau...................................................................17

Hình 2. 3: Các chế độ giao tiếp các tầng mạng khác nhau.......................................................18

Hình 2. 4. Minh họa quá trình khởi tạo TCP Socket Server.....................................................19

Hình 2. 5. Mô tả quá trình khởi tạo TCP Socket Client kết nối tới Server...............................19

Hình 2. 6. Mô tả quá trình truyền nhận thông tin giữa Server và Client..................................20

Hình 2. 7. Mô tả kết thúc phiên làm việc giữa Client và Server...............................................20

Hình 2. 8. Mô tả quá trình khởi tạo UDP Socket Server..........................................................21

Hình 2. 9. Mô tả quá trình khởi tạo UDP Socket Client...........................................................21

Hình 2. 10. Mô tả quá trình truyền nhận dữ liệu bằng UDP.....................................................22

Hình 2. 11. Mô hình trao đổi thông tin của .Net Remoting......................................................29

Hình 2. 12. Lập trình sự kiện trong Windows..........................................................................33

Hình 2. 13. Gửi và nhận sự kiện trong Windows.....................................................................34

Hình 2. 14. Kết quả chương trình không sử dụng đồng bộ hóa................................................41

Hình 2. 15. Kết quả chương trình sử dụng đồng bộ hóa...........................................................42

Hình 2. 16. Biểu diễn ảnh trong hệ màu RGB..........................................................................46

Hình 2. 17. Mô tả thuật toán cắt ảnh.........................................................................................46

Hình 2. 18. Mô tả ma trận điểm ảnh.........................................................................................47Hình 2. 19. Minh họa thuật toán so sánh ảnh......................................................................................47

Hình 3. 1. Mô hình phân cấp chức năng...................................................................................56

Hình 3. 2. Hình minh họa chức năng chia sẻ màn hình............................................................57

Hình 3. 3. Các nội dung giảng dạy có trên màn hình các máy học viên...................................57

Hình 3. 4. Minh họa chia sẻ màn hình cho toàn bộ học viên....................................................58

Hình 3. 5. Minh họa các tài liệu được chia sẻ..........................................................................58

Hình 3. 6. Minh họa chức năng chia sẻ màn hình.....................................................................59

Hình 3. 7. Mô hình luồng dữ liệu..............................................................................................60

Page | 6

DANH MỤC BẢNG BIỂU

Bảng 1. 1. Cấu hình tối thiểu của phòng máy...........................................................................13Bảng 1. 2. Cấu hình được khuyến cáo trong phòng máy.....................................................................13

Bảng 2. 1. Một số phương thức của lớp NetworkStream ................................................23

Bảng 2. 2. Một số phương thức lớp StreamRead......................................................................24

Bảng 2. 3. Một số phương thức lớp StreamWriter....................................................................24

Bảng 2. 4. Các thành viên của lớp TCPClient..........................................................................25

Bảng 2. 5. Các phương thành viên của lớp TCPListener..........................................................26

Bảng 2. 6. các thành viên của lớp UDPClient..........................................................................27

Bảng 2. 7. Các phương thức của lập trình Socket bất đồng bộ.................................................28

Bảng 2. 8. Một số lớp thuộc tính của thư viện System.Thread.................................................36

Bảng 2. 9. Các thành phần static của lớp Thread......................................................................36

Bảng 2. 10. Các thành viên cấp đối tượng của lớp Thread.......................................................37

Bảng 2. 11. Các thành phần chính của Registry.......................................................................53

Page | 7

DANH MỤC CÁC THUẬT NGỮ VIẾT TẮT

Danh sách từ viết tắt Nghĩa của từ

LanVC Lan Virual Class (Phần mềm lớp học ảo).

IP Internet Protocol.

TCP Transmission Control Protocol.

UDP User Datagram Protocol.

TCP/IP Internet Protocol Suite.

FPT File Transfer Protocol.

SMTP Simple Mail Transfer Protocol.

HTTP HyperText Transfer Protocol.

DNS Doname System.

RGB Không gian màu gồm ba màu Red - Blue - Green.

API Application programming interface.

DLL Dynamic Link Library.

XML Extensible Markup Language.

HTML HyperText Markup Language.

Page | 8

MỤC LỤC

PHIẾU GIAO ĐỀ TÀI..............................................................................................................2NHẬN XÉT CỦA GIÁO VIÊN HƯỚNG DẪN.....................................................................3LỜI NÓI ĐẦU...........................................................................................................................4TÓM TẮT NỘI DUNG BÁO CÁO THỰC TẬP TỐT NGHIỆP.........................................5DANH SÁCH HÌNH ẢNH.......................................................................................................6DANH MỤC BẢNG BIỂU.......................................................................................................7DANH MỤC CÁC THUẬT NGỮ VIẾT TẮT.......................................................................8MỤC LỤC..................................................................................................................................9CHƯƠNG 1. TỔNG QUAN VỀ ĐỀ TÀI.............................................................................12

1.1. Lý do chọn đề tài..........................................................................................................121.2. Tình hình nghiên cứu trên thực tế..............................................................................121.3. Vấn đề đặt ra của đề tài...............................................................................................13

1.3.1. Một số vấn đề về cấu hình của hệ thống.................................................................131.3.2. Đề xuất các module.................................................................................................13

1.4. Mục tiêu của đề tài.......................................................................................................141.5. Đối tượng và phương pháp nghiên cứu.....................................................................14

1.5.1. Đối tượng nghiên cứu.............................................................................................141.5.2. Phương pháp nghiên cứu........................................................................................14

1.6. Dự kiến các kết quả nghiên cứu..................................................................................151.7. Kết luận.........................................................................................................................15

CHƯƠNG 2. LÝ THUYẾT CƠ SỞ......................................................................................162.1. Lập trình Socket C#.....................................................................................................16

2.1.1. Socket là gì?............................................................................................................162.1.2. Chức năng của Socket.............................................................................................162.1.3. Phân loại Socket......................................................................................................162.1.4. Thành phần của một Socket....................................................................................17

2.1.4.1. Số hiệu cổng (port number).............................................................................172.1.4.2. Địa chỉ IP.........................................................................................................17

2.1.5. Các chế độ giao tiếp................................................................................................182.1.6. Xây dựng ứng dụng Client-Server với Socket:.......................................................18

2.1.6.1. Mô hình Client-Server sử dụng Socket ở chế độ có kết nối (TCP).................192.1.6.2. Mô hình Client-Server sử dụng Socket ở chế độ không kết nối (UDP)..........20

2.1.7. Sử dụng C# Stream với TCP...................................................................................222.1.7.1. Lớp NetworkStream.........................................................................................222.1.7.2. Lớp StreamReader và StreamWriter................................................................23

2.1.8. Sử dụng các lớp Helper Socket...............................................................................242.1.8.1.TCPClient.........................................................................................................242.1.8.2. TCPListener.....................................................................................................252.1.8.3. UDPClient........................................................................................................26

2.1.9. Lập trình Socket bất đồng bộ..................................................................................272.1.9.1. Thành lập kết nối.............................................................................................282.1.9.2. Trao đổi dữ liệu................................................................................................28

2.2. Lập trình .Net Remoting.............................................................................................292.2.1. Các khái niệm.........................................................................................................292.2.2. Remote Objects trong .NET Remoting...................................................................292.2.3.Domain.....................................................................................................................302.2.4.Channel....................................................................................................................302.2.5. Object Activation....................................................................................................312.2.6. Client Activated Objects.........................................................................................31

Page | 9

2.2.7. Tạo một Remotable Object.....................................................................................322.3. Lập trình sự kiện trong Windows..............................................................................33

2.3.1. Sử dụng Event và Delegate.....................................................................................332.4. Lập trình đa luồng.......................................................................................................34

2.4.1. Khái niệm đa luồng (Thread)..................................................................................342.4.2. Tham khảo thư viện System.Thread.......................................................................352.4.2. Lớp Thread..............................................................................................................362.4.3. Thao tác với luồng..................................................................................................372.4.4. Đồng bộ hóa (Synchronization) trong lập trình đa luồng.......................................39

2.4.4.1. Đồng bộ hóa.....................................................................................................392.4.4.2. Deadlock..........................................................................................................422.4.4.3. Race condition.................................................................................................43

2.5. Lập trình xử lý ảnh trong C#......................................................................................452.5.1. Một số khái niệm xử lý ảnh....................................................................................45

2.5.1.1. Khái niệm ảnh..................................................................................................452.5.2. Kỹ thuật xử lý ảnh cơ bản.......................................................................................46

2.5.2.1. Thuật toán cắt ảnh............................................................................................462.5.2.2. Thuật toán so sánh hai ảnh bitmap...................................................................47

2.6. Một số kỹ thuật khác...................................................................................................482.5.1. Các hàm API...........................................................................................................48

2.5.1.1. Khái niệm API.................................................................................................482.5.1.2. Các thành phần của Windows API..................................................................482.5.1.3. Cách dùng các hàm API...................................................................................482.5.1.4. Sử dụng các hàm API......................................................................................49

2.5.2. XML........................................................................................................................502.5.2.1. Khái niệm về XML..........................................................................................502.5.2.2. Các quy tắc viết thẻ XML................................................................................51

2.5.3. Registry trong C#....................................................................................................512.5.3.1. Khái niệm Registry..........................................................................................512.5.3.2. Các lớp .Net Registry.......................................................................................51

2.7. Kết luận chương...........................................................................................................53CHƯƠNG 3. ỨNG DỤNG PHẦN MỀM QUẢN LÝ LỚP HỌC ẢO................................54

3.1. Phân tích thiết kế hệ thống..........................................................................................543.1.1.Khảo sát hiện trạng và lập dự án..............................................................................54

3.1.1.2. Đề xuất ý tưởng xây dựng hệ thống mới.........................................................543.1.1.3. Mô tả hoạt động của hệ thống..........................................................................54

3.1.2. Phân tích các chức năng của hệ thống....................................................................553.1.2.1. Mô hình phân cấp chức năng...........................................................................553.1.2.2. Giải thích rõ từng chức năng của hệ thống......................................................563.1.2.3. Mô hình luồng dữ liệu......................................................................................59

3.2. Xây dựng các lớp xử lý chính......................................................................................603.2.1. Các lớp bên phía Server..........................................................................................60

3.2.1.1. Lớp ServerReceiver.........................................................................................603.2.1.2. Lớp ServerSender............................................................................................623.2.1.3. Lớp ServerTCP................................................................................................653.2.1.4. Lớp BuffData...................................................................................................70

3.2.2. Các lớp bên phía Client...........................................................................................713.2.2.1. Lớp ClientReceiver..........................................................................................723.2.2.2. Lớp ClientSender.............................................................................................743.2.2.3. Lớp ClientTCP.................................................................................................76

Page | 10

3.3. Thiết kế giao diện.........................................................................................................79CHƯƠNG 5. KẾT LUẬN......................................................................................................80

5.1. Những kết quả đạt được..............................................................................................805.2. Hướng phát triển..........................................................................................................80

TÀI LIỆU THAM KHẢO......................................................................................................81

Page | 11

CHƯƠNG 1. TỔNG QUAN VỀ ĐỀ TÀI

1.1. Lý do chọn đề tài.

Hiện nay, với sự phát triển vượt bậc của khoa học công nghệ trong đời sống xã hội. Việc ứng dụng công nghệ mạng Lan vào trong việc giảng dạy tại các trường Đại Học, và Cao Đẳng ngày càng phát triển. Nhưng việc quản lý phòng học trong mạng Lan còn nhiều bất cập.

Tốn kém đầu tư tiền của vào hệ thống máy chiếu, bảng hiện tại.

Khó khăn trong khâu chia sẻ tài liệu học tập.

Giáo viên khó khăn trong quá trình giảng dạy, và giải đáp thắc mắc học viên.

Không có nhiều sự tương tác giữa giảng viên và học sinh.

Vì vậy xuất phát từ vấn đề đó nhóm chúng em quyết định lựa chọn đề tài “Xây dựng phần mềm lớp học ảo trong mạng Lan”. Với mong muốn đem lại một phần mềm giúp tận dụng sức mạnh của CNTT đem lại hiệu quả cho việc giảng dạy trong các phòng học hiện tại.

1.2. Tình hình nghiên cứu trên thực tế.

Hiện nay trên thị trường cũng đã có các sản phẩm phần mềm có tính năng tương tự hoặc một số phần mềm có tính năng như một module nhỏ của phần mềm lớp học ảo.

Farstone Virtual Class.

Ưu điểm : Là một phần mềm của hãng FarStone đưa ra với mục đích quản lý lớp học ảo gần như rất hoàn hảo, nó có thể cho phép giảng viên và học sinh tương tác với nhau vô cùng đơn giản và tiện lợi.

Nhược điểm : giá cả của nó thì không hề dẻ chút nào với 299$. Và nó còn thiếu một tính năng đó là chức năng quay phim màn hình và Void chat trong lớp học.

Remote Desktop Connection.

Ưu điểm : là một phần mềm của hãng Micosoft được chạy trên Windows 7 và Windows Vista và nó là một phần mềm miễn phí, và sử dụng được một cách linh hoạt.

Nhược điểm : còn có nhiều thiếu sót đó là chỉ có chức năng remote desktop từ xa mà không hề có chức năng như giảng dạy,.. Do đó phần mềm này chỉ giúp ích được không nhiều trong việc quản lý lớp học ảo. Và thêm nữa là chúng ta cần phải nhớ tên của máy Client và Password đây là việc cực kỳ bất tiện.

Page | 12

FreeVC.

Ưu điểm : là một phần mềm của người việt được viết bởi tác giả Bùi Duy Hùng, phần mềm này đã nhận được giải thưởng phần mềm sáng tạo của trường Đại học Công Nghiệp Hà Nội. Phần mềm này được đánh giá là tiện ích như phần mềm Farstone Virtual Class nhưng nó là một phần mềm miễn phí và hiệu năng và tính năng đơn giản dễ sử dụng

Nhược điểm : tuy vậy phần mềm này còn nhiều thiếu sót như quản lý Usb, Turn Off Computer, và một vài chức năng khác.

Microsoft NetMeeting :

Ưu điểm : cũng là một phần mềm của hãng Microsoft có hỗ trợ trên Windows XP nó có thể cho phép người sử dụng dùng để tổ chức hội thảo, nhìn thấy người nói chuyện với mình, hoặc có thể chia sẻ tài liệu một cách dễ dàng.

Nhược điểm : tuy vậy phần mềm còn có khá nhiều vấn đề như nó không thể xem các máy Client khi cần thiết, mà nó chỉ xem được danh sách các máy Client. Và một vài khuyết điểm khác như khóa Usb, quản lý các máy Client khi cần thiết.

1.3. Vấn đề đặt ra của đề tài.

Dựa vào tình hình nghiên cứu các phần mềm trên thực tế chúng ta sẽ tiến hành xây dựng lên một phần mềm hoàn hảo hơn, nhằm loại bỏ đi những khuyết điểm của các phần mềm thực tế, và tận dụng hết các điểm mạnh của phần mềm thực tế.

1.3.1. Một số vấn đề về cấu hình của hệ thống.

Một vấn đề không kém phần quan trọng đó là cấu hình cần thiết để thực hiện chạy ứng dụng phần mềm lớp học ảo trong mạng Lan.

Server Client

Hardware

Ram 512 MB

CPU P IV 3.0 GHz

LAN network

Ram 256 MB

CPU Ce 1.8 GHz

LAN network

Software

Window XP

SQL Server 2005

.Net framework 3.5

Windows XP.

.Net framework 3.5

Bảng 1. 1. Cấu hình tối thiểu của phòng máy.

Server Client

Page | 13

Hardware

Ram 2.0 GB

CPU Core 2 Duo 2.8 GHz

LAN network

Ram 512 MB

CPU P IV 2.4 GHz

LAN network

Software

Window Server 2003.

SQL Server 2005

.Net framework 3.5

Windows XP.

.Net framework 3.5

Bảng 1. 2. Cấu hình được khuyến cáo trong phòng máy.1.3.2. Đề xuất các module.

Như trong phần 1.1 và 1.2 chúng ta đã được biết mức độ cấp bách và cần thiết phải thực hiện “Xây dựng phần mềm lớp học ảo trong mạng Lan”. Do đó phần mềm của chúng em được đề xuất các module chính sau đây cần thiết phải thực hiện.

Module chia sẻ (gồm chia sẻ tài liệu, chia sẻ màn hình, thực hiện việc trao đổi thông tin bằng chat message).

Module tiện ích (gồm có Turn off computer, Disable/Enable Usb disk, Remote desktop, và chức năng VoIP).

Trong đó có hai module chính quan trọng và cần thiết nhất cần giải quyết đó và Remote desktop và chia sẻ màn hình. Hai module này về giải thuật và cách xây dựng là tương đối giống nhau.

1.4. Mục tiêu của đề tài.

Đưa ra những giải pháp cụ thể của phần mềm để giải quyết các bất cập đã nêu.

Đề xuất xây dựng một phần mềm với mục đích giúp việc học tập và giảng dạy tại lớp học trong mạng Lan trở lên dễ dàng và trực quan hơn.

Xây dựng một mô hình cụ thể cho vấn đề đang nghiên cứu. Và đưa mô hình đó vào ứng dụng thực tế.

1.5. Đối tượng và phương pháp nghiên cứu.

1.5.1. Đối tượng nghiên cứu.

Tìm hiểu các kỹ thuật cơ bản của lập trình mạng với Socket, và .Net Remoting.

Nghiên cứu về lập trình Thread, lập trình sự kiện Delegate.

Tìm hiểu các kỹ thuật trong lập trình sử dụng các hàm API ứng dụng vào bài toán lập trình phần mềm lớp học ảo.

Ngoài ra còn nghiên cứu lập trình xử lý ảnh trong C# trong vấn đề giải quyết bài toán chia sẻ màn hình và điều khiển máy tính từ xa.

1.5.2. Phương pháp nghiên cứu.

Page | 14

Tìm hiểu các kiến thức về lập trình mạng với Socket và .Net Remoting thông qua các giáo trình, các bài viết về lập trình mạng trên các diễn đàn - song song với việc tham khảo từ tài liệu của giáo viên hướng dẫn.

Tham khảo các kiến thức về lập trình xử lý ảnh, lập trình các hàm API và Thread trong sách vở cũng như trên các website.

Tìm kiếm các mã nguồn mở về các mảng cần nghiên cứu trên các website như codeproject.com, codeplex.com, sourceforge.net, github.com ... Nhằm mục đích tìm hiểu về quá trình cài đặt thuật toán xử lý cơ bản và nâng cao trên ngôn ngữ lập trình C/C++ và C#.

Từng bước nghiên cứu, đánh giá và đề xuất các kỹ thuật sử dụng trong phần mềm.

Thực nghiệm dựa trên xây dựng ứng dụng và đánh giá các kết quả đã thực hiên được và những kết quả chưa thực hiện được. Từ đó đưa ra các giải pháp và các triển vọng của đề tài.

1.6. Dự kiến các kết quả nghiên cứu.

Hoàn thiện quá trình nghiên cứu, đưa ra một số kỹ thuật cơ bản trong quá trình lập trình mạng.

Xây dựng một báo cáo cụ thể và chi tiết về các kỹ thuật lập trình Thread, API và xử lý ảnh được ứng dụng trong bài toán.

Cài đặt và xây dựng một phần mềm lớp học ảo thực tế. Và sau đó đánh giá các kết quả thực nghiệm.

Kết luận chương.

Nội dung chương này chúng em sẽ trình bầy lý do để chọn ra đề tài, các nội dung và các mục cần thiết để nghiên cứu, đưa ra các module cần thiết phải xây dựng trong chương trình. Và đưa ra dự kiến thực hiện đề tài gồm : báo cáo và chương trình demo các kết quả đã đạt được.

Page | 15

CHƯƠNG 2. LÝ THUYẾT CƠ SỞ

2.1. Lập trình Socket C#.

2.1.1. Socket là gì?.

Socket là một phương pháp để thiết lập kết nối truyền thông giữa một chương trình yêu cầu dịch vụ ( client) và một chương trình cung cấp dịch vụ (server) trên mạng LAN, WAN hay Internet và đôi lúc là giữa những tiến trình ngay trong một máy tính. Mỗi socket có thể được xem như một điểm cuối (EndPoint) trong một kết nối.

Một socket trên máy yêu cầu dịch vụ có địa chỉ mạng được cấp sẵn để “gọi” một socket trên máy cung cấp dịch vụ. Một khi socket đã được thiết lập phù hợp, hai máy tính có thể trao đổi dịch vụ và dữ liệu.

Socket được giới thiệu lần đầu tiên trong ấn bản UNIX - BSD 4.2 dưới dạng các hàm hệ thống theo cú pháp ngôn ngữ C (socket(), bind(), connect(), send(), receive(), read(), write(), close() ,..). Ngày nay, Socket được hỗ trợ trong hầu hết các hệ điều hành như MS Windows (WinSock), Linux và được sử dụng trong nhiều ngôn ngữ lập trình khác nhau: như C, C++, C#, Java, Visual Basic, Visual C++ . . .

Dữ liệu gởi và nhận bằng Socket bắt buộc phải là mảng các byte.

2.1.2. Chức năng của Socket

Socket cho phép thiết lập các kênh giao tiếp mà hai đầu kênh được xác định bởi hai cổng (port). Thông qua các cổng này một tiến trình có thể nhận và gởi dữ liệu với các tiến trình khác.

Hình 2. 1: Chức năng của Socket.2.1.3. Phân loại Socket

Có các loại Socket chính là:

Socket kiểu AF_UNIX chỉ cho phép giao tiếp giữa các tiến trình trong cùng một máy tính.

Page | 16

Socket kiểu AF_INTET cho phép giao tiếp giữa các tiến trình trên nhưng máy tính khác nhau trên mạng.

Phân loại theo kiểu kết nối:

Socket hướng kết nối (TCP Socket)

Socket không hướng kết nối (UDP Socket)

2.1.4. Thành phần của một Socket

2.1.4.1. Số hiệu cổng (port number)

Để có thể thực hiện các cuộc giao tiếp, một trong hai tiến trình phải cho biết số hiệu cổng của socket mà mình sử dụng. Mỗi cổng giao tiếp thể hiện một địa chỉ xác định trong một hệ thống. Khi tiến trình được gán một số hiệu cổng (Server), nó có thể nhận dư liệu gởi đến cổng này từ tiến trình khác (Client). Tiến trình còn lại cũng 8 yêu cầu tạo ra một socket.

2.1.4.2. Địa chỉ IP

Ngoài số hiệu cổng, hai bên giao tiếp còn phải biết địa chỉ IP của nhau. Trong khi số hiệu cổng dùng để phân biệt các quá trình khác nhau trên cùng một máy tính thì IP dùng để phân biệt các máy tính khác nhau trên cùng một mạng TCP/IP.

Hình 2. 2. Sơ đồ giao tiếp các máy tính khác nhau.Trong hình trên, địa chỉ của tiến trình B1 được xác định bằng 2 thông tin: (Host

B, Port B1)

Địa chỉ máy tính có thể là địa chỉ IP dạng 118.69.123.139 hay là địa chỉ theo dạng domain như www.uit.edu.vn.

Số hiệu cổng gán cho Socket phải là duy nhất trên phạm vi máy đó, có giá trị trong khoảng từ 0-65535 (16 bits). Trong đó các cổng từ 1-1023 được gọi là cổng hệ thống được dành riêng cho các tiến trình của hệ thống.

Page | 17

2.1.5. Các chế độ giao tiếp

Xét kiến trúc của hệ thống mạng TCP/IP:

Hình 2. 3: Các chế độ giao tiếp các tầng mạng khác nhau.Tầng vận chuyển (Transport Layer) giúp chuyển tiếp các thông điệp giữa các

chương trình với nhau. Nó có thể hoạt động theo hai chế độ:

Giao tiếp có nối kết, nếu giữa chúng sử dụng giao thức TCP.

Giao tiếp không kết nổi, nếu sử dụng giao thức UDP.

Socket là giao diện giữa chương trình và lớp vận chuyển. Nó cho phép ta chọn giao thức sử dụng ở tầng vận chuyển là TCP hay UDP cho chương trình ứng dụng của mình.

Bảng so sánh sự khác biện giữa hai chế độ giao tiếp có kết nối và không kết nối.

Chế độ có nối kết Chế độ không nối kết

- Tồn tại kênh giao tiếp ảo giữa hai bên giao tiếp. - Dữ liệu được gởi đi theo bảo đảm: có kiểm tra lỗi, truyền lại gói tin lỗi hay mất, đảm báo thứ tự của các gói tin. - Dữ liệu chính xác nhưng tốc độ truyền chậm.

- Không tồn tại kênh giao tiếp ảo giữa hai bên. - Dữ liệu được gởi đi không đảm bảo: Không kiểm tra lỗi, không phát hiện và truyền lại gói tin bị lỗi hay mất, không đảm bảo thứ tự đến của các gói tin. - Dữ liệu không chính xác, tốc độ truyền nhanh.

2.1.6. Xây dựng ứng dụng Client-Server với Socket:

Socket là phương tiện hiệu quả để xây dựng các ứng dụng theo kiến trúc Client-Server. Các ứng dụng trên Internet như Web, Mail, FTP.. . là các ví dụ điển hình.

Page | 18

Chúng ta sẽ tìm hiểu về các bước cơ bản trong việc xây dựng các ứng dụng Client-Server sử dụng Socket làm phương tiện giao tiếp theo chế độ hướng kết nối (được ứng dụng trong phần gởi file và gởi hình ảnh trong chương trình).

2.1.6.1. Mô hình Client-Server sử dụng Socket ở chế độ có kết nối (TCP)

Giai đoạn 1: Server tạo Socket, gán số hiệu cổng và lắng nghe các kết nối.

Hình 2. 4. Minh họa quá trình khởi tạo TCP Socket Server. Socket() : Server yêu cầu tạo ra một Socket để có thể sử dụng các dịch vụ

của tầng vận chuyển.

Bind() : Socket khi được tạo ra cần phải được gắn vào một port cục bộ.

Listen() : Server lắng nghe các yêu cầu kết nối từ Client trên cổng đã được gán.

Giai đọan 2: Client tạo Socket, yêu cầu thiết lập một nối kết với Server

Hình 2. 5. Mô tả quá trình khởi tạo TCP Socket Client kết nối tới Server. Socket() : Client yêu cầu tạo một Socket để có thể sử dụng dịch vụ của tầng

vận chuyển, thông thường hệ thống thường tự động gán một port còn dảnh cho Socket của Client. Nhưng ở đây ta sẽ tự động đưa vào port cho Socket của Client.

Connect() : Client gửi yêu cầu kết nối tới Server có địa chỉ ip và port xác định.

Page | 19

Accept() : Sau khi bên phía Client kết nối tới Server thì Server sẽ chấp nhận kết nối của Client, khi đó một kênh giao tiếp ảo được hình thành. Client và Server có thể trao đổi thông tin với nhau thông qua kênh giao tiếp ảo này.

Giai đoạn 3: Trao đổi thông tin giữa Client và Server

Hình 2. 6. Mô tả quá trình truyền nhận thông tin giữa Server và Client. Sau khi chấp nhận yêu cầu kết nối, Server đợi Client gửi yêu cầu đến. Ở đây

Client sẽ sử dụng hàm Send() gửi lần lượt các byte dữ liệu.

Server phân tích và thực thi yêu cầu. Kết quả và nó gửi lại dữ liệu cho Client bằng lệnh Send().

Trong giai đoạn này, việc trao đổi thông tin giữa Server và Client phải tuân thủ theo giao thức ứng dụng. Thông thường thì Client sẽ là bên gửi yêu cầu đến Server trước.

Giai đoạn 4: Kết thúc phiên làm việc.

Hình 2. 7. Mô tả kết thúc phiên làm việc giữa Client và Server. Việc trao đổi dữ liệu giữa Server và Client được thực hiện nhiều lần.

Kênh ảo sẽ bị xóa khi Server hoặc Client đóng Socket bằng lệnh Close().

2.1.6.2. Mô hình Client-Server sử dụng Socket ở chế độ không kết nối (UDP)

Page | 20

UDP là giao thức theo phương thức không liên kết được sử dụng thay thế cho TCP . Nó khác với TCP, không có chức năng thiết lập liên kết và kết thúc liên kết. Do vậy việc trao đổi thông tin dữ liệu là không đáng tin cậy.

Các giai đoạn thực hiện của Socket không hướng kết nối.

Giai đoạn 1: Server tạo ra Socket và gán số hiệu cổng.

Hình 2. 8. Mô tả quá trình khởi tạo UDP Socket Server. Socket(): Server yêu cầu tạo ra một Socket để sử dụng các dịch vụ của tầng

vận chuyển.

Bind(): Sau khi đã khởi tạo Socket thì cần phải gắn một port cục bộ cho nó.

Giai đoạn 2: Client tạo Socket.

Hình 2. 9. Mô tả quá trình khởi tạo UDP Socket Client. Bên phía Client sẽ yêu cầu tạo ra một Socket để sử dụng dịch vụ của tầng

vận chuyển.

Sau đó Client có thể Send dữ liệu tới một địa chỉ ip và port cục bộ của Server.

Giai đoạn 3: Trao đổi thông tin giữa Client và Server

Page | 21

Hình 2. 10. Mô tả quá trình truyền nhận dữ liệu bằng UDP. Client và Server có thể trao đổi thông tin với nhau nhiều lần qua hai hàm đó

là Sendto() và hàm Recvfrom().

Giữa Client và Server không hề có một kênh ảo nào vì vậy việc truyền nhận dữ liệu thường dễ bị mất mát.

2.1.7. Sử dụng C# Stream với TCP.

Điều khiển thông điệp dùng giao thức TCP thường gây ra khó khăn cho các lập trình viên, do vậy .Net Framwork cung cấp một số lớp đề giảm gánh nặng lập trình. Một trong những lớp đó là NetworkStream, và hai lớp dùng để gởi và nhận dữ liệu sử dụng hai lớp đó là StreamWriter và StreamReader.

2.1.7.1. Lớp NetworkStream.

Lớp này được nằm trong thư viện System.Net.Socket. Lớp NetworkStream có thể được tạo lập bằng nhiều phương thức khác nhau, nhưng một phương thức tạo lập mà ta hay sử dụng đó là gán vào Socket của Server và Client đã được tạo lập sẵn.

Socket newsock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

NetworkStream ns = new NetworkStream(newsock);

Một số phương thức của lớp NetworkStream.

Thuộc tính Mô tả

CanRead() true nếu NetworkStream hỗ trợ đọc

CanSeek() Luôn luôn false

CanWrite() true nếu NetworkStream hỗ trợ ghi

DataAvailable() true nếu có dữ liệu để đọc

Phương thức Mô tả

BeginRead() Bắt đầu đọc NetworkStream bất đồng bộ

BeingWrite() Bắt đầu ghi NetworkStream bất đồng bộ

EndRead() Kết thúc đọc NetworkStream bất đồng bộ

Page | 22

EndWrite() Kết ghi đọc NetworkStream bất đồng bộ

Flush() Đẩy toàn bộ dữ liệu đi

Read() Đọc dữ liệu từ NetworkStream

Write() Ghi dữ liệu từ NetworkStream

Equals() So sánh hai đối tượng NetworkStream

GetHashCode() Lấy hash code cho NetworkStream.

Close() Đóng đối tượng NetworkStream

Bảng 2. 1. Một số phương thức của lớp NetworkStream

Chú ý : Phương thức Flush() được dùng sau mỗi phương thức Write() để đảm bảo dữ liệu được đặt vào NetworkStream sẽ lập tức gửi đến hệ thống ở xa.

NetworkStream khi truyền dữ liệu cũng có gặp một số vấn đề về biên dữ liệu.

Vấn đề này đã được giải quyết với hai lớp StreamReader và lớp StreamWriter.

2.1.7.2. Lớp StreamReader và StreamWriter.

Hai lớp này nằm trong thư viện System.IO để điều khiển đọc và ghi các thông điệp text từ mạng. Cả hai lớp đều triển khai với đối tượng NetworkStream để xác định các hệ thống đánh dấu cho thông điệp TCP.

Các phương thức tạo lập lớp StreamRead và StreamWriter, trong đó một phương thức tạo lập mà ta hay được sử dụng nhất đó là gắn hai lớp trên vào lớp NetworkStream đã được tạo lập từ trước.

Socket newsock = new Socket(AddressFamily. InterNetwork, SocketType. Stream, ProtocolType. Tcp);

NetworkStream ns = new NetworkStream(newsock);

StreamReader nr = new StreamReader(ns);

StreamWriter nw = new StreamWriter(ns);

Một số phương thức của lớp StreamRead.


Read() Đọc một hoặc nhiều byte dữ liệu từ

StreamReader.

Peek() Trả về byte dữ liệu hợp lệ tiếp theo mà

Không gỡ bỏ nó khỏi Stream.

ReadLine() Đọc dữ liệu bắt đầu từ đối tượng

Page | 23

StreamRead trở lên cho tới khi bắt gặp ký tự xuống dòng đầu tiên.

ReadToEnd() Đọc dữ liệu cho đến hết Stream.

ToString() Tạo ra một chuỗi mô tả đối tượng Stream.

Equals() So sánh hai đối tượng StreamRead.

Close() Đóng đối tượng StreamRead

Bảng 2. 2. Một số phương thức lớp StreamRead

Một số phương thức của lớp StreamWriter.

Lớp StreamWriter cũng có nhiều phương thức kết hợp với nó, một số phương thức của lớp StreamRead cũng có trong đối tượng StreamWriter, ngoài ra nó còn có một số phương thức giêng dưới đây.


Flush() Gửi tất cả dữ liệu trong bộ đệm

StreamWriter ra Stream.

Writer() Gửi một hoặc nhiều byte ra Stream.

WriterLine() Gửi dữ liệu cùng với ký tự xuống dòng ra Stream

Bảng 2. 3. Một số phương thức lớp StreamWriter

2.1.8. Sử dụng các lớp Helper Socket.

Cũng nhằm giảm gánh nặng cho các lập trình viên .Net Framwork đã đưa ra lớp Helper để hỗ trợ cả lập trình hướng kết nối với Socket (TCP) và lập trình không hướng kết nối với Socket (UDP).

2.1.8.1.TCPClient.

TCPClient được thiết kế nhằm hỗ trợ cho việc viết các ứng dụng TCP Client được dễ dàng.

Bảng các thành viên của lớp TCPClient.

Phương thức khởi tạo Mô tả

TcpClient() Tạo một đối tượng TcpClient. Chưa đặt thông số gì.

TcpClient(IPEndPoint)

Tạo một TcpClient và gắn cho nó một EndPoint cục bộ. (Gán địa chỉ máy cục bộ và số hiệu cổng để sử dụng trao đổi thông tin về sau)

TcpClient(String,Int32 Tạo một đối tượng TcpClient và kết nối đến một máy có

Page | 24

) địa chỉ và số hiệu cổng được truyền vào. RemoteHost có thể là địa chỉ IP chuẩn hoặc tên máy.

Các thuộc tính Mô tả

Available Cho biết số byte đã nhận về từ mạng và có sẵn để đọc.

Client Trả về Socket ứng với TCPClient hiện hành.

Connected Trạng thái cho biết đã kết nối được đến Server hay chưa?

Các hàm thành phần Mô tả

Close() Giải phóng đối tượng TcpClient nhưng không đóng kết nối.

Connect(RemoteHost, RemotePort)

Kết nối đến một máy TCP khác có Tên và số hiệu cổng.

GetStream() Trả về NetworkStream để từ đó giúp ta gửi hay nhận dữ liệu. (Thường làm tham số khi tạo StreamReader và StreamWriter để gửi và nhận dữ liệu dưới dạng xâu ký tự) .

Khi đã gắn vào StreamReader và StreamWriter rồi thì ta có thể gửi và nhận dữ liệu thông qua các phương thức Readline, writeline tương ứng của các lớp này.

Bảng 2. 4. Các thành viên của lớp TCPClient.

Từ các thành viên của lớp TcpClient ở trên ta thấy rằng, việc kết nối và thực hiện gửi nhận rất đơn giản. Theo các trình tự sau:

Bước 1: Tạo một đối tượng TcpClient.

Bước 2: Kết nối đến máy chủ (Server) dùng phương thức Connect.

Bước 3: Tạo 2 đối tượng StreamReader (Receive)và StreamWriter (Send) và "nối" với GetStream của TCPClient.

Bước 4:

Dùng đối tượng StreamWriter.Writeline/Write vừa tạo ở trên để gửi dữ liệu đi.

Dùng đối tượng StreamReader.Readline/Read vừa tạo ở trên để đọc dữ liệu về.

Bước 5: Đóng kết nối.

Nếu muốn gửi/nhận dữ liệu ở mức byte (nhị phân) thì dùng NetworkStream. (truyền GetStream cho NetworkStream).

Page | 25

ms-help://MS.VSCC.v80/MS.MSDN.v80/MS.NETDEVFX.v20.en/cpref10/html/P_System_Net_Sockets_TcpClient_Connected.htm

ms-help://MS.VSCC.v80/MS.MSDN.v80/MS.NETDEVFX.v20.en/cpref10/html/P_System_Net_Sockets_TcpClient_Client.htm

ms-help://MS.VSCC.v80/MS.MSDN.v80/MS.NETDEVFX.v20.en/cpref10/html/P_System_Net_Sockets_TcpClient_Available.htm

2.1.8.2. TCPListener.

TCPListerner là một lớp cho phép người lập trình có thể xây dựng các ứng dụng Server (Ví dụ như SMTP Server, FTP Server, DNS Server, POP3 Server hay server tự định nghĩa ….). Ứng dụng server khác với ứng dụng Client ở chỗ nó luôn luôn thực hiện lắng nghe và chấp nhận các kết nối đến từ Client.

Bảng các thành viên của lớp TCPListener.


TcpListener ( Int32) Tạo một TcpListener và lắng nghe tại cổng chỉ định.

TcpListener (IPEndPoint) Tạo một TcpListener với giá trị Endpoint truyền vào.

TcpListener(IPAddress,Int32) Tạo một TcpListener và lắng nghe các kết nối đến tại địa chỉ IP và cổng chỉ định.


AcceptSocket( ) Chấp nhận một yêu cầu kết nối đang chờ.

AcceptTcpClient() Chấp nhận một yêu cầu kết nối đang chờ. (Ứng dụng sẽ dừng tại lệnh này cho đến khi nào có một kết nối đến – “Blocking”).

Pending() Cho biết liệu có kết nối nào đang chờ đợi không

Start() Bắt đầu lắng nghe các yêu cầu kết nối.

Stop() Dừng việc nghe.

Bảng 2. 5. Các phương thành viên của lớp TCPListener.

2.1.8.3. UDPClient.

Giao thức UDP (User Datagram Protocol hay User Define Protocol) là một giao thức phi kết nối (connectionless) có nghĩa là một bên có thể gửi dữ liệu cho bên kia mà không cần biết là bên đó đã sẵn sàng hay chưa? (Nói cách khác là không cần thiết lập kết nối giữa hai bên khi tiến hành trao đổi thông tin). Giao thức này không tin cậy bằng giao thức TCP nhưng tốc độ lại nhanh và dễ cài đặt. Ngoài ra, với giao thức UDP ta còn có thể gửi các gói tin quảng bá (Broadcast) cho đồng thời nhiều máy.

Trong .NET, lớp UDPClient (nằm trong namesapce System.Net.Sockets) đóng gói các chức năng của giao thức UDP.

Bảng các thành viên của lớp UDPClient


Page | 26

UdpClient () Tạo một đối tượng (thể hiện) mới của lớp UDPClient.

UdpClient (AddressFamily) Tạo một đối tượng (thể hiện) mới của lớp UDPClient. Thuộc một dòng địa chỉ

(AddressFamily) được chỉ định.

UdpClient (Int32) Tạo một UdpClient và gắn (bind) một cổng cho nó.

UdpClient (IPEndPoint) Tạo một UdpClient và gắn (bind) một IPEndpoint (gán địa chỉ IP và cổng) cho nó.

UdpClient(Int32, AddressFamily)

Tạo một UdpClient và gán số hiệu cổng, AddressFamily

UdpClient(String, Int32) Tạo một UdpClient và thiết lập với một trạm từ xa mặc định.


BeginReceive() Nhận dữ liệu Không đồng bộ từ máy ở xa.

BeginSend() Gửi không đồng bộ dữ liệu tới máy ở xa

Close() Đóng kết nối.

Connect() Thiết lập một Default remote host.

EndReceive() Kết thúc nhận dữ liệu không đồng bộ ở trên

EndSend() Kết thúc việc gửi dữ liệu không đồng bộ ở trên

Receive (ref IPEndPoint) Nhận dữ liệu (đồng bộ) do máy ở xa gửi. (Đồng bộ có nghĩa là các lệnh ngay sau lệnh Receive chỉ được thực thi nếu Receive đã nhận được dữ liệu về . Còn nếu nó chưa nhận được – dù chỉ một chút – thì nó vẫn cứ chờ (blocking))

Send() Gửi dữ liệu (đồng bộ) cho máy ở xa.

Bảng 2. 6. các thành viên của lớp UDPClient.

2.1.9. Lập trình Socket bất đồng bộ.

Ở phần đầu của báo cáo chúng ta đã lập trình Socket trong chế độ blocking. Socket blocking sẽ chờ mãi cho đến khi hoàn thành nhiệm vụ của nó. Trong khi nó bị blocking thì các chức năng khác của chương trình không thực hiện được.

Khi lập trình Windows thì lúc gọi một phương thức bị blocking thì toàn bộ chương trình sẽ đứng lại và không thể thực hiện các chức năng khác được. Do đó việc lập trình bất đồng bộ là cần thiết để cho chương trình khỏi bị treo.

Page | 27

Lớp AsyncCallback cung cấp các phương thức để bắt đầu một chức năng bất đồng bộ và cung cấp một phương thức delegate để gọi chức năng bất đồng bộ kết thúc.

Các phương thức bất đồng bộ trong Socket chia các chức năng mạng làm hai phần.

Một phương thức Begin bắt đầu các chức năng mạng và đăng ký phương thức AsyncCallback.

Một phương thức End hoàn thành chức năng mạng khi phương thức AsyncCallback được gọi.

Phương thức bắt đầu Mô tả Phương thức kết thúc

BeginAccept() Chấp nhận kết nối EndAccept()

BeginConnect() Kết nối đến thiết bị ở xa EndConnect()

BeginReceive() Nhận dữ liệu từ Socket EndReceive()

BeginReceiveFrom() Nhận dữ liệu từ thiết bị ở xa EndReceiveFrom()

BeginSend() Gửi dữ liệu từ Socket EndSend ()

BeginSendTo() Gửi dữ liệu đến thiết bị ở xa EndSendTo()

Bảng 2. 7. Các phương thức của lập trình Socket bất đồng bộ.

2.1.9.1. Thành lập kết nối.

Phương thức dùng để thành lập kết nối với thiết bị ở xa phụ thuộc vào chương trình đóng vai trò là Server hay Client. Nếu là Server thì phương thức BeginAccept() được dùng, còn bên Client thì phương thức BeginConnect() được sử dụng.

Phương thức BeginAccept() và EndAccept().

Server.BeginAccept(new AsyncCallback(CallAccept), Server);

Socket s = (Socket)ia.AsyncState;

Server = s.EndAccept(ia);

Sau khi phương thức BeginAccept() kết thúc, phương thức AsyncCallback định nghĩa sẽ được gọi khi kết nối xảy ra. Phương thức AsyncCallback phải bao gồm phương thức EndAccept() để kết thúc việc chấp nhận Socket. Sau đây là định dạng của phương thức EndAccept().

Phương thức Beginconnect() và EndConnect()

_clientsocket.BeginConnect(_ipep,

new AsyncCallback(CallPConnect), _clientsocket);

_clientsocket.EndConnect(ia);

2.1.9.2. Trao đổi dữ liệu.

Page | 28

Sau khi Server và Client đã thiết lập kết nối, ta có thể thực hiện việc trao đổi dữ liệu giữa Server và Client.

Phương thức BeginSend() và EndSend().

_ServerSocket.BeginSend(data, 0, data.Length, SocketFlags.None, new AsyncCallback(SendcmdMessage), _ServerSocket);

Socket s = (Socket) ia.AsyncState;

s.EndSend(ia);

Các phương thức khác thực hiện giống như phương thức BeginSend() và EndSend().

2.2. Lập trình .Net Remoting.

2.2.1. Các khái niệm.

.Net Remoting là cơ chế giao tiếp giữa các đối tượng (object) mà không cùng thuộc một Process. Giúp các lớp đối tượng thuộc các ứng dụng khác nhau có thể liên lạc được với nhau. Các đối tượng của các ứng dụng này có thể được thiết lập trên cùng một máy tính hay các máy tính khác nhau và được giao tiếp từ xa thông qua các giao thức kết nối như HTTP,TCP.

Microsft .Net Remoting được giới thiệu từ .Net Framework 1.1 cùng với Webservice. Cung cấp các kĩ thuật cho phép một đối tượng này truy xuất đến một đối tượng khác nằm ở các Application Domain khác nhau.

Hình 2. 11. Mô hình trao đổi thông tin của .Net Remoting.2.2.2. Remote Objects trong .NET Remoting.

Nếu như ở một chương trình đơn thì các đối tượng sẽ cùng thuộc trong ứng dụng đó, và chúng dễ dàng giao tiếp được với nhau; đây có thể được coi là Local Objects. Tuy nhiên nếu các đối tượng lại thuộc những ứng dụng khác nhau (các

Page | 29

Application domain khác nhau) thì cần có những Remote Object để giao tiếp với nhau. Remote Object có thể được dẫn xuất từ MarshalByRefObject hay sử dụng

[Serializable] tag hoặc bằng cách tạo các giao diện ISerializable.

Các loại Remote Object:

Trong .NET Remoting, có hai cơ chế để tạo instance của Remote Object rồi từ đó thực thi request. Đó là Singleton và Singlecall. Tùy vào mục đích sử dụng, nhu cầu của ứng dụng mà server có thể khai báo theo cơ chế

WellKnownObjectMode.SingleCall, hay WellKnownObjectMode.Singleton.

Single Call Object: Remote Object sẽ được sinh ra, thực thi request, trả lời cho client, sau đó Object này vẫn được lưu lại chứ không bị hủy đi. Đến khi nào process chạy chương trình Server kết thúc thì instance này mới bị trình hốt rác Garbage Collection hốt đi.

Singleton Object: Ngược lại với Single Call, khi khai báo Remote Object là Singleton thì Remote Object sẽ được khởi tạo và hủy đi đối với mỗi lần nhận request từ phía Client. Cơ chế này tương tự như mô hình .NET Webservice truyền thống.

Client-Activated Objects (CAO): Thuộc kiểu “Server-side object”, chúng chỉ được kích hoạt mỗi khi có request đến từ Client. Khi một Client gửi một request tới Server sử dụng toán tử “new”, một thông điệp sẽ được gửi tới Remote Application. Server sau đó sẽ tạo ra một Instance của lớp được yêu cầu, và trả về một ObjRef cho Client Application.

2.2.3.Domain.

Trong .NET, khi một ứng dụng được nạp vào trong bộ nhớ, một tiến trình được tạo ra, và trong quá trình này, một miền ứng dụng (Application Domain) cũng được tạo ra. Trên thực tế, ứng dụng này sẽ được nạp vào Application Domain. Mỗi ứng dụng có thuộc các Application Domain khác nhau, vì thế nếu chúng muốn giao tiếp được với nhau thì phải sử dụng Remoting chứ không thể giao tiếp trực tiếp với nhau được. Các Application Domain có thể cùng thuộc một process hoặc khác process.

2.2.4.Channel.

Trong kỹ thuật .Net Remoting thì Channel được hiểu như là một kênh để giao tiếp giữa Client và Server. Một Object từ Client sẽ thông qua Channel để giao tiếp với Object phía Server, Channel sẽ truyền tải những Message từ hai phía. Như giới thiệu phía trên thì có hai Channel chính là TcpChannel và HttpChannel tương ứng với các giao thức TCP và HTTP. Ngoài ra, TcpChannel và HttpChannel đều có khả năng Extend thành những Custom Channel.

Các nguyên tắc khi thiết lập một Channel.

Page | 30

Cần có ít nhất một Channel được đăng ký với .NET Remoting trước khi Remote Object được gọi. Và các Channels này cần đăng ký trước các Remote Object.

Channel được đăng ký trong mỗi Application Domain hoặc nhiều Application Domain thuộc một Process. Khi Process kết thúc thì các Channel này cũng tự động được hủy đi.

Không thể đăng ký các Channel khác nhau trên cùng một port thuộc cùng một máy tính mặc dù các Channel này có thể ở các Application Domai khác nhau. Khi thiết lập nhiều Channel trên cùng một máy tính thì chúng cần listen ở các port khác nhau.

Client liên lạc với Remote Object thông qua các kênh đã đăng ký bằng việc gọi các RegisterChannel trên lớp ChannelService.

2.2.5. Object Activation.

Server Actived Object chỉ được tạo ra ở lần đầu tiên Client thiết lập cuộc gọi tới các Remote Method. Hay nói cách khác, Khi một Client yêu cầu tạo ra các Remote Object thì chỉ các proxy cục bộ được tạo ra ở Client, còn Remote Object thực tế nằm trên Server. Các Remote Object này sẽ được khởi tạo ở lần đầu tiên Client thiếp lập cuộc gọi cho Server. Ví dụ tạo ra các Proxy như sau.

// Trên Server

RemotingConfiguration.RegisterWellKnownServiceType(

typeof (RemoteServerObject), "Test",

WellKnownObjectMode.SingleCall);

...

// Trên Client

IRemoteCom obj = (IRemoteCom)Activator.GetObject(typeof(IRemoteCom),

"tcp://localhost:1002/Test");

...

Như đã nói ở trên, chúng ta có hai cơ chế để tạo instance của Remote Object là Single Call và Singleton. Đoạn mã ví dụ của nó như sau.

RemotingConfiguration.RegisterWellKnownServiceType( typeof(RemoteServerObject),

"Test", WellKnownObjectMode.SingleCall);

...

RemotingConfiguration.RegisterWellKnownServiceType( typeof(RemoteServerObject),

"Test", WellKnownObjectMode.Singleton);

Page | 31

2.2.6. Client Activated Objects.

Đối tượng Client Activated Object được tạo ra mỗi trên Server ngay lập tức mỗi khi có request từ Client hoặc cũng có thể tạo ra bằng từ khóa new hoặc

Activator.CreateInstance(…).

// On the Server

RemotingConfiguration.ApplicationName = "TestCAO";

RemotingConfiguration.RegisterActivatedServiceType(typeof(RemoteObjectCAO));

...

// On the Client

RemotingConfiguration.RegisterActivatedClientType(typeof(RemoteObjectCAO), "tcp://localhost:1002/TestCAO");

obj = new RemoteObjectCAO();

...

Tùy thuộc vào hoàn cảnh và nhu cầu mà ta sử dụng loại khác nhau. Ví dụ:

Singleton object được dùng để tham chiếu đến những đối tượng cùng trên một server, và bất kỳ thay đổi của Client cũng sẽ “visible” (hiện hữu) với những Client khác. Ví dụ như trong hệ điều hành Windows, khi một chương trình thay thì các Client Program khác cũng biết được. Dữ liệu sẽ được lưu trên máy chủ và được truy cập bởi tất cả các Client.

Chúng ta sử dụng SingleCall khi muốn cung cấp một môi trường “stateless” (Kiểu giống của Web services truyền thống.

Chúng ta sử dụng Client Activation nếu đối đượng cần phải được duy trì trạng thái kết nối liên tục, trao đổi thông tin với các client khác.

2.2.7. Tạo một Remotable Object.

Một Remote Object là một đối tượng được kế thừa từ lớp MarshalByRefObject.

Trong C#, khi tạo một lớp thư viện mới. Ta Add thêm lớp có tên MarshalByRefObject như đã nói ở trên. Khai báo using System.Runtime.Remoting để có thể sử dụng được các TcpChannel hay HttpChannel.

Ví dụ.

MyRemotableObject.cs

namespace RemotableObjects

{

public class MyRemotableObject : MarshalByRefObject

{

public MyRemotableObject()

{

Page | 32

}

public void SetMessage(string message)

{

Cache.GetInstance().MessageString = message;

}

}

}

2.3. Lập trình sự kiện trong Windows.

Trong lập trình sự kiện của Windows, mỗi khi sự kiện sảy ra, một phương thức được gọi để thực thi dựa trên sự kiện đó như trong hình dưới đây.

Hình 2. 12. Lập trình sự kiện trong Windows.2.3.1. Sử dụng Event và Delegate.

Evetn là một thông điệp được gửi bởi một đối tượng mô tả một hoạt động mà nó diễn ra. Thông điệp này xác định hoạt động và truyền các dữ liệu cần thiết cho hoạt động. Event có thể mô tả hoạt động nào đó, chẳng hạn như hoạt động click một Button, hoạt động nhận và gửi dữ liệu trên Socket. Event sender không cần thiết phải biết đối tượng nào sẽ điều khiển thông điệp sự kiện mỗi khi nó được gửi thông qua hệ thống Windows. Nó để cho bộ phận sự kiện đăng ký với hệ thống Windows và thông báo kiểu sự kiện mà bộ phận nhận sự kiện muốn nhận như hình minh họa sau.

Page | 33

Hình 2. 13. Gửi và nhận sự kiện trong Windows.Bộ nhận sự kiện được xác định trong hệ thống Windows bởi một con trỏ lớp

được gọi là Delegate. Một Delegate là một lớp nó giữ tham chiếu đến một phương thức mà phương thức này điều khiển sự kiện được nhận. Khi hệ thống Windows nhận sự kiện, nó kiểm tra xem thử có Delegate nào đăng ký để xử lý nó không. Nếu có Delegate đăng ký để sử lý sự kiện, thông điệp sự kiện được truyền vào phương thức được định nghĩa bởi Delegate. Sau khi phương thức hoàn tất, hện thống Windows sẽ xử lý sự kiện tiếp theo xảy ra cho tới khi sự kiện kết thúc chương trình được phát ra.

2.4. Lập trình đa luồng.

2.4.1. Khái niệm đa luồng (Thread).

Một luồng (Thread) là một chuỗi liên tiếp những sự thực thi trong chương trình. Trong một chương trình C#, việc thực thi bắt đầu bằng phương thức main() và tiếp tục cho đến khi kết thúc hàm main(). Cấu trúc này rất hay cho những chương trình có một chuỗi xác định những nhiệm vụ liên tiếp. Nhưng thường thì một chương trình cần làm nhiều công việc hơn vào cùng một lúc. Ví dụ trong Internet Explorer khi ta đang tải một trang web thì ta nhấn nút back hay một link nào đó, để làm việc này Internet Explorer sẽ phải làm ít nhất là 3 việc:

Lấy dữ liệu được trả về từ Internet cùng với các tập tin đi kèm.

Thể hiện trang Web.

Xem người dùng có nhập để làm thứ gì khác không.

Để đơn giản vấn đề này ta giả sử Internet Explorer chỉ làm hai công việc:

Trình bày trang Web.

Xem người dùng có nhập gì không.

Để thực hành việc này ta sẽ viết một phương thức dùng để lấy và thể hiện trang Web. Giả sử rằng việc trình bày trang Web mất nhiều thời gian (do phải thi hành các đoạn javascript hay các hiệu ứng nào đó …). Vì vậy sau một khoảng thời gian ngắn

Page | 34

khoảng 1/12 giây, phương thức sẽ kiểm tra xem người dùng có nhập gì không. Nếu có thì nó sẽ đuơc xử lí, nếu không thì việc trình bày trang sẽ được tiếp tục. Và sau 1/12 giây việc kiểm tra sẽ được lặp lại. Tuy nhiên viết phương thức này thì rất phức tạp do đó ta sẽ dùng kiến trúc event trong Window nghĩa là khi việc nhập xảy ra hệ thống sẽ thông báo cho ứng dụng bằng cách đưa ra một event. Ta sẽ cập nhật phương thức để cho phép dùng các event:

Ta sẽ viết một bộ xử lí event để đáp ứng đối với việc nhập của người dùng.

Ta sẽ viết một phương thức để lấy và trình bày dữ liệu. Phương thức này được thực thi khi ta không làm bất cứ điều gì khác.

Ta hãy xem cách phương thức lấy và trình bày trang web làm việc: đầu tiên nó sẽ tự định thời gian. Trong khi nó đang chạy, máy tính không thể đáp ứng việc nhập của người dùng . Do đó nó phải chú ý đến việc định thời gian để gọi phương thức kiểm tra việc nhập của người dùng, nghĩa là phương thức vừa chạy vừa quan sát thời gian. Bên cạnh đó nó còn phải quan tâm đến việc lưu trữ trạng thái trước khi nó gọi phương thức khác để sau khi phương thức khác thực hiện xong nó sẽ trả về đúng chỗ nó đã dừng. Vào thời Window 3.1 đây thực sự là những gì phải làm để xử lí tình huống này. Tuy nhiên ở NT3.1 và sau đó là Windows 95 trở đi đã có việc xử lí đa luồng điều này làm việc giải quyết vấn đề tiện lợi hơn. Dưới đây chúng ta sẽ tìm hiểu một vài lớp cơ bản trong ngôn ngữ lập trình C# và vấn đề đồng bộ hóa (Synchronization) trong lập trình đa luồng.

2.4.2. Tham khảo thư viện System.Thread.

Namespace System.Threading cung cấp một số kiểu dữ liệu cho phép bạn thực hiện lập trình đa luồng. Ngoài việc cung cấp những kiểu dữ liệu tượng trưng cho một luồng cụ thể nào đó, namespace này còn định nghĩa những lớp có thể quản lý một collection các luồng (ThreadPool), một lớp Timer đơn giản (không dựa vào GUI) và các lớp cung cấp truy cập được đồng bộ vào dữ liệu được chia sẽ sử dụng.

Các lớp thành viên Mô tả

Interlocked Lớp này dùng cung cấp truy cập đồng bộ hóa vào dữ liệu được chia sẽ sử dụng (shared data).

Moniter Lớp này cung cấp việc đồng bộ hóa các đối tượng luồng sử dụng khóa chốt (lock) và tín hiệu chờ (wait signal).

Mutex Lớp này cung cấp việc đồng bộ hóa sơ đẳng có thể được dùng đối với inter process synchronization.

Thread Lớp này tượng trưng cho một luồng được thi hành trong lòng Common Language Runtime. Sử dụng lớp này bạn có khả năng bổ sung những luồng khác trong cùng AppDomain.

Page | 35

ThreadPool Lớp này quản lý những luồng có liên hệ với nhau trong cùng một Process nào đó.

Timer Cho biết một delegate có thể được triệu gọi vào một lúc được khai báo nào đó. Tác vụ wait được thi hành bởi luồng trong thread pool.

WaitHandle Lớp này tượng trưng cho tất cả các đối tượng đồng bộ hóa (cho phép multiple wait) vào lúc chạy.

ThreadStart Lớp này là một delegate chỉ về hàm hành sự nào đó phải được thi hành đầu tiên khi một luồng bắt đầu.

TimerCallBack Delegate đối với Timer.

WaitCallBack Lớp này là một delegate định nghĩa hàm hành sự kêu gọi lại (callback) đối với ThreadPool user work item.

Bảng 2. 8. Một số lớp thuộc tính của thư viện System.Thread.

2.4.2. Lớp Thread.

Lớp đơn giản nhất trong tất cả các lớp thuộc Namespace System.Threading là lớp Thread. Lớp này tượng trưng cho một vỏ bọc hướng đối tượng bao quanh một lộ trình thi hành trong lòng một AppDomain nào đó. Lớp này định nghĩa một số hàm thực thi (cả static lẫn shared) cho phép bạn tạo mới những luồng từ luồng hiện hành, cũng như cho Sleep, Stop hay Kill một luồng nào đó.

Các thành phần Static Mô tả

CurrentThread Thuộc tính read-only này trả về một quy chiếu về luồng hiện đang chạy.

GetData() Đi lấy vị trí từ slot được khai báo trên luồng hiện hành đối với domain hiện hành trong luồng.

SetData() Cho đặt để trị lên slot được khai báo trên luồng hiện hành đối với domain hiện hành trong luồng

GetDomain()

GetDomainID()

Đi lấy một qui chiếu về AppDomain hiện hành (hoặc mã nhận diện ID của domain này) mà luồng hiện đang chạy trên đó.

Sleep() Cho ngưng luồng hiện hành trong một thời gian nhất định được khai báo.

Bảng 2. 9. Các thành phần static của lớp Thread.

Ngoài ra lớp Thread cũng hỗ trợ các thành viên cung cấp đối tượng.

Các lớp thành viên Mô tả

IsAlive Thuộc tính này trả về một trị boolean cho biết liệu xem luồng đã khởi đông hay chưa.

Page | 36

IsBackground Đi lấy hoặc đặt để giá trị cho biết liệu xem luồng là một luồng nền hay không.

Name Thuộc tính này cho phép bạn thiết lập một tên văn bản mang tính thân thiện đối với luồng.

Priority Đi lấy hoặc đặt để ưu tiên của một luồng. Có thể được gán một trị lấy từ enumeration ThreadPriority (chẳng hạn Normal, Lowest, Highest, BelowNormal, AboveNormal).

ThreadState Đi lấy hoặc đặt để tình trạng của luồng. Có thế được gán từ enumeration ThreadState (chẳng hạn Unstarted, Running, WaitSleepJoin, Suspended, SuspendRequested, AbortRequested, Stopped).

Interrup() Cho ngưng chạy luồng hiện hành.

Join() Yêu cầu luồng chờ đối với luồng bị ngưng chạy.

Resume() Tiếp tục lại đối với một luồng bị ngưng chạy.

Start() Cho bắt đầu thi hành luồng được khai báo bởi delegate ThreadStart.

Suspend() Cho ngưng chạy một luồng. Nếu luồng đã bị ngưng rồi, một triệu gọi hàm Suspend() sẽ không có tác dụng.

Bảng 2. 10. Các thành viên cấp đối tượng của lớp Thread.

2.4.3. Thao tác với luồng.

Luồng được thao tác bằng cách dùng lớp Thread nằm trong thư viện System.Threading. Một thể hiện của luồng đại diện cho một luồng. Ta có thể tạo các luồng khác bằng cách khởi tạo một đối tượng Thread.

Giả sử rằng ta đang viết 1 trình biên tập hình ảnh đồ hoạ, và người dùng yêu cầu thay đổi độ sâu của màu trong ảnh. Ta bắt đầu khởi tạo một đối tượng luồng như sau:

// entryPoint được khai báo trước là 1 delegate kiểu ThreadStart

Thread depthChangeThread = new Thread(entryPoint);

Đoạn mã trên biểu diễn một hàm khởi tạo của Thread với một thông số chỉ định điểm nhập của một luồng. Đó là phương thức nơi luồng bắt đầu thi hành. Trong tình huống này ta dùng thông số là delegate, một delegate đã được định nghĩa trong System.Threading gọi là ThreadStart, chữ kí của nó như sau:

public delegate void ThreadStart();

Thông số ta truyền cho hàm dựng phải là 1 delegate kiểu này. Ta bắt đầu luồng bằng cách gọi phương thức Thread.Start(), giả sử rằng ta có phương thức ChanColor():

void ChanColor()

Page | 37

{

// xử lí để thay đổi màu

}

Sắp xếp lại ta có đoạn mã sau.

ThreadStart entryPoint = new ThreadStart(ChangeColorDepth);

Thread depthChangeThread = new Thread(entryPoint);

depthChangeThread.Name = “Depth Change Thread”;

depthChangeThread.Start();

Sau điểm này, cả hai luồng sẽ chạy đồng bộ với nhau.

Trong đoạn mã này ta đăng kí tên cho luồng bằng cách dùng thuộc tính Thread.Name. Không cần thiết làm điều này nhưng nó có thể hữu ích.

Lưu ý vì điểm đột nhập vào luồng (trong ví dụ này là ChanColor() ) không thể lấy bất kì thông số nào. Ta sẽ phải tìm một cách nào đó để truyền thông số cho phương thức nếu cần. Cách tốt nhất là dùng các trường thành viên của lớp mà phương thức này là thành viên. Cũng vậy phương thức không thể trả về bất cứ thứ gì .

Mỗi lần ta bắt đầu một luồng khác, ta cũng có thể đình chỉ, hồi phục hay bỏ qua nó. Đình chỉ nghĩa là cho luồng đó ngủ (sleep) - nghĩa là không chạy trong 1 khoảng thời gian. Sau đó nó thể đưọc phục hồi, nghĩa là trả nó về thời diểm mà nó bị định chỉ. Nếu luồng đưọc bỏ, nó dừng chạy. Window sẽ huỷ tất cả dữ liệu mà liên hệ đến luồng đó, để luồng không thể được bắt đầu lại. Tiếp tục ví dụ trên, ta giả sử vì lí do nào đó luồng giao diện người dùng trình bày một hộp thoại cho người dùng cơ hội để đình chỉ tạm thời sự đổi tiến trình. Ta sẽ soạn mã đáp ứng trong luồng main :

depthChangeThread.Suspend();

Và nếu người dùng được yêu cầu cho tiến trình được phục hồi:

depthChangeThread.Resume();

Cuối cùng nếu người dùng muốn huỷ luồng :

depthChangeThread.Abort();

Phương thức Suspend() có thể không làm cho luồng bị định chỉ tức thời mà có thể là sau một vài lệnh, điều này là để luồng được đình chỉ an toàn. Đối với phương thức Abort() nó làm việc bằng cách tung ra biệt lệ ThreadAbortException.

ThreadAbortException là một lớp biệt lệ đặc biệt mà không bao giờ được xử lí. Nếu luồng đó thực thi mã bên trong khối try, bất kì khối finally sẽ được thực thi trước khi luồng bị huỷ. Sau khi huỷ luồng ta có thể muốn đợi cho đến khi luồng thực sự bị huỷ trước khi tiếp tục luồng khác ta có thể đợi bằng cách dùng phương thức join():

depthChangeThread.Abort();

depthChangeThread.Join();

Page | 38

Join() cũng có một số overload khác chỉ định thời gian đợi. Nếu hết thời gian này việc thi hành sẽ được tiếp tục. Nếu một luồng chính muốn thi hành một vài hành động trên nó, nó cần một tham chiếu đến đối tượng luồng mà đại diện cho luồng riêng. Nó có thể lấy một tham chiếu sử dụng thuộc tính static -CurrentThread- của lớp Thread:

Thread myOwnThread = Thread.CurrentThread;

Có hai cách khác nhau mà ta có thể thao tác lớp Thread:

Ta có thể khởi tạo một đối tượng luồng, mà sẽ đại diện cho luồng đang chạy và các thành viên thể hiện của nó áp dụng đến luồng đang chạy.

Ta có thể gọi một số phương thức static, những phương thức này sẽ áp dụng đến luồng mà ta thực sự đang gọi phương thức từ nó. Một phương thức static mà ta muốn Sleep(), đơn giản đặt luồng đang chạy ngủ một khoảng thời gian, sau đó tiếp tục.

2.4.4. Đồng bộ hóa (Synchronization) trong lập trình đa luồng .

2.4.4.1. Đồng bộ hóa.

Đôi khi có thể bạn muốn điều khiển việc truy cập vào một nguồn lực, chẳng hạn các thuộc tính hoặc các hàm của một đối tượng, làm thế nào chỉ một mạch trình được phép thay đổi hoặc sử dụng nguồn lực đó mà thôi. Việc đồng bộ hóa được thể hiện thông qua một cái khóa được thiết lập trên đối tượng, ngăn không cho luồng nào đó truy cập khi mạch trình đi trước chưa xong công việc.

Trong phần này, ta sẽ là quen với cơ chế đồng bộ hóa mà Common Language Runtime cung cấp: lệnh lock. Nhưng trước tiên, ta cần mô phỏng một nguồn lực được chia sẽ sử dụng bằng cách sử dụng một biến số nguyên đơn giản: counter.

Để bắt đầu, ta khai báo biến thành viên và khởi gán về zero:

int counter = 0;

Bài toán được đặt ra ở đây như sau: luồng thứ nhất sẽ đọc trị counter (0) rồi gán giá trị này cho biến trung gian (temp). Tiếp đó tăng trị của temp rồi Sleep một khoảng thời gian. Luồng thứ nhất xong việc thì gán trị của temp trả về cho counter và cho hiển thị trị này. Trong khi nó làm công việc, thì luồng thứ hai cũng thực hiện một công việc giống như vậy. Ta cho việc này lập này khoảng 1000 lần. Kết quả mà ta chờ đợi là hai luồng trên đếm lần lượt tăng biến counter lên 1 và in ra kết quả 1, 2, 3, 4 … tuy nhiên ta sẽ xét đoạn chương trình dưới đây và thấy rằng kết quả hoàn toàn khác với những gì mà chúng ta mong đợi.

Đoạn mã của chương trình sau

using System;

using System.Threading;

namespace TestThread

Page | 39

{

public class Tester

{

private int counter = 0;

static void Main(string[] args)

{

Tester t = new Tester();

t.DoTest();

Console.ReadLine();

}

public void DoTest()

{

Thread t1 = new Thread(new ThreadStart(Incrementer));

t1.IsBackground = true;

t1.Name = "Thread One";

t1.Start();

Console.WriteLine("Start thread {0}", t1.Name);

Thread t2 = new Thread(new ThreadStart(Incrementer));

t2.IsBackground = true;

t2.Name = "Thread Two";

t2.Start();

Console.WriteLine("Start thread {0}", t2.Name);

t1.Join();

t2.Join();

Console.WriteLine("All my threads are done.");

}

public void Incrementer()

{

try

{

while (counter < 1000)

{

int temp = counter;

temp++;

Thread.Sleep(1);

counter = temp;

Page | 40

Console.WriteLine("Thread {0}. Incrementer: {1}",

Thread.CurrentThread.Name, counter);

}

}

catch (ThreadInterruptedException)

{

Console.WriteLine("Thread {0} interrupted! Cleaning up...", Thread.CurrentThread.Name);

}

finally

{

Console.WriteLine("Thread {0} Existing.",

Thread.CurrentThread.Name);

}

}

}

}

Kết quả đạt được là:

Hình 2. 14. Kết quả chương trình không sử dụng đồng bộ hóa.Do đó ta cần phải đồng bộ hóa việc truy cập đối tượng counter.

C# cung cấp đối tượng Lock để thưc hiện công việc đồng bộ hóa này. Một lock sẽ đánh dấu một critical section trên đoạn mã đồng thời cung cấp việc đồng bộ hóa đối với đối tượng được chỉ định khi lock có hiệu lực. Cú pháp sử dụng một Lock yêu cầu khóa chặt một đối tượng rồi thi hành một câu lệnh hoặc một khối lệnh rồi sẽ mở khóa ở cuối câu hoặc khối lệnh đó. C# cung cấp hổ trợ trực tiếp khóa chặt thông qua từ chốt lock. Ta sẽ tra qua theo một đối tượng qui chiếu và theo sau từ chốt là một khối lệnh.

lock(expression) statement-block

Page | 41

Trong ví dụ trên, để có được kết quả như mong muốn, ta sẽ sửa hàm Incrementer lại như sau:

try

{

lock (this)

{

while (counter < 1000)

{

int temp = counter;

temp++;

Thread.Sleep(1);

counter = temp;

Console.WriteLine("Thread {0}. Incrementer: {1}",

Thread.CurrentThread.Name, counter);

}

}

}// Các khối catch và finally không thay đổi

Kết quả đạt được là:

Hình 2. 15. Kết quả chương trình sử dụng đồng bộ hóa.Việc đồng bộ các luồng là quan trọng trong các ứng dụng đa luồng. Tuy nhiên

có một số lỗi tinh vi và khó kiểm soát có thể xuất hiện cụ thể là deadlock và race condition.

2.4.4.2. Deadlock.

Deadlock là một lỗi mà có thể xuất hiện khi hai luồng cần truy nhập vào các tài nguyên bị khoá lẫn nhau. Giả sử một luồng đang chạy theo đoạn mã sau, trong đó A, B là hai đối tượng tham chiếu mà cả hai luồng cần truy nhập:

lock (A)

{

Page | 42

// do something

lock (B)

{

// do something

}

}

Vào cùng lúc đó 1 luồng khác đang chạy :

lock (B)

{

// do something

lock (A)

{

// do something

}

}

Có thể xảy ra biến cố sau: luồng đầu tiên yêu cầu một lock trên A, trong khi vào cùng thời điểm đó luồng thứ hai yêu cầu lock trên B. Một khoảng thời gian ngắn sau, luồng A gặp câu lệnh lock(B), và ngay lập tức bước vào trạng thái ngủ, đợi cho lock trên B được giải phóng. Và tương tự sau đó, luồng thứ hai gặp câu lệnh lock(A) và cũng rơi vào trạng thái ngủ chờ cho đến khi lock trên A được giải phóng . Không may, lock trên A sẽ không bao giờ được giải phóng bởi vì luồng đầu tiên mà đã lock trên A đang ngủ và không thức dậy cho đến khi lock trên B được giải phóng điều này cũng không thể xảy ra cho đến khi nào luồng thứ hai thức dậy. Kết quả là deadlock. Cả hai luồng đều không làm gì cả, đợi lẫn nhau để giải phóng lock. Loại lỗi này làm toàn ứng dụng bị treo, ta phải dùng Task Manager để hủy nó.

Deadlock có thể được tránh nếu cả hai luồng yêu cầu lock trên đối tượng theo cùng thứ tự . Trong ví dụ trên nếu luồng thứ hai yêu cầu lock cùng thứ tự với luồng đầu, A đầu tiên rồi tới b thì những luồng mà lock trên a đầu sẽ hoàn thành nhiệm vụ của nó sau đó các luồng khác sẽ bắt đầu.

2.4.4.3. Race condition.

Race condition là cái cái gì đó tinh vi hơn deadlock. Nó hiếm khi nào dừng việc thực thi của tiến trình , nhưng nó có thể dẫn đến việc dữ liệu bị lỗi. Nói chung nó xuất hiện khi vài luồng cố gắng truy nhập vào cùng một dữ liệu và không quan tâm đến các luồng khác làm gì để hiểu ta xem ví dụ sau :

Giả sử ta có một mảng các đối tượng, mỗi phần tử cần được xử lí bằng một cách nào đó, và ta có một số luồng giữa chúng làm tiến trình này. Ta có thể có một đối

Page | 43

tuợng gọi là ArrayController chứa mảng đối tượng và một số int chỉ định số phẩn tử được xử lí .tacó phương thức:

int GetObject(int index)

{

// trả về đối tượng với chỉ mục được cho

}

Và thuộc tính read/write.

int ObjectsProcessed

{

// chỉ định bao nhiêu đối tượng được xử lí

}

Bây giờ mỗi luồng mà dùng để xử lí các đối tượng có thể thi hành đoạn mã sau:

lock(ArrayController)

{

int nextIndex = ArrayController.ObjectsProcessed;

Console.WriteLine(”Object to be processed next is ” + NextIndex);

++ArrayController.ObjectsProcessed;

object next = ArrayController.GetObject();

}

ProcessObject(next);

Nếu ta muốn tài nguyên không bị giữ quá lâu , ta có thể không giữ lock trên ArrayController trong khi ta đang trình bày thông điệp người dùng . Do đó ta viết lại đoạn mã trên:


{

int nextIndex = ArrayController.ObjectsProcessed;

}

Console.WriteLine(”Object to be processed next is ” + NextIndex);


{

++ArrayController.ObjectsProcessed;

object next = ArrayController.GetObject();

}

ProcessObject(next);

Ta có thể gặp một vấn đề. Nếu một luồng lấy lấy đối tưọng (đối tượng thứ 11 trong mảng) và đi tới trình bày thông điệp nói về việc xử lí đối tượng này. Trong khi đó luồng thứ hai cũng bắt đầu thi hành cũng đoạn mã gọi ObjectProcessed, và quyết

Page | 44

định đối tượng xử lí kế tiếp là đối tượng thứ 11, bởi vì luồng đầu tiên vẫn chưa được cập nhật.

ArrayController.ObjectsProcessed trong khi luồng thứ hai đang viết đến màn hình rằng bây giờ nó sẽ xử lí đối tượng thứ 11, luồng đầu tiên yêu cầu một lock khác trên ArrayController và bên trong lock này tăng ObjectsProcessed. Không may, nó quá trễ. Cả hai luồng đều đang xử lí cùng một đối tượng và loại tình huống này ta gọi là Race Condition.

2.5. Lập trình xử lý ảnh trong C#

2.5.1. Một số khái niệm xử lý ảnh.

2.5.1.1. Khái niệm ảnh.

Thông tin về vật thể hay quang cảnh được chiếu sáng mà con người quan sát và cảm nhận được bằng mắt và hệ thống thần kinh thị giác.

Biểu diễn ảnh về mặt toán học.

F(x,y) : trong đó x, y là tọa độ không gian hai chiều và f là tọa độ của độ chói (ảnh đơn sắc), màu (đối với ảnh màu).

Chú ý : x,y biến thiên liên tục và f cũng liên tục.

Một số ảnh thường được biểu diễn như một ma trận các điểm ảnh. Trong đó mỗi điểm ảnh có thể được biểu diễn bằng.

Ảnh nhị phân (1 bit).

Ảnh đa mức xám (8 bit).

Ảnh màu (16, 24 bit).

Ảnh được biểu diễn dưới dạng ma trận các điểm ảnh được gọi là ảnh bitmap.

Ảnh được chụp màn hình thường thu lại nằm trong hệ màu RGB, được đặc trưng bởi ba màu : màu đỏ ( Red - R ),màu xanh lá cây (Green - G ), màu xanh nước biển (Blue - B) tạo lên không gian màu đặc trưng cho điểm ảnh và tạo lên màu sắc tại điểm ảnh đó.

Page | 45

Hình 2. 16. Biểu diễn ảnh trong hệ màu RGB.2.5.2. Kỹ thuật xử lý ảnh cơ bản.

2.5.2.1. Thuật toán cắt ảnh.

Hình 2. 17. Mô tả thuật toán cắt ảnh.Với mỗi đầu vào, ảnh luôn được thu thập dưới dạng ma trận điểm ảnh (và mỗi

điểm ảnh đặc trưng bởi các thông tin riêng). Ví dụ ta thu được ma trận điểm ảnh như sau :

Page | 46

Hình 2. 18. Mô tả ma trận điểm ảnh.Đầu vào : Ảnh ban đầu, vùng để cắt lấy thông tin (x , y , w , h).

Đầu ra : Vùng ảnh mong muốn.

Tư tưởng thuật toán :

Khởi tạo một ảnh có kích thước bằng với kích thước vùng ảnh cần cắt.

Nhảy con trỏ chuột đến dòng thứ y.

Duyệt ảnh theo từng dòng cho đến hết w dòng, duyệt đến tọa độ x, và gán w giá trị điểm ảnh vào đích.

2.5.2.2. Thuật toán so sánh hai ảnh bitmap.

Hình 2. 19. Minh họa thuật toán so sánh ảnh.Chúng ta sẽ thực hiện việc chụp màn hình desktop liên tục, và tiến hành so sánh

giữa hai ảnh với nhau, nếu có sự khác biệt giữa hai ảnh thì tiến hành khoanh vùng khác biệt và cắt những điểm khác biệt đó (sử dụng thuật toán cắt ảnh).

Đầu vào : Ta sẽ đưa vào 2 ảnh chụp màn hình để so sánh.

Page | 47

Đầu ra : Vùng ảnh thay đổi.

Tư tưởng thuật toán.

Chia mỗi ảnh thành ma trận 10x10 với Rectangle.

Sau đó cắt từng Rectangle ở hai ảnh ra đem so sánh với nhau.

Thực hiện việc so sánh từng pixel của hai Rectangle với nhau nếu một trong các pixel đó thay đổi thì Rectangle đó bị thay đổi.

Ta sẽ lấy ra Rectangle bị thay đổi đó.

2.6. Một số kỹ thuật khác.

2.5.1. Các hàm API.

2.5.1.1. Khái niệm API.

API là viết tắt của Application Programming Interface (Giao diện lập trình ứng dụng). API cung cấp hầu hết các tính năng thông dụng cho tất cả các chương trình chạy trên nền Window. Hầu hết các hàm API thường được chứa trong file DLL trong thư mục của hệ thông Window (thường là C:\Windows\System).

2.5.1.2. Các thành phần của Windows API.

Có 4 thành phần tạo lên Windows API.

Các hàm (Function) là thành phần chính của Windows API, chúng được chứa trong các file DLL và có thể được truy xuất một cách dễ dàng bởi các chương trình trên nền Windows.

Các cấu trúc (Structure) nhiều hàm API đòi hỏi một cấu trúc phải được truyền cho chúng để có thể vận chuyển một lượng lớn thông tin mà mà không cần phải dùng quá nhiều đối số. Các cấu trúc này được dùng trong hàm API nhưng chúng ta phải tự định nghĩa.

Các hằng được đặt tên (name constant) cũng như cấu trúc, các hằng phải được định nghĩa rõ ràng trong chương trình.

Các hàm Callback (Callback Function) về mặt khái niệm, các hàm Callback ngược với các hàm API. Một hàm Callback được định nghĩa hoàn toàn trong chương trình của bạn. Sau đó hàm này sẽ được một hàm API khác gọi nó khi thực hiện một tác vụ nào đó. Các hàm Callback cung cấp một cách thức để chương trình của bạn có thể can thiệp trực tiếp vào một tác vụ nào đó.

2.5.1.3. Cách dùng các hàm API.

2.5.1.3.1. Cách khai báo.

[DllImport(“Tên thư viện dll”)]

Public static extern <kiểu> <Tên hàm> (<Các tham số truyền vào >);

Page | 48

Trong đó

<Tên hàm > là các hàm trong thư viện DLL.

<Tên thư viện DLL> trước tiên cần phải import vào một thư viện DLL cụ thể.

<kiểu> truyền vào một kiểu dữ liệu nào đó cho các hàm trong thư viện API.

Để sử dụng được các hàm API thì chúng ta cần phải khai báo thư viện sau đây System.Runtime. InteropServices.

Khai báo các hằng API hỗ trợ.

<Mức độ tham chiếu> const <kiểu> <Tên hằng> = <giá trị cụ thể>;

Trong đó

<Mức độ tham chiếu> là mức độ truy xuất khác nhau public, private ..

<kiểu> truyền vào một kiểu dữ liệu nào đó cho các hằng API.

<Tên hằng> Khai báo một tên thằng trong thư viện API.

<Giá trị cụ thể> Mỗi một hằng API đều có một giá trị cụ thể truyền vào.

2.5.1.3.2. Các file thư viện phổ biến.

Advapi32.dll : Thư viện API nâng cao bao gồm bảo mật và registry.

Comdlg32.dll : Thư viện API dùng cho các hộp thoại (Common dialog API library).

Gdi32.dll : Thư viện API dùng cho giao diện ứng dụng đồ hoạ.

Kernel32.dll : Gồm các hàm đặc trưng cho hệ điều hành.

Netapi32.dll : Thư viện Network API.

User32.dll : Thư viện tạo cho giao diện người dùng.

Version.dll : Thư viện các phiên bản (Version library)

Winmm.dll : Thư viện Windows đa phương tiện.

2.5.1.4. Sử dụng các hàm API.

// Tìm kiếm cửa số chương trình trong windows

[DllImport("user32.dll")]

public static extern IntPtr FindWindow(string lpClassName, string lpWindowName);

//Tìm kiếm cửa số con khi đã biết được Handle của cửa số cha.


public static extern IntPtr FindWindowEx(IntPtr hWnd1, IntPtr hWnd2, string lpsz1, string lpsz2);

Page | 49

//Active một cửa sổ chương trình.


public static extern bool SetForegroundWindow(IntPtr hWnd);

//SendMessageW: gửi thông điệp đến cửa số ứng dụng (thông điệp unicode)


public static extern IntPtr SendMessageW(IntPtr hWnd, uint Msg, IntPtr wParam, IntPtr lParam);

//lấy caption của cửa số ứng dụng


public static extern int GetWindowText(IntPtr hWnd, StringBuilder lpString, int nMaxCount);

////Các hàm về menu

////GetMenu: lấy menu của cửa sổ ứng dụng.


public static extern IntPtr GetMenu(IntPtr hwnd);

//GetSubMenu: lấy submenu khi có giá trị của Menu


public static extern IntPtr GetSubMenu(IntPtr hMenu, int nPos);

//GetMenuItemID: lấy Id của menu trong Submenu


public static extern IntPtr GetMenuItemID(IntPtr hMenu, int nPos);

//EnableMenuItem: set Enable của menu(tham số wEnable có giá trị: 1 hoặc 0)


public static extern IntPtr EnableMenuItem(IntPtr hMenu, IntPtr wIDEnableItem, int wEnable);

Trên đây chỉ là một số hàm cơ bản được áp dụng vào bài toán. Ngoài ra còn rất nhiều các hàm khác được sử dụng.

2.5.2. XML.

2.5.2.1. Khái niệm về XML.

XML là ngôn ngữ xây dựng cấu trúc tài liệu văn bản, dựa theo chuẩ n SGML (Standard Generalized Markup Language: siêu ngôn ngữ có khả năng sinh ngôn ngữ khác).

XML cũng giống như HTML đều là ngôn ngữ đánh dấu, nhưng điều cần nói ở đây là sự ra đời của XML để khắc phục cho một số yếu kém của HTML. HTML và XML đều sử dụng các tag nhưng các tag của HTML là một bộ dữ liệu tag đượ c xây

Page | 50

dựng và định nghĩa trước, tức là người lập trình phải tuân thủ theo các thẻ đã định nghĩa của HTML, hiện HTML có khoảng hơn 400 tag, để nhớ hết 400 tag này cũng không có gì khó khăn đối với người lập trình web chuyên nghiệp nhưng thật khó đối với những người không chuyên. Hơn nữa các tag của HTML không nói lên được mô tả dữ liệu trong đó. Nhưng đối với XML thì hoàn toàn khác bởi vì tag trong XML là do người lập trình định nghĩa và mỗi tag là một mô tả dữ liệu mà người lập trình muốn truyền đạt.

2.5.2.2. Các quy tắc viết thẻ XML.

Phải có một phần tử gốc duy nhất nó chứa tất cả các phần tử trong tài liệu.

Mỗi tag mở phải có một tag đóng (Giống như trong HTML).

Tên thẻ XML phân biệt giữa chữ hoa và chữ thường (khác biệt so với thể HTML không phân biệt hoa thường).

Mỗi phần tử con phải nằm trọn bên trong phần tử cha của nó (các phần tử lồng nhau phải đúng cấp).

Giá trị thuộc tính phải được đặt trong dấu nháy kép hoặc nháy đơn.

Ví dụ .

<Order>

<OrderDate>2002-6-14</OrderDate>

<Customer>Helen Mooney</Customer>

<Item>

<ProductID>1</ProductID>

<Quantity>2</Quantity>

</Item>

<Item>

<ProductID>4</ProductID>

<Quantity>1</Quantity>

</Item>

</Order>

2.5.3. Registry trong C#.

2.5.3.1. Khái niệm Registry.

Registry là một cơ sở dữ liệu dùng để lưu trữ thông tin về những sự thay đổi, những lựa chọn, những cấu hình từ người sử dụng Windows. Registry bao gồm tất cả các thông tin về phần cứng, phần mềm, người sử dụng. Registry luôn được cập nhật khi người sử dụng tiến hành sự thay đổi Control Panel, File Associations, và một số thay đổi trong Menu Options của một số ứng dụng, ...

2.5.3.2. Các lớp .Net Registry.

Page | 51

Để lập trình Registry trong C# ta cần sử dụng lớp Microsoft.Win32 cho phép thực hiện đọc, viết với Registry một cách dễ dàng. Sau đây là các namespace này.

Registry : Một trừu tượng hóa cao cấp về bản thân Registry, với tất cả các lớp được gắn liền.

RegistryKey : Đây là lớp cốt lõi cho phép bạn gõ thêm vào, xóa bỏ thông tin, sửa thông tin được lưu trữ trong Registry.

RegistryHive: Đây chỉ là mỗi khuôn tổ ong (hive) trên Registry.

Registry có cấu trúc hình cây, tương tự như cấu trúc cây thư mục với rất nhiều nhánh tỏa ra tùy theo cấu trúc ứng dụng. Thông thường thì Registry của Windows có 5 nhánh chính như sau.

HKEY_CLASSIES_ROOT (HKCR): chứa những chi tiết về các loại tập tin (.txt,.doc,…) và những ứng dụng nào đó có khả năng mở các tập tin loại nào. Ngoài ra, nó còn chứa những thông tin đăng ký đối với tất cả các cấu kiện Com.

HKEY_CURRENT_USER (HKCU): chứa những chi tiết liên quan đến những sở thích của người sử dụng hiện được đăng nhập trên máy tính.

HKEY_LOCAL_MACHINE (HKLM): là một hive đồ sộ chứa những chi tiết của tất cả các phần mềm và phần cứng được cài đặt trên máy. Nó cũng bao gồm HKCR hive: HKCR hiện thật sự không phải là 1 hive độc lập tự thân, nhưng đơn giản là một ánh xạ tiện lợi trên Registry key.

HKEY_USERS (HKUSR): chứa những chi tiết liên quan đến sở thích của tất cả các người sử dụng. Như bạn có thể chờ đợi, nó cũng chứa hive HKCU, đơn giản là 1 ánh xạ lên 1 trong những key trên HKEY_USERS

HKEY_CURRENT_CONFIG: chứa những chi tiết liên quan đến phần cứng trên máy tính.

Tên thuộc tính Mô tả

Name Tên của key (Read - Only).

SubKeyCount() Số lượng sub key.

ValueCount() Các giá trị trên key.

Tên phương thức Mô tả

Close() Đóng lại key.

CreateSubKey() Tạo một SubKey mới.

DeleteSubKey() Xóa bỏ một key được chỉ định.

DeleteSubKeyTree() Gỡ bỏ một cách đệ quy một SubKey.

GetValue() Hàm tìm lại giá trị được khai báo.

Page | 52

GetValueName() Hàm này cho tìm lại 1 bản dãy chuỗi chữ chứa tất cả các tên trị (value name).

OpenSubKey() Hàm trả về một giá trị SubKey.

SetValue() Hàm để đặt một giá trị được chỉ định không phân biệt hoa thường.

Ví dụ ghi key để phần mềm khởi động cùng hệ thống sử dụng Registry.

RegistryKey rkApp = Registry.CurrentUser.OpenSubKey("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run", true);

if (rkApp != null)

rkApp.SetValue(Application.ProductName, Application.ExecutablePath.ToString());

Bảng 2. 11. Các thành phần chính của Registry.

2.7. Kết luận chương.

Trong chương này chúng em đưa ra những kiến thức cơ bản cần thiết trong lập trình mạng với C# nói riêng và các ngôn ngữ khác nói chung. Và một số các kỹ thuật như lập trình xử lý ảnh, lập trình đa nhiệm, lập trình nâng cao với Windows. Và một số các kỹ thuật truyền tải thông tin trong mạng Lan nói riêng và mạng Internet nói chung. Qua chương này chúng ta có thể hiểu được những kiến thức quan trọng và cần thiết để xây dựng lên phần mềm “Lớp học ảo trong mạng Lan”.

Page | 53

CHƯƠNG 3. ỨNG DỤNG PHẦN MỀM QUẢN LÝ LỚP HỌC ẢO

3.1. Phân tích thiết kế hệ thống.

3.1.1.Khảo sát hiện trạng và lập dự án.

3.1.1.1. Khảo sát hệ thống hiện tại.

Với sự phát triển không ngừng nghỉ của khoa học vào đời sống xã hội. Việc sử dụng các công nghệ thông tin vào trong các trường Đại Học, Cao Đẳng và các trung tâm đã không còn là xa lạ với chúng ta. Việc ứng dụng công nghệ mạng Lan vào trong giảng dạy ngày càng phổ biến và có nhiều phát triển vượt bận. Tuy vậy nhưng việc quả lý các phòng học trong mạng Lan vẫn còn rất nhiều vấn đề bất cập cần được giải quyết.

Tốn kém trong khâu đầu tư máy chiếu, bảng viết các.

Việc sử dụng bảng viết, bụi phấn có thể gây ảnh hưởng tới sức khỏe của giảng viên.

Khó khăn trong việc chia sẻ tài liệu học tập cho các học viên.

Không có nhiều sự tương tác giữa giảng viên và học sinh.

Học sinh gặp khó khăn trong việc học, và thực hành ở nhà.

Do vậy nhóm chúng em đề xuất xây dựng “phần mềm lớp học ảo trong mạng Lan” nhằm giải quyết phần nào các vấn đề trên và góp phần đưa các ứng dụng công nghệ thôn tin vào trong thực tế.

3.1.1.2. Đề xuất ý tưởng xây dựng hệ thống mới.

Do việc giảng dạy còn nhiều bất cập đã được nêu ở trên. Nhóm chúng em đã đưa ra các đề xuất và ý tưởng để giải quyết từng vấn đề ở trên.

Việc sử dụng công nghệ chia sẻ màn hình sẽ tiết kiệm được hệ thống bảng, máy chiếu và còn tránh được bụi phấn làm ảnh hưởng tới sức khỏe giảng viên.

Với phần mềm này việc chia sẻ tài liệu của giảng viên cho học sinh giờ đây đã trở lên rất dễ dàng và thuận tiện và giúp ích rất nhiều cho việc học tập tại nhà của các học viên.

Giáo viên có thể giải đáp thắc mắc của học sinh mà không tốn nhiều thời gian, và bằng công nghệ điều khiển từ xa. Đây thực sự là một công nghệ tuyệt vời bởi nó còn cho phép giảng viên có thể theo dõi các hoạt động của học viên một cách dễ dàng.

Việc sử dụng phần mềm cũng tránh được các gian lận trong quá trình học tập, bằng công nghệ khóa USB.

3.1.1.3. Mô tả hoạt động của hệ thống.

Page | 54

Hệ thống sẽ lưu trữ thông tin về các máy trong mạng Lan gồm tên máy, địa chỉ Ip của các máy trong phòng học, trạng thái hiện tại của các máy.

a. Giai đoạn bắt đầu buổi học.

Giảng viên sử dụng phần mềm từ bên phía Server để tổ chức lớp học và cho phép máy các học viên (máy Client) đăng nhập vào.

Sau khi học viên đăng nhập vào hệ thống thì Server sẽ tiến hành lưu lại các thông tin của máy học viên đó giúp ta dễ dàng trong việc quản lý.

b. Các hoạt động trong buổi học.

Giảng viên bắt đầu bài giảng bằng tính năng chia sẻ màn hình. Màn hình của máy giảng viên sẽ xuất hiện trên toàn bộ máy của các học viên, việc theo dõi trở lên dễ dàng hơn.

Giảng viên có thể disable/ enable chuột & bàn phím, usb, có thể tắt, khởi động lại, log off, hoặc có thể khóa màn hình của một học viên bất kỳ.

Giảng viên có thể trực tiếp giải đáp thắc mắc cho học viên ngay trên máy tính của mình qua chức năng điều khiển máy tính từ xa.

Trong suốt quá trình học giảng viên có thể theo dõi và kiểm soát hoạt động của các học viên.

c. Kết thúc buổi học.

Giảng viên có thể chia sẻ video bài giảng của mình và gửi tới đồng loạt các máy học viên (có thể gửi tài liệu học tập khác : sách điện tử, video, các mã nguồn ...).

Cho phép học viên được sử dụng Usb để copy tài liệu giúp đỡ cho việc học tại nhà của học viên dễ dàng hơn.

3.1.2. Phân tích các chức năng của hệ thống.

3.1.2.1. Mô hình phân cấp chức năng.

Page | 55

Hình 3. 1. Mô hình phân cấp chức năng.3.1.2.2. Giải thích rõ từng chức năng của hệ thống.

Qua khảo sát quy trình hoạt động của quản lý phòng máy của trường Đại Học, và Cao Đẳng ta có thể nhận thấy hệ thống bao gồm các chức năng.

Chia sẻ màn hình.

Chia sẻ tài liệu.

Chat message.

Remote desktop (điều khiển máy tính từ xa).

Disable/Enable usb.

Disable/Enable mouse và keyboard.

Lock/Unlock computer.

Turn off computer.

3.1.2.2.1. Chức năng “Chia sẻ màn hình”.

Page | 56

Hình 3. 2. Hình minh họa chức năng chia sẻ màn hình.Khi giảng viên giảng bài trên lớp. Những thao tác trên màn hình máy tính của

giảng viên sẽ hiển thị trên toàn bộ các máy tính của học viên trong phòng học. Việc này có thể giúp học viên dễ dàng quan sát hơn.

Hình 3. 3. Các nội dung giảng dạy có trên màn hình các máy học viên.Giảng viên cũng có thể chia sẻ màn hình của một học viên cho toàn bộ các học

viên khác. Việc này phục vụ cho mục đích giải đáp thắc cho học viên.

Page | 57

Hình 3. 4. Minh họa chia sẻ màn hình cho toàn bộ học viên.Ngoài ra tính năng chia sẻ màn hình có thêm chức năng ghi lại màn hình của

giảng viên. Nó giúp cho giảng viên có thể chia sẻ cho học viên thêm tài liệu học ở nhà nếu cần thiết.

3.1.2.2.2. Chức năng “chia sẻ tài liệu”.

Hình 3. 5. Minh họa các tài liệu được chia sẻ.Tài liệu chia sẻ có thể bao gồm:

Sách điện tử.

Video bài giảng.

Các bài viết.

Tài liệu lưu trữ các buổi thảo luận.

Tài liệu được chia sẻ trên máy chủ Server của giáo viên. Giáo viên có thể chia sẻ bất kỳ tài liệu nào cho học viên.

3.1.2.2.3. Chức năng “Chat message”.

Trong quá trình học tập giảng viên có thể giải đáp những thắc mắc hoặc những vấn đề muốn đưa ra. Mà không muốn chia sẻ tài liệu, chức năng chat message được sinh ra để giải quyết vấn đề này.

Ngoài ra chức năng này còn giúp cho học viên gửi yêu cầu giải đáp thắc mắc tới giảng viên khi có vướng mắc trong quá trình học tập. Điều này giúp tăng chất lượng dạy và học trong lớp.

3.1.2.2.4. Chức năng “Remote desktop”.

Page | 58

Hình 3. 6. Minh họa chức năng chia sẻ màn hình.Tính năng điều khiển máy tính từ xa, nhằm giúp giáo viên có thể giải đáp thắc

mắc của các học viên một cách dễ dàng và thuận tiện.

3.1.2.2.5. Chức năng “Disable/Enable usb”.

Nhằm mục đích chống gian lận trong quá trình thi cử, hoặc nghiêm cấm học viên sử dụng Usb có thể gây truyền nhiễm virus trong máy tính. Hoặc có thể cho phép học viên sử dụng Usb để copy tài liệu phục vụ cho việc học tập tại nhà.

3.1.2.2.6. Chức năng “Disable/Enable mouse và keyboard”.

Chức năng disable/enable cho phép giảng viên có thể khóa thiết bị chuột, bàn phím của một hay nhiều máy học viên bất kỳ. Nó sẽ có thể giúp việc quản lý phòng máy, hoặc quản lý thư cử trong phòng máy.

3.1.2.2.7. Chức năng “Lock/Unlock computer”.

Khi muốn khóa máy tính đây thực sự là một chức năng tuyệt vời, nó cho phép giảng viên có thể khóa máy của học viên bất kỳ nếu phát hiện thấy vi phạm nội quy của phòng học.

3.1.2.2.7. Chức năng “Turn off computer”.

Chức năng này cho phép giảng viên có thể thực hiện tắt máy, khởi động lại, Log off một hay nhiều máy bất kỳ. Việc này sẽ rất thuận tiện cho quá trình tắt máy, thay vì giảng viên phải đến từng máy thực hiện thao tác. Giảng viên có thể ngồi trực tiếp trên máy tính của mình thực hiện điều này.

3.1.2.3. Mô hình luồng dữ liệu.

Page | 59

Hình 3. 7. Mô hình luồng dữ liệu.3.2. Xây dựng các lớp xử lý chính.

3.2.1. Các lớp bên phía Server.

3.2.1.1. Lớp ServerReceiver.

Có nhiệm vụ là nhận các gói tin từ bên máy các Client gửi cho Server và trả ra thông báo.

Mô hình

Mã nguồn Class ServerReceiver

public class ServerReceiver

{

public Socket client;// client da duoc accept

public int clientIndex;// chi so client trong listClient

Page | 60

public DelegateControlMessageServerReceiveFromClient deleReceive;// --- Top

public Thread threadReceive;// thread de nhan du lieu dong bo

// Khoi tao

public ServerReceiver(Socket client, int clientIndex,

DelegateControlMessageServerReceiveFromClient deleReceive)

{

this.client = client; this.clientIndex = clientIndex;

this.deleReceive = deleReceive;

}

// Bat dau nhan du lieu

public void StartReceive()

{

threadReceive = new Thread(OnReceive);

threadReceive.Start();

}

// Thuc hien nhan du lieu kem kich thuoc cua du lieu

public void OnReceive()

{

while (true)

{

try

{

int total = 0;

int receve;

byte[] dataSize = new byte[4];

receve = client.Receive(dataSize, 0, 4, SocketFlags.None);

int size = BitConverter.ToInt32(dataSize, 0);

int dataLeft = size;

byte[] message = new byte[size];

while (total < size)

{

receve = client.Receive(message, total, dataLeft,

SocketFlags.None);

if (receve == 0)

{

message = null;

Page | 61

return;

}

total += receve;

dataLeft -= receve;

}

deleReceive(message, clientIndex);

}

catch (Exception ex)

{

StopReceive();

MessageBox.Show(ex.Message, String.Format("LAN Virtual Class v1.0 - ServerReceiver - OnReceive() - listClient[{0}]", clientIndex), MessageBoxButtons.OK, MessageBoxIcon.Error);

break;

}

}

}

// Dung viec nhan du lieu

public void StopReceive()

{

try

{

if (client != null)

{

client.Close(); client = null;

}

threadReceive.Abort();

threadReceive.Join();

}


{

MessageBox.Show(ex.Message, "LAN Virtual Class v1.0 - ServerReceiver - StopReceive()", MessageBoxButtons.OK, MessageBoxIcon.Error);

}

}

}

3.2.1.2. Lớp ServerSender.

Page | 62

Có Chức năng là gửi các gói tin từ Server cho các máy Client.

Mô hình

Mã nguồn.

public class ServerSender

{

public Socket client;// client da duoc ket noi den server

public int clientIndex;// chi so cua client trong listClient cua server

public byte[] message;// tin nhan can gui di

public DelegateControlMessageServerSendToClient deleSend;// --- Xem phan Delegate ben tren

public Thread threadSend;// --- thread de thuc hien viec send dong bo

// Khoi tao

public ServerSender(Socket client, int clientIndex,

DelegateControlMessageServerSendToClient deleSend)

{

this.client = client; this.clientIndex = clientIndex;

this.deleSend = deleSend;

}

// Bat dau send du lieu

public void StartSend()

{

while (threadSend == null || threadSend.ThreadState == ThreadState.Stopped)

threadSend = new Thread(OnSend);

threadSend.Start();

}

// Thuc hien send du lieu kem kich thuoc cua du lieu

Page | 63

public void OnSend()

{

try

{

int total = 0;

int size = message.Length;


int sent;


dataSize = BitConverter.GetBytes(size);

sent = client.Send(dataSize);


{

sent = client.Send(message, total, dataLeft, SocketFlags.None);

total += sent;

dataLeft -= sent;

}

deleSend(message, clientIndex);

}

catch (ThreadAbortException)

{

}


{

StopSend();

threadSend.Abort();

MessageBox.Show(ex.Message, "LAN Virtual Class v1.0 - ServerSender - OnSend()", MessageBoxButtons.OK, MessageBoxIcon.Error);

}

}

// Dung viec send du lieu

public void StopSend()

{

try

{

if (client != null)

{

Page | 64

client.Close(); client = null;

}

threadSend.Abort();

threadSend.Join();

}


{

MessageBox.Show(ex.Message, "LAN Virtual Class v1.0 - ServerSender - StopSend()", MessageBoxButtons.OK, MessageBoxIcon.Error);

}

}

}

3.2.1.3. Lớp ServerTCP.

Khởi tạo một đối tượng Server và đại diện cho Server.

Mô hình

Mã nguồn.

public class ServerTcp

{

public Socket server;// socket server

public List<Socket> listClient;// danh sach cac client ket noi den server

public List<ServerSender> listSender;// danh sach cac sender cho cac client

public List<ServerReceiver> listReceiver;// danh sach cac receiver cho cac client

Page | 65

public DelegateControlMessageServerReceiveFromClient deleReceive;// --- Top

public DelegateControlMessageServerSendToClient deleSendToClient;// --- Top

public DelegateControlMessageServerSendToListClient deleSendToListClient;// --- Top

public DelegateSetControlServer deleSetControl;// --- Top

public DelegateUpdateListClient deleUpdateListClient;// --- Top

// Bat dau server, chap nahn cac client ket noi den, voi backlog la so luong toi da client ket noi duoc chap nhan

public void StartServer(IPEndPoint localIPEP, int backlog)

{

try

{

listClient = new List<Socket>(0);

listSender = new List<ServerSender>(0);

listReceiver = new List<ServerReceiver>(0);

EndPoint localEP = (EndPoint)localIPEP;

server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

server.Bind(localEP);

server.Listen(backlog);

deleSetControl(true);

server.BeginAccept(new AsyncCallback(AcceptCallBack), null);

}


{

StopServer();

MessageBox.Show(ex.Message, "LAN Virtual Class v1.0 - ServerTcp - StartServer()", MessageBoxButtons.OK, MessageBoxIcon.Error);

}

}

// Thuc hien chap nhan cac client ket noi

public void AcceptCallBack(IAsyncResult iAR)

{

try

{

Socket client = server.EndAccept(iAR);

listClient.Add(client);

Page | 66

// ---> Can kiem tra xem client da ton tai hay chua? Neu ton tai roi thi thay the cai cu = cai moi

// Neu khong thi add --> thuc hien = IndexClient(Socket client)// Chua giai quyet duoc

listReceiver.Add(new ServerReceiver(listClient[listClient.Count - 1], listClient.Count - 1, deleReceive));

listReceiver[listClient.Count - 1].StartReceive();

listSender.Add(new ServerSender(listClient[listClient.Count - 1], listClient.Count - 1, deleSendToClient));

// Gui thong tin server cho client

for (int i = 0; i < 5; i++)

SendMessageToClient(listClient.Count - 1, BufferData.CreateMessage(TypeMessage.Command,

Command.ServerInfo,

BufferData.CreateInforMessage()));

// Gui clientIndex cho client

SendMessageToClient(listClient.Count - 1, BufferData.CreateMessage(TypeMessage.Command,Command.ClientIndex,BitConverter.GetBytes(listClient.Count - 1)));

deleUpdateListClient();

server.BeginAccept(new AsyncCallback(AcceptCallBack), null);

}

catch// (Exception ex)

{

// Loi do dong server

//MessageBox.Show(ex.Message, "LAN Virtual Class v1.0 - ServerTcp - AcceptCallBack()", MessageBoxButtons.OK, MessageBoxIcon.Error);

}

}

// Phuong thuc tin kiem client trong listClient va tra ve vi tri dau tien ma client xuat hien trong listClient

public int IndexClient(Socket client)

{

int i = 0;

while (i < listClient.Count && listClient[i].Equals(client) == false)

i++;

return (i < listClient.Count) ? i : -1;

Page | 67

}

// Thuc hien send mot tin nhan toi tat ca cac client trong listClient ket noi den server

public void SendMessageToAllClient(byte[] message)

{

for (int i = 0; i < listClient.Count; i++)

SendMessageToClient(i, message);

deleSendToListClient(message);

}

// Thuc hien gui tin nhan den mot client co chi so la clientIndex trong listClient ket noi

public void SendMessageToClient(int clientIndex, byte[] message)

{

if (listClient[clientIndex] != null)

{

listSender[clientIndex].message = message;

listSender[clientIndex].StartSend();

listSender[clientIndex].threadSend.Join();

}

}

// Thuc hien gui tin nhan den mot list cac client duoc quy dinh trong listClientIndex

public void SendDataToListClient(byte[] message, List<int> listClientIndex)

{

foreach (int clientIndex in listClientIndex)

SendMessageToClient(clientIndex, message);

deleSendToListClient(message);

}

// Ngat ket noi cua mot client co chi so la clientIndex trong listClient

public void DisAcceptClient(int clientIndex)

{

if (listClient[clientIndex] != null)

{

// Gui tin nhan offline client de client update lai tinh trang ket noi

if (listReceiver[clientIndex] != null)

{

listReceiver[clientIndex].StopReceive();

listReceiver[clientIndex] = null;

Page | 68

}

SendMessageToClient(clientIndex, BufferData.CreateMessage(TypeMessage.Command, Command.OffLineClient, null));

if (listSender[clientIndex] != null)

{

listSender[clientIndex].StopSend();

listSender[clientIndex] = null;

}

listClient[clientIndex].Close();

listClient[clientIndex] = null;

}

}

// Ngat ket noi cua moi client va dung server

public void StopServer()

{

try

{

if (listClient != null)

{

for (int i = 0; i < listClient.Count; i++)

{

DisAcceptClient(i);

}

listClient = null;

}

if (server != null)

{

server.Close();

server = null;

}

}


{

MessageBox.Show(ex.Message, "LAN Virtual Class v1.0 - ServerTcp - StopServer()", MessageBoxButtons.OK, MessageBoxIcon.Error);

}

finally

Page | 69

{

deleSetControl(false);

}

}

}

3.2.1.4. Lớp BuffData.

Có nhiệm vụ lấy các thông tin của máy Server gửi các gói tin Broadcast cho tất cả các máy trong mạng Lan bao gồm thông tin về Server và địa chỉ IP của Server.

Mô hình.

Mã nguồn.

// Tao ra du lieu quoang ba la su ket hop cua dia chi IP local va chuoi tin quang ba

public static byte[] CreateDataBroadCast(string messageBroadcast)

{

List<byte> result = new List<byte>(0);

string localIPAddress = GetLocalIPAddress().ToString();

result.AddRange(BitConverter.GetBytes(localIPAddress.Length));

result.AddRange(Encoding.UTF8.GetBytes(localIPAddress));

result.AddRange(Encoding.UTF8.GetBytes(messageBroadcast));

return result.ToArray();

}

// Lay ra dia chi IP cua Server

public static string GetRemoteIPAddress(byte[] dataBroadCast)

Page | 70

{

byte[] dataSizeRemoteIPAddressString = new byte[4];

try

{

Array.Copy(dataBroadCast, 0, dataSizeRemoteIPAddressString, 0, 4);

int sizeRemoteIPAddressString = BitConverter.ToInt32(dataSizeRemoteIPAddressString, 0);

byte[] dataRemoteIPAddressString = new byte[sizeRemoteIPAddressString];

Array.Copy(dataBroadCast, 4, dataRemoteIPAddressString, 0, sizeRemoteIPAddressString);

return Encoding.UTF8.GetString(dataRemoteIPAddressString);

}

catch

{

return "";

}

}

// Lay chuoi tin quang ba tu du lieu cua tin quang ba

public static string GetMessageBroadCast(byte[] dataBroadCast)

{

byte[] dataSizeRemoteIPAddressString = new byte[4];

try

{

Array.Copy(dataBroadCast, 0, dataSizeRemoteIPAddressString, 0, 4);

int sizeRemoteIPAddressString = BitConverter.ToInt32(dataSizeRemoteIPAddressString, 0);

byte[] dataMessageBroadCast = new byte[dataBroadCast.Length - 4 - sizeRemoteIPAddressString];

Array.Copy(dataBroadCast, 4 + sizeRemoteIPAddressString, dataMessageBroadCast,

0, dataMessageBroadCast.Length);

return Encoding.UTF8.GetString(dataMessageBroadCast);

}

catch

{

return "";

}

}

Page | 71

3.2.2. Các lớp bên phía Client.

3.2.2.1. Lớp ClientReceiver.

Lớp này thực hiện việc nhận các gói tin từ bên phía Server gửi cho Client.

Mô hình

Mã nguồn

public class ClientReceiver

{

public Socket server;// server da duoc connect

public DelegateControlMessageClientReceiveFromServer deleReceive;// --- Top

public Thread threadReceive;// thread de nhan du lieu

// Khoi tao

public ClientReceiver(Socket server, DelegateControlMessageClientReceiveFromServer deleReceive)

{

this.server = server; this.deleReceive = deleReceive;

}

// Bat dau receive

public void StartReceive()

{

threadReceive = new Thread(OnReceive);

threadReceive.Start();

}

// Trong qua trinh nhan du lieu

public void OnReceive()

{

while (true)

{

Page | 72

try

{

int total = 0;

int receve;


receve = server.Receive(dataSize, 0, 4, SocketFlags.None);

int size = BitConverter.ToInt32(dataSize, 0);


byte[] message = new byte[size];


{

receve = server.Receive(message, total, dataLeft, SocketFlags.None);

if (receve == 0)

{

message = null;

return;

}

total += receve;

dataLeft -= receve;

}

deleReceive(message);

}


{

StopReceive();

MessageBox.Show(ex.Message, "LAN Virtual Class v1.0 - ClientReceiver - OnReceive()", MessageBoxButtons.OK, MessageBoxIcon.Error);

break;

}

}

}

// Dung viec nhan du lieu

public void StopReceive()

{

try

{

if (server != null)

Page | 73

{

server.Close();

server = null;

}

threadReceive.Abort();

threadReceive.Join();

}


{

MessageBox.Show(ex.Message, "LAN Virtual Class v1.0 - ClientReceiver - StopReceive()", MessageBoxButtons.OK, MessageBoxIcon.Error);

}

}

}

3.2.2.2. Lớp ClientSender.

Có nhiệm vụ gửi các gói tin từ bên phía Client cho bên Server.

Mô hình

Mã nguồn

public class ClientSender

{

public Socket server;// socket server da connect

public byte[] message;// tin nhan can gui

public DelegateControlMessageClientSendToServer deleSend;// --- Top

public Thread threadSend;// thread de send

// Khoi tao

public ClientSender(Socket server, DelegateControlMessageClientSendToServer deleSend)

{

this.server = server; this.deleSend = deleSend;

Page | 74

}

// Bat dau send du lieu

public void StartSend()

{

threadSend = new Thread(OnSend);

threadSend.Start();

}

// Thuc hien send du lieu dong bo

public void OnSend()

{

try

{

int total = 0;

int size = message.Length;


int sent;


dataSize = BitConverter.GetBytes(size);

sent = server.Send(dataSize);


{

sent = server.Send(message, total, dataLeft, SocketFlags.None);

total += sent;

dataLeft -= sent;

}

deleSend(message);

}


{

StopSend();

MessageBox.Show(ex.Message, "LAN Virtual Class v1.0 - ClientSender - OnSend()", MessageBoxButtons.OK, MessageBoxIcon.Error);

}

}

// Dung viec send du lieu

public void StopSend()

{

try

Page | 75

{

if (server != null)

{

server.Close(); server = null;

}

threadSend.Abort();

threadSend.Join();

}


{

MessageBox.Show(ex.Message, "LAN Virtual Class v1.0 - ClientSender - StopSend()", MessageBoxButtons.OK, MessageBoxIcon.Error);

}

}

}

3.2.2.3. Lớp ClientTCP.

Khởi tạo một đối tượng Client và đại diện cho Client.

Mô hình

Mã nguồn.

public class ClientTcp

{

public Socket server;// socket server ma client ket noi den

public ClientSender sender;// sender cua client

public ClientReceiver receiver;// receiver cua client

public DelegateControlMessageClientReceiveFromServer deleReceive;// --- Top

Page | 76

public DelegateControlMessageClientSendToServer deleSend;// --- Top

public DelegateSetControlClient deleSetControl;// --- Top

public int clientIndex;

// Connect den server

public void Connect(IPEndPoint remoteIPEP)

{

try

{

server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

server.BeginConnect(remoteIPEP, new AsyncCallback(ConnectCallBack), server);

}


{

DisConnect();

MessageBox.Show(ex.Message, "LAN Virtual Class v1.0 - ClientTcp - Connect()", MessageBoxButtons.OK, MessageBoxIcon.Error);

}

}

// Thuc hien ket noi

public void ConnectCallBack(IAsyncResult iAR)

{

try

{

server = (Socket)iAR.AsyncState;

server.EndConnect(iAR);

receiver = new ClientReceiver(server, deleReceive);

receiver.StartReceive();

sender = new ClientSender(server, deleSend);

// Gui thong tin client cho server

for (int i = 0; i < 5; i++)

Send(BufferData.CreateMessage(TypeMessage.Command, Command.ClientInfo, BufferData.CreateInforMessage()));

deleSetControl(true);

}

Page | 77

catch// (Exception ex)

{

// Loi do dong client

//MessageBox.Show(ex.Message, "LAN Virtual Class v1.0 - ClientTcp - ConnectCallBack()", MessageBoxButtons.OK, MessageBoxIcon.Error);

}

}

// gui message toi server da ket noi

public void Send(byte[] message)

{

if (sender != null)

{

sender.message = message;

sender.StartSend();

}

}

// Ngat ket noi

public void DisConnect()

{

try

{

if (server != null)

{

// Gui tin offline den cho server de server cap nhat lai listClient

Send(BufferData.CreateMessage(TypeMessage.Command, Command.OffLineClient, BitConverter.GetBytes(clientIndex)));

if (receiver != null)

{

receiver.StopReceive();

receiver = null;

}

if (sender != null)

{

sender.StopSend();

sender = null;

}

server.Close();

server = null;

Page | 78

}

}


{

MessageBox.Show(ex.Message, "LAN Virtual Class v1.0 - ClientTcp - DisConnect()", MessageBoxButtons.OK, MessageBoxIcon.Error);

}

finally

{

deleSetControl(false);

}

}

}

3.3. Thiết kế giao diện.

CHƯƠNG 5. KẾT LUẬN

Page | 79

5.1. Những kết quả đạt được.

Sau quá trình nghiên cứu và triển khai đề tài “Xây dựng phần mềm lớp học ảo trong mạng Lan” đã thu được những kết quả sau đây.

Tìm hiểu được các cách thức lập trình Socket và lập trình .Net Remoting trong C#.

Nghiên cứu các kiến thức lập trình Windows nâng cao như lập trình với các hàm API, lập trình trên nền tảng Registry.

Ngoài ra còn có kiến thức nâng cao về sử lý ảnh, lập trình đa luồng, lập trình sự kiện Delegate.

Xây dựng được hoàn chỉnh các module chia sẻ màn hình, remote desktop, và một số chức năng khác.

5.2. Hướng phát triển.

Về cơ bản phần mềm đã đạt được những vấn đề đặt ra. Tuy nhiên trong giai đoạn thực tập xây dựng lên phần mềm này còn nhiều vấn đề cần phải phát triển thêm.

Xây dựng một phần mềm LanVc hoàn chỉnh và hoàn toàn miễn phí có thể thay thế được phần mềm Farstone Virtual Class có giá rất đắt và thiếu đi chức năng quay phim màn hình và VoIP.

Xây dựng một modul tách biệt Remote desktop thành một sản phẩm remote control over Internet có thêm các chức năng như VoIP và chat thoại có sức cạnh tranh tốt có thể thay thế phần mềm thông dụng hiện nay Teamviewer.

Xây dựng thêm được các module Screen record riêng biệt mà không cần phải phụ thuộc vào sử dụng công cụ Windows Media Encorder sẽ giúp việc quay video trở lên chất lượng hơn và có thêm cả chức năng ghi âm được giọng nói trong video.

Hướng phát triển tích hợp thêm vào phần mềm thi trắc nghiệm trong mạng Lan có các chức năng thi, chấm bài thi.

Hoặc có thể phát triển lênư phần mềm thành một phần mềm dạy học trực tuyến với đầy đủ các chức năng như của phần mềm “Lớp học ảo trong mạng Lan”.

TÀI LIỆU THAM KHẢO

[1]. Ingo Rammer, Advanced .Net Remoting (C# Edition), Impressions Book and Journal Services, Inc (2002).

Page | 80

[2]. Andrew Krowczyk, Vinod Kumar, Nauman Laghari, Tim Parker, Srinivasa Sivakumar, Professional_.NET_Network_Programming, Wrox Press Ltd.

[3]. Brent Rector, Introduction to .NET Remoting, Wise Owl Consulting, Inc (2004).

[4]. Fiach Reid, Network programming in .NET with C# and VB.NET (Digital Press), Elsevier’s Science & Technology Rights Department in Oxford (2004).

[5]. Richard Blum, Sybex_-_Csharp_Network_Programming, Sybex © 2003.[6]. Joe Mayo, C# 3.0 UNLEASHED , Copyright © 2008 by Pearson Education,

Inc.[7]. Simon Robinson, Christian Nagel, Jay Glynn, Morgan Skinner, Karli Watson,

Bill Evjen, Professional C# Third Edition, Wiley Publishing, Inc (2004). [8]. Wei-Meng Lee , C# 2008 Programmer’s Reference , Wiley Publishing, Inc

(2009).[9]. Joseph Albahari and Ben Albahari, C# 4.0 IN A NUTSHELL, O’Reilly

Media, Inc.[10].Đào Lưu Duy, Bài giảng lập trình mạng với C#, Sách điện tử.[11].Ngô Bá Hùng, Nguyễn Công Huy, Giáo trình lập trình mạng với Java, Khoa

Công Nghệ Thông Tin trường Đại học Cần Thơ.[12].Nguyễn Cao Đạt, Bài giảng lập trình mạng, Trường Đại học Bách Khoa TP.

Hồ Chí Minh.[13].Nhóm tác giả, Giáo trình lập trình mạng với Java, Tổng hợp diễn đàn Đại học.[14].Nhóm tác giả, Giáo trình lập trình mạng với C#, Trường Đại học Đà Lạt.[15].Văn Thiên Hoàng, Giáo trình lập trình mạng, Trường Đại học Công Nghệ Đại

học Quốc Gia TP.Hồ Chí Minh.[16].Nguyễn Quang Hoan, Giáo trình xử lý ảnh, Học viện công nghệ Bưu Chính

Viễn Thông.[17].Nguyễn Hùng Cường, Bài thực hành xử lý ảnh với C#, Trường Đại học Công

Nghiệp Hà Nội.[18].Nhóm tác giả, Căn bản XML, Trung tâm công nghệ phần mềm Thừa Thiên

Huế.[19].Nguyễn Hà Giang, Lập trình Windows C#, Trường Đại học Khoa học tự nhiên

Đại học Quốc Gia Hà Nội.[20].Nguyễn Ngọc Bình Phương, Thái Thanh Phong, Các giải pháp lập trình C#,

Nhà xuất bản giao thông vận tải.[21].Nguyễn Tấn Thuận, Lập trình ứng dụng Windows From trong C#, Học viện

công nghệ thông tin NIT.[22].Bùi Duy Hùng, Phần mềm Free Virtual Class, Giải thưởng phần mềm sáng tạo

trường Đại học Công Nghiệp Hà Nội.

[23]. Nguyễn Thành Trung, Phần mềm quản lý phòng Lab, Đồ án tốt nghiệp.

[24].Nguyễn Huy Khánh, Mã nguồn phần mềm chat trong mạng Lan, Đồ án môn học lập trình mạng.

[25]. David Robinson, Mã nguồn Remote Desktop.

[26].http://diendan.congdongcviet.com/showthread.php?t=31306 (thuật toán so sánh hai ảnh bitmap) truy cập lần cuối cùng ngày 20/04/2012.

Page | 81

http://diendan.congdongcviet.com/showthread.php?t=31306

http://blog.bobcravens.com/2009/05/multiple-remote-desktop-viewer-c-wcf/#comment-1649

http://khanh.com.vn/post/2011/07/07/LAN-Messenger-Chuong-trinh-chat-qua-mang-LAN.aspx

http://diendan.congdongcviet.com/showthread.php?t=31468

http://duyhunghd6.net/blog/2010/sharing-net-sourcecode-chia-s%E1%BA%BB-ma-ngu%E1%BB%93n-%E1%BB%A9ng-d%E1%BB%A5ng-freevc-qu%E1%BA%A3n-ly-phong-lab-vi%E1%BA%BFt-c/

[27]. http://45th.the-up.com/t91-topic (Các thuật toán so sánh ảnh) truy cập lần cuối 20/04/2012.

[28].http://www.pinvoke.net/default.aspx/user32.enablewindow thư viện các hàm API.

[29].http://hedieuhanh.forumvi.net/t3686-topic thư viện các hàm API.

[30].http://thanhcuong.wordpress.com/2011/01/19/d%E1%BB%8Dc-v-ghi-vo- registry-read-and-write-to-registry/ Các thao tác với Registry.

[31].http://csharp.net-informations.com/ Kiến thức lập trình mạng với C#.

[32].http://www.codeproject.com/Articles/19836/Palantir-Remote-Desktop- Manager Remote desktop.

Page | 82

http://www.codeproject.com/Articles/19836/Palantir-Remote-Desktop-Manager

http://www.codeproject.com/Articles/19836/Palantir-Remote-Desktop-Manager

http://csharp.net-informations.com/

http://thanhcuong.wordpress.com/2011/01/19/d%E1%BB%8Dc-v-ghi-vo-registry-read-and-write-to-registry/

http://thanhcuong.wordpress.com/2011/01/19/d%E1%BB%8Dc-v-ghi-vo-registry-read-and-write-to-registry/

http://hedieuhanh.forumvi.net/t3686-topic

http://www.pinvoke.net/default.aspx/user32.enablewindow

http://45th.the-up.com/t91-topic

Documents

Báo cáo thực tập tốt nghiệp Hoàng Văn Vang _ Nguyễn Mạnh Dũng _ Xây dựng phần mềm lớp học ảo trong mạng Lan _Lop KHMT1K3