Trong C# một chỉ dẫn lập trình đầy đủ
được gọi là câu lệnh. Chương trình bao gồm nhiều câu lệnh tuần tự với nhau. Mỗi câu lệnh phải kết thúc với một dấu chấm phẩy, ví dụ như:
int
x; // một câu lệnh
x =
32; // câu lệnh khác
int
y =x; // đây cũng là một câu lệnh
Những câu lệnh
này sẽ được xử lý theo thứ tự. Đầu tiên trình biên dịch bắt đầu ở vị trí đầu của danh sách các câu lệnh và lần
lượt đi từng câu lệnh cho đến
lệnh cuối cùng, tuy nhiên chỉ đúng cho trường hợp các câu lệnh
tuần tự không phân nhánh.
Có hai loại câu lệnh
phân nhánh trong C# là: phân nhánh không có điều kiện
(unconditional branching statement) và phân nhánh có điều kiện (conditional branching statement).
Ngoài ra còn có các câu lệnh làm cho một số đoạn chương trình được thực hiện nhiều lần, các câu lệnh
này được gọi là câu lệnh lặp hay
vòng lặp. Bao gồm các lệnh lặp for,
while, do, in, và each sẽ
được đề cập tới trong mục tiếp theo.
Sau đây chúng ta sẽ xem xét hai loại lệnh phân nhánh phổ biến nhất trong lập trình C#.
Phân nhánh không có điều kiện có thể tạo ra bằng hai cách: gọi một hàm và
dùng từ khoá phân nhánh
không điều kiện.
Gọi hàm
Khi trình biên dịch xử lý đến
tên của một hàm, thì sẽ ngưng thực hiện hàm hiện thời mà bắt
đầu phân nhánh dể tạo một gọi hàm mới. Sau khi hàm vừa tạo thực hiện xong và trả
về một giá trị thì trình biên dịch sẽ tiếp tục thực hiện dòng lệnh tiếp sau của hàm ban đầu.
Ví dụ: Gọi một hàm.
using
System;
class
GoiHam
{
static void Main()
{
Console.WriteLine( “Ham Main chuan bi goi ham
Func()...” );
Func();
Console.WriteLine( “Tro lai ham Main()” );
}
static void Func()
{
Console.WriteLine( “---->Toi la ham Func()...”);
}
}
-----------------------------------------------------------------
Kết
quả:
Ham
Main chuan bi goi ham Func()...
---->Toi
la ham Func()...
Tro
lai ham Main()
-----------------------------------------------------------------
Luồng chương trình thực hiện bắt đầu từ hàm Main
xử lý đến dòng lệnh Func(), lệnh
Func() thường
được gọi là một lời gọi hàm. Tại điểm
này luồng
chương trình sẽ
rẽ nhánh để thực hiện hàm vừa gọi. Sau khi thực
hiện xong hàm Func, thì
chương trình quay lại hàm Main và thực hiện câu lệnh ngay sau câu lệnh gọi hàm Func.
Từ khoá phân nhánh không điều
kiện
Để thực hiện phân nhánh ta gọi một trong các từ
khóa sau: goto, break, continue, return, statementthrow. Việc trình bày các từ khóa phân nhánh không điều kiện này sẽ được đề cập trong chương tiếp theo. Trong phần này chỉ đề cập chung không đi vào chi tiết.
Phân nhánh có điều kiện
được tạo bởi các lệnh
điều kiện. Các từ khóa của các
lệnh này như : if,
else, switch. 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.
Câu lệnh if...else
Câu lệnh phân nhánh if...else dựa trên một
điều kiện. Điều kiện là một biểu thức sẽ được kiểm tra giá trị ngay khi bắt
đầu gặp câu lệnh đó. Nếu
điều kiện được kiểm tra là đúng, thì câu lệnh hay một khối các câu lệnh bên trong thân của câu lệnh if
được thực hiện.
Trong câu điều kiện
if...else thì else là phần
tùy chọn. Các câu lệnh bên trong thân của else chỉ được
thực hiện khi điều kiện của if là sai. Do vậy khi câu lệnh đầy
đủ if...else
được dùng thì
chỉ có một trong hai if hoặc else được thực hiện. Ta có
cú pháp câu điều kiện if... else sau:
if
(biểu thức điều kiện)
<Khối lệnh thực hiện
khi điều kiện đúng>
[else
<Khối 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 { }:
if
(biểu thức điều kiện)
{
<lệnh 1>
<lệnh 2>
....
}
[else
{
<lệnh 1>
<lệnh 2>
...
}]
Như trình bày bên trên do else là phần tùy chọn nên được đặt
trong dấu ngoặc vuông [...].
Minh họa cách sử dụng câu lệnh if...else.
using System;
class ExIfElse
{
static void Main()
{
int var1 = 10;
int var2 = 20;
if ( var1 > var2)
{
Console.WriteLine( “var1: {0} >
var2:{1}”, var1, var2);
}
else
{
Console.WriteLine( “var2: {0} >
var1:{1}”, var2, var1);
}
var1 = 30;
if ( var1 > var2)
{
var2 = var1++;
Console.WriteLine( “Gan gia tri
var1 cho var2”);
Console.WriteLine( “Tang bien var1
len mot ”);
Console.WritelLine( “Var1 = {0},
var2 = {1}”, var1, var2);
}
else
{
var1 = var2;
Console.WriteLine( “Thiet lap gia
tri var1 = var2” );
Console.WriteLine( “var1 = {0},
var2 = {1}”, var1, var2 );
}
}
}
-----------------------------------------------------------------
Kết quả:
Gan gia tri var1 cho var2
Tang bien var1 len mot
Var1 = 31, var2 = 30
-----------------------------------------------------------------
Trong ví dụ 3.7 trên, câu lệnh if đầu
tiên sẽ kiểm tra xem giá trị của var1 có lớn
hơn giá trị của var2 không. Biểu thức điều kiện này sử dụng toán tử quan hệ lớn hơn
(>), các toán tử khác
như nhỏ hơn
(<), hay bằng (==).
Các toán tử này thường xuyên được sử dụng trong lập trình và kết quả trả là giá trị đúng hay sai.
Việc kiểm tra xác
định giá trị var1 lớn hơn var2 là sai (vì var1 = 10 trong khi var2 = 20), khi
đó các lệnh trong
else sẽ được thực hiện, và các
lệnh này in ra màn hình:
var2: 20 > var1: 10
Tiếp theo đến
câu lệnh if thứ hai, sau khi thực hiện lệnh gán giá
trị của var1 = 30, lúc này điều kiện if đúng nên các câu lệnh trong khối
if sẽ được thực hiện và kết quả là in ra ba dòng sau:
Gan
gia tri var1 cho var2
Tang
bien var1 len mot
Var1
= 31, var2 = 30
Các lệnh điều
kiện if có thể lồng nhau để phục vụ cho việc xử lý các
câu điều kiện phức tạp. Việc này cũng thường xuyên gặp
khi lập trình. Giả sử chúng ta cần
viết một chương trình có yêu cầu xác định tình trạng
kết hôn của một công dân dựa
vào các thông tin như tuổi, giới tính,
và tình trạng hôn nhân, dựa trên một số thông tin
như sau:
Nếu công dân là nam thì độ tuổi có thể kết hôn là 20 với
điều kiện là chưa có gia đình. Nếu công dân là nữ thì độ tuổi có thể kết hôn là 19 cũng với điều kiện là chưa có gia đình.
Tất cả các công
dân có tuổi nhỏ hơn 19 điều không được kết hôn.
Dựa trên các yêu cầu trên ta có thể dùng các lệnh
if lồng nhau để thực hiện.
Ví dụ: Các lệnh if lồng
nhau.
using System;
class TinhTrangKetHon
{
static void Main()
{
int tuoi;
bool coGiaDinh; // 0: chưa có
gia đình; 1: đã có gia đình
bool gioiTinh; // 0: giới
tính nữ; 1: giới tính nam tuoi = 24;
coGiaDinh = false; // chưa có
gia đình
gioiTinh = true; // nam
if ( tuoi >= 19)
{
if ( coGiaDinh == false)
{
if ( gioiTinh == false) // nu
Console.WriteLine(“ Nu co the ket
hon”);
else // nam
if (tuoi >19) // phải
lớn hơn 19 tuoi mới được kết hôn
Console.WriteLine(“ Nam co the ket
hon”);
}
else // da co gia dinh
Console.WriteLine(“Khong the ket
hon nua, da ket hon”);
}
else // tuoi < 19
Console.WriteLine(“ Khong du tuoi ket
hon” );
}
}
Kết quả:
Nam co the ket hon
Theo trình tự kiểm tra thì
câu lệnh if đầu tiên được thực hiện, biểu thức điều kiện đúng do tuổi có giá trị là 24 lớn
hơn 19. Khi đó khối lệnh trong
if sẽ được thực thi. Ở trong
khối này lại xuất hiện một lệnh if khác để kiểm tra tình
trạng xem người đó đã có gia đình
chưa, kết quả điều kiện if là
đúng vì coGiaDinh = false nên biểu thức so sánh
coGiaDinh == false sẽ trả về giá trị
đúng. Tiếp tục xét xem giới tính của
người đó là nam
hay nữ, vì chỉ có nam trên 19 tuổi mới được kết hôn. Kết quả kiểm tra là
nam nên câu lệnh if thứ ba được thực hiện và xuất ra kết quả : “Nam
co the ket hon”.
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. C#
cũng cung cấp câu lệnh nhảy switch có cú pháp sau:
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>]
}
Cũng tương tự như câu lệnh if, biểu thức để so sánh được đặt sau từ khóa
switch, tuy nhiên giá trị
so sánh lại được đặt sau mỗi các
từ khóa case. Giá trị sau từ khóa case là các giá trị hằng số nguyên như đã đề cập trong phần
trước.
Nếu một câu lệnh case được thích hợp tức là giá
trị sau case bằng với giá trị của biểu thức sau
switch thì các câu lệnh
liên quan đến câu lệnh case này sẽ được
thực thi. Tuy nhiên phải có một câu lệnh nhảy như break, goto để điều khiển nhảy qua các case khác.Vì nếu không có các lệnh nhảy này thì khi đó chương trình sẽ thực hiện tất cả các case theo sau.
Ví dụ: Câu lệnh
switch.
-----------------------------------------------------------------
using System;
class MinhHoaSwitch
{
static void Main()
{
const int mauDo = 0;
const int mauCam = 1;
const int mauVang = 2;
const int mauLuc = 3;
const int mauLam = 4;
const int mauCham = 5;
const int mauTim = 6;
int chonMau = mauLuc;
switch ( chonMau )
{
case mauDo:
Console.WriteLine( “Ban cho mau
do” );
break;
case mauCam:
Console.WriteLine( “Ban cho mau
cam” );
break;
case mauVang:
Console.WriteLine( “Ban chon mau
luc”);
break;
case mauLam:
Console.WriteLine( “Ban chon mau
lam”);
goto case mauCham;
case mauCham:
Console.WriteLine( “Ban
cho mau cham”);
goto case mauTim;
case mauTim:
Console.WriteLine( “Ban chon mau
tim”);
goto case mauLuc;
default:
Console.WriteLine( “Ban khong chon
mau nao het”);
break;
}
Console.WriteLine( “Xin cam on!”);
}
}
Trong ví dụ trên liệt kê
bảy loại màu và dùng câu lệnh switch để kiểm tra các trường hợp chọn màu.Ở đây chúng ta thử phân tích từng câu lệnh
case mà không quan tâm đến giá trị biến chonMau.
Bảng 1.12. Mô tả các trường hợp thực hiện
câu lệnh switch
|
Giá trị chonMau
|
Câu lệnh case
thực hiện
|
Kết quả
thực hiện
|
|
mauDo
|
case mauDo
|
Ban chon mau do
|
|
mauCam
|
case mauCam
|
Ban chon mau cam
|
|
mauVang
|
case mauVang
|
Ban chon mau luc
|
|
case mauLuc
|
|
mauLuc
|
case mauLuc
|
Ban chon mau luc
|
|
mauLam
|
case mauLam
|
Ban chon mau lam
|
|
case mauCham
|
Ban chon mau cham
|
|
case mauTim
|
Ban chon mau tim
|
|
case mauLuc
|
Ban chon mau luc
|
|
mauCham
|
case mauCham
|
Ban chon mau cham
|
|
case mauTim
|
Ban chon mau tim
|
|
case mauLuc
|
Ban chon mau luc
|
|
mauTim
|
case mauTim
|
Ban chon mau tim
|
|
case mauLuc
|
Ban chon mau luc
|
Trong đoạn ví dụ do giá
trị của biến chonMau = mauLuc nên khi vào lệnh switch thì case mauLuc sẽ được
thực hiện và kết quả như
sau:
Kết
quả
Ban chon mau luc
Xin
cam on!
@Ghi chú: Đối với người lập trình C/C++, trong C# chúng ta không thể nhảy xuống một trường
hợp case tiếp theo nếu câu lệnh
case hiện tại không rỗng. Vì vậy
chúng ta phải viết như sau:
case 1: //
nhảy xuống
case 2:
Như minh họa trên thì trường hợp xử lý case 1 là rỗng, tuy nhiên chúng ta không thể viết như sau:
case
1:
DoAnything();
// Trường hợp này không
thể nhảy xuống case 2
case
2:
trong đoạn chương trình thứ hai trường
hợp case 1 có một câu lệnh nên không thể nhảy xuống được. Nếu muốn
trường hợp case1 nhảy qua case 2 thì ta phải sử dụng câu lệnh goto một
các tường minh:
case
1:
DoAnything();
goto case 2;
case
2:
Do vậy khi thực hiện xong các câu lệnh của một trường hợp nếu muốn thực hiện một trường hợp case
khác thì ta dùng câu lệnh
nhảy goto với nhãn của trường
hợp đó:
goto case <giá trị>
Khi gặp lệnh thoát
break thì chương trình thoát khỏi switch và thực hiện lệnh tiếp sau khối
switch đó.
Nếu không có trường hợp nào
thích hợp và trong câu lệnh switch có dùng câu lệnh defalut thì các câu lệnh của trường
hợp default sẽ được thực hiện. Ta có thể dùng default để cảnh báo một lỗi hay xử lý một trường hợp ngoài tất cả các trường
hợp case trong switch.
Trong ví dụ minh họa câu
lệnh switch trước thì giá trị để kiểm tra các trường hợp thích hợp là
các hằng số nguyên. Tuy nhiên C# còn có khả năng cho phép chúng ta dùng câu
lệnh switch với giá trị là một chuỗi, có thể viết như
sau:
switch
(chuoi1)
{
case “mau do”:
....
break;
case “mau cam”:
...
break;
...
}
C# cung cấp một bộ mở rộng các câu
lệnh lặp, bao gồm các câu lệnh
lặp for, while và do...
while. Ngoài ra ngôn ngữ
C# còn bổ sung thêm một câu lệnh lặp
foreach, lệnh này mới đối với người lập trình C/C++ nhưng khá thân thiện với người lập trình VB. Cuối cùng là các câu lệnh nhảy
như goto, break, continue, và return.
Lệnh nhảy goto
là một lệnh nhảy đơn giản, cho phép chương trình nhảy vô điều
kiện tới một vị trí trong chương trình
thông qua tên nhãn. Tuy nhiên việc sử dụng lệnh goto thường làm mất
đi tính cấu trúc thuật toán, việc lạm dụng sẽ dẫn đến một chương trình nguồn mà giới lập trình gọi là “mì ăn liền” rối
như mớ bòng bong vậy. Hầu hết các
người lập trình có kinh nghiệm đều tránh dùng lệnh goto. Sau đây là cách sử dụng lệnh nhảy goto:
Tạo một nhãn
goto đến nhãn: Nhãn là một định
danh theo sau bởi dấu hai chấm (:). Thường thường
một lệnh goto gắn với một điều kiện nào
đó, ví dụ sau sẽ minh họa các sử dụng lệnh nhảy goto
trong chương trình.
Ví
dụ: Sử dụng goto.
-----------------------------------------------------------------
using
System;
public
class UsingGoto
{
public static int Main()
{
int i = 0;
lap: // nhãn
Console.WriteLine(“i:{0}”,i);
i++;
if ( i < 10 )
goto lap; // nhãy về nhãn lap
return 0;
}
}
Kết quả:
i:0
i:1
i:2
i:3
i:4
i:5
i:6
i:7
i:8
i:9
------------------------------------------------------------------
Nếu chúng ta vẽ
lưu đồ của một chương trình có sử dụng nhiều lệnh goto, thì ta sẽ thấy kết quả rất nhiều đường chồng chéo lên nhau, giống như là các sợi mì vậy.
Chính vì vậy nên những đoạn mã chương trình có dùng lệnh goto còn được gọi là
“spaghetti code”.
Việc tránh dùng lệnh nhảy goto
trong chương trình hoàn toàn thực hiện
được, có thể dùng vòng lặp while để thay thế hoàn
toàn các câu lệnh goto.
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 sử dụng vòng lặp while như sau:
while
(Biểu thức)
<Câu lệnh thực hiện>
Biểu thức của vòng lặp while là điều kiện để các lệnh được thực hiện, biểu thức này bắt buộc phải trả về một giá trị kiểu bool là true/false. Nếu có nhiều câu
lệnh cần được thực hiện trong
vòng lặp while thì phải đặt các lệnh này
trong khối lệnh. Ví dụ minh họa việc sử dụng vòng lặp while.
Ví
dụ: Sử dụng vòng lặp while.
-----------------------------------------------------------------
using
System;
public
class UsingWhile
{
public static int Main()
{
int i = 0;
while ( i < 10 )
{
Console.WriteLine(“ i: {0} ”,i);
i++;
}
return 0;
}
}
Kết quả:
i:0
i:1
i:2
i:3
i:4
i:5
i:6
i:7
i:8
i:9
Đoạn chương trình trên cũng cho kết quả
tương tự
như chương trình minh họa dùng lệnh
goto. Tuy nhiên chương trình trên rõ ràng hơn và có ý nghĩa tự nhiên hơn. Có thể diễn giải ngôn ngữ tự nhiên
đoạn vòng lặp while như sau: “Trong khi i nhỏ hơn 10, thì in ra giá trị của i và tăng i lên một đơn vị”.
Lưu ý rằng vòng lặp
while sẽ kiểm tra điều kiện
trước khi thực hiện các lệnh bên
trong, điều này
đảm bảo nếu ngay từ
đầu điều kiện sai thì vòng lặp sẽ không bao
giờ thực hiện. do vậy nếu khởi tạo biến i có giá trị là 11, thì vòng lặp sẽ không
được thực hiện.
Đôi khi vòng lặp while không thoả mãn yêu cầu
trong tình huống sau,
chúng ta muốn chuyển ngữ nghĩa của
while là “chạy trong khi
điều kiện đúng” thành ngữ nghĩa khác như “làm
điều này trong khi
điều kiện vẫn còn đúng”. Nói cách khác thực hiện một hành động, và sau khi hành động được hoàn thành thì kiểm tra điều
kiện. Cú pháp sử dụng vòng lặp
do...while như sau:
do
<Câu lệnh thực hiện>
while
( điều kiện )
Ở đây có sự khác biệt quan trọng
giữa vòng lặp while và vòng lặp do...while là khi dùng vòng lặp do...while thì tối thiểu sẽ có một lần các câu lệnh
trong do...while được thực hiện. Điều này cũng dễ hiểu vì lần đầu tiên đi vào vòng lặp do...while thì điều kiện
chưa được
kiểm tra.
Ví
dụ: Minh hoạ việc sử dụng vòng lặp
do..while.
using System;
public
class UsingDoWhile
{
public static int Main( )
{
int i = 11;
do
{
Console.WriteLine(“i: {0}”,i);
i++;
} while ( i < 10 ) return 0;
}
}
-----------------------------------------------------------------
Kết
quả:
i:
11
-----------------------------------------------------------------
Do khởi tạo biến i giá trị là 11, nên điều kiện của while là sai, tuy nhiên vòng lặp do...while vẫn được thực hiện một lần.
Vòng lặp for bao gồm
ba phần chính:
·
Khởi tạo biến đếm vòng lặp
·
Kiểm tra điều
kiện biến đếm, nếu
đúng thì sẽ thực hiện các lệnh bên
trong vòng for
·
Thay đổi bước lặp.
Cú pháp sử dụng vòng lặp for như sau:
for ([ phần khởi tạo] ; [biểu thức điều kiện]; [bước lặp])
<Câu lệnh
thực hiện>
Vòng lặp for được minh họa
trong ví dụ sau:
using
System;
public
class UsingFor
{
public static int Main()
{
for (int i = 0; i < 30; i++)
{
if (i % 10 == 0)
{
Console.WriteLine(“{0} ”,i);
}
else
{
Console.Write(“{0} ”,i);
}
}
return 0;
}
}
------------------------------------------------------------------
Kết
quả:
0
12345678910
11
12 13 14 15 16 17 18 19 20
21
22 23 24 25 26 27 28 29
------------------------------------------------------------------
Trong đoạn chương trình trên có sử dụng toán tử chia lấy dư modulo, toán tử này sẽ
được đề cập đến phần sau. Ý nghĩa lệnh i%10 == 0 là kiểm tra xem i có phải là bội số của 10 không, nếu i là bội số của 10 thì sử dụng lệnh WriteLine để xuất giá trị i và sau đó đưa
cursor về đầu dòng sau. Còn ngược lại chỉ cần xuất giá trị của i và không xuống dòng.
Đầu tiên biến i
được khởi tạo giá trị ban
đầu là 0, sau
đó chương trình sẽ kiểm tra
điều kiện, do 0 nhỏ hơn 30 nên điều kiện
đúng, khi đó các câu lệnh bên trong vòng lặp for sẽ
được thực hiện. Sau khi thực
hiện xong thì biến i sẽ được
tăng thêm một
đơn vị (i++).
Có một điều
lưu ý là biến i do
khai bao bên trong vòng lặp for nên chỉ
có phạm vi hoạt động bên trong vòng lặp. Ví dụ 3.14
sau sẽ không được biên dịch vì xuất hiện một lỗi.
Ví
dụ: Phạm vi của biến khai báo trong vòng lặp.
-----------------------------------------------------------------
using
System;
public
class UsingFor
{
public static int Main()
{
for (int i = 0; i < 30; i++)
{
if (i %10 ==0)
{
Console.WriteLine(“{0} ”,i);
}
else
{
Console.Write(“{0} ”,i);
}
}
//Lệnh sau sai do biến i chỉ
được khai báo trong vòng lặp
Console.WriteLine(“ Ket qua cuoi cung cua i:{0}”,i);
return 0;
}
}
-----------------------------------------------------------------
Vòng lặp foreach cho phép tạo vòng lặp
thông qua một tập hợp hay một mảng. Đây là một câu lệnh lặp mới không có trong ngôn ngữ C/C++. Câu lệnh foreach có cú pháp chung như sau:
foreach
(<kiểu tập hợp> <tên thành phần> in <tên
tập hợp>)
{
<Các câu lệnh thực hiện>
}
Do lặp dựa trên một mảng hay tập hợp nên toàn bộ vòng lặp sẽ duyệt qua tất cả các thành phần của tập hợp theo thứ tự được sắp. Khi duyệt đến phần tử cuối cùng trong tập hợp thì
chương trình sẽ
thoát ra khỏi vòng lặp foreach.
Ví
dụ minh họa việc sử dụng vòng lặp foreach.
-----------------------------------------------------------------
using
System;
public
class UsingForeach
{
public static int Main()
{
int[] intArray = {1,2,3,4,5,6,7,8,9,10};
foreach( int item in intArray)
{
Console.Write(“{0} ”, item);
}
return 0;
}
}
------------------------------------------------------------------
Kết
quả:
1 2
3 4 5 6 7 8 910
------------------------------------------------------------------
Khi đang thực hiện các lệnh trong vòng lặp, có yêu cầu như sau: không thực hiện các lệnh còn lại nữa mà thoát
khỏi vòng lặp, hay không thực hiện các công việc
còn lại của vòng lặp hiện tại mà nhảy qua vòng lặp
tiếp theo. Để đáp ứng yêu cầu
trên C# cung cấp hai lệnh nhảy là break và continue để thoát khỏi
vòng lặp.
Break khi được sử dụng sẽ đưa chương trình
thoát khỏi vòng lặp và tiếp tục thực hiện các lệnh tiếp ngay sau vòng lặp.
Continue ngừng thực hiện các công việc còn lại của vòng lặp hiện thời và quay về đầu vòng
lặp để thực hiện bước lặp tiếp theo
Hai lệnh break và continue tạo ra nhiều
điểm thoát và làm
cho chương trình khó hiểu cũng như là khó duy trì. Do vậy phải cẩn trọng khi sử dụng các lệnh nhảy này.
Ví dụ sau sẽ được trình bày bên dưới minh họa
cách sử dụng lệnh continue và break. Đoạn chương trình mô phỏng hệ thống xử lý tín hiệu
giao thông đơn giản. Tín hiệu mô
phỏng là các ký tự chữ hoa hay số
được nhập vào từ bàn phím, sử
dụng hàm ReadLine của lớp Console để đọc một chuỗi ký tự từ bàn phím.
Thuật toán của
chương trình khá đơn giản: Khi nhận
tín hiệu ‘0’ có
nghĩa là mọi việc bình thường, không cần phải làm bất cứ công việc gì
cả, kể cả việc ghi lại các sự kiện. Trong
chương trình này đơn giản nên các tín hiệu được nhập từ bàn phím, còn trong ứng dụng thật thì
tín hiệu này sẽ được phát sinh theo các mẫu tin thời
gian trong cơ sở dữ liệu. Khi nhận
được tín hiệu thoát (mô phỏng bởi ký tự ‘T’)
thì ghi lại tình trạng và kết thúc xử lý.
Cuối cùng, bất cứ tín hiệu nào
khác sẽ phát ra một thông báo, có thể là thông báo đến nhân viên cảnh sát chẳng hạn...Trường hợp tín hiệu là ‘X’ thì cũng sẽ phát ra một thông báo nhưng sau vòng lặp xử lý
cũng kết thúc.
Ví dụ: Sử dụng break
và continue.
------------------------------------------------------------------
using System;
public class TrafficSignal
{
public static int Main()
{
string signal = “0”; // Khởi
tạo tín hiệu bắt đầu chu trình xử lý tín hiệu
while ( signal != “X”)
{
//nhập tín hiệu
Console.Write(“Nhap vao mot tin
hieu: ”);
signal = Console.ReadLine();
// xuất tín hiệu hiện
thời
Console.WriteLine(“Tin hieu nhan
duoc: {0}”, signal);
//phần xử lý tín hiệu
if (signal == “T”)
{
//Tín hiệu thoát
được gởi lưu lại sự kiện và thoát
Console.WriteLine(“Ngung xu ly!
Thoat\n”);
break;
}
if ( signal == “0”)
{
//Tín hiệu nhận
được bình thường
//Lưu lại sự kiện
và tiếp tục
Console.WriteLine(“Tat ca dieu
tot!\n”);
continue;
}
//Thực hiện một
số hành động nào đó và tiếp tục
Console.WriteLine(“---bip bip
bip\n”);
}
return 0;
}
}
---------------------------------------------------------------------
Kết
quả: sau khi nhập tuần tự các tín hiệu : “0”,
“B”, “T”
Nhap
vao mot tin hieu: 0
Tin
hieu nhan duoc: 0
Tat
ca dieu tot!
Nhap
vao mot tin hieu: B
Tin
hieu nhan duoc: B
---bip
bip bip
Nhap vao mot tin hieu: T
Tin
hieu nhan duoc: T
Ngung
xu ly! Thoat
------------------------------------------------------------------
Điểm chính yếu của đoạn chương trình trên là khi nhập vào tín hiệu
“T” thì sau khi thực hiện một số hành
động cần thiết chương trình sẽ thoát ra khỏi
vòng lặp và không xuất ra câu thông báo bip bip bip.
Ngược lại khi nhận được tín hiệu 0
thì sau khi xuất thông
báo chương trình sẽ quay về
đầu vòng lặp để thực hiện tiếp tục và
cũng không xuất ra
câu thông báo bip bip bip.