GIÁO TRÌNH

Giáo trình ngôn ngữ lập trình C#

Science and Technology

Sử dụng các thành viên tĩnh (static member)

Tác giả: Khuyet Danh

Sử dụng các thành viên tĩnh(static member)

Chúng ta có thể truy cập đến thành viên tĩnh của một lớp thông qua tên lớp đã được khai báo. Ví dụ chúng ta có một lớp tên là Button và có hai thể hiện của lớp tên là btnUpdate và btnDelete. Và giả sử lớp Button này có một phương thức tĩnh là Show(). Để truy cập phương thức tĩnh này ta viết :

Button.Show();

Đúng hơn là viết:

btnUpdate.Show();

Trong ngôn ngữ C# không cho phép truy cập đến các phương thức tĩnh và các biến thành viên tĩnh thông qua một thể hiện, nếu chúng ta cố làm điều đó thì trình biên dịch C# sẽ báo lỗi, điều này khác với ngôn ngữ C++.

Trong một số ngôn ngữ thì có sự phân chia giữa phương thức của lớp và các phương thức khác (toàn cục) tồn tại bên ngoài không phụ thuộc bất cứ một lớp nào. Tuy nhiên, điều này không cho phép trong C#, ngôn ngữ C# không cho phép tạo các phương thức bên ngoài của lớp, nhưng ta có thể tạo được các phương thức giống như vậy bằng cách tạo các phương thức tĩnh bên trong một lớp.

Phương thức tĩnh hoạt động ít nhiều giống như phương thức toàn cục, ta truy cập phương thức này mà không cần phải tạo bất cứ thể hiện hay đối tượng của lớp chứa phương thức toàn cục. Tuy nhiên, lợi ích của phương thức tĩnh vượt xa phương thức toàn cục vì phương thức tĩnh được bao bọc trong phạm vi của một lớp nơi nó được định nghĩa, do vậy ta sẽ không gặp tình trạng lộn xộn giữa các phương thức trùng tên do chúng được đặt trong namespace.

Chúng ta không nên bị cám dỗ bởi việc tạo ra một lớp chứa toàn bộ các phương thức linh tinh. Điều này có thể tiện cho công việc lập trình nhưng sẽ điều không mong muốn và giảm tính ý nghĩa của việc thiết kế hướng đối tượng. Vì đặc tính của việc tạo các đối tượng là xây dựng các phương thức và hành vi xung quanh các thuộc tính hay dữ liệu của đối tượng.

Gọi một phương thức tĩnh

Như chúng ta đã biết phương thức Main() là một phương thức tĩnh. Phương tĩnh được xem như là phần hoạt động của lớp hơn là của thể hiện một lớp. Chúng cũng không cần có một tham chiếu this hay bất cứ thể hiện nào tham chiếu tới.

Phương thức tĩnh không thể truy cập trực tiếp đến các thành viên không có tính chất tĩnh (nonstatic). Như vậy Main() không thể gọi một phương thức không tĩnh bên trong lớp. Ta xem lại đoạn chương trình minh họa trong ví dụ bài trước :

using System;
    public class Class1
    {
    public void SomeMethod(int p1, float p2)
    {
    Console.WriteLine("Ham nhan duoc hai tham so: {0} va {1}", p1,p2);
    }
    }
    public class Tester
    {
    static void Main()
    {
    int var1 = 5;
    float var2 = 10.5f;
    Class1 c = new Class1();
    c.SomeMethod( var1, var2 );
    }
    }

Phương thức SomeMethod() là phương thức không tĩnh của lớp Class1, do đó để truy cập được phương thức của lớp này cấn phải tạo một thể hiện là một đối tượng cho lớp Class1.

Sau khi tạo thì có thể thông qua đối tượng c ta có thể gọi được được phương thức Some- Method().

Sử dụng bộ khởi dựng tĩnh

Nếu một lớp khai báo một bộ khởi tạo tĩnh (static constructor), thì được đảm bảo rằng phương thức khởi dựng tĩnh này sẽ được thực hiện trước bất cứ thể hiện nào của lớp được tạo ra.

Chúng ta không thể điều khiển chính xác khi nào thì phương thức khởi dựng tĩnh này được thực hiện. Tuy nhiên ta biết chắc rằng nó sẽ được thực hiện sau khi chương trình chạy và trước bất kì biến đối tượng nào được tạo ra.

Ta có thể thêm một bộ khởi dựng tĩnh cho lớp ThoiGian như sau:

static ThoiGian()
    {
    Ten = "Thoi gian";
    }

Ở đây không có bất cứ thuộc tính truy cập nào như public trước bộ khởi dựng tĩnh. Thuộc tính truy cập không cho phép theo sau một phương thức khởi dựng tĩnh. Do phương thức tĩnh nên không thể truy cập bất cứ biến thành viên không thuộc loại tĩnh.

Vì vậy biến thành viên Name bên trên cũng phải được khai báo là tĩnh:

private static string Ten;

Cuối cùng ta thêm một dòng vào phương thức ThoiGianHienHanh() của lớp ThoiGian:

public void ThoiGianHienHanh()
    {
    System.Console.WriteLine(" Ten: {0}", Ten); 
    System.Console.WriteLine(" Thoi Gian:\t {0}/{1}/{2} {3}:{4}:{5}",Ngay, Thang, Nam, Gio, Phut, Giay);
    }

Sau khi thay đổi ta biên dịch và chạy chương trình được kết quả sau:

Ten: Thoi Gian

Thoi Gian: 5/6/2002 18:35:20

Mặc dù chương trình thực hiện tốt, nhưng không cần thiết phải tạo ra bộ khởi dựng tĩnh để phục vụ cho mục đích này. Thay vào đó ta có thể dùng chức năng khởi tạo biến thành viên như sau:

private static string Ten = "Thoi Gian";

Tuy nhiên, bộ khởi tạo tĩnh có hữu dụng khi chúng ta cần cài đặt một số công việc mà không thể thực hiện được thông qua chức năng khởi dựng và công việc cài đặt này chỉ được thực hiện duy nhất một lần.

Sử dụng bộ khởi dựng private

Như đã nói ngôn ngữ C# không có phương thức toàn cục và hằng số toàn cục. Do vậy chúng ta có thể tạo ra những lớp tiện ích nhỏ chỉ để chứa các phương thức tĩnh. Cách thực hiện này luôn có hai mặt tốt và không tốt. Nếu chúng ta tạo một lớp tiện ích như vậy và không muốn bất cứ một thể hiện nào được tạo ra. Để ngăn ngừa việc tạo bất cứ thể hiện của lớp ta tạo ra bộ khởi dựng không có tham số và không làm gì cả, tức là bên trong thân của phương thức rỗng, và thêm vào đó phương thức này được đánh dầu là private. Do không có bộ khởi dựng public, nên không thể tạo ra bất cứ thể hiện nào của lớp.

Sử dụng các thuộc tính tĩnh

Một vấn đề đặt ra là làm sao kiểm soát được số thể hiện của một lớp được tạo ra khi thực hiện chương trình. Vì hoàn toàn ta không thể tạo được biến toàn cục để làm công việc đếm số thể hiện của một lớp.

Thông thường các biến thành viên tĩnh được dùng để đếm số thể hiện đã được được tạo ra của một lớp. Cách sử dụng này được áp dụng trong minh họa sau:

Sử dụng thuộc tính tĩnh để đếm số thể hiện.

-----------------------------------------------------------------------------

using System;

public class Cat

{

public Cat()

{

instance++;

}

public static void HowManyCats()

{

Console.WriteLine("{0} cats", instance);

}

private static int instance =0;

}

public class Tester

{

static void Main()

{

Cat.HowManyCats();

Cat mun = new Cat();

Cat.HowManyCats();

Cat muop = new Cat();

Cat miu = new Cat();

Cat.HowManyCats();

}

-----------------------------------------------------------------------------

Kết quả:

0 cats

1 cats

3 cats

-----------------------------------------------------------------------------

Bên trong lớp Cat ta khai báo một biến thành viên tĩnh tên là instance biến này dùng để đếm số thể hiện của lớp Cat, biến này được khởi tạo giá trị 0. Lưu ý rằng biến thành viên tĩnh được xem là thành phần của lớp, không phải là thành viên của thể hiện, do vậy nó sẽ không được khởi tạo bởi trình biên dịch khi tạo các thể hiện. Khởi tạo tường minh là yêu cầu bắt buộc với các biến thành viên tĩnh. Khi một thể hiện được tạo ra thì bộ dựng của lớp Cat sẽ thực hiện tăng biến instance lên một đơn vị.

Hủy đối tượng

Ngôn ngữ C# cung cấp cơ chế thu dọn (garbage collection) và do vậy không cần phải khai báo tường minh các phương thức hủy. Tuy nhiên, khi làm việc với các đoạn mã không được quản lý thì cần phải khai báo tường minh các phương thức hủy để giải phóng các tài nguyên.

C# cung cấp ngần định một phương thức để thực hiện điều khiển công việc này, phương thức đó là Finalize() hay còn gọi là bộ kết thúc. Phương thức Finalize này sẽ được gọi bởi cơ chế thu dọn khi đối tượng bị hủy.

Phương thức kết thúc chỉ giải phóng các tài nguyên mà đối tượng nắm giữ, và không tham chiếu đến các đối tượng khác. Nếu với những đoạn mã bình thường tức là chứa các tham chiếu kiểm soát được thì không cần thiết phải tạo và thực thi phương thức Finalize(). Chúng ta chỉ làm điều này khi xử lý các tài nguyên không kiểm soát được.

Chúng ta không bao giờ gọi một phương thức Finalize() của một đối tượng một cách trực tiếp, ngoại trừ gọi phương thức này của lớp cơ sở khi ở bên trong phương thức Finalize() của chúng ta. Trình thu dọn sẽ thực hiện việc gọi Finalize() cho chúng ta.

Bộ hủy của C#

Cú pháp phương thức hủy trong ngôn ngữ C# cũng giống như trong ngôn ngữ C++. Nhưng về hành động cụ thể chúng có nhiều điểm khác nhau. Ta khao báo một phương thức hủy trong C# như sau:

~Class1() {}

Tuy nhiên, trong ngôn ngữ C# thì cú pháp khai báo trên là một shortcut liên kết đến một phương thức kết thúc Finalize được kết với lớp cơ sở, do vậy khi viết

~Class1()
    {
    // Thực hiện một số công việc
    }
    Cũng tương tự như viết :
    Class1.Finalize()
    {
    // Thực hiện một số công việc base.Finalize();
    }

Do sự tương tự như trên nên khả năng dẫn đến sự lộn xộn nhầm lẫn là không tránh khỏi, nên chúng ta phải tránh viết các phương thức hủy và viết các phương thức Finalize tường minh nếu có thể được.

Phương thức Dispose

Như chúng ta đã biết thì việc gọi một phương thức kết thúc Finalize trong C# là không hợp lệ, vì phương thức này dành cho bộ thu dọn thực hiện. Nếu chúng ta xử lý các tài nguyên không kiểm soát như xử lý các handle của tập tin và ta muốn được đóng hay giải phóng nhanh chóng bất cứ lúc nào, ta có thực thi giao diện IDisposable, phần chi tiết IDisposable sẽ được trình bày chi tiết trong Chương 8. Giao diện IDisposable yêu cầu những thành phần thực thi của nó định nghĩa một phương thức tên là Dispose() để thực hiện công việc dọn dẹp mà ta yêu cầu. Ý nghĩa của phương thức Dispose là cho phép chương trình thực hiện các công việc dọn dẹp hay giải phóng tài nguyên mong muốn mà không phải chờ cho đến khi phương thức Finalize() được gọi.

Khi chúng ta cung cấp một phương thức Dispose thì phải ngưng bộ thu dọn gọi phương thức Finalize() trong đối tượng của chúng ta. Để ngưng bộ thu dọn, chúng ta gọi một phương thức tĩnh của lớp GC (garbage collector) là GC.SuppressFinalize() và truyền tham số là tham chiếu this của đối tượng. Và sau đó phương thức Finalize() sử dụng để gọi phương thức Dispose() như đoạn mã sau:

public void Dispose()
    {
    // Thực hiện công việc dọn dẹp
    // Yêu cầu bộ thu dọc GC trong thực hiện kết thúc
    GC.SuppressFinalize( this );
    }
    public override void Finalize()
    {
    Dispose();
    base.Finalize();
    }

Phương thức Close

Khi xây dựng các đối tượng, chúng ta có muốn cung cấp cho người sử dụng phương thức

Close(), vì phương thức Close có vẻ tự nhiên hơn phương thức Dispose trong các đối tượng có liên quan đến xử lý tập tin. Ta có thể xây dựng phương thức Dispose() với thuộc tính là private và phương thức Close() với thuộc tính public. Trong phương thức Close() đơn giản là gọi thực hiện phương thức Dispose().

Câu lệnh using

Khi xây dựng các đối tượng chúng ta không thể chắc chắn được rằng người sử dụng có thể gọi hàm Dispose(). Và cũng không kiểm soát được lúc nào thì bộ thu dọn GC thực hiện việc dọn dẹp. Do đó để cung cấp khả năng mạnh hơn để kiểm soát việc giải phóng tài nguyên thì C# đưa ra cú pháp chỉ dẫn using, cú pháp này đảm bảo phương thức Dispose() sẽ được gọi sớm nhất có thể được. Ý tưởng là khai báo các đối tượng với cú pháp using và sau đó tạo một phạm vi hoạt động cho các đối tượng này trong khối được bao bởi dấu ({}). Khi khối phạm vi này kết thúc, thì phương thức Dispose() của đối tượng sẽ được gọi một cách tự động.

Sử dụng chỉ dẫn using.

-----------------------------------------------------------------------------

using System.Drawing;

class Tester

{

public static void Main()

{

using ( Font Afont = new Font("Arial",10.0f))

{

// Đoạn mã sử dụng AFont

.......

}// Trình biên dịch sẽ gọi Dispose để giải phóng AFont

Font TFont = new Font("Tahoma",12.0f);

using (TFont)

{

// Đoạn mã sử dụng TFont

.......

}// Trình biên dịch gọi Dispose để giải phóng TFont

}

-----------------------------------------------------------------------------

Còn trong phần khai báo thứ hai, một đối tượng Font được tạo bên ngoài câu lệnh using. Khi quyết định dùng đối tượng này ta đặt nó vào câu lệnh using. Và cũng tương tự như trên khi khối câu lệnh using thực hiện xong thì phương thức Dispose() của font được gọi.

TẢI VỀ

TÁI SỬ DỤNG

MỤC LỤC

Giáo trình ngôn ngữ lập trình C#

NỘI DUNG CÙNG TÁC GIẢ