Tìm hiểu ngôn ngữ lập c và ứng dụng trong chương trình quản lý học viên ở trung tâm tin học ngoại ngữ đại học vinh
Bạn đang xem bản rút gọn của tài liệu. Xem và tải ngay bản đầy đủ của tài liệu tại đây (503.05 KB, 56 trang )
TRƯỜNG ĐẠI HỌC VINH
KHOA CÔNG NGHỆ THÔNG TIN
===== =====
KHÓA LUẬN TỐT NGHIỆP
Đề tài:
TÌM HIỂU NGÔN NGỮ C# VÀ ỨNG DỤNG
TRONG CHƯƠNG TRÌNH QUẢN LÝ HỌC VIÊN TẠI
TRUNG TÂM
TIN HỌC NGOẠI NGỮ ĐH VINH
Giáo viên hướng dẫn:
THS. VŨ VĂN NAM
Lớp:
43E2 - CNTT
VINH - 5/2007
MỤC LỤC
Trang
LỜI NÓI ĐẦU..................................................................................................
CHƯƠNG I:TÌM HIỂU VỀ NGÔN NGỮ C#..................................................
I.1. Tổng quan về ngôn ngữ C#.........................................................................
I.2. Cơ bản về C#...............................................................................................
I.2.1. Biến.........................................................................................................
I.2.2. Hằng........................................................................................................
I.2.3. Câu lệnh điều kiện..................................................................................
I.2.4. Vòng lặp.................................................................................................
I.2.5. Cấu trúc chương trình.............................................................................
I.2.6. Phương thức............................................................................................
I.2.7. Toán tử....................................................................................................
I.2.8. An toàn kiểu............................................................................................
I.2.9. Kiểu liệt kê..............................................................................................
I.2.10. Namespaces..........................................................................................
I.2.11. Phương thức Main()..............................................................................
I.2.12. Console I/O...........................................................................................
I.2.13. Sử dụng các ghi chú............................................................................
I.2.14. Từ định danh và từ khoá.....................................................................
I.3. Hướng đối tượng trong C#.........................................................................
I.3.1. Lớp và thừa kế......................................................................................
I.3.2. Gọi các phiên bản cơ sở của các chức năng.........................................
I.3.3. Các lớp và hàm Astract.........................................................................
I.3.4. Sealed các lớp và phương thức.............................................................
I.3.5. Những bổ từ truy cập............................................................................
I.3.6. Thuộc tính.............................................................................................
I.3.7. Lớp đối tượng.......................................................................................
I.3.8. Phương thức Tostring().........................................................................
CHƯƠNG II: LẬP TRÌNH C# VỚI CƠ SỞ DỮ LIỆU..................................
...................................................................................................
II.1. Tổng quan về ADO.NET..........................................................................
II.1.1. Các Namespace...................................................................................
II.1.2. Các lớp dùng chung.............................................................................
II.1.3. Các lớp cơ sở chuyên biệt...................................................................
II.2. Sử dụng các Database Connection...........................................................
II.3. Commands................................................................................................
II.3.1. Executing Commands.........................................................................
II.3.2. Gọi các Stored Procedure....................................................................
II.4. Tạo một Dataset.......................................................................................
II.5. Các cố gắng thay đổi Dataset...................................................................
II.6. Nguồn dữ liệu...........................................................................................
II.7. Gắn kết CSDL..........................................................................................
CHƯƠNG III: PHÂN TÍCH VÀ THIẾT KẾ HỆ THỐNG.............................
III.1. Lựa chọn hướng phân tích......................................................................
III.2. Phân tích hệ thống cũ .............................................................................
III.3. Thiết kế hệ thống mới ............................................................................
III.4. Sơ đồ phân cấp chức năng .....................................................................
III.5. Biểu đồ luồng dữ liệu..............................................................................
III.6. Mô hình thực thể và các thuộc tính.........................................................
III.7. Thiết kế các file dữ liệu...........................................................................
CHƯƠNG IV: THIẾT KẾ GIAO DIỆN VÀ THIẾT KẾ MODUL.................
KẾT LUẬN......................................................................................................
LỜI KẾT..........................................................................................................
TÀI LIỆU THAM KHẢO...............................................................................
Kho¸ luËn tèt nghiÖp
LỜI NÓI ĐẦU
Cùng với sự phát triển của các lĩnh vực kinh tế, xã hội, nhu cầu ứng
dụng công nghệ thông tin ngày càng cao và không ngừng biến đổi. Khi hệ
thống càng phát triển, càng phức tạp thì các phương thức quản lý cổ điển
truyền thống sẽ trở nên cồng kềnh và khó có thể đáp ứng được yêu cầu ngày
càng cao của hệ thống. Để xử lý các thông tin một cách nhanh chóng, chính
xác và có hiệu quả, đòi hỏi phải có sự hỗ trợ của một công cụ hiện đại, đó
chính là công nghệ thông tin.
Sự phát triển nhảy vọt của công nghệ thông tin đã tác động mạnh mẽ
đến các hoạt động xã hội, làm thay đổi một cách sâu sắc đến phong cách
sống làm việc của một xã hội. Công nghệ thông tin đã trở thành trụ cột chính
của nền kinh tế tri thức. Ứng dụng công nghệ thông tin vào việc quản lý các
hoạt động xã hội và nghiên cứu khoa học được nhiều người quan tâm. Phạm
vi ứng dụng của công nghệ thông tin ngày càng mở rộng trên nhiều lĩnh vực:
truyền thông, đo lường, tự động hoá, quản lý các hoạt động của con người và
xã hội… Những lợi ích mà các phần mềm ứng dụng mang lại là đáng kể: xử
lý thông tin nhanh chóng, chính xác, khoa học, giảm bớt nhân lực và công
sức, phí tổn thấp và hiệu quả công việc nâng cao một cách rõ rệt.
Trong lĩnh vực công nghệ thông tin, các ngôn ngữ lập trình, các hệ
quản trị cơ sở dữ liệu không ngừng phát triển và đổi mới, cho phép chúng ta
xây dựng các phần mềm ứng dụng hỗ trợ việc quản lý các hoạt động xã hội
một cách tốt nhất.
Trong đề tài này tôi đề cập đến “Tìm hiểu ngôn ngữ lập C# và ứng
dụng trong chương trình quản lý Học viên ở Trung tâm tin học ngoại ngữ
Đại học Vinh”.
Với tầm quan trọng của ứng dụng công nghệ thông tin trong quản lý
nên tôi muốn tìm hiểu ngôn ngữ lập trình C# và hệ quản trị cơ sở dữ liệu
4
Kho¸ luËn tèt nghiÖp
Microsoft Access để xây dựng phần mềm quản lý Học viên ở Trung tâm Tin
học – Ngoại ngữ Đại học Vinh.
Khoá luận bao gồm:
Chương I.
Tìm hiểu về ngôn ngữ lập trình C#
Chương II.
Lập trình C# với CSDL
Chương III.
Phân tích và thiết kế hệ thống
Chương IV.
Thiết kế giao diện và thiết kế Modul
Kết luận
Lời kết
Tài liệu tham khảo
Khoá luận được hoàn thành vào tháng 5 năm 2007 tại trường Đại Học
Vinh, với sự hướng dẫn của thầy giáo Thạc sĩ Vũ Văn Nam. Nhân dịp này
tôi xin bày tỏ lòng biết ơn sâu sắc đến thầy, người đã định hướng và tận tình
giúp đỡ tôi trong quá trình học tập nghiên cứu. Cảm ơn các thầy cô giáo
khoa Công nghệ thông tin trường Đại Học Vinh đã giảng dạy và chỉ bảo
những vấn đề liên quan đến đề tài. Xin cảm ơn các thầy cô ở Trung Tâm Tin
học - Ngoại ngữ trường Đại Học Vinh đã tạo điều kiện cho tôi trong quá
trình khảo sát hệ thống và hoàn thành chương trình ứng dụng này. Xin cảm
ơn người thân và bạn bè đã giúp đỡ tạo điều kiện cho tôi suốt quá trình học
tập và hoàn thành khoá luận.
Vinh, tháng 5 năm 2007.
Sinh viên
Lê Thùy Tâm
5
Kho¸ luËn tèt nghiÖp
CHƯƠNG I
TÌM HIỂU VỀ NGÔN NGỮ LẬP TRÌNH C#
I.1. Tổng quan về ngôn ngữ C#
C# là một ngôn ngữ lập trình hướng đối tượng được phát triển bởi
Microsoft, là phần khởi đầu cho kế hoạch.NET của họ.
C# được nghiên cứu và thiết kế trong hơn 3 năm bởi một đội ngũ
chuyên gia lập trình xuất sắc nhất của Microsoft. C# được phát triển dựa trên
hai ngôn ngữ, hay nói một cách khác là nó được bắt nguồn từ hai ngôn ngữ
C++ và Java. C# được miêu tả là ngôn ngữ có được sự cân bằng giữa C++,
Visual Basic, Delphi và Java. Công cụ hỗ trợ lập trình C# là Visual C#.NET.
C# là một ngôn ngữ lập trình mạnh, mới lập trình làm việc trên các đối
tượng. Nó hỗ trợ người lập trình trên mọi phương diện, có thể nói nó cung cấp
các phương tiện để lập trình tự động. C# có thể lập trình “mọi thứ” nếu cần.
Ngoài những ưu việt trên C# còn kết nối được với các hệ quản trị CSDL
khác như Access, SQL,…Nó tạo thuận lợi vô cùng cho người lập trình khi lập
trình về quản lý hay lập trình liên quan đến web.
I.2. Cơ bản C#
C# là một ngôn ngữ lập trình hướng đối tượng do đó chúng ta phải nắm
vững thế nào là class, objects, interface và inheritance.
I.2.1. Biến
Một biến dùng để lưu trữ giá trị mang một kiểu dữ liệu nào đó. Cú pháp
C# sau đây dùng để khai báo một biến: [ modifier ] datatype identifer. Với
Modifier là một trong những từ khoá: public, private, protected,… còn
Datatype là kiểu dữ liệu (int, long, float…) và identifier là tên biến.
Phạm vi hoạt động của biến là vùng đoạn mã mà từ đó biến có thể truy
xuất được. Trong một phạm vi hoạt động, không thể có hai biến cùng mang
một tên trùng nhau.
6
Kho¸ luËn tèt nghiÖp
I.2.2. Hằng
Một hằng là một biến nhưng trị của nó không thể thay đổi trong suốt
thời gian thi hành chương trình. Đôi lúc ta cũng cần có những giá trị bao giờ
cũng bất biến. Những thuận lợi khi dùng hằng trong chương trình của bạn:
+ Hằng làm cho chương trình đọc dễ dàng hơn, bằng cách thay thế
những con số vô cảm bởi những tên mang đầy ý nghĩa hơn.
+ Hằng làm cho dễ sửa chương trình hơn
+ Hằng làm cho việc tránh lỗi dễ dàng hơn.
I.2.3. Câu lệnh điều kiện
+ Câu lệnh điều kiện if
Cú pháp như sau:
if (condition)
statement(s)
[else
statement(s)]
+ Câu lệnh Switch
Các câu lệnh if nằm lồng rất khó đọc, khó gỡ rối. Khi bạn có một loạt
lựa chọn phức tạp thì nên sử dụng câu lệnh switch
Cú pháp như sau:
switch (biểu thức)
{
casce biểu thức ràng buộc:
cõu lệnh
cõu lệnh nhảy
[default: câu lệnh mặc định]
}
I.2.4. Vòng lặp (Loops)
C# cung cấp cho chúng ta 4 vòng lặp khác nhau (for, while, do...while,
và foreach) cho phép chúng ta thực hiện một đoạn mã lặp lại cho đến khi đúng
điều kiện lặp
+ Vòng lặp for
Cỳ phỏp:
for (initializer; condition; iterator)
7
Kho¸ luËn tèt nghiÖp
statement(s)
+ Vòng lặp while (The while Loop)
Cú pháp:
while(condition)
statement(s);
+ Vòng lặp do... while (The do…while Loop)
bool condition;
do
{
// Vũng lặp này sẽ thực hiện ớt nhất một lần thậm chớ nếu cõu điều kiện sai
MustBeCalledAtLeastOnce();
condition = CheckCondition();
} while (condition);
+ Vòng lặp foreach (The foreach Loop)
Cho phép bạn duyệt qua tất cả các phần tử bản dãy hoặc các tập hợp
khác, và tuần tự xem xét từng phần tử một.
Cú pháp:
foreach (type identifier in expression) statement
+ Câu lệnh goto
goto Label1;
Console.WriteLine("This won't be executed");
Label1:
Console.WriteLine("Continuing execution from here");
+ Câu lệnh Break
Ta dùng câu lệnh break khi muốn ngưng việc thi hành và thoát khỏi
vòng lặp
+ Câu lệnh Continue
Câu lệnh Contiue được dùng trong vòng lặp khi bạn muốn khởi động lại
một vòng lặp nhưng lại không muốn thi hành một phần lệnh còn lại trong
vòng lăp, ở một điểm nào đó trong thân vòng lặp
+ Câu lệnh Return
Câu lệnh Return dùng thoát khỏi một hàm hành sự của một lớp, trả
quyền điều khiển về phía triệu gọi hàm (caller). Nếu hàm có một kiểu dữ liệu
8
Kho¸ luËn tèt nghiÖp
trả về thì return phải trả về kiễu dữ liệu này, bằng không thì câu lệnh được
dùng không có biểu thức
I.2.5. Cấu trúc chương trình
+ Lớp
Như bạn đã biết, các class tạo nên một chương trình lớn trong C#. Tuy
nhiên nó thực sự có khả năng viết 1chương trình mà không sử dụng đến lớp, ở
đây chúng ta chỉ cần một ít về lớp. Lớp là một khuôn mẫu thiết yếu mà chúng
ta cần tạo ra đối tượng. Mỗi đối tượng chứa dữ liệu và các phương thức chế
tác truy cập dữ liệu. Lớp định nghĩa cái mà dữ liệu và hàm của mỗi đối tượng
riêng biệt (được gọi là thể hiện) của lớp có thể chứa.
+ Các lớp thành viên
Dữ liệu và các hàm không có lớp được biết như là lớp thành viên
+ Thành phần dữ liệu (Datamembers) là những thành phần chứa dữ liệu
cho lớp – Trường (fields), Hằng số (Constants) và sự kiện (events).
Fields là các biến kết hợp với lớp
Các hằng số có thể kết hợp với các lớp như là biến. Chúng ta khai báo
một hằng số sử dụng từ khoá const. Nếu nó khai báo public thì có thể truy cập
ở ngoài lớp.
+ Hàm thành phần (Function Members):
Bao gồm các thuộc tính và các phương thức. Chúng ta sử dụng các từ
khoá sau để bổ nghĩa cho một phương thức:
Modifier
Description
new
Phương thức ẩn một phương thức kế thừa với cùng kí hiệu
public Phương thức có thể được truy cập bất kỳ
protected Phương thức có thể bị truy xuất không từ lớp nó thuộc hoặc từ lớp
dẫn xuất;
internal Phương thức có thể được truy cập không cùng assembly
private Phương thức có thể được truy cập từ bên trong lớp nó phụ thuộc
static Phương thức có thể không được tính trên trên một lớp thể hiển cụ
thể
virtual Phương thức bị ghi đè bởi một lớp dẫn xúât
abstract Phương thức trừu tượng
9
Kho¸ luËn tèt nghiÖp
Modifier
Description
override Phương thức ghi đè một phương thức ảo kế thừa hoặc trừu tượng.
sealed Phương thức ghi đè một phương thức ảo kế thừa, nhưng không thể
bị ghi đè từ lớp kế thừa này
extern Phương thức được thực thi theo bên ngoài từ một ngôn ngữ khác
+ Cấu trúc (Structs)
Ngoài các lớp nó cũng có thể để khai báo các cấu trúc, cấu trúc về cơ
bản bạn biết ngoại trừ chúng ta dùng từ khoá structs thay cho class.
I.2.6. Phương thức
+ Khai báo phương thức (Declaring Metholds)
Cú pháp khai báo trong C# gần như giống với cách khai báo C, C++ và
Java. Chỉ khác là mỗi phương thức được khai báo tách biệt public và private.
Không thể dùng public để nhóm các phương thức định nghĩa. Ngoài ra tất cả
các phương thức trong C# được định nghĩa trong lớp định nghĩa.
Trong C#, các phương thức kèm theo các từ khoá dùng bổ nghĩa cho
phương thức, kiểu giá trị trả về, các tham số nhập vào và phần thân trong dấu
ngoặc kép.
[modifiers] return_type MethodName([parameters])
{
// Thân phương thức
}
Mỗi tham số có tên của kiểu của tham số và tên mà nó được tham khảo
trong thân phương thức, và cả giá trị trả về nếu có.
+ Gọi phương thức (Invoking Methods)
+ Truyền tham số cho phương thức (Passing Paramemter to Methods)
- Mảng (Arrays): là một cấu trúc dữ liệu cấu tạo bởi một số biến được
gọi là những phần tử mảng. Tất cả các phần tử này đều thuộc một kiểu dữ
liệu. Bạn có thể truy xuất phần tử thông qua chỉ số (Index).
Có nhiều loại mảng: mảng 1 chiều, mảng nhiều chiều
Cú pháp:
type[ ] array-name;
10
Kho¸ luËn tèt nghiÖp
I.2.7. Toán tử
Bảng dưới đây trỡnh bày một danh sỏch đầy đủ của shortcut operators
có giá trị trong C#:
Shortcut Operator
Tương đương
x++, ++x
x=x+1
x--, --x
x=x-1
x += y
x=x+y
x -= y
x=x–y
x *= y
x=x*y
x /= y
x=x/y
x %= y
x=x%y
x >>= y
x = x >> y
x <<= y
x = x << y
x &= y
x=x&y
x |= y
x=x|y
x ^= y
x=x^y
I.2.8. An toàn kiểu (Type Safety)
+ Quá trình chuyển đổi kiểu (Type Conversions)
Chúng ta thường chuyển đổi dữ liệu từ một kiểu sang kiểu khác
+ Implicit Conversions
Bảng sau hiển thị cách chuyển đổi kiểu implicit được hỗ trợ trong C#.
From
To
sbyte
short, int, long, float, double, decimal
byte
short, ushort, int, uint, long, ulong, float, double, decimal
short
int, long, float, double, decimal
ushort
int, uint, long, ulong, float, double, decimal
int
long, float, double, decimal
uint
long, ulong, float, double, decimal
11
Kho¸ luËn tèt nghiÖp
From
To
long, ulong float, double, decimal
float
double
char
ushort, int, uint, long, ulong, float, double, decimal
I.2.9. Kiểu liệt kê
Phương án thay thế hằng là enumeration (liệt kê), gồm một tập hợp
những hằng đuợc đặt tên.
I.2.10. Namespaces
Namespace cung cấp cho ta cách mà chúng ta tổ chức quan hệ giữa các
lớp và các kiểu khác.Namespace(địa bàn hoạt động của các tên) là cách
mà.NET tránh né việc các tên lớp, tên biến, tên hàm.... đụng độ vỡ trựng tờn
giữa cỏc lớp.
Câu lệnh using
Từ khoỏ using giỳp bạn giảm thiểu việc phải gừ những namespace
trước các hàm hành sự hoặc thuộc tính.
I.2.11. Phương thức Main()
Đa phương thức Main()
Khi một C# console hoặc ứng dụng Windows được biên dịch, theo mặc
định trỡnh biờn dịch nhỡn vào phương thức Main() thoả đúng như danh sách
dưới đây, và tạo ra phương thức lớp trỏ toàn bộ chương trỡnh, nếu cú nhiều
hơn một phương thức Main(), trỡnh biờn dịch sẽ trả về thông báo lỗi do đó một
chương trỡnh C# phải chứa một hàm main(), được xem là điểm đột nhập vào
chương trỡnh.
I.2.12. Console I/O
Để đọc một ký tự văn bản từ của sổ console, Chúng ta dùng phương
thức Console.Read(), giỏ trị trả về sẽ là kiểu int hoặc kiểu string tuỳ ý . Và chúng ta
cũng có hai phương thức dùng để viết ra chuổi ký tự như sau
. Console.Write() - Viết một giỏ trị ra của sổ window
12
Kho¸ luËn tèt nghiÖp
. Console.WriteLine() - tương tự trên nhưng sẽ tự động xuống hàng khi
kết thúc lệnh
I.2.13. Sử dụng các ghi chú
Ở chủ đề này chúng ta xem phần đơn giản của chương này đó là thêm
các ghi chú vào đoạn mó. C# sử dụng kiểu truyền thống của C hàng đơn (//...)
và nhiều hàng (/*... */)
I.2.14. Từ định danh và từ khoá
Trong phần này chúng ta khảo sát các quy tắc để đặt tên cho các biến,
lớp, các phương thức.. .
Từ định danh là tên chúng ta đặt cho biến, để định nghĩa kiểu sử dụng
như các lớp, cấu trúc, và các thành phần của kiểu này. C# có một số quy tắc để
định rừ cỏc từ định danh như sau:
. Chúng phải bắt đầu bằng ký tự không bị gạch dưới
. Chúng ta không được sử dụng từ khoá làm từ định danh
Trong C# cú sẵn một số từ khoỏ (keyword).
abstract
do
implicit
params
switch
as
double
in
private
this
base
else
int
protected
throw
bool
enum
interface
public
true
break
event
internal
readonly
try
byte
explicit
is
ref
typeof
case
extern
lock
return
uint
catch
false
long
sbyte
ulong
char
finally
namespace
sealed
unchecked
checked
fixed
new
short
unsafe
class
float
null
sizeof
ushort
const
for
object
stackalloc
using
continue
foreach
operator
static
virtual
decimal
goto
out
string
volatile
13
Kho¸ luËn tèt nghiÖp
default
if
override
struct
delegate
void
while
I.3. Hướng đối tượng trong C#
I.3.1. Lớp và thừa kế
Lớp trong C# được định nghĩa với cú pháp sau:
class MyClass
{
private int someField;
public string SomeMethod(bool parameter)
{
}
}
Cỏc lớp bao gồm nhiều thành viờn, mỗi thành viờn là thuật ngữ(term)
dùng để chỉ đến một dữ liệu hay một chức năng nào đó được định nghĩa trong
lớp đó. Ví dụ chúng ta dùng thuật ngữ Function để chỉ những thành viên chứa
mó như các phương thức(methods), các thuộc tính(properties), constructor,
hay các nạp chồng toán hạng(Operator Overloads). Tất cả cỏc lớp trong C# là
những kiểu tham khảo. Tức là khi bạn khai bỏo một kiểu lớp thỡ cú một biến
lưu trữ sự tham khảo đến một thể hiện (instance) của lớp đó. Và sử dụng lệnh
new để tạo ra một đối tượng.
Đơn thừa kế:
C# hỗ trợ đơn thừa kế giữa các lớp. Một lớp có thể thừa hưởng những
thuộc tính và phương thức từ một lớp khác. Cú pháp:
class MyDerivedClass: MyBaseClass
{
// functions and data members here
}
Cỳ phỏp này khỏc với C++ về phạm vi, không có bổ từ truy cập(access
modifier). Tức là C# không hỗ trợ như C++ về các khái niệm thừa kế public
14
Kho¸ luËn tèt nghiÖp
hay private vỡ nú làm ngụn ngữ thờm phức tạp. Trong thực tế thỡ thừa kế
private rất ớt được sử dụng.
Trong C# một lớp bắt buột phải thừa kế từ một lớp nào đó. C# hỗ trợ
một lớp cơ sở toàn diện gọi là System.Object.
Phương thức nạp chồng (Overloading)
C# hỗ trợ phương thức nạp chồng với một vài dạng phương thức khác
nhau về những đặc tính sau: tên, số lượng thông số, và kiểu thông số. Nhưng
nó không hỗ trợ những thông số mặc định như C++ và VB.
Trong C# có một vài điểm khác nhỏ về thông số trong các phương thức
nạp chồng cần biết như sau:
. Nó không chấp nhận hai phương thức chỉ khác nhau về kiểu trả về.
. Nó không chấp nhận hai phương thức chỉ khác nhau về đặc tính của
một thông số đang được khai báo như ref hay out.
Phương thức Overriden và Hide:
Bằng cách khai báo virtual trong một hàm ở lớp cơ sở thỡ cho phộp
hàm đó được overriden trong bất kỳ một lớp thừa hưởng nào. Và khi gọi
phương thức trong một thể hiện của lớp thừa hưởng thỡ phương thức của lớp
thừa hưởng sẽ được thi hành mà không quan tâm đến phương thức đó ở lớp cơ
sở. Khác với C++ và Java, trong C# những hàm không được khai báo virtual
mặc định mà bạn phải khai báo virtual một cỏch rừ ràng và khi một hàm
muốn override một hàm khỏc thỡ phải sử dụng từ khoỏ override.
I.3.2. Gọi các phiên bản cơ sở của các chức năng (base versions of
functions)
Trong C# có một cú pháp đặc biệt để gọi những phiên bản cơ sở của
một phương thức từ một lớp thừa hưởng. Cỳ phỏp: base.<methodname>().
I.3.3. Các lớp và hàm Astract
C# cho phép cả lớp và phương thức có thể khai báo abstract. Một lớp
abstract không được thể hiện và một phương thức abstract không được thực
thi mà phải được overriden trong bất kỳ lớp thừa hưởng không abstract nào.
Một phương thức abstract sẽ tự động được khai báo virtual.
15
Kho¸ luËn tèt nghiÖp
I.3.4. Sealed các lớp và phương thức
C# cho phép các lớp và phương thức được khai báo sealed. Nếu là lớp
có nghĩa là bạn không được quyền thừa kế lớp đó, nếu là phương thức tức là
bạn không được phép override nó.
I.3.5. Những bổ từ truy cập (Aceess Modifiers)
Trong C# cung cấp một số lượng những bổ từ để cho biết sự tồn tại của
một thành viên của một lớp. C# có 5 bổ từ như sau:
Accessibility
Mụ tả
public
Biến và phương thức có thể được truy cập từ bất kỳ nơi đâu.
internal
Biến và phương thức chỉ có thể được truy cập trong cùng một
gói.
protected
Biến hay phương thức chỉ có thể được truy cập từ kiểu của nó
hay từ những kiểu thừa kế kiểu đó.
protected
internal
Biến hay phương thức có thể được truy cập từ gói hiện tại, hay
từ những kiểu thừa kế kiểu hiện tại.
private
Biến hay phương thức chỉ có thể truy cập từ trong kiểu của nó.
I.3.6. Thuộc tính (Properties)
Để định nghĩa thuộc tính trong C# bạn dùng cú pháp sau:
public string SomeProperty
{
get
{
return "This is the property value";
}
set
{
// do whatever needs to be done to set the property
}
}
Khác với VB các thủ tục get và set được định nghĩa như là những hàm
riêng biệt, trong C# chúng được khai báo cùng nhau trong một khai báo thuộc
tính đơn.Trong VB bạn khai báo tường minh tham số cho thủ tục set và có thể
16
Kho¸ luËn tèt nghiÖp
chọn tên của nó, nhưng ngược lại trong C# tham số này hoàn toàn giả lập và
luụn mang tờn là value.
+ Thuộc tính chỉ đọc và chỉ viết
Bạn có thể tạo ra thuộc tính chỉ đọc bằng cách bỏ thủ tục set trong khai
báo và tạo ra thuộc tính chỉ ghi bằng cách bỏ thủ tục get trong khai báo thuộc
tính đó.
+ Bổ từ truy cập
C# không cho phép cài đặt những bổ từ khác nhau cho thủ tục set và
get. Nếu bạn muốn tạo ra một thuộc tính có public để đọc nhưng lại muốn hạn
chế protected trong gán thỡ đầu tiên bạn phải tạo thuộc tính chỉ đọc với bổ từ
public sau đó tạo một hàm set() với bổ từ protected ở bên ngoài thuộc tính đó.
+ Thuộc tính Virtual và Abstract
C# cho phép bạn tạo một thuộc tính virtual hay abstract. Để khai báo
một thuộc tính virtual, overriden hay abstract bạn chỉ cần thêm từ khoá đó
trong lúc định nghĩa thuộc tớnh.
I.3.7. Lớp đối tượng
Trong C#, nếu bạn khụng chỉ rừ rằng một lớp thỡ thừa kế từ một lớp
khỏc thỡ trỡnh biờn dịch sẽ tự động hiểu rằng lớp của bạn thừa kế từ lớp
Object. Đều này có nghĩa là ngoài những thuộc tính và phương thức mà bạn
định nghĩa thỡ bạn cú thể truy cập đến những phương thức protected và public
của lớp Object. Và những phương thức này cũng có trong tất cả lớp mà bạn
định nghĩa.
Một số phương thức được định nghĩa trong lớp Object là:
Phương thức
Bổ từ truy cập
string ToString()
public virtual
Trả về một chuỗi mô tả của
đối tượng
int GetHashTable()
public virtual
Được sử dụng nếu thi hành
từ điển
bool Equals(object obj)
public virtual
So sánh các thực thể của đối
tượng
bool Equals(object objA,
public static
So sánh các thực thể của đối
17
Chức năng
Kho¸ luËn tèt nghiÖp
Phương thức
Bổ từ truy cập
object objB)
Chức năng
tượng
bool ReferenceEquals(object
objA, object objB)
public static
So sánh hai sự tham khảo
đến một đối tượng
Type GetType()
public
Trả về chi tiết kiểu của một
đối tượng.
object MemberwiseClone()
protected
Tạo ra một bản copy của đối
tượng
void Finalize()
protected virtual
Đây là một dạng Destructor
của.Net
I.3.8. Phương thức Tostring()
Tostring() là một cách tiện lợi để lấy một chuỗi mô tả đối tượng
Object.Tostring() được khai báo như virtual. Trong C#, cỏc kiểu dữ liệu
có sẳn đó được override cho chúng ta để trả chuỗi đúng với sự mô tả của các
kiểu đó. Nếu bạn không override phương thức ToString() trong lớp bạn định
nghĩa, thỡ lớp bạn sẽ thừa kế sự thực thi phương thức ToString() của
system.Object và xuất ra tờn lớp của bạn. Nếu bạn muốn phương thức
ToString() trả về một chuỗi chứa nội dung thông tin về giá trị của đối tượng
của lớp bạn tạo ra thỡ bạn phải override phương thức ToString().
18
Kho¸ luËn tèt nghiÖp
CHƯƠNG II
LẬP TRÌNH C# VỚI CSDL
II.1. Tổng quan về ADO.NET
Giống như hầu hết các thành phần của.NET Framework, ADO.NET
không chỉ là vỏ bọc của một vài API sẵn có. Nó chỉ giống ADO ở cái tên - các
lớp và phương thức truy xuất dữ liệu đều khác hoàn toàn.
ADO (Microsoft's ActiveX Data Objects) là một thư viện của cỏc thành
phần COM đó từng được ca ngợi trong một vài năm trở lại đây. Phiên bản
hiện tại là 2.7, các thành phần chủ yếu của ADO là Connection, Command,
Recordset, và các Field object. Một connection có thể mở cơ sở dữ liệu, một
vài dữ liệu được chọn vào một recordset, bao gồm các trường, dữ liệu này sau
đó có thể thao tác, cập nhập lên server, và connection cần phải được đóng lại.
ADO cũng giới thiệu một disconnected recordset, cái được dùng khi không
muốn giữ kết nối trong một thời gian dài.
ADO.NET chứa hai khụng gian tờn cơ sở dữ liệu - một cho SQL
Server, và một cái khác cho các cơ sở dữ liệu được trỡnh bày thụng qua một
giao diện OLE DB. Nếu cơ sở dữ liệu của bạn chọn là một bộ phận của OLE
DB, bạn có thể dễ dàng kết nối với nó từ.NET - chỉ cần dùng các lớp OLE DB
và kết nối thông qua các driver cơ sở dữ liệu hiện hành của bạn.
II.1.1. Cỏc Namespace
Các không gian tên sau chỉ ra các lớp và các giao diện được dùng cho
việc truy xuất dữ liệu trong.NET:
•
System.Data - Cỏc lớp truy xuất dữ liệu chung
•
System.Data.Common - Cỏc lớp dựng chung bởi cỏc data provider
khỏc nhau
•
System.Data.OleDb - Cỏc lớp của OLE DB provider
•
System.Data.SqlClient - Cỏc lớp của SQL Server provider
•
System.Data.SqlTypes - Cac kiểu của SQL Server
Các lớp chính trong ADO.NET được liệt kê dưới đây:
19
Kho¸ luËn tèt nghiÖp
II.1.2. Các lớp dùng chung
ADO.NET chứa một số lớp được dùng không quan tâm là bạn đang
dùng các lớp của SQL Server hay là các lớp của OLE DB.
Các lớp trong không gian tên System.Data được liệt kê sau đây:
•
DataSet - Đối tượng này chứa một bộ các DataTable, cú thể bao gồm
quan hệ giữa các bảng, và nó được thiết kế cho truy xuất dữ liệu
không kết nối.
•
DataTable - Một kho chứa dữ liệu. Một DataTable bao gồm một hoặc
nhiều DataColumns, và khi được tạo ra nó sẽ có một hoặc nhiều
DataRows chứa dữ liệu.
•
DataRow - Một bộ giỏ trị, cú bà con với một dũng trong bảng cơ sở
dữ liệu, hoặc một dũng của bảng tớnh.
•
DataColumn - Chứa các định nghĩa của một cột, chẳng hạn như tên và
kiểu dữ liệu.
•
DataRelation - Một liờn kết giữa hai DataTable trong một DataSet. Sử
dụng cho khúa ngoại và cỏc mối quan hệ chủ tớ.
•
Constraint - Định nghĩa một qui tắc cho một DataColumn (hoặc một bộ
các cột dữ liệu), như các giá trị là độc nhất.
Sau đây là hai lớp được tỡm thấy trong khụng gian tờn
System.Data.Common:
•
DataColumnMapping - Ánh xạ tờn của một cột từ cơ sở dữ liệu vào tên
của một cột trong một DataTable.
•
DataTableMapping - Ánh xạ tên của một bảng từ cơ sở dữ liệu vào một
bảng trong một DataSet.
II.1.3. Các lớp cơ sở chuyên biệt
Bổ sung cho cỏc lớp dựng chung ở trờn, ADO.NET cú một số cỏc lớp
dữ liệu chuyên biệt được đưa ra dưới đây. Các lớp này thực thi một bộ các
giao diện chuẩn được định nghĩa trong không gian tên System.Data, cho phép
sử dụng các lớp có cùng kiểu giao diện. Ví dụ cả hai lớp SqlConnection và
OleDbConnection thực thi giao diện IDbConnection.
20
Kho¸ luËn tèt nghiÖp
•
SqlCommand, OleDbCommand - Một vỏ bọc của cỏc cõu lệnh SQL
hoặc cỏc lời gọi stored procedure.
•
SqlCommandBuilder, OleDbCommandBuilder - Một lớp sử dụng các câu
lệnh SQL (chẳng hạn như các câu lệnh INSERT, UPDATE, và
DELETE) từ một cõu lệnh SELECT.
•
SqlConnection, OleDbConnection - Kết nối với cơ sở dữ liệu. Giống như
một ADO Connection.
•
SqlDataAdapter, OleDbDataAdapter - Một lớp giữ các câu lệnh select,
insert, update, và delete, chúng được sử dụng để tạo một DataSet và
cập nhật Database.
•
SqlDataReader, OleDbDataReader - Chỉ đọc, kết nối với data reader.
•
SqlParameter, OleDbParameter - Định nghĩa một tham số cho một stored
procedure.
•
SqlTransaction, OleDbTransaction - Một giao tiếp cơ sở dữ liệu, được
bọc trong một đối tượng.
Một đặc tính quan trọng của các lớp ADO.NET là chúng được thiết kế
để làm việc trong môi trường không kết nối, đóng một vai trũ quan trọng
trong thế giới "web-centric". Nú hiện được dùng để kiến trúc một server
(chẳng hạn như mua sách qua mạng) để kết nối một server, lấy một vài dữ
liệu, và làm việc trên những dữ liệu này trên PC khách trước khi kết nối lại và
truyền dữ liệu trở lại để xử lí.
II.2. Sử dụng các Database Connection
Trong trỡnh tự truy xuất cơ sở dữ liệu, bạn cần cung cấp các thông số
kết nối, chẳng hạn như thiết bị mà cơ sở dữ liệu đang chạy, và khả năng đăng
nhập của bạn. Bất kỡ ai đó từng làm việc với ADO sẽ dễ dàng quen với cỏc
lớp kết nối của.NET, OleDbConnection và SqlConnection:
21
Kho¸ luËn tèt nghiÖp
Đoạn mó sau đây mô tả cách để tạo, mở và đóng một kết nối đến cơ sở
dữ liệu Northwind. Các ví dụ trong chương này chúng ta dùng cơ sở dữ liệu
Northwind, được cài đặt chung với các ví dụ của.NET Framework SDK:
using System.Data.SqlClient;
string source = "server=(local)\\NetSDK;" +
"uid=QSUser;pwd=QSPassword;" +
"database=Northwind";
SqlConnection conn = new SqlConnection(source);
conn.Open();
// Do something useful
conn.Close();
Chuỗi kết nối sẽ trở nên thân thiện nếu bạn đó từng dựng ADO hay
OLE DB trước đây - thật vậy, bạn cú thể cắt và dỏn từ mó cũ của bạn, nếu bạn
dựng OleDb provider.
•
server=(local)\\NetSDK - Nó biểu diễn database server được kết nối.
SQL Server cho phép một số các tiến trỡnh database server
processes khỏc nhau chạy trờn cựng một mỏy, vỡ vậy ở đây chỳng ta
thực hiện kết nối với tiến trỡnh NetSDK trờn mỏy cụ bộ.
•
uid=QSUser - Tham số này mô tả người dùng cơ sở dữ liệu. Bạn cũng
có thể sử dụng User ID.
•
pwd=QSPassword - và đây là password cho người dùng đó. NET SDK
là một bộ các cơ sở dữ liệu giống nhau, và user/password này được
liên kết và được thêm vào trong quá trỡnh cài đặt các ví dụ.NET.
Bạn cũng có thể dùng Password.
•
database=Northwind - Cái này mô tả loại dữ liệu để kết nối - mỗi tiến
trỡnh SQL Server cú thể đưa ra một vài loại dữ liệu khác nhau.
Vỡ trờn mở một kết nối cơ sở dữ liệu dùng chuỗi kết nối đó được
định nghĩa, sau đó đóng kết nối lại. Khi kết nối đó được mở, bạn có thể
phát các lệnh để thao tác trên cơ sở dữ liệu, và khi hoàn tất, kết nối có thể
được đóng lại.
22
Kho¸ luËn tèt nghiÖp
SQL Server có một chế độ bảo mật khác - nó có thể dùng chế độ bảo
mật của Windows, vỡ thế cỏc khả năng truy cập của Windows có thể truyền
cho SQL Server. Với lựa chọn này bạn có thể bỏ đi các vị trí uid và pwd trong
chuỗi kết nối, và thêm vào Integrated Security=SSPI.
Sử dụng hiệu quả các Connection
Một cách tổng quát, khi sử dụng các tài nguyên "hiếm" trong.NET,
chẳng hạn như các kết nối cơ sở dữ liệu, các cửa sổ, hoặc các đối tượng đồ
họa, tốt hơn hết bạn nên đảm bảo rằng các tài nguyên này luôn phải được
đóng lại sau khi đó sử dụng xong. Dù vậy các nhà thiết kế của.NET có thể làm
điều này nhờ trỡnh thu gom rỏc, nú luụn làm sau bộ nhớ sau một khoảng thời
gian nào đó, tuy nhiên nó nên được giải phóng càng sớm càng tốt.
Rừ ràng là khi viết mó truy xuất một cơ sở dữ liệu, việc giữ một kết nối
càng ít thời gian càng tốt để không làm ảnh hưởng đến các phần khác. Trong
nhiều tỡnh huống tiờu cực, nếu khụng đóng một kết nối có thể khoá không
cho các người dùng khác truy nhập vào các bảng dữ liệu đó, một tác hại to lớn
đối với khả năng thực thi của ứng dụng. Việc đóng một kết nối cơ sở dữ liệu
có thể coi là bắt buộc, vỡ thế ứng dụng này chỉ ra cỏch cấu trỳc mó của bạn để
giảm thiểu các rủi ro cho một mó nguồn mở.
Có hai cách để đảm bảo rằng các kết nối cơ sở dữ liệu được giải phóng
sau khi dùng.
Cách 1: Tựy chọn một - try/catch/finally
Tùy chọn thứ nhất để đảm bảo rằng các tài nguyên được dọn sạch là sử
dụng các khối lệnh try…catch…finally, và đảm bảo rằng bạn đó đóng các kết
nối trong khối lệnh finally. Đây là một ví dụ nhỏ:
try
{
// Open the connection
conn.Open();
// Do something useful
}
catch (Exception ex)
{
23
Kho¸ luËn tèt nghiÖp
// Do something about the exception
}
finally
{
// Ensure that the connection is freed
conn.Close () ;
}
Với khối kết nối bạn cú thể giải phúng bất kỡ tài nguyờn nào mà bạn đó
dựng. Vấn đề duy nhất trong phương thức này là bạn phải bảo đảm rằng bạn
có đóng các kết nối - rất là dễ quên việc thêm vào khối finally, vỡ vậy một
phong cỏch lập trỡnh tốt rất quan trọng.
Ngoài ra, bạn có thể mở một số tài nguyên (chẳng hạn hai kết nối cơ sở
dữ liệu và một file) trong một phương thức, vỡ vậy đôi khi các khối try…
catch…finally trở nên khó đọc. Có một cách khác để đảm bảo rằng các tài
nguyên được dọn dẹp - sử dụng câu lệnh.
Cách 2: Tựy chọn hai - Sử dụng khối cõu lệnh
Trong lúc phát triển C#, phương thức.NET's dọn dẹp các đối tượng khi
chúng không cũn được tham chiếu nữa sử dụng các huỷ tử bất định trở thành
một vấn đề nóng hổi. Trong C++, ngay khi một đối tượng rời khỏi tầm vực,
khối huỷ tử của nó sẽ tự động được gọi. Nó là một điều rất mới cho các nhà
thiết kế các lớp sử dụng tài nguyên, khi một huỷ tử được sử dụng để đóng các
tài nguyên nếu các người dùng quên làm điều đó. Một huỷ tử C++ được gọi
bất kỡ khi nào một đối tượng vượt quá tầm vực của nó - vỡ vậy khi một ngoại
lệ được phát ra mà không được chặn, tất cả các hủy tử cần phải được gọi.
Với C# và các ngôn ngữ có quản khác, tất cả đều tự động, các khối huỷ
tử định trước được thay thế bởi trỡnh thu gom rỏc, cỏi được dùng để tháo các
tài nguyên tại một thời điểm trong tương lai. Chúng mang tính bất định, nghĩa
là bạn sẽ không biết trước được khi nào thỡ việc đó sẽ xảy ra. Nếu quên không
đóng một kết nối cơ sở dữ liệu có thể là nguyên nhân gây ra lỗi khi chạy
trong.NET. Mó sau đây sẽ giải thích cách để sử dụng giao diện IDisposable để
giải phóng tài nguyên khi thoát khỏi khối using.
24
Kho¸ luËn tèt nghiÖp
string source = "server=(local)\\NetSDK;" +
"uid=QSUser;pwd=QSPassword;" +
"database=Northwind";
using (SqlConnection conn = new SqlConnection (source))
{
// Open the connection
conn.Open () ;
// Do something useful
}
Mệnh đề using đó được giới thiệu trong chương I. Đối tượng trong
mệnh đề using phải thực thi giao diện IDisposable, nếu khụng một sẽ tạo ra
một lỗi biên dịch. Phương thức Dispose() sẽ tự động được gọi trong khi thoát
khỏi khối using.
Khi xem mó IL của phương thức Dispose() của SqlConnection (và
OleDbConnection), cả hai đều kiểm tra trạng thái của đối tượng kết nối, và
nếu nó đang mở phương thức Close() sẽ được gọi.
Khi lập trỡnh bạn nờn dựng cả hai tựy chọn trờn. Ở những chỗ bạn cần
các tài nguyên tốt nhất là sử dụng mệnh đề using(), dù vậy bạn cũng có thể sử
dụng câu lệnh Close(), nếu quên không sử dụng thỡ khối lệnh using sẽ đóng
lại giúp bạn. Không gỡ cú thể thay thế được mọt bẫy ngoại lệ tốt, vỡ thế tốt
nhất bạn dựng trộn lẫn hai phương thức như ví dụ sau:
try
{
using (SqlConnection conn = new SqlConnection (source))
{
// Open the connection
conn.Open () ;
// Do something useful
// Close it myself
conn.Close () ;
}
}
catch (Exception e)
25
