NGÔN NGỮ C#

Đặng Thành Trung

GIỚI THIỆU

 Được phát triển bởi đội ngũ kỹ sư của Microsoft, dẫn đầu là Anders Hejlsberg và Scott Wiltamuth.

 Có khoảng 80 từ khóa và 20 kiểu dữ liệu dựng sẵn

 C# là ngôn ngữ lập trình hướng đối tượng và có những từ khóa hỗ trợ đầy đủ việc khai báo một lớp

 C# có các đặc trưng

 Hỗ trợ khái niệm giao diện

 Hỗ trợ kiểu cấu trúc

 Cung cấp đặc trưng hướng thành phần : property, sự kiện,

 Truy cập bộ nhớ trực tiếp dùng con trỏ

TỪ KHÓA C#

CHƯƠNG TRÌNH ĐẦU TIÊN

 Chương trình bắt đầu thực hiện từ hàm Main

 In ra màn hình

 Tên file và class không nhất thiết giống nhau

CẤU TRÚC CHƯƠNG TRÌNH

 Nếu namespace không được xác định => sử dụng namespace mặc định

 Namespace có thể chứa struct, interface, delegate và enum

 Namespace có thể được sử dụng ở các file khác

 Trường hợp đơn giản nhất: Một lớp, một file, và chỉ sử dụng namespace mặc định

MỘT CHƯƠNG TRÌNH 2 FILE

CÁC BƯỚC TẠO CHƯƠNG TRÌNH

 Xác định mục tiêu chương trình

 Xác định phương pháp giải quyết

 Tạo chương trình giải quyết

 Thực thi chương trình để xem kết quả

LỚP, ĐỐI TƯỢNG, KIỂU

 Bản chất của lập trình hướng đối tượng là tạo ra kiểu mới

 Một kiểu mới được định nghĩa bằng từ khóa class gọi là một lớp.

 Khai báo lớp trong C# không có dấu ";" ở cuối lệnh khai báo.

 Khai báo lớp trong C# không chia thành 2 phần header và definition như trong C++.

 Một thể hiện của lớp gọi là một đối tượng

PHƯƠNG THỨC

 Hai thành phần chính của lớp là

 Phương thức (Method) : các hàm được định nghĩa trong lớp

 Thuộc tính (Attribute) : các biến được khái báo trong lớp

 Hàm "Main" là một phương thức đặc biệt của lớp, xác định đầu vào của lớp.

 Giá trị của hàm Main có thể là void hoặc int.

 Mỗi chương trình có thể có nhiều hàm Main nhưng cần phải xác định chỉ dẫn biên dịch để thực thi một hàm Main cụ thể.

CHÚ THÍCH

 Chú thích nhằm mục đích giải thích các đoạn mã khác

 Chú thích là các đoạn mã chương trình không được biên dịch

 Có hai loại chú thích

 Chú thích đơn dòng, bắt đầu bằng ký tự "//"

 Chú thích đa dòng, bắt đầu bằng ký tự "/*" và kết thúc bằng ký tự "*/"

ỨNG DỤNG CONSOLE

 Ứng dụng giao tiếp với người dùng thông qua bàn phím và không có giao diện đồ họa.

NAMESPACE

 .NET có rất nhiều các lớp thư viện khác nhau.

 Các lớp được nhóm với nhau bằng các vùng tên (name space).

 Các vùng tên cũng có thể được nhóm với nhau bằng các vùng tên lớn hơn.

 Người dùng có thể tạo ra các vùng tên riêng cho các lớp tự định nghĩa.

 Để truy xuất đến các phương thức trong các lớp, trong các vùng tên, ... người ta sử dụng toán tử "."

 Vùng_tên.Vùng_tên_con....Tên_lớp...Tên_phương_thức

PHÂN BIỆT HOA THƯỜNG

 Ngôn ngữ C# phân biệt chữ hoa, chữ thường giống như C, C++

 Ví dụ : Writeline, WriteLine, WRITELINE, ... là khác nhau

 Tên biến, hàm, hằng, lớp, ... đều phân biệt chữ hoa, chữ thường

KIỂU DỮ LIỆU & TOÁN TỬ

Đặng Thành Trung

PHÂN LOẠI KIỂU

KIỂU GIÁ TRỊ & KIỂU THAM CHIẾU

CÁC KIỂU DỰNG SẴN

CHUYỂN ĐỔI KIỂU

 Một đối tượng có thể chuyển đổi từ kiểu này sang kiểu khác theo hai cách:

 Chuyển đổi ngầm định: được thực hiện tự động bởi trình biên dịch.

 Chuyển đổi tường minh: có sự can thiệp của người lập trình.

KIỂU LIỆT KÊ : enum

 Được sử dụng để liệt kê các hằng

TOÁN TỬ KIỂU ENUM

 Chương trình không kiểm tra kết quả có phải là một giá trị hợp lệ của kiểu enum không

 Chú ý:

 enum không được gán cho kiểu int, trừ khi phải ép kiểu tường minh

 enum kế thừa kiểu object (Equals, ToString, ...)

 Lớp System.enum cung cấp các phương thức : GetName, Format, GetValues,...

MỘT SỐ KIỂU MỞ RỘNG

 Kiểu xâu (string) : được sử dụng như một kiểu chuẩn string.

 Khai báo : string s ="Hello";

 Kiểu string không thể chỉnh sửa được (Nếu muốn chỉnh sửa dùng StringBuilder)

 Toán tử nối chuỗi là phép cộng "+"

 string là kiểu tham chiếu, nhưng có thể thực hiện phép so sánh

 Lớp string có nhiều phương thức hữu dụng: Length, CompareTo, IndexOf, StartsWith, Substring...

MỘT SỐ KIỂU MỞ RỘNG

 Mảng : tập hợp các phần tử có cùng kiểu

 Khai báo : int [] a; int [][] b;

 Mỗi thành phần được xác định thông qua chỉ số

 Có nhiều kiểu mảng : mảng một chiều, mảng nhiều chiều, mảng ziczắc, ...

 Danh sách : mảng có kích thước thay đổi.

 Khai báo : ArrayList a;

 Cấu trúc (struct)

 Lớp (class)

BIẾN VÀ HẰNG

 Biến là một vùng nhớ dành riêng cho một kiểu dữ liệu nào đó.

 Biến có thể được gán giá trị và có thể thay đổi giá trị trong quá trình thực hiện chương trình.

 Biến phải luôn được gán giá trị trước khi được sử dụng.

 Cú pháp khai báo biến

 <tên kiểu> <tên biến>

 Ví dụ : int x,y;

 Hằng là một biến nhưng giá trị của hằng không thể thay đổi trong quá trình thực hiện chương trình.

 Cú pháp khai báo hằng

 <const> <tên kiểu> <tên hằng> = <giá trị>

 Ví dụ : const float so_pi = 3.1415

TOÁN TỬ

 Toán tử được ký hiệu bằng một biểu tượng, dùng để thực hiện một hành động

 Toán tử gán: được ký hiệu là dấu "=", là toán tử hai ngôi làm toán hạng bên trái có giá trị bằng toán hạng bên phải.

 Ví dụ : x = y;

 Toán tử toán học : Là các toán tử thao tác số học.

 Có 5 toán tử toán học : +,-,*,/ và %

 Toán tử tăng, giảm: Thực hiện các thao tác số học và gán lại giá trị cho chính biến được tính toán

 Có 5 toán tử tăng, giảm tương ứng với 5 toán tử số học: +=, -=, *=, /=, %=

 Ví dụ : x = x + 3 tương đương với x += 3;

TOÁN TỬ

 Toán tử tăng, giảm 1: ++, --

 Ví dụ: x = x + 1 tương đương với x+=1 hoặc x++

 Có hai loại tăng, giảm 1 :

 Tăng, giảm tiền tố : ++x hoặc --x

 Tăng, giảm hậu tố : x++ hoặc x-

 Toán tử quan hệ : Dùng để so sánh giữa hai giá trị và trả về một giá trị logic kiểu bool (true hoặc false).

 == : so sánh bằng

 != : so sánh khác

 > : so sánh lớn hơn

 >= : so sánh lớn hơn hoặc bằng

 < : so sánh nhỏ hơn

 <= : so sánh nhỏ hơn hoặc bằng

TOÁN TỬ

 Toán tử logic : Dùng để kết hợp hai hoặc nhiều biểu thức logic

 && : kết hợp theo phép and

 || : kết hợp theo phép or

 ! : kết hợp theo phép not.

 Toán tử thao tác bit : Dùng để thực hiện các phép toán nhị phân

 & : phép and bit

 | : phép or bit

 ~ : phép not bit

 ^ : phép xor bit

 Toán tử ba ngôi :

 Cú pháp : <biểu thức điều kiện>?<biểu thức 1>:<biểu thức 2>

 Nếu biểu thức điều kiện đúng sẽ trả về giá trị của biểu thức 1, ngược lại trả về giá trị của biểu thức 2.

ĐỘ ƯU TIÊN TOÁN TỬ

KHAI BÁO

Đặng Thành Trung

PHẠM VI KHÁI BÁO

 Phân loại phạm vi khai báo

 namespace: khai báo class, interface, struct, enum, delegate

 class, interface, struct: khai báo trường dữ liệu, phương thức, ...

 enumeration: khai báo các hằng thuộc enum

 khối lệnh: khai báo các biến cục bộ

CÁC NGUYÊN TẮC KHAI BÁO

 Nguyên tắc về phạm vi khai báo

 Không có hai tên trùng nhau trong cùng một phạm vi và cùng một mức

 Có thể khai báo trùng tên khi ở các mức khác nhau

 Nguyên tắc về tầm hoạt động

 Tên chỉ có tác dụng trong phạm vi khai báo của nó.

 Tầm hoạt động còn bị ảnh hưởng bởi các modifier như: public, private, protected và internal.

VÍ DỤ

 Các namespace ở file khác nhau tạo lên phạm vi khai báo khác nhau

 Namespace lồng tạo nên phạm vi khai báo của riêng nó

SỬ DỤNG NAMESPACE

 Đối với các namespace ngoài

 Phải bổ sung thêm, dùng từ khoá using (e.g. using Util;)

 sử dụng tên đầy đủ (e.g. Util.Color)

 Hầu hết các chương trình phải sử dụng namespace System => using System;

CLASS, INTERFACE, STRUCT

 Phạm vi khai báo của subclass không phụ thuộc vào phạm vi khai báo của base class => có thể khai báo tên trùng nhau trong subclass và base class

KHỐI LỆNH

 Phạm vi khai báo của khối lệnh bao gồm phạm vi khai báo của các khối lệnh lồng trong nó.

 Các tham số hình thức phụ thuộc vào phạm vi khai báo của khối lệnh của phương thức.

 Các biến được sử dụng trong vòng lặp phụ thuộc vào khối lệnh của vòng lặp

 Phải khai báo biến cục bộ trước khi sử dụng chúng

KHAI BÁO BIẾN CỤC BỘ

CÂU LỆNH

Đặng Thành Trung

CÁC CÂU LỆNH ĐƠN GIẢN

 Lệnh rống

; // dấu "; " là kết thúc lệnh

 Lệnh gán

x = 3 * y + 1;

 Gọi phương thức

string s = "a,b,c";

string[] parts = s.Split(','); // viện dẫn tới phương thức của đối tượng

// (non-static)

s = String.Join(" + ", parts); // viện dẫn tới phương thức của class (static)

LỆNH IF ... ELSE ...

 Lệnh if ... else ... phân nhánh dựa trên một điều kiện duy nhất.

 else là phần tùy chọn, và chỉ được thực hiện khi điều kiện khi điều kiện bị sai

 Cú pháp :

if (biểu thức điều kiện)

<khối lệnh 1>

[else <khối lệnh 2>]

 Nếu các khối lệnh trong điều kiện if có nhiều hơn một lệnh thì chúng phải được đặt trong cặp dấu {}

LỆNH SWITCH

 Lệnh switch phân nhánh tùy theo từng giá trị của của biểu thức điều kiện

 Cú pháp :

switch (biểu thức điều kiện) {

case <giá trị 1> :

<khối lệnh 1>

<lệnh nhảy>

case <giá trị 2> :

<khối lệnh 2>

<lệnh nhảy>

...

[default :

<khối lệnh default>]

}

 default là phần tùy chọn được thực hiện khi biểu thức điều kiện không khớp với phần case nào.

 Lệnh nhảy có thể là break, goto, ...

VÍ DỤ

 Cài đặt switch với lệnh nhảy break

switch (country) {

case "England":

case "USA":

language = "English";

break;

case "Germany":

case "Austria":

case "Switzerland":

language = "German";

break;

case null:

Console.WriteLine("no country specified");

break;

default:

Console.WriteLine("don't know the language of " + country);

break;

}

LỆNH LẶP

 Lệnh while :

 Ý nghĩa : Trong khi điều kiện đúng thì làm ...

 Cú pháp :

while (biểu thức điều kiện)

<khối lệnh>

 Biểu thức điều kiện chỉ có giá trị đúng hoặc sai

 Vòng lặp while luôn kiểm tra điều kiện trước khi thực hiện khối lệnh.

 Nếu khối lệnh có nhiều hơn một lệnh thì các lệnh phải được đặt trong dặp dấu {}

LỆNH LẶP

 Lệnh do ... while :

 Ý nghĩa : Làm trong khi điều kiện đúng

 Cú pháp :

do

<khối lệnh>

while (biểu thức điều kiện)

 Biểu thức điều kiện chỉ có giá trị đúng hoặc sai

 Vòng lặp while luôn kiểm tra điều kiện trước sau khi thực hiện khối lệnh.

 Nếu khối lệnh có nhiều hơn một lệnh thì các lệnh phải được đặt trong dặp dấu {}

LỆNH LẶP

 Lệnh for :

 Gồm ba phần chính

 Khởi tạo biến đếm vòng lặp

 Kiểm tra biến đếm, nếu đúng thì thực hiện khối lệnh trong vòng lặp

 Thay đổi biến đếm

 Cú pháp :

for ([phần khởi tạo];[biểu thức điều kiện];[thay đổi bước lắp])

<khối lệnh>

Ví dụ :

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

sum += i;

 Nếu khối lệnh có nhiều hơn một lệnh thì các lệnh phải được đặt trong dặp dấu {}

LỆNH LẶP

 Lệnh foreach : Lặp trên một tập hợp hoặc một mảng

 Cú pháp

foreach (<kiểu tập hợp> <tên thành phần> in <tên tập hợp>)

<khối lệnh>

 Ý nghĩa : Vòng lặp sẽ duyệt qua từng phần tử của toàn bộ tập hợp hoặc mảng.

 Ví dụ :

int[] a = {3, 17, 4, 8, 2, 29};

foreach (int x in a) sum += x;

LỆNH NHẢY

 break : Dùng để "nhảy" ra khỏi lệnh lặp hoặc lệnh case.

 continue : Bỏ qua phần còn lại và tiếp tục vòng lặp tiếp theo.

 goto : Nhảy tới một nhãn xác định.

 Không nhảy vào một khối lệnh

 Không nhảy ra ngoài khối lệnh finally

LỆNH ĐƠN GIẢN TRÊN CONSOLE

 Hiển thị lên Console

 Cú pháp :

 System.Console.Write(<tham số>)

 System.Console.WriteLine(<tham số>)

 Ví dụ :

 System.Console.Write("Hello everybody.");

 System.Console.Write("x = {0}",x);

 Đọc giá trị từ bàn phím

 Cú pháp :

 int System.Console.Read();

 string System.Console.ReadLine();

 Ví dụ :

 int ch = System.Console.Read();

 string line = System.Console.ReadLine();

MẢNG

ĐẶNG THÀNH TRUNG

MẢNG

 Mảng là một tập hợp có thứ tự của những đối tượng có cùng kiểu.

 Các mảng khai báo trong C# thực chất là đối tượng của kiểu System.Array

 Cú pháp khai báo mảng:

 <kiểu dữ liệu>[] <tên mảng>

 <kiểu dữ liệu>[,] <tên mảng>

 Ví dụ :

 int[] myArray;

 Tạo thể hiện mảng:

 myArray = new int[6];

TRUY CẬP MẢNG

 Để truy cập vào mảng, dùng toán tử chỉ mục []

 Chỉ mục đầu tiên của mảng bắt đầu từ 0.

 Khi tạo một mảng có kiểu giữ liệu giá trị, mỗi thành phần sẽ chứa giá trị mặc định của kiểu dữ liệu.

 Mảng các số nguyên sẽ có giá trị ban đầu là 0

 Mảng các kiểu tham chiếu sẽ có giá trị ban đầu là null

 Để truyền kiểu mảng cho các phương thức, phải dùng từ khóa params

 Ví dụ : public void DisplayVals(params int[] val);

CÁC LOẠI MẢNG

 Mảng 1 chiều:

 int[] a = new int[3];

 int[] b = new int[] {3, 4, 5};

 int[] c = {3, 4, 5};

 SomeClass[] d = new SomeClass[10];// phần tử của mảng là tham chiếu

 SomeStruct[] e = new SomeStruct[10]; // phần tử của mảng là giá trị

 Mảng nhiều chiều

 Mảng nhiều chiều hình chữ nhật

 int[,] a = new int[2, 3];

 int[,] b = {{1, 2, 3}, {4, 5, 6}};

 int[,,] c = new int[2, 4, 2];

 Mảng nhiều chiều zíc zắc

 int[][] a = new int[2][]; // Phần tử của mảng tham chiếu tới một mảng khác

 a[0] = new int[] {1, 2, 3}; // Khởi tạo từng phần tử của mảng

 a[1] = new int[] {4, 5, 6};

CÁC LOẠI MẢNG

CÁC PHƯƠNG THỨC MẢNG

CÁC PHƯƠNG THỨC MẢNG

LỚP VÀ CẤU TRÚC

Đặng Thành Trung

LỚP

 Khai báo lớp

[Thuộc tính] [Bổ sung truy cập] class <Định danh lớp> [: Lớp cơ sở]

{

<Phần thân của lớp: bao gồm định nghĩa các thuộc tính và

phương thức hành động >

}

 Trong C#, phần kết thúc của lớp không có dấu ":" giống như trong C++. Tuy nhiên nếu người lập trình đưa vào thì chương trình dịch vẫn không báo lỗi.

 Trong C#, mọi chuyện đều xảy ra trong một lớp.

 Lớp chỉ kế thừa từ một lớp khác

 Lớp có thể cài đặt cho nhiều interface.

 Một đối tượng gọi là một thể hiện của lớp.

 Một đối tượng được cấp phát vùng nhớ trên heap

 Đối tượng phải được tạo với từ khóa new

VÍ DỤ VỀ LỚP

class Thoigian {

int nam, thang, ngay; //các thuộc tính

int gio, phut, giay;

public thoiGianHienHanh() { //một phương thức

System.Console.WriteLine("Hien thi thoi gian !");

}

}

public class Tester {

static void Main() {

Thoigian t = new Thoigian();

t.thoiGianHienHanh();

}

}

THUỘC TÍNH TRUY CẬP

 Thuộc tính truy cập quyết định khả năng truy cập vào lớp từ các yếu tố bên ngoài

 Trong C#,có các thuộc tính truy cập như sau:

 public : Không hạn chế truy cập

 private : Chỉ các thành phần bên trong lớp mới được truy cập.

 protect : Chỉ các thành phần bên trong lớp hoặc lớp kế thừa có thể truy cập.

 internal : Chỉ các thành phần của lớp cùng khối khai báo có thể truy cập

 protected internal : chỉ các thành phần của lớp cùng khối khai báo hoặc kế thừa có thể truy cập.

 Khi không khai báo rõ thuộc tính truy cập, các thành phần sẽ được xem như là private.

THUỘC TÍNH

THUỘC TÍNH TĨNH

Phụ thuộc vào class, không phụ thuộc vào đối tượng

class Rectangle {

static Color defaultColor; // mỗi class chỉ có một

static readonly int scale; // mỗi class chỉ có một

int x, y, width,height; // mỗi đối tượng có một

...

}

Hằng không được khai báo với từ khoá static

Truy nhập trong class Truy nhập từ class khác

... defaultColor ... scale ... ... Rectangle.defaultColor ... Rectangle.scale .

ĐÓNG GÓI DỮ LIỆU

 Thực hiện truy cập vào các biến thành viên của lớp thông qua các phương thức nhằm bảo mật dữ liệu của lớp

 Có hai bộ truy cập được thiết lập

 Bộ truy cập lấy dữ liệu

 Bộ truy cập thiết lập dữ liệu

 Ví dụ

ĐÓNG GÓI DỮ LIỆU

 Đóng gói dữ liệu giúp người lập trình kiểm tra trường dữ liệu trước khi sử dụng

 Đóng gói dữ liệu được sử dụng để thiết lập quyền readonly hoặc writeonly cho thuộc tính.

PHƯƠNG THỨC

Ví dụ

class C {

int sum = 0, n = 0;

public void Add (int x) {

sum = sum + x; n++;

}

public float Mean() {

return (float)sum / n;

}

}

Truy nhập trong class Truy nhập từ class khác

Add(3); C c = new C();

float x = Mean(); c.Add(3);

float x = c.Mean();

PHƯƠNG THỨC TĨNH

 Chỉ làm việc trên các thành phần dữ liệu static

class Rectangle {

static Color defaultColor;

public static void ResetColor() {

defaultColor = Color.white;

}

}

Truy nhập trong class Truy nhập từ class khác

ResetColor(); Rectangle.ResetColor();

THAM SỐ PHƯƠNG THỨC

 Một phương thức có thể có số lượng tham số tùy ý.

 Mỗi tham số phải được khai báo cùng kiểu dữ liệu

 Các tham số được xem như các biến cục bộ

 Có ba kiểu tham số :

THAM SỐ PHƯƠNG THỨC

THAM SỐ PHƯƠNG THỨC

 Tham số có số lượng thay đổi

NẠP CHỒNG PHƯƠNG THỨC

 Nạp chồng phương thức là cách khai báo các phương thức có thể trùng tên nhau.

 Các phương thức có thể khai báo trùng tên nhau nếu

 Số lượng tham số của chúng khác nhau

 Kiểu dữ liệu của các tham số là khác nhau

 Kiểu truyền tham số khác nhau

NẠP CHỒNG PHƯƠNG THỨC

 Các hàm chồng chỉ khác nhau về kiểu dữ liệu trả về không được chấp nhận

 Khai báo :

 int F();

 string F();

 Gọi hàm

 F(); //lỗi khi dịch

 Các hàm chồng sau cũng không hợp lệ

 Khai báo

 void P(int[] a) {...}

 void P(params int[] a) {...}

 Gọi hàm

 int[] a = {1, 2, 3};

 P(a);

 P(1, 2, 3);

HÀM KHỞI TẠO CỦA LỚP

 Phương thức được thực hiện khi người dùng tạo ra một đối tượng gọi là hàm khởi tạo của lớp

 Hàm khởi tạo cũng bị nạp chồng

 Trong hàm khởi tạo có thể gọi hàm khởi tạo khác, sử dụng từ khóa this

HÀM KHỞI TẠO MẶC ĐỊNH

 Nếu người dùng không định nghĩa hàm khởi tạo khi xây dựng lớp thì hệ thống sử dụng hàm khởi tạo mặc định, không có tham số.

class C { int x; }

C c = new C(); // ok

 Hàm tạo mặc định khởi tạo trường dữ liệu theo nguyên tắc sau:

số 0

enum 0

bool false

char '\0'

tham chiếu null

 Nếu class khai báo hàm tạo, thì hàm tạo mặc định sẽ không được tạo ra

class C {

int x;

public C(int y) { x = y; }

}

C c1 = new C(); // lỗi khi dịch chương trình

C c2 = new C(3); // ok

HÀM KHỞI TẠO TĨNH

 Không có tham số và không sử dụng từ khoá public hoặc private

 Mỗi class/struct chỉ có một hàm tạo static

 Nó chỉ được viện dẫn một lần trước khi class/struct được sử dụng.

 Được sử dụng để khởi tạo các trường dữ liệu static

HÀM KHỞI TẠO SAO CHÉP

 Hàm khởi tạo sao chép thực hiện sao chép tất cả các biến từ một đối tượng đã có và cùng một kiểu dữ liệu.

TỪ KHÓA this

 Từ khóa this được dùng để tham chiếu đến thể hiện hiện thời của một đối tượng

 Từ khóa this được xem là con trỏ ẩn đến tất cả các phương thức không có thuộc tính tĩnh trong một lớp.

 Tham chiếu this được sử dụng theo ba cách

 Sử dụng khi các biến thành viên bị che lấp bởi tham số đưa vào

 Sử dụng tham chiếu this để truyền đối tượng hiện hành vào một tham số của một phương thức đối tượng khác

 Sử dụng tham chiếu this như là mảng chỉ mục (indexer)

HÀM HỦY CỦA LỚP

 Được gọi trên một đối tượng trước khi bị xoá bởi garbage collector.

 Hàm huỷ của lớp cơ sở được tự động gọi vào cuối cùng

 Không sử dụng từ khoá public hoặc private.

 Struct không cần có hàm huỷ

 Ví dụ

class Test {

~Test() {

... cleanup actions ...

}

}

INDEXER

 Indexer được sử dụng để đánh chỉ số cho một tập hợp

class File {

FileStream s;

public int this [int index] {

get {s.Seek(index, SeekOrigin.Begin);

return s.ReadByte();

}

set {s.Seek(index, SeekOrigin.Begin);

s.WriteByte((byte)value);

}

}

}

Sử dụng

File f = ...;

int x = f[10]; // gọi phương thức f.get(10)

f[10] = 'A'; // gọi phương thức f.set(10, 'A')

 Có thể bỏ qua phương thức get hoặc set (read-only hoặc write-only)

 Indexer có thể bị chồng với nhiều kiểu chỉ số khác nhau

INDEXER

class MonthlySales {

int[] apples = new int[12];

int[] bananas = new int[12];

...

public int this[int i] {

// bỏ qua phương thức set => read-only

get { return apples[i-1] + bananas[i-1]; }

}

public int this[string month] {

// indexer bị chồng

get {

switch (month) {

case "Jan": return apples[0] + bananas[0];

case "Feb": return apples[1] + bananas[1];

...

}

}

}

}

MonthlySales sales = new MonthlySales();

Console.WriteLine(sales[1] + sales["Feb"]);

CẤU TRÚC

 Là một kiểu đơn giản, có kích thước nhỏ, dùng để thay thế cho lớp.

 Các đối tượng được cấp phát trên stack (struct là kiểu giá trị)

 Khai báo

[thuộc tính] [bổ sung truy cập] struct <tên cấu trúc> [:<danh sách giao diện>]{

[<thành viên của cấu trúc>]

}

 Ví dụ

struct Point {

int x, y;

public Point(int x, int y) { this.x = x; this.y = y; }

public MoveTo (int x, int y) {...}

}

CẤU TRÚC

 Cấu trúc có thể được cấp phát với từ khóa new

Point p; // các trường dữ liệu của p chưa được khởi tạo

Point q = new Point();

 Các trường dữ liệu không được khởi tạo lúc khai báo

struct Point {

int x = 0; // lỗi dịch chương trình

}

 Cấu trúc không hỗ trợ việc thừa kế nhưng có thể cài đặt cho giao diện

 Cấu trúc không có bộ hủy và bộ khởi tạo mặc định tùy chọn

HÀM KHỞI TẠO CỦA struct

 Chương trình dịch sẽ tạo ra hàm tạo mặc định, không có tham số cho tất cả các struct (kể cả struct đã khai báo hàm tạo)

 Không cần phải khai báo hàm tạo không có tham số cho struct

 Hàm tạo của struct phải khởi tạo tất cả các trường dữ liệu

CLASS & STRUCT

Class System.Object

 Là class cơ sở của tất cả các kiểu tham chiếu

class Object {

public virtual bool Equals(object o) {...}

public virtual string ToString() {...}

public virtual int GetHashCode() {...}

...

}

 Có thể được sử dụng như các kiểu chuẩn: object

object obj; // chương trình dịch sẽ ánh xạ kiểu object sang kiểu System.Object

 Có thể gán đối tượng của kiểu Object cho bất kỳ kiểu tham chiếu nào

obj = new Rectangle();

obj = new int[3];

 Các phương thức của Object có thể làm việc trên bất kỳ kiểu tham chiếu nào

void Push(object x) {...}

Push(new Rectangle());

Push(new int[3]);

Boxing và Unboxing

 Các kiểu giá trị (int, struct, enum) tương thích với kiểu object

Boxing :

object obj = 3;

gói giá trị 3 vào một đối tượng trên heap (wrap)

Unboxing :

int x = (int) obj;

trả giá trị từ đối tượng trên heap (unwrap)

Boxing và Unboxing

class Queue {

...

public void Enqueue(object x) {...}

public object Dequeue() {...}

...

}

Queue có thể sử dụng cả kiểu tham chiếu và kiểu giá trị

Queue q = new Queue();

q.Enqueue(new Rectangle());

q.Enqueue(3);

Rectangle r = (Rectangle) q.Dequeue();

int x = (int) q.Dequeue();

NẠP CHỒNG TOÁN TỬ

Đặng Thành Trung

VÍ DỤ

 Xây dựng lớp phân số có thể thực hiện các phép toán số học : cộng, trừ, nhân chia, ...

 Có hai cách xây dựng các phép toán

 Dùng phương thức :

Faction theSum,firstFraction, secondFraction;

the Sum = firstFraction.add(secondFraction);

 Dùng toán tử

Faction theSum,firstFraction, secondFraction;

the Sum = firstFraction+secondFraction;

SỬ DỤNG TỪ KHÓA operator

 Các toán tử là các phương thức tĩnh. Giá trị trả về thể hiện kết quả của một toán tử và các tham số là toán hạng.

 Tạo một toán tử cho một lớp tức là thực hiện việc lạp chồng.

 Toán tử nạp chồng được khai báo sử dụng từ khóa operator

 Ví dụ

class Fraction {

int x, y;

public Fraction (int x, int y) {this.x = x; this.y = y; }

public static Fraction operator + (Fraction a, Fraction b) {

return new Fraction(a.x * b.y + b.x * a.y, a.y * b.y);

}

}

 Sử dụng

Fraction a = new Fraction(1, 2);

Fraction b = new Fraction(3, 4);

Fraction c = a + b; // c.x == 10, c.y == 8

MỘT SỐ LUẬT

 Định nghĩa những toán tử trong kiểu dữ liệu giá trị, kiểu do ngôn ngữ xây dựng sẵn

 Cung cấp những phương thức nạp chồng toán tử chỉ bên trong của lớp nơi mà những phương thức được định nghĩa.

 Sử dụng tên và những ký hiệu qui ước mô tả trong Common Language Specification (CLS)

 Phải cung cấp các phương thức thay thế cho toán tử nạp chồng

MỘT SỐ LUẬT

MỘT SỐ LUẬT

MỘT SỐ LUẬT

TOÁN TỬ SO SÁNH BẰNG

 Nếu nạp chồng toán tử so sánh bằng (==), nên phủ quyết phương thức ảo Equals của lớp object và chuyển lại cho toán tử so sánh bằng thực hiện.

 Ví dụ

public overide bool Equals(object o)

{

if ( !(o is Fraction) ) return false;

return this == (Fraction) o;

}

 Nạp chồng toán tử có tính đối xứng, tức là nếu toán tử so sánh bằng được nạp chồng thì cũng phải nạp chồng toán tử không bằng (!=).

 Nếu toán tử (==) và (!=) mà được nạp chồng và phương thức Equals không được nạp chồng thì chương trình sẽ cảnh báo.

VÍ DỤ

using System;

public class Fraction

{

public Fraction(int numerator,int denominator)

{

Console.WriteLine("In Fraction Constructor( int, int) ");

this.numerator = numerator;

this.denominator = denominator;

}

public Fraction(int wholeNumber)

{

Console.WriLine("In Fraction Constructor( int )");

numerator = wholeNumber;

denominator = 1;

}

public static implicit operator Fraction( int theInt )

{

Console.WriteLine(" In implicit conversion to Fraction");

return new Fraction( theInt );

}

VÍ DỤ

public static explicit operator int( Fraction theFraction )

{

Console.WriteLine("In explicit conversion to int");

return theFraction.numerator / theFraction.denominator;

}

public static bool operator == ( Fraction lhs, Fraction rhs)

{

Console.WriteLine("In operator ==");

if ( lhs.numerator == rhs.numerator &&

lhs.denominator == rhs.denominator ) return true;

// thực hiện khi hai phân số không bằng nhau

return false;

}

public static bool operator != ( Fraction lhs, Fraction rhs)

{

Console.WriteLine("In operator !=");

return !( lhs == rhs );

}

public override bool Equals( object o )

{

Console.WriteLine("In method Equals");

if ( !(o is Fraction )) return false;

return this == ( Fraction ) o;

}

VÍ DỤ

public static Fraction operator+( Fraction lhs, Fraction rhs )

{

Console.WriteLine("In operator +");

if (lhs.denominator == rhs.denominator )

return new Fraction( lhs.numerator + rhs.numerator, lhs.denominator );

//thực hiện khi hai mẫu số khộng bằng nhau

int firstProduct = lhs.numerator * rhs.denominator;

int secondProduct = rhs.numerator * lhs.denominator;

return new Fraction( firstProduct + secondProduct,

lhs.denominator * rhs.denominator);

}

public override string ToString()

{

string s = numerator.ToString() + "/" + denominator.ToString();

return s;

}

//biến thành viên lưu tử số và mẫu số

private int numerator;

private int denominator;

}

VÍ DỤ

public class Tester

{

static void Main()

{

Fraction f1 = new Fraction( 3, 4);

Console.WriteLine("f1:{0}",f1.ToString());

Fraction f2 = new Fraction( 2, 4);

Console.WriteLine("f2:{0}",f2.ToString());

Fraction f3 = f1 + f2;

Console.WriteLine("f1 + f2 = f3:{0}",f3.ToString());

Fraction f4 = f3 + 5;

Console.WriteLine("f4 = f3 + 5:{0}",f4.ToString());

Fraction f5 = new Fraction( 2, 4);

if( f5 == f2 )

{

Console.WriteLine("f5:{0}==f2:{1}",

f5.ToString(), f2.ToString());

}

}

}

THỪA KẾ VÀ ĐA HÌNH

Đặng Thành Trung

ĐẶC BIỆT HÓA & TỔNG QUÁT HÓA

 Lớp và các thể hiện của lớp (đối tượng) tuy không cùng tồn tại trong cùng một khối nhưng chúng tồn tại trong một mạng lưới các quan hệ phụ thuộc lẫn nhau.

 Quan hệ là một (is-a) là một sự đặc biệt hóa

 Mèo là một loài động vật có vú. Nó có tất cả các đặc tính của một loài động vật có vú và có thêm các thuộc tính đặc trưng riêng của họ nhà mèo.

 Quan hệ đặc biệt hóa & tổng quát hóa là đối ngẫu và phân cấp

 Tạo ra cây quan hệ

 Di chuyển đi lên là tổng quát hóa, ngược lại di chuyển đi xuống là đặc biệt hóa.

KẾ THỪA

 Quan hệ đặc biệt hóa được thực thi bằng cách sử dụng sự kế thừa.

 Trong ngôn ngữ C#, để tạo một lớp kế thừa từ lớp khác, thêm dấu ":" vào sau tên lớp đó

 public class Meo : Dongvatcovu

 Lớp kế thừa (Meo) gọi là lớp dẫn xuất

 Lớp được kế thừa (Dongvatcovu) gọi là lớp được dẫn xuất hoặc lớp cơ sở.

 Lớp dẫn xuất kế thừa tất cả các thành phần của lớp cơ sở.

 Lớp dẫn xuất có thể tạo phương thức mới bằng việc đánh dấu với từ khóa new

VÍ DỤ

class A { // lớp cơ sở

public int a;

public A() {...}

public void F() {...}

}

class B : A { // lớp con (kế thừa từ A, mở rộng A)

int b;

public B() {...}

public void G() {...}

}

 Lớp B kế thừa thuộc tính a và phương thức F, bổ sung thêm thuộc tính b và phương thức G

 Hàm tạo không được kế thừa

 Các phương thức được kế thừa có thể chồng lớp con

 Một lớp chỉ được kế thừa từ lớp khác nhưng có thể cài đặt cho nhiều interface.

 Một lớp chỉ có thể kế thừa từ một lớp khác không phải là struct

 Một lớp không có lớp cơ sở tường minh sẽ kế thừa từ lớp object

GÁN VÀ KIỂM TRA KIỂU

Khai báo

class A {...}

class B : A {...}

class C: B {...}

Lệnh gán

A a = new A(); // kiểu static của biến a là kiểu khi khai báo (A)

// kiểu dynamic type của biến a là kiểu của đối tượng được khởi tạo (A)

a = new B(); // kiểu dynamic là B

a = new C(); // kiểu dynamic là C

B b = a; // lỗi khi dịch chương trình

Kiểm tra kiểu khi thực thi (Toán tử is)

a = new C();

if (a is C) ... // true, nếu kiểu dynamic của a là C hoặc subclass của C

if (a is B) ... // true

if (a is A) ... // true

a = null;

if (a is C) ... // false

ÉP KIỂU

Ép kiểu

A a = new C();

B b = (B) a; // đúng, nếu a có kiểu dynamic là B hoặc subclass của B

C c = (C) a;

a = null;

c = (C) a; // đúng, c = null

Toán tử as

A a = new C();

B b = a as B; // if (a is B) b = (B)a; else b = null;

C c = a as C;

a = null;

c = a as C; // c == null

CHỒNG PHƯƠNG THỨC

Chỉ những phương thức được khai báo với từ khoá virtual mới được chồng.

class A {

public void F() {...} // F không được chồng

public virtual void G() {...} // Có thể chồng G trong subclass

}

Các phương thức chồng được khai báo với từ khoá override

class B : A {

public void F() {...} // nên sử dụng từ khoá new

public void G() {...} // nên sử dụng từ khoá new

public override void G() { // ok: chồng toán tử G

... base.G(); // gọi G() của lớp cơ sở

}

}

 Thuộc tính và indexer cũng được chồng.

 Phương thức static không được chồng

GÁN ĐỘNG

class A {

public virtual void WhoAreYou() {Console.WriteLine("I am an A"); }

}

class B : A {

public override void WhoAreYou() { Console.WriteLine("I am a B"); }

}

Thông điệp viện dẫn phương thức phụ thuộc vào kiểu dynamic của đối tượng.

A a = new B();

a.WhoAreYou(); // "I am a B"

Ưu điểm: mọi phương thức có thể làm việc với A đều làm việc được với B

void Use (A x) {

x.WhoAreYou();

}

Use(new A()); // "I am an A"

Use(new B()); // "I am a B"

ẨN

Trong subclass, các thành phần được khai báo với từ khoá new sẽ ẩn tất cả các thành phần có cùng tên và dấu hiệu trong baseclass.

class A {

public int x;

public void F() {...}

public virtual void G() {...}

}

class B : A {

public new int x;

public new void F() {...}

public new void G() {...}

}

B b = new B();

b.x = ...; // truy nhập tới B.x

b.F(); ... b.G(); // gọi tới B.F và B.G

((A)b).x = ...; // truy nhập tới A.x

((A)b).F(); ... ((A)b).G(); // gọi tới A.F và A.G

VÍ DỤ

class Animal {

public virtual void WhoAreYou() { Console.WriteLine("I am an animal"); }

}

class Cat : Animal {

public override void WhoAreYou() { Console.WriteLine("I am a cat"); }

}

Animal pet = new Cat();

pet.WhoAreYou(); // "I am a cat"

HÀM TẠO VÀ THỪA KẾ

PROTECTED VÀ INTERNAL

protected có thể được truy nhập trong cùng class và các subclass của nó

internal có thể được truy nhập trong cùng assembly

protected internal có thể được truy nhập trong cùng class và các subclass của nó, nhưng phải thuộc cùng một assembly

Ví dụ

class Stack {

protected int[] values = new int[32];

protected int top = -1;

public void Push(int x) {...}

public int Pop() {...}

}

class BetterStack : Stack {

public bool Contains(int x) {

foreach (int y in values) if (x == y) return true;

return false;

}

}

class Client {

Stack s = new Stack();

... s.values[0] ... // lỗi khi dịch

}

LỚP TRỪU TƯỢNG

Ví dụ

abstract class Stream {

public abstract void Write(char ch);

public void WriteString(string s) { foreach (char ch in s) Write(s); }

}

class File : Stream {

public override void Write(char ch) {... ghi ch vào bộ nhớ ...}

}

Chú ý

 Các phương thức abstract không có phần cài đặt.

 Nếu một lớp có phương thức abstract (do khai báo hoặc do kế thừa) thì lớp đó phải là lớp trừu tượng.

 Không thể tạo ra đối tượng của lớp trừu tượng

THUỘC TÍNH VÀ INDEXER TRỪU TƯỢNG

Ví dụ

abstract class Sequence {

public abstract void Add(object x); // phương thức

public abstract string Name { get; } // thuộc tính

public abstract object this [int i] { get; set; } // indexer

}

class List : Sequence {

public override void Add(object x) {...}

public override string Name { get {...} }

public override object this [int i] { get {...} set {...} }

}

Chú ý

 Các thuộc tính và indexer được chồng phải có cùng các phương thức get/set tương tự như trong baseclass

LỚP CÔ LẬP (SEALED CLASS)

Ví dụ

sealed class Account : Asset {

long val;

public void Deposit (long x) { ... }

public void Withdraw (long x) { ... }

...

}

Chú ý

 Không thể kế thừa từ sealed class, nhưng sealed class vẫn kế thừa từ lớp khác.

 Cũng có thể sử dụng từ khoá sealed với các phương thức

LỚP TỔNG QUAN (System.object)

System.Object là baseclass của tất cả các lớp

class Object {

protected object MemberwiseClone() {...}

public Type GetType() {...}

public virtual bool Equals (object o) {...}

public virtual string ToString() {...}

public virtual int GetHashCode() {...}

}

Sử dụng trực tiếp

Type t = x.GetType(); trả về kiểu được khai báo của x

object copy = x.MemberwiseClone(); tạo ra bản sao

Chồng trong subclass:

x.Equals(y) so sánh giá trị của x và y

x.ToString() trả về xâu biểu diễn x

int code = x.getHashCode(); trả về mã băm của x

VÍ DỤ VỀ LỚP System.object

class Fraction {

int x, y;

public Fraction(int x, int y) { this.x = x; this.y = y; }

...

public override string ToString() { return String.Format("{0}/{1}", x, y); }

public override bool Equals(object o) { Fraction f = (Fraction)o; return f.x == x && f.y == y; }

public override int GetHashCode() { return x ^ y; }

public Fraction ShallowCopy() { return (Fraction) MemberwiseClone(); }

}

class Client {

static void Main() {

Fraction a = new Fraction(1, 2);

Fraction b = new Fraction(1, 2);

Fraction c = new Fraction(3, 4);

Console.WriteLine(a.ToString()); // 1/2

Console.WriteLine(a); // 1/2 (ToString được gọi tự động)

Console.WriteLine(a.Equals(b)); // true

Console.WriteLine(a == c); // false

Console.WriteLine(a.GetHashCode()); // 3

a = c.ShallowCopy();

Console.WriteLine(a); // 3/4

}

}

INTERFACE - GIAO DIỆN

Đặng Thành Trung

CÚ PHÁP

public interface IList : ICollection, IEnumerable {

int Add (object value); // methods

bool Contains (object value);

...

bool IsReadOnly { get; } // property

...

object this [int index] { get; set; } // indexer

}

 Interface là abstract class; không có phần cài đặt.

 Có thể chứa methods, properties, indexers and events

(không chứa trường dữ liệu, hằng, hàm tạo, hàm huỷ, toán tử, kiểu lồng).

 Các thành phần của interface là public abstract (virtual).

 Các thành phần của interface không thể là static.

 Class và struct có thể cài đặt nhiều interface.

 Interface có thể mở rộng các interface khác.

interface được cài đặt bởi class và struct

class MyClass : MyBaseClass, IList, ISerializable {

public int Add (object value) {...}

public bool Contains (object value) {...}

...

public bool IsReadOnly { get {...} }

...

public object this [int index] { get {...} set {...} }

}

 Một class chỉ kế thừa từ một baseclass, nhưng có thể cài đặt cho nhiều interface.

Một struct không kế thừa, nhưng có thể cài đặt cho nhiều interface.

 Tất cả các thành phần của interface (method, property, indexer) đều phải được cài đặt hoặc được thừa kế.

 Khi cài đặt các phương thức của interface không cần sử dụng từ khoá override, có thể sử dụng từ khoá virtual hoặc abstract .

 Nếu phương thức Add của MyClass được chồng trong các subclass thì nó nên được khai báo với từ khoá virtual .

THỰC THI GIAO DIỆN

Gán: MyClass c = new MyClass();

IList list = c;

Gọi phương thức: list.Add("Tom"); // gán động => myClass.Add

Kiểm tra kiểu: if (list is MyClass) ... // true

if (list is ISerializable) ... // true

Ép kiểu: c = list as MyClass;

c = (MyClass) list;

ISerializable ser = (ISerializable) list;

VÍ DỤ

interface ISimpleReader {

int Read();

}

interface IReader : ISimpleReader {

void Open(string name);

void Close();

}

class Terminal : ISimpleReader {

public int Read() { ... }

}

class File : IReader {

public int Read() { ... }

public void Open(string name) { ... }

public void Close() { ... }

}

// null có thể được gán cho các biến của các kiểu interface

ISimpleReader sr = null; sr = new Terminal();

sr = new File();

IReader r = new File();

sr = r;

XUNG ĐỘT TÊN

Xảy ra khi có hai interface cơ sở có phương thức cùng tên

interface I1 {

void F();

}

interface I2 {

void F();

}

class B : I1, I2 {

//-----cài đặt phương thức F của class B

public void F() { Console.WriteLine("B.F"); }

//----- cài đặt phương thức F cho từng interface

void I1.F() { Console.WriteLine("I1.F"); }

void I2.F() { Console.WriteLine("I2.F"); } // phải là public

}

B b = new B();

b.F(); // B.F

I1 i1 = b;

i1.F(); // I1.F

I2 i2 = b;

i2.F(); // I2.F

DELEGATE - ỦY QUYỀN

Đặng Thành Trung

delegate

 delegate là kiểu dữ liệu đặc biệt, có khả năng lưu trữ một tham chiếu tới phương thức có dấu hiệu cụ thể (tức là các tham số và kiểu trả về của phương thức).

 delegate có thể viện dẫn các phương thức một cách động khi sự kiện xảy ra.

 delegate không quan tâm tới những lớp đối tượng mà nó tham chiếu tới.

delegate LÀ KIỂU PHƯƠNG THỨC

Khai báo kiểu delegate

delegate void Notifier (string sender);// tương tự khai báo phương thức

// sử dụng từ khoá delegate

Khai báo biến delegate

Notifier greetings;

Gán một phương thức cho biến delegate

void SayHello(string sender) {

Console.WriteLine("Hello from " + sender);

}

greetings = new Notifier(SayHello);

Lời gọi biến delegate

greetings("John"); // viện dẫn phương thức SayHello("John") => "Hello from John"

GÁN PHƯƠNG THỨC KHÁC NHAU

 Tất cả các phương thức phù hợp với delegate đều có thể được gán với biến delegate đó

void SayGoodBye(string sender) {

Console.WriteLine("Good bye from " + sender);

}

greetings = new Notifier(SayGoodBye);

greetings("John");// SayGoodBye("John") => "Good bye from John"

Chú ý

 Biến delegate có thể được gán giá trị null (không có phương thức nào được gán cho nó).

 Nếu biến delegate bằng null thì sẽ không được gọi

TẠO GIÁ TRỊ CỦA delegate

new DelegateType (obj.Method)

 Biến delegate chứa phương thức và đối tượng nhận, nhưng không chứa tham số

new Notifier(myObj.SayHello);

 Đối tượng có thể là this (và có thể bỏ qua)

new Notifier(SayHello);

 Phương thức có thể là static. Trong trường hợp này, tên của class phải được thay thế cho đối tượng.

new Notifier(MyClass.StaticSayHello);

 Phương thức không thể là abstract, nhưng có thể là virtual, override, hoặc new.

 Dấu hiệu của phương thức phải trùng với dấu hiệu của DelegateType

- số lượng tham số

- kiểu dữ liệu của tham số (bao gồm cả kiểu trả về)

- kiểu truyền tham số (ref, out, value)

MULTICAST delegate

 Biến delegate có thể chứa nhiều giá trị cùng một thời điểm

Notifier greetings;

greetings = new Notifier(SayHello);

greetings += new Notifier(SayGoodBye);

greetings("John"); // "Hello from John"

// "Good bye from John"

greetings -= new Notifier(SayHello);

greetings("John"); // "Good bye from John"

 Chú ý

 Nếu multicast delegate là một hàm, thì sẽ trả về giá trị của lời gọi cuối cùng

 Nếu multicast delegate có tham số out, tham số của lời gọi cuối cùng sẽ được trả về. Tham số ref được truyền qua tất cả các phương thức.

Event là delegate đặc biệt

class Model {

public event Notifier notifyViews;

public void Change() { ... notifyViews("Model"); }

}

class View {

public View(Model m) { m.notifyViews += new Notifier(Update); }

void Update(string sender) { Console.WriteLine(sender + " was changed"); }

}

class Test {

static void Main() {

Model model = new Model();

new View(model); new View(model); ...

model.Change();

}

}

Tại sao phải sử dụng event để thay thế cho các biến delegate khác?

 Chỉ class khai báo event thì mới được kích hoạt nó

 Các class khác có thể thay đổi event bằng toán tử += hoặc -= (nhưng không sử dụng toán tử =)

BẮT SỰ KIỆN

Các delegate dùng để bắt sự kiện có dấu hiệu như sau:

delegate void SomeEvent (object source, MyEventArgs e);

 Kiểu trả về: void

 Tham số thứ nhất: Đối tượng gửi sự kiện (kiểu object)

 Tham số thứ hai: sự kiện (subclass của System.EventArgs)

public class EventArgs {

public static readonly EventArgs Empty;

}

VÍ DỤ

public delegate void KeyEventHandler (object sender, KeyEventArgs e);

public class KeyEventArgs : EventArgs {

public virtual bool Alt { get {...} } // true nếu nhấn phím Alt

public virtual bool Shift { get {...} } // true nếu nhấn phím Shift

public bool Control { get {...} }// true nếu nhấn phím Ctrl

public bool Handled { get{...} set {...} } // cho biết có bắt được sự kiện không

public int KeyValue { get {...} }// mã phím

...

}

class MyKeyEventSource {

public event KeyEventHandler KeyDown;

public KeyPressed() {

KeyDown(this, new KeyEventArgs(...));

}

}

class MyKeyListener {

public MyKeyListener(...) { keySource.KeyDown += new KeyEventHandler(HandleKey);}

void HandleKey (object sender, KeyEventArgs e) {...}

}

EXCEPTION - NGOẠI LỆ

Đặng Thành Trung

LỆNH try

FileStream s = null;

try {

s = new FileStream(curName, FileMode.Open);

...

} catch (FileNotFoundException e) {

Console.WriteLine("file {0} not found", e.FileName);

} catch (IOException) {

Console.WriteLine("some IO exception occurred");

} catch {

Console.WriteLine("some unknown error occurred");

} finally {

if (s != null) s.Close();

}

 Mệnh đề catch được kiểm tra theo thứ tự.

 Mệnh đề finally luôn luôn được thực hiện (nếu xuất hiện)

 Tên của Exception trong mệnh đề catch có thể được bỏ qua

 Kiểu của Exception phải thừa kế từ System.Exception.

System.Exception

Thuộc tính

e.Message thông báo lỗi

e.StackTrace vết lưu stack lời gọi phương thức

e.Source ứng dụng hoặc đối tượng trả về Exception

...

Phương thức

e.ToString() Trả về tên của Exception và StackTrace

...

TRẢ VỀ Exception

 Do các thao tác không hợp lệ (ngoại lệ không tường minh)

 Chia cho 0

 Tràn chỉ số

 Truy nhập vào tham số có giá trị null

 ...

 Do lệnh throw (ngoại lệ tường minh)

throw new FunnyException(10);

class FunnyException : ApplicationException {

public int errorCode;

public FunnyException(int x) { errorCode = x; }

}

 (Do lời gọi tới một phương thức có trả ra ngoại lệ nhưng không được bắt)

s = new FileStream(...);

CẤU TRÚC EXCEPTION

 Exception

 SystemException

ArithmeticException

DivideByZeroException

OverflowException

...

NullReferenceException

IndexOutOfRangeException

InvalidCastException

...

 ApplicationException

... user-defined exceptions

...

 IOException

FileNotFoundException

DirectoryNotFoundException

...

 WebException

...

TÌM KIẾM MỆNH ĐỀ catch

 Chuỗi lời gọi sẽ được thực hiện cho đến khi có một phương thức có mệnh đề catch tương ứng được tìm thấy

 Nếu không tìm thấy, chương trình sẽ báo lỗi

EXCEPTION TRONG delegate

 Trong quá trình tìm kiếm mệnh đề catch, delegate cũng được coi như các hàm

exception trong multicast delegate

 Nếu Exc1 được trả ra từ G() thì F() sẽ bắt và sau đó gọi H()

 Nếu Exc2 được trả ra từ G() thì hàm Main() sẽ bắt và H() không được gọi nữa.

THƯ VIỆN

Đặng Thành Trung

TỔNG QUAN

Math

public sealed class Math {

public const double PI = 3.14....;

public const double E = 2.71...;

public static T Abs(T val); // T là kiểu: sbyte, short, int, long, float, double, decimal

public static T Sign(T val);

public static T1 Min(T1 x, T1 y); // T1, T là kiểu: byte, ushort, uint, ulong

public static T1 Max(T1 x, T1 y);

public static double Round(double x);

public static double Floor(double x);

public static double Ceiling(double x);

public static double Sqrt(double x);

public static double Pow(double x, double y); // xy

public static double Exp(double x) // ex

public static double Log(double x); // logex

public static double Log10(double x); // log10x

public static double Sin(double x); // góc tính theo radian

public static double Cos(double x);

public static double Tan(double x);

public static double Asin(double x);

public static double Acos(double x);

public static double Atan(double x);

}

Random

public class Random {

public Random();

public Random(int seed);

public virtual int Next(); // 0 <= res < int.MaxVal

public virtual int Next(int x); // 0 <= res < x

public virtual int Next(int x, int y); // x <= res < y

public virtual double NextDouble(); // 0.0 <= res < 1.0

public virtual void NextBytes(byte[] b); // các phần tử của mảng b là số ngẫu nhiên

}

String

public sealed class String : ICloneable, IComparable, IEnumerable {

public String(char[] a);

public String(char[] a, int start, int len);

public static string Copy(string s);

public static string Format(String s, params object[]);

public static string Join(string separator, string[] parts);

public static bool operator ==(bool a, bool b);

public static bool operator !=(bool a, bool b);

public int Length { get; }

public char this[int i] { get; }

public override bool Equals(object o);

public int CompareTo(object o);

public static int CompareOrdinal(string a, string b);

public void CopyTo(int from, char[] dest, int to, int len);

public bool StartsWith(string s);

public bool EndsWith(string s);

public int IndexOf(T s); // T ... string, char

public int LastIndexOf(T s);

public string Substring(int pos);

public string Substring(int pos, int len);

public string[] Split(params char[]);

public char[] ToCharArray();

...

}

Chuyển đổi giữa string và số

public sealed class Convert { // namespace System

public static string ToString(T x); // T là kiểu số bất kỳ

public static bool ToBoolean(string s);

public static byte ToByte(string s);

public static sbyte ToSByte(string s);

public static char ToChar(string s);

public static short ToInt16(string s);

public static int ToInt32(string s);

public static long ToInt64(string s);

public static ushort ToUInt16(string s);

public static uint ToUInt32(string s);

public static ulong ToUInt64(string s);

public static float ToSingle(string s);

public static double ToDouble(string s);

public static decimal ToDecimal(string s);

...

}

string s = Convert.ToString(123); // "123"

s = 123.ToString(); // "123"

int i = Convert.ToInt32(s); // 123

StringBuilder

public sealed class StringBuilder { // namespace System.Text

public StringBuilder();

public StringBuilder(int initCapacity);

public StringBuilder(string s);

public StringBuilder(string s, int from, int len);

public int Length { get; set; }

public int Capacity { get; set; }

public char this[int i] { get; set; }

public StringBuilder Append(T x); // T là kiểu string hoặc kiểu số

public StringBuilder Insert(int pos, T x);

public StringBuilder Remove(int pos, int len);

public StringBuilder Replace(T x, T y); // T là kiểu string, char

public bool Equals(object x);

public string ToString();

...

}

Ví dụ

StringBuilder b = new StringBuilder("A.C");

b.Insert(2, "B.");

b.Replace('.', '/');

Console.WriteLine(b.ToString()); // A/B/C

Collection class

Array

Tất cả các mảng đều kế thừa từ lớp Array

public abstract class Array : IList, ICloneable, IEnumerable{ // namespace System

public int Length { get; } // tổng số các phần tử trong các chiều

public int Rank { get; } // tổng số các chiều

public static void Clear(Array a, int pos, int length);

public static void Copy(Array src, int from, Array dst, int to, int len);

public static int IndexOf(Array a, object x);

public static int LastIndexOf(Array a, object x);

public static void Reverse(Array a);

public static void Sort(Array a);

public static int BinarySearch(Array a, object x);

public virtual object Clone();

public virtual bool Equals(object x);

public int GetLength(int dimension);

...

}

Ví dụ

int[] a = {17, 3, 5, 9, 6};

Array.Sort(a);

Array.Reverse(a);

foreach (int x in a) Console.Write("{0} ", x); // 17 9 6 5 3

ArrayList

Mảng động

public class ArrayList : IList, IEnumerable, ICloneable { // namespace System.Collections

public ArrayList();

public ArrayList(int initCapacity);

public ArrayList(ICollection c);

public virtual int Count { get; }

public virtual int Capacity { get; set; }

public virtual object this[int i] { get; set; }

public virtual void Clear();

public virtual int Add(object x);

public virtual void Insert(int pos, object x);

public virtual void Remove(object x);

public virtual void RemoveAt(int pos);

public virtual object Clone();

public virtual bool Equals(object x);

public virtual bool Contains(object x);

public virtual int IndexOf(object x);

public virtual void Reverse();

public virtual void Sort();

public virtual int BinarySearch(object x);

...

}

Ví dụ ArrayList

using System;

using System.Collections;

class Test {

static void Main(string[] arg) {

ArrayList a = new ArrayList();

foreach (string s in arg) a.Add(s);

a.Sort();

Console.Write("a = ");

for (int i = 0; i < a.Count; i++) Console.Write("{0} ", a[i]);

Console.WriteLine();

int pos = a.BinarySearch("Tom");

if (pos >= 0)

Console.WriteLine("Tom found at {0}", pos);

else

Console.WriteLine("Tom not found");

}

}

Aufruf: Test John Tom Alice Charly

Ausgabe:

a = Alice Charly John Tom

Tom found at 3

ListDictionary

Tương tự như danh sách liên lết

public class ListDictionary : IDictionary, IEnumerable { // System.Collections.Specialized

public ListDictionary();

public int Count { get; }

public ICollection Keys { get; }

public ICollection Values { get; }

public object this[object key] { get; set; }

public void Clear();

public void Add(object key, object value);

public void Remove(object key);

public bool Contains(object key);

public virtual bool Equals(object x);

public IDictionaryEnumerator GetEnumerator();

...

}

Ví dụ

ListDictionary population = new ListDictionary();

population["Vienna"] = 1592600;

population["London"] = 7172000 ;

population["Paris"] = 2305000;

...

foreach (DictionaryEntry x in tab) Console.WriteLine("{0} = {1}", x.Key, x.Value);

Hashtable

public class Hashtable : IDictionary, IEnumerable, ISerializable, ICloneable { // System.Collections

public HashTable();

public virtual object Clone();

public virtual bool ContainsKey(object key);

public virtual bool ContainsValue(object value);

}

Ví dụ

Hashable population = new Hashtable();

population["Vienna"] = 1592600;

population["London"] = 7172000;

population["Paris"] = 2305000;

...

foreach (DictionaryEntry x in population) Console.WriteLine("{0} = {1}", x.Key, x.Value);

SortedList

Là mảng và được sắp xếp bởi Key

public class SortedList : IDictionary, IEnumerable, ICloneable { // System.Collections

public SortedList(); // variants exist

//... gleiche Members wie Hashtable; zusätzlich:

public virtual int Capacity { get; set; }

public virtual object GetKey(int i); // returns Key[i]

public virtual object GetByIndex(int i); // returns Value[i]

public virtual void SetByIndex(int i, object value);

public virtual IList GetKeyList();

public virtual IList GetValueList();

public virtual int IndexOfKey(object key);

public virtual int IndexOfValue(object value); // returns index of the first occurrence of value

public virtual void RemoveAt(int i);

}

Ví dụ

SortedList population = new SortedList();

population["Vienna"] = 1592600;

population["London"] = 7172000;

...

foreach (DictionaryEntry x in population) Console.WriteLine("{0} = {1}", x.Key, x.Value);

// in ra các phần tử được sắp xếp theo Key

Stack

public class Stack : ICollection, IEnumerable, ICloneable { // System.Collections

public Stack();

public Stack(int initCapacity);

public virtual int Count { get; }

public virtual void Clear();

public virtual void Push(object x);

public virtual object Pop();

public virtual object Peek();

public virtual bool Contains(object x);

public virtual object Clone();

public virtual IEnumerator GetEnumerator();

public virtual object[] ToArray();

...

}

Ví dụ

Stack s = new Stack();

for (int i = 0; i <= 20; i++) s.Push(i);

while (s.Count > 0) Console.Write("{0} ", (int)s.Pop()); // trả về 20 19 18 17 ... 0

Queue

public class Queue : ICollection, IEnumerable, ICloneable { // System.Collections

public Queue();

public virtual int Count { get; }

public virtual void Clear();

public virtual void Enqueue(object x);

public virtual object Dequeue();

public virtual object Peek();

public virtual bool Contains(object x);

public virtual object Clone();

public virtual IEnumerator GetEnumerator();

public virtual object[] ToArray();

...

}

Ví dụ

Queue q = new Queue();

q.Enqueue("one");

q.Enqueue("two");

q.Enqueue("three");

foreach (string s in q) Console.Write(s + " "); // one two three

// q vẫn đầy

Console.WriteLine();

while (q.Count > 0) Console.Write((string)q.Dequeue() + " "); // one two three

// q rỗng

Stream class

Ví dụ FileStream

using System;

using System.IO;

class Test {

static void Copy(string from, string to, int pos) {

try {

FileStream sin = new FileStream(from, FileMode.Open);

FileStream sout = new FileStream(to, FileMode.Create);

sin.Seek(pos, SeekOrigin.Begin); // di chuyển tới cuối file

int ch = sin.ReadByte();

while (ch >= 0) {

sout.WriteByte((byte)ch);

ch = sin.ReadByte();

}

sin.Close();

sout.Close();

} catch (FileNotFoundException e) {

Console.WriteLine("-- file {0} not found", e.FileName);

}

}

static void Main(string[] arg) {

Copy(arg[0], arg[1], 10);

}

}