Giáo trình Lập trình Windows Forms với C#.NET (Phần 1)
BỘ GIÁO DỤC VÀ ĐÀO TẠO
TRƯỜNG ĐẠI HỌC LẠC HỒNG
GIÁO TRÌNH
LẬP TRÌNH WINDOWS FORMS VỚI C#
LỜI NÓI ĐẦU
Giáo trình Lập trình Windows Forms với C#.NET sử dụng cho sinh viên ngành
Công nghệ thông tin. Giáo trình giúp sinh viên có cái nhìn tổng quan về ứng dụng
Windows Application trong bộ công cụ Visual Studio .NET của Microsoft. Ngoài ra
giáo trình còn cung cấp những kiến thức về các điều khiển mà Windows Application
hỗ trợ, đi kèm đó là các ví dụ đơn giản được mô tả cụ thể để sinh viên có thể đọc và
hiểu một cách nhanh chóng nhất.
Nội dung của giáo trình gồm 11 chương.
Chương 1: Giới thiệu tổng quan về ngôn ngữ C#, Cấu trúc của một chương
trình C#, các kiểu dữ liệu cơ bản, cấu trúc lặp và cấu trúc rẽ nhánh, lớp String và cách
tạo thư viện DLL.
Chương 2: Giới thiệu về ứng dụng Windows Form, tạo form với hình dạng
khác nhau, các sự kiện và phương thức của form.
Chương 3: Giới thiệu về cách sử dụng của các điều khiển thông thường như:
Label, Button, Textbox, ComboBox, ListBox, CheckBox và RadioButton.
Chương 4: Giới thiệu về cách sử dụng các điều khiển đặc biệt như: Tooltip,
HelpProvider, ErrorProvider, ProgressBar, Timer, ListView, TreeView,
DateTimePicker và MonthlyCalendar.
Chương 5: Giới thiệu về cách sử dụng của các điều khiển tạo Menu như:
MenuStrip, ContextMenuStrip. Cách sử dụng các điều khiển: ImageList, NotifyIcon,
ToolStrip, StatusStrip.
Chương 6: Giới thiệu về các điều khiển có thể chứa điều khiển khác như: Panel,
GroupBox, FlowLayoutPanel, TableLayoutPanel, TabControl, SplitContainer.
Chương 7: Giới thiệu về các sử dụng của các điểu khiển dạng hộp thoại:
MessageBox,
ColorDialog,
FontDialog,
OpenFileDialog,
SaveFileDialog,
FolderBrowseDialog.
Chương 8: Giới thiệu về các điều khiển làm việc với in ấn:PageSetupDialog,
PrintPreviewDialog, PrintPreviewControl, PrintDialog, PrintDocument.
Chương 9: Giới thiệu về cách xây dựng và sử dụng UserControl.
Chương 10: Giới thiệu về các lớp đối tượng làm việc với màn hình và hệ thống
như: Lớp SystemInformation, lớp Screen, lớp Sendkeys, lớp PowerStatus, Lớp
Application, lớp Clipboard, lớp Cursor.
Chương 11: Bài tập tổng hợp kiến thức.
MỤC LỤC
Lời nói đầu
Chương 1: Giới thiệu về C# ............................................................................................1
1.1. Giới thiệu về Microsoft .NET Framework .............................................................1
1.1.1. .NET Framwork là gì .....................................................................................1
1.1.2. Các thành phần của Microsoft .NET Framework ..........................................1
1.2. Tổng quan ...............................................................................................................2
1.3. Cấu trúc tổng quát của một chương trình C#..........................................................4
1.3.1. Soạn thào bằng Notepad ................................................................................4
1.3.2. Soạn thảo bằng Microsoft Visual Studio 2010 ..............................................5
1.4. Biến và kiểu dữ liệu................................................................................................8
1.4.1. Biến ................................................................................................................8
1.4.2. Kiểu dữ liệu....................................................................................................9
1.4.2.1. Kiếu giá trị ........................................................................................9
1.4.2.2. Kiểu tham chiếu ..............................................................................10
1.4.2.3. So sánh sự khác biệt giữa kiểu giá trị và kiểu tham chiếu..............11
1.4.2.4. Chuyển kiểu dữ liệu........................................................................11
1.5. Câu lệnh phân nhánh.............................................................................................13
1.5.1. Câu lệnh if....................................................................................................13
1.5.2. Câu lệnh switch............................................................................................13
1.6. Câu lệnh lặp ..........................................................................................................14
1.6.1. Lệnh lặp while..............................................................................................14
1.6.2. Lệnh lặp do/ while........................................................................................15
1.6.3. Lệnh lặp for..................................................................................................15
1.6.4. Lệnh lặp foreach...........................................................................................16
1.7. Lớp String .............................................................................................................17
1.7.1. Giới thiệu về chuỗi ký tự .............................................................................17
1.7.2. Phương thức và thuộc tính lớp String ..........................................................18
1.8. Mảng .....................................................................................................................31
1.8.1. Mảng một chiều ...........................................................................................31
1.8.2. Mảng hai chiều ............................................................................................32
1.9. Tạo và sử dụng DLL trong C# ...........................................................................33
1.9.1. Ưu điểm và nhược điểm khi sử dụng DLL..................................................33
1.9.2. Các bước để tạo tập tin DLL........................................................................34
1.9.3. Các bước để sử dụng tập tin DLL................................................................36
1.10. Bài tập cuối chương............................................................................................39
Chương 2: Giới thiệu về Windows Forms ....................................................................40
2.1. Giới thiệu ..............................................................................................................40
2.1.1. Ứng dụng Windows Forms..........................................................................40
2.1.2. Không gian tên (namespace)........................................................................44
2.1.3. Thanh công cụ (Toolbox).............................................................................46
2.1.4. Định dạng mã C# .........................................................................................48
2.2. Các loại Form........................................................................................................48
2.2.1. Thuộc tính Form...........................................................................................48
2.2.2. Các loại Form...............................................................................................53
2.2.3. Các hình dạng của Form ..............................................................................55
2.2.4. Biến cố của Form .........................................................................................57
2.2.5. Phương thức .................................................................................................60
2.3. Bài tập cuối chương..............................................................................................64
Chương 3: Các điều khiển thông thường ......................................................................65
3.1. Điều khiển Label...................................................................................................66
3.2. Điều khiển Button.................................................................................................70
3.3. Điều khiển TextBox..............................................................................................73
3.4. Điều khiển ComboBox và ListBox.......................................................................77
3.4.1. ListBox.........................................................................................................78
3.4.2. ComboBox ...................................................................................................82
3.4.3. Phương thức và sự kiện của ComboBox và ListBox...................................85
3.5. Điều khiển CheckBox và RadioButton.................................................................89
3.5.1. CheckBox.....................................................................................................89
3.5.2. RadioButton .................................................................................................93
3.6. Bài tập cuối chương..............................................................................................97
Chương 4: Các điều khiển đặc biệt .............................................................................102
4.1. Điều khiển Tooltip, HelpProvider, ErrorProvider ..............................................103
4.1.1. Điều khiển Tooltip .....................................................................................103
4.1.2. Điều khiển HelpProvider ...........................................................................107
4.1.3. Điều khiển ErrorProvider...........................................................................110
4.2. Điều khiển ProgressBar và Timer.......................................................................115
4.2.1. Điều khiển ProgressBar .............................................................................115
4.2.2. Điều khiển Timer .......................................................................................116
4.3. Điều khiển ListView...........................................................................................120
4.4. Điều khiển TreeView..........................................................................................130
4.5. Điều khiển DateTimePicker, MonthCalendar ....................................................136
4.5.1. Điều khiển DateTimePicker.......................................................................136
4.5.2. Điều khiển MonthCalendar........................................................................138
4.6. Bài tập cuối chương............................................................................................142
Chương 5: Điều khiển dùng để xây dựng Menu .........................................................146
5.1. Điều khiển ImageList..........................................................................................146
5.2. Điều khiển MenuStrip.........................................................................................149
5.3. Điều khiển ContextMenuStrip............................................................................159
5.4. Điều khiển NotifyIcon ........................................................................................164
5.5. Điều khiển ToolStrip ..........................................................................................167
5.5.1. Điều khiển chứa trong ToolStrip ...............................................................170
5.5.2. ToolStripContainer.....................................................................................172
5.6. Điều khiển StatusStrip ........................................................................................178
5.7. Bài tập cuối chương............................................................................................180
Chương 6: Điều khiển chứa các điều khiển khác........................................................185
6.1. Điều khiển GroupBox.........................................................................................185
6.2. Điều khiển Panel.................................................................................................190
6.3. Điều khiển FlowLayoutPanel .............................................................................191
6.4. Điều khiển TableLayoutPanel ............................................................................197
6.5. Điều khiển TabControl .......................................................................................200
6.6. Điều khiển SplitContainer ..................................................................................211
6.7. Bài tập cuối chương ...........................................................................................218
Chương 7: Điều khiển Dialog và phương thức Message ............................................222
7.1. Lớp MessageBox ................................................................................................223
7.2. Điều khiển ColorDialog......................................................................................228
7.3. Điều khiển FontDialog........................................................................................231
7.4. Điều khiển OpenFileDialog................................................................................234
7.5. Điều khiển SaveFileDialog.................................................................................238
7.6. Điều khiển FolderBrowserDialog.......................................................................243
7.7. Bài tập cuối chương............................................................................................248
Chương 8: Làm việc với điều khiển in ấn ...................................................................253
8.1. Điều khiển PageSetupDialog..............................................................................254
8.2. Điều khiển PrintPreviewDialog..........................................................................258
8.3. Điều khiển PrintPreviewControl.........................................................................261
8.4. Điều khiển PrintDialog .......................................................................................266
8.5. Điều khiển PrintDocument .................................................................................273
Chương 9: Điều khiển người dùng tự tạo
9.1. User Control........................................................................................................280
9.2. Xây dựng User Control.......................................................................................280
9.2.1. Thêm mới User Control ngay trong dự án.................................................280
9.2.2. Tạo lớp và khai báo thừa kế từ lớp Control ...............................................285
9.2.3. Tạo dự án mới bằng cách chọn loại dự án là Windows Control Library...288
9.3. Sử dụng User Control .........................................................................................291
9.4. Cách sử dụng những thư viện tạo sẵn để thiết kế giao diện ...............................294
9.5. Bài tập cuối chương............................................................................................294
Chương 10: Làm việc với màn hình và hệ thống........................................................298
10.1. Lớp SystemInformation......................................................................................298
10.2. Lớp Screen..........................................................................................................301
10.3. Lớp SendKeys.....................................................................................................304
10.4. Lớp PowerStatus.................................................................................................309
10.5. Lớp Application..................................................................................................310
10.6. Lớp Clipboard.....................................................................................................312
10.7. Lớp Cursors ........................................................................................................316
Chương 11: Bài tập tổng hợp ......................................................................................318
Tài liệu tham khảo.......................................................................................................325
CHƢƠNG 1: GIỚI THIỆU VỀ C#
1.1. Giới thiệu về Microsoft .NET Framework
1.1.1. .NET Framework là gì ?
.NET Framework là nền tảng phát triển hoàn hảo của Microsoft, cung cấp cho lập
trình viên các thư viện dùng chung hỗ trợ cho việc phát triển các kiểu ứng dụng khác
nhau bao gồm:
Ứng dụng ASP.NET
Ứng dụng Windows Form
Web Services
Windows Services
Ứng dụng mạng và các ứng dụng điều khiển truy cập từ xa
1.1.2. Các thành phần của Microsoft .NET Framework
.NET Framework gồm hai thành phần chính là: Common Language Runtime
(CLR) và thư viện lớp.
CLR: là nền tảng của .NET Framework, giúp Microsoft có thể tích hợp nhiều
ngôn ngữ lập trình khác nhau như: VB.NET, C#.NET, ASP.NET,… vào bộ công
cụ lập trình Visual Studio.NET. Đồng thời giúp các ứng dụng viết trên các ngôn
ngữ này có thể chạy được chung trên nền tảng hệ điều hành Windows. Sở dĩ
Microsoft có thể làm được điều này, bởi vì các ngôn ngữ lập trình đều được biên
dịch ra một ngôn ngữ trung gian (Intermediate Language – IL) và sử dụng chung
kiểu dữ liệu hệ thống (Common Type System). Sau đó CLR sử dụng một trình
biên dịch gọi là Just-in-Time (JIT) Compiler chuyển các đoạn mã IL thành mã
máy và thực thi.
Ngoài ra CLR còn làm các thành phần khác như:
- Garbage Collection (GC): Gọi là bộ phận thu gom rác; có chức năng tự
động quản lí bộ nhớ. Tại một thời điểm nhất được định sẵn, GC sẽ tiến
hành thực hiện việc thu hồi những vùng nhớ không còn được sử dụng.
- Code Access Security (CAS): Cung cấp quyền hạn cho các chương trình,
tùy thuộc vào các thiết lập bảo mật của máy. Chẳng hạn, thiết lập bảo mật
của máy cho phép chương trình chạy trên đó được sửa hay tạo file mới,
nhưng không cho phép nó xóa file. CAS sẽ chăm sóc các đoạn mã, không
cho phép chúng làm trái với các qui định này.
- Code Verification: Bộ phận chứng nhận đoạn mã. Bộ phận này đảm bảo
cho việc chạy các đoạn mã là đúng đắn, và đảm bảo an toàn kiểu dữ liệu.
1
ngăn chặn các đoạn mã hoạt động vượt quyền như truy nhập vào các vùng
nhớ không được phép.
Thư viện lớp: là một tập hợp lớn các lớp được viết bởi Microsoft, những lớp này
được xây dựng một cách trực quan và dễ sử dụng; cho phép lập trình viên thao
tác rất nhiều các tác vụ sẵn có trong Windows.
- Base class library: Đây là thư viện các lớp cơ bản nhất, được dùng trong
khi lập trình hay bản thân những người xây dựng .NET Framework cũng
phải dùng nó để xây dựng các lớp cao hơn. Một số thư viện lớp base class
library như: String, Interger, Exception, …
- ADO.NET và XML: Bộ thư viện này gồm các lớp dùng để xử lý dữ
liệu. ADO.NET thay thế ADO để trong việc thao tác với các dữ liệu thông
thường. Các lớp đối tượng XML được cung cấp để xử lý các dữ liệu theo
định dạng mới XML. Một số thư viện trong ADO.NET và XML như:
sqlDataAdapter, SqlCommand, DataSet, …
- Windows Forms: Bộ thư viện về lập trình Windows Forms gồm các lớp
đối tượng dành cho việc xây dựng các ứng dụng Windows cơ bản. Một số
thư viện thường dùng như: Form, UserControl, TextBox, Label, Button,
ComboBox, ListBox, ListView, TreeView, …
- Web Services: là các dịch vụ được cung cấp qua Web (hay Internet). Dịch
vụ được coi là Web Service không nhắm vào người dùng mà nhằm vào
người xây dựng phần mềm. Web Services có thể dùng để cung cấp các dữ
liệu hay một chức năng tính toán.
- ASP.NET: Ứng dụng Web xây dựng bằng ASP.NET tận dụng được toàn
bộ khả năng của .NET Framework. ASP.Net cung cấp một bộ các Server
Control để lập trình viên bắt sự kiện và xử lý dữ liệu của ứng dụng như
đang làm việc với ứng dụng của Windows. Một số thư như:
WebControl, HTML Control, …
1.2. Tổng quan về C#
Vào ngày 12/2/2002, Microsoft chính thức cho ra mắt Visual Studio 2002 cùng
với bản .NET Framework 1.0. Với nền tảng .NET Framework thì các ứng dụng về
Windows Form, web, … đều có thể được xây dựng trên nền tảng .NET. Hai ngôn ngữ
chính mà Microsoft sử dụng để phát triển các ứng dụng trên là C# và Visual
Basic.NET.
C# được phát triển bởi đội ngũ kỹ sư của Microsoft, trong đó hai người dẫn đầu
là Anders Hejlsberg và Scott Wiltamult. Vì là ngôn ngữ ra đời sau các ngôn ngữ khác
2
như: Java, C, C++, Perl, Visual Basic, … do đó C# có những đặc điểm nổi trội và
mạnh mẽ hơn nhưng không kém phần đơn giản.
Các đặc điểm của C#:
Microsoft thêm vào những đặc điểm mới vào để C# dễ sử dụng hơn:
- C# là ngôn ngữ đơn giản: Các cú pháp, biểu thức, toán tử đều giống với C,
C++. Ngoài ra C# loại bỏ một số khái niệm phức tạp khó hiểu như: Con trỏ,
Macro, đa kế thừa, template, lớp cơ sở ảo.
- C# là ngôn ngữ hiện đại: Có tất cả các đặc tính của một ngôn ngữ hiện đại
như: xử lý ngoại lệ, thu gom bộ nhớ tự động, kiểu dữ liệu mở rộng, và bảo
mật mã nguồn.
- C# là ngôn ngữ hướng đối tượng: Là một ngôn ngữ thuần hướng đối tượng,
do đó chứa tất cả các đặc điểm để có thể lập trình theo hướng đối tượng: Sự
đóng gói (Encapsulation), sự thừa kế (Inheritance), và sự đa hình
(Polymorphism).
- C# là ngôn ngữ mạnh mẽ và mềm dẻo: Có thể sử dụng cho những dự án khác
nhau như: xử lý văn bản, ứng dụng đồ họa, bảng tính, …
- C# là ngôn ngữ có ít từ khóa: là ngôn ngữ sử dụng giới hạn các từ khóa, chỉ
khoảng 80 từ khóa và hơn 10 kiểu dữ liệu được xây dựng sẵn như bảng 1.1.
Bảng 1.1: Bảng mô tả các từ khóa của C#
abstract
default
delegate
do
foreach
goto
if
object
operator
out
sizeof
stackalloc
static
string
struct
switch
this
unsafe
ushort
using
as
base
bool
double
else
implicit
in
override
params
private
protected
public
readonly
ref
virtual
volatile
void
break
byte
enum
event
explicit
extern
false
int
case
interface
internal
is
while
catch
char
throw
true
decimal
for
checked
class
const
lock
try
null
finally
fixed
long
return
typeof
uint
short
namespace sbyte
unchecked
3
continue float
new
sealed
ulong
1.3. Cấu trúc tổng quát của một chƣơng trình C#
Các đoạn mã C# có thể được soạn thảo trong một trình soạn thảo văn bản bất kỳ,
sau khi biên soạn xong cần lưu tập tin với đuôi .cs
1.3.1. Soạn thảo bằng Notepad
Trong quá trình soạn thảo cần lưu ý C# là một ngôn ngữ thuần hướng đối tượng.
Do đó tất cả đoạn mã của chương trình đều phải thuộc lớp.
Ví dụ 1.1: Soạn thảo một chương trình C# in dòng chữ Hello World ra màn hình
Bước 1:
Giải thích:
- Ở đoạn chương trình trên, hàm Main được khai báo là static. Việc khai báo
này cho biết hàm Main có thể được sử dụng mà không cần thông qua đối
tượng
- Hàm WriteLine nằm trong lớp Console, do đó nếu sử dụng phải khai báo
thêm dòng lệnh “Using System;” phía trên cùng để việc gõ lệnh được nhanh
chóng hơn như sau: “Console.WriteLine()”. Nếu không khai báo “Using
System;” thì buộc phải viết đầy đủ cú pháp: “System.Console.WriteLine()”,
với System là một namespace.
- C# phân biệt chữ thường và chữ hoa, do đó lệnh writeline khác lệnh
WriteLine.
Bước 2: Khi soạn thảo xong. Lưu tập tin với tên: ChaoMung.cs
Bước 3: Thực thi chương trình phải thực hiện hai bước:
- Mở cửa sổ Command Line và biên dịch tập tin ChaoMung.cs vừa tạo ra
sang mã máy (tạo ra file có đuôi .exe) như hình 1.1: Để biên dịch dùng trình
biên dịch dòng lệnh C# (csc.exe) chương trình này được chép vào máy
4
trong quá trình cài .NET Framework. Nếu cài Framwork 4.0 thì tiến hành
vào đường dẫn:
C:\Windows\Microsoft.NET\Framework\v4.0.30319\csc.exe
Hình 1.1: Biên dịch tập tin hello.cs
- Thực thi tập tin có đuôi .exe như hình 1.2:
Hình 1.2: Thực thi tập tin Hello.exe
1.3.2. Soạn thảo bằng Microsoft Visual Studio 2010
Bước 1: Mở Microsoft Visual Studio 2010 và tạo 1 dự án mới như hình 1.3
5
Bước 1: Chọn thực
Bước 2: Chọn mục
đơn File > New
Project
Hình 1.3: Tạo dự án mới
Bước 2: Tạo một loại dự án đơn giản là Console Application để minh họa bằng
ngôn ngữ C# và đặt tên Baitap lưu ở ổ đĩa D như hình 1.4
Bước 1: Chọn loại
dự án. Nếu lập trình
môi trường Console
thì chọn loại dự án
là Console
Application. Nếu
lập trình môi trường
Windows Forms thì
chọn Windows
Forms Application
Hình 1.4: Tạo loại dự án và đặt tên cho dự án
Bước 3: Soạn thảo mã C# trong trình biên dịch như hình 1.5
6
Hình 1.5: Giao diện soạn thảo mã lệnh
Bước 4: Biên dịch chương trình: trên thanh menu chọn Build > Build Solution
như hình 1.6 hoặc ấn tổ hợp phím Ctrl + Shift + B.
Hình 1.6: Biên dịch chương trình
Bước 5: Thực thi chương trình: trên thanh menu chọn Debug > Start Debugging
như hình 1.7 hoặc phím F5.
7
Hình 1.7: Thực thi chương trình
1.4. Biến và Kiểu dữ liệu
1.4.1. Biến
Biến là nơi lưu trữ dữ liệu của chương trình. Dữ liệu của biến nằm trong bộ nhớ
vật lý của Ram và có thể thay đổi được. Muốn sử dụng biến trước tiên lập trình phải
chỉ định biến có một kiểu dữ liệu cụ thể nào đó.
Cú pháp khai báo biến:
<Kiểu dữ liệu> <Tên biến>
Lưu ý: Tên biến phải được đặt phù hợp với quy tắc đặt tên
Cú pháp khởi tạo giá trị cho biến:
<Tên biến> = <giá trị>
Trong đó:
= là phép toán gán giá trị
Quy tắc đặt tên: Các tên biến, tên hằng, tên hàm, … trong C# đề phải đặt tên đúng
với quy tắc sau:
Một tên biến có thể bắt đầu bằng chữ hoa hay chữ thường. Tên có thể chứa ký tự
hay số và ký tự gạch dưới (_).
Ký tự đầu tiên của biến phải là ký tự , không được là số.
Trong C# phân biệt hoa thường.
8
Các từ khóa không thể sử dụng để đặt tên cho biến. Nếu muốn dùng từ khóa đặt
tên thì ta thêm ký tự @ phía trước.
Ví dụ 1.2:
Employee:
student:
Hợp lệ
Hợp lệ
_Name:
Hợp lệ
Emp_Name:
@goto:
Hợp lệ
Hợp lệ
static:
Không hợp lệ, trùng từ khóa
4myclass:
Student&Falculty:
Không hợp lệ, không thể bắt đầu bằng ký tự số
Không hợp lệ, không được chứa ký tự đặc biệt
1.4.2. Kiểu dữ liệu
Cũng như ngôn ngữ lập trình C++ hay Java, C# chia thành hai tập kiểu dữ liệu
chính:
Kiểu giá trị
Kiểu tham chiếu
Mọi kiểu dữ liệu trong C# sẽ thuộc một trong hai kiểu giá trị hoặc kiểu tham
chiếu. Kiểu giá trị thì lưu trong stack, còn kiểu tham chiếu lưu trong heap.
Stack: một vùng bộ nhớ dành lưu trữ dữ liệu với chiều dài cố định.
Ví dụ 1.3: số nguyên kiểu int luôn chiếm dụng 4 bytes.
Mỗi chương trình khi thực thi đều được cấp riêng 1 stack mà các chương trình khác
không truy cập tới được
Heap: một vùng bộ nhớ dùng lưu trữ dữ liệu có dung lượng thay đổi.
Ví dụ 1.4: như kiểu string, khi ta tạo đối tượng thuộc lớp string, thì đối tượng sẽ được
xác định bởi hai thành phần: Địa chị đối tượng lưu ở stack, còn giá trị đối tượng thì sẽ
lưu ở heap.
1.4.2.1. Kiểu giá trị
Kiểu giá trị thường là các kiểu do C# định nghĩa sẵn bao gồm: double, char, int,
float, enum, struct, ….
Biến của kiểu giá trị lưu trữ một giá trị thực, giá trị này được lưu trữ trong
stack, không thể mang giá trị null và phải chứa giá trị xác định.
Bảng 1.2: Bảng mô tả các kiểu dữ liệu giá trị trong C#
Kiểu C#
byte
char
bool
sbyte
short
Số Byte
Kiểu .NET
Byte
Char
Boolean
Sbyte
Int16
Mô tả
1
2
1
1
2
Số nguyên dương không dấu: 0 đến 255
Ký tự Unicode
Giá trị logic true/ false
Số nguyên có dấu: -128 đến 127
Số nguyên có dấu: -32.768 đến 32.767
9
ushort
int
2
4
Uint16
Int32
Số nguyên không dấu: 0 đến 65.535
Số nguyên có dấu: -2.147.483.647 đến
2.147.483.647
uint
4
4
Uint32
Single
Số nguyên không dấu: 0 đến
4.294.967.295
Kiểu dấu chấm động, giá trị xấp xỉ từ
3,4E-38 đến 3,4E+38; với 7 chữ số có
nghĩa
float
double
8
8
Double
Kiểu dấu chấm động, giá trị xấp xỉ từ
1,7E-308 đến 1,7E+308; với 15, 16 chữ
số có nghĩa
Có độ chính xác đến 28 con số và giá trị
thập phân, được dùng trong tính toán tài
chính, kiểu này đòi hỏi phải có hậu tố
“m” hay “M” theo sau giá trị
Kiểu số nguyên có dấu có giá trị trong
khoảng:
-9.233.370.036.854.775.808 đến -
9.233.372.036.854.775.807
Số nguyên không dấu từ 0 đến
0xfffffffffffffff
decimal
Decimal
long
8
8
Int64
ulong
Uint64
Lưu ý:
Kiểu số thực: Trình biên dịch luôn hiểu bất cứ một số thực nào cũng là một số kiểu
double trừ khi khai báo rõ ràng, do đó để gán một số kiểu float thì số phải có ký tự f
theo sau.
ví dụ 1.5: float a=0.15f;
Kiểu giá trị bool trong C# nhất thiết phải là true hoặc false.
1.4.2.2. Kiểu tham chiếu
Biến có kiểu dữ liệu tham chiếu lưu trữ địa chỉ của biến khác trên bộ nhớ heap.
Như vậy các lớp đối tượng String, Object, … đều được hiểu như kiểu dữ liệu tham
chiếu. Ngoài ra các kiểu dữ liệu do người dùng xây dựng nên cũng được gọi là kiểu
tham chiếu.
Ví dụ 1.6:
string str = “A”;
Stack
@
Heap
“A”
Địa chỉ biến str
Giá trị của biến
10
1.4.2.3. Bảng so sánh sự khác biệt giữa kiểu giá trị và kiểu tham
chiếu
Bảng 1.3: Bảng so sánh sự khác biệt giữa kiểu giá trị và kiểu tham
chiếu
Kiểu giá trị
Giá trị của biến
Kiểu tham chiếu
Địa chỉ của biến
Biến lưu trữ
Vị trí lưu trữ giá trị
Stack
Heap
Giá trị mặc định
0
Null
Phép toán gán
Sao chép giá trị
Sao chép địa chỉ
1.4.2.4. Chuyển kiểu dữ liệu
Việc chuyển đổi kiểu dữ liệu trong C# có thể thực hiện bằng một trong các cách
sau:
Sử dụng lớp Convert:
Đây là một lớp được C# xây dựng sẵn phục vụ cho việc chuyển đổi từ kiểu dữ
liệu này sang kiểu dữ liệu khác. Các phương thức trong lớp Convert phần lớn đều là
phương thức tĩnh:
- ToInt32(<Tham số>)
- ToInt64(<Tham số>)
- ToString(<Tham số>)
- ToDouble(<Tham số>)
- ToBoolean(<Tham số>)
- ToByte(<Tham số>)
- …
<Tham số>: có thể là chuỗi ký tự, hằng số, biến số nguyên, số thực hoặc kiểu
bool. Nếu trong quá trình chuyển kiểu đặt tham số là null thì hàm Convert sẽ trả về giá
trị mặc định.
Ví dụ 1.7:
int a = Convert.ToInt32("10"); //chuyển chuỗi 10 sang số nguyên
bool b = Convert.ToBoolean(27); //chuyển số 27 sang kiểu boolean
bool a = Convert.ToBoolean("hello"); //Sai định dạng, không chuyển được
int b = Convert.ToInt32("123456787654"); //Tràn bộ nhớ, không chuyển được
double d = Convert.ToDouble(null); //Trả về giá trị mặc định
Sử dụng phương thức Parse:
Phương thức Parse thường được sử dụng để chuyển đổi chuỗi sang một kiểu dữ
liệu cụ thể nào đó. Mỗi kiểu dữ liệu xây dựng sẵn trong C# đều có hỗ trợ phương thức
Parse để chuyển đổi chuỗi sang kiểu dữ liệu tương ứng:
11
- Double.Parse(<chuoi>): Chuyển chuỗi về kiểu Double
- Int32.Parse(<chuoi>): Chuyển chuỗi về kiểu Int32
- Int64.Parse(<chuoi>): Chuyển chuỗi về kiểu Int64
- Boolean.Parse(<chuoi>): Chuyển chuỗi về kiểu Boolean
- Single.Parse(<chuoi>): Chuyển chuỗi về kiểu Single
- …
Ví dụ 1.8:
int a = Int32.Parse("123"); //a sẽ mang giá trị 123
float b = Float.Parse("20.7"); //b sẽ mang giá trị 20.7
bool c = Boolean.Parse("true"); //c sẽ mang giá trị true
int a = Int32.Parse(“Hello”); //sai định dạng, không chuyển được
byte b = Byte.Parse(“10000000000”); //quá giới hạn, không chuyển được
bool c = Boolean.Parse(null); //tham số là null, không chuyển được
Sử dụng phương thức TryParse:
Phương thức TryParse cũng được sử dụng để chuyển đổi chuỗi sang một kiểu dữ
liệu cụ thể như Parse. Các kiểu dữ liệu xây dựng sẵn trong C# đều có phương thức
TryParse. Tuy nhiên, sự khác biệt của TryParse và Parse là:
- Cú pháp sử dụng có sự khác biệt: Có hai tham số truyền vào TryParse;
Tham số thứ nhất là chuỗi cần chuyển đổi và tham số thứ hai là biến chứa
giá trị chuyển đổi (biến truyền vào phải truyền ở dạng tham chiếu)
- Giá trị trả về của TryParse sẽ là true nếu chuyển kiểu thành công và trả về
false nếu chuyển kiểu không thành công.
Ví dụ 1.9:
int a;
Int32.TryParse(“123”, out a); //a sẽ mang giá trị 123
bool b;
Boolean.TryParse(“false”, out b); //b sẽ mang giá trị false
int a;
Int32.TryParse("hello", out a); //trả về giá trị false, a mang giá trị 0
bool b;
Boolean.TryParse("", out b); //trả về giá trị false, b mang giá trị false
Casting (ép kiểu):
Đây là cách chuyển kiểu được sử dụng khi muốn chuyển đổi giữa những kiểu dữ
liệu gần tương tự nhau. Thường áp dụng với kiểu số.
12
Ví dụ 1.10:
int x= 10;
float y = x;
int z = (int)y;
int x = 10;
//chuyển đổi ngầm định, y = 10
//chuyển đổi rõ ràng, z = 10
Trong quá trính chuyển kiểu có thể xảy ra lỗi do chuyển giữa các kiểu dữ liệu
không tương thích: Kiểu chuỗi sang kiểu số, kiểu bool sang kiểu float, …
1.5. Câu lệnh phân nhánh
Việc phân nhánh có thể được tạo ra bằng các từ khóa: if, else, switch, case. Sự
phân nhánh chỉ được thực hiện khi biểu thức điều kiện phân nhánh được xác định là
đúng.
1.5.1. Câu lệnh if
Cú pháp:
if (biểu thức điều kiện)
<Câu lệnh thực hiện khi điều kiện đúng>
[else
<Câu lệnh thực hiện khi điều kiện sai> ]
Nếu các câu lệnh trong thân của if hay else mà lớn hơn một lệnh thì các lệnh này
phải được bao trong một khối lệnh, tức là phải nằm trong dấu khối { }:
Cú pháp:
if (biểu thức điều kiện)
{
<lệnh 1>; < lệnh 2>;….
}
[else
{
<lệnh 3>; < lệnh 3>;….
}]
1.5.2. Câu lệnh switch
Khi có quá nhiều điều kiện để chọn thực hiện thì dùng câu lệnh if sẽ rất rối rắm
và dài dòng, Các ngôn ngữ lập trình cấp cao đều cung cấp một dạng câu lệnh switch
liệt kê các giá trị và chỉ thực hiện các giá trị thích hợp.
13
Cú pháp:
switch (biểu thức điều kiện)
{
case <giá trị>:
<Các câu lệnh thực hiện>
<lệnh nhảy>
[default:
<Các câu lệnh thực hiện mặc định>]
}
Lưu ý:
- <lệnh nhảy>: Là lệnh chỉ định việc kết thúc một case, lệnh nhảy trong switch
là break hoặc goto; Trường hợp trong case không có lệnh nhảy thì trình biên
dịch sẽ tuần tự thực hiện các câu lênh trong từng case của switch theo thứ tự từ
trên xuống.
- Trong trường hợp switch sử dụng nhiều case, có thể nhảy trực tiếp đến case cụ
thể nào đó bằng goto; hoặc thoát khỏi switch sử dụng break.
- <giá trị>: là hằng nguyên hoặc biến; Nếu là biến bắt buộc phải là biến kiểu số
nguyên.
1.6. Câu lệnh lặp
C# kế thừa cú pháp câu lệnh của C/C++:
Lệnh lặp while
Lệnh lặp do/ while
Lệnh lặp for
Ngoài ra 3 lệnh lặp cơ bản trên, C# còn có thêm lệnh lặp foreach dùng để làm
việc với mảng, tập hợp.
C# cũng cung cấp các lệnh nhảy như: break, goto, continue và return sử dụng kết
hợp với lệnh lặp
1.6.1. Lệnh lặp while
Ý nghĩa của vòng lặp while là: “Trong khi điều kiện đúng thì thực hiện các công
việc này”.
Cú pháp:
while (Biểu thức)
{
<Câu lệnh thực hiện>
}
14
Tải về để xem bản đầy đủ
181 trang
22301
Free
Bạn đang xem 20 trang mẫu của tài liệu "Giáo trình Lập trình Windows Forms với C#.NET (Phần 1)", để tải tài liệu gốc về máy hãy click vào nút Download ở trên
File đính kèm:
- giao_trinh_lap_trinh_windows_forms_voi_c_net_phan_1.pdf
