Tham khảo tài liệu 'giáo trình hình thành hệ thống khởi tạo các giá trị ban đầu cho các biến thành viên p2', công nghệ thông tin, kỹ thuật lập trình phục vụ nhu cầu học tập, nghiên cứu và làm việc hiệu quả
AMBIENT/
Chủ đề:
Nội dung Text: Giáo trình hình thành hệ thống khởi tạo các giá trị ban đầu cho các biến thành viên p2
- . Ngôn Ngữ Lập Trình C#
// bộ khởi tạo lớp Document lấy một tham số
public Document( string s)
{
Console.WriteLine(“Creating document with: {0}”, s);
}
// thực thi giao diện IStorable
public void Read()
{
Console.WriteLine(“Implementing the Read Method for IStorable”);
}
public void Write( object o)
{
Console.WriteLine(“Implementing the Write Method for IStorable”);
}
public int Status
{
get
{
return status;
}
set
{
status = value;
}
}
// thực thi ICompressible
public void Compress()
{
Console.WriteLine(“Implementing Compress”);
}
public void Decompress()
{
Console.WriteLine(“Implementing Decompress”);
}
// thực thi giao diện ILoggedCompressible
public void LogSavedBytes()
{
Console.WriteLine(“Implementing LogSavedBytes”);
183
.
Thực Thi Giao Diện
- .
Ngôn Ngữ Lập Trình C#
}
// thực thi giao diện IStorableCompressible
public void LogOriginalSize()
{
Console.WriteLine(“Implementing LogOriginalSize”);
}
// thực thi giao diện
public void Encrypt()
{
Console.WriteLine(“Implementing Encrypt”);
}
public void Decrypt()
{
Console.WriteLine(“Implementing Decrypt”);
}
// biến thành viên lưu dữ liệu cho thuộc tính
private int status = 0;
}
public class Tester
{
public static void Main()
{
// tạo đối tượng document
Document doc = new Document(“Test Document”);
// gán đối tượng cho giao diện
IStorable isDoc = doc as IStorable;
if ( isDoc != null)
{
isDoc.Read();
}
else
{
Console.WriteLine(“IStorable not supported”);
}
ICompressible icDoc = doc as ICompressible;
if ( icDoc != null )
{
icDoc.Compress();
184
. Thực Thi Giao Diện
- .
Ngôn Ngữ Lập Trình C#
}
else
{
Console.WriteLine(“Compressible not supported”);
}
ILoggedCompressible ilcDoc = doc as ILoggedCompressible;
if ( ilcDoc != null )
{
ilcDoc.LogSavedBytes();
ilcDoc.Compress();
// ilcDoc.Read(); // không thể gọi được
}
else
{
Console.WriteLine(“LoggedCompressible not supported”);
}
IStorableCompressible isc = doc as IStorableCompressible;
if ( isc != null )
{
isc.LogOriginalSize(); // IStorableCompressible
isc.LogSavedBytes(); // ILoggedCompressible
isc.Compress(); // ICompress
isc.Read(); // IStorable
}
else
{
Console.WriteLine(“StorableCompressible not supported”);
}
IEncryptable ie = doc as IEncryptable;
if ( ie != null )
{
ie.Encrypt();
}
else
{
Console.WriteLine(“Encryptable not supported”);
}
}
185
.
Thực Thi Giao Diện
- .
Ngôn Ngữ Lập Trình C#
}
-----------------------------------------------------------------------------
Kết quả:
Creating document with: Test Document
Implementing the Read Method for IStorable
Implementing Compress
Implementing LogSavedBytes
Implementing Compress
Implementing LogOriginalSize
Implementing LogSaveBytes
Implementing Compress
Implementing the Read Method for IStorable
Implementing Encrypt
-----------------------------------------------------------------------------
Ví dụ 8.2 bắt đầu bằng việc thực thi giao diện IStorable và giao diện ICompressible. Sau đó
là phần mở rộng đến giao diện ILoggedCompressible rồi sau đó kết hợp cả hai vào giao diện
IStorableCompressible. Và giao diện cuối cùng trong ví dụ là IEncrypt.
Chương trình Tester tạo đối tượng Document mới và sau đó gán lần lượt vào các giao diện
khác nhau. Khi một đối tượng được gán cho giao diện ILoggedCompressible, chúng ta có thể
dùng giao diện này để gọi các phương thức của giao diện ICompressible bởi vì ILogged-
Compressible mở rộng và thừa kế các phương thức từ giao diện cơ sở:
ILoggedCompressible ilcDoc = doc as ILoggedCompressible;
if ( ilcDoc != null )
{
ilcDoc.LogSavedBytes();
ilcDoc.Compress();
// ilcDoc.Read(); // không thể gọi được
}
Tuy nhiên, ở đây chúng ta không thể gọi phương thức Read() bởi vì phương thức này của
giao diện IStorable, không liên quan đến giao diện này. Nếu chúng ta thêm lệnh này vào thì
chương trình sẽ biên dịch lỗi.
Nếu chúng ta gán vào giao diện IStorableCompressible, do giao diện này kết hợp hai giao
diện IStorable và giao diện ICompressible, chúng ta có thể gọi tất cả những phương thức của
IStorableCompressible, ICompressible, và IStorable:
IStorableCompressible isc = doc as IStorableCompressible;
if ( isc != null )
{
isc.LogOriginalSize(); // IStorableCompressible
186
.
Thực Thi Giao Diện
- . Ngôn Ngữ Lập Trình C#
isc.LogSaveBytes(); // ILoggedCompressible
isc.Compress(); // ICompress
isc.Read(); // IStorable
}
Truy cập phương thức giao diện
Chúng ta có thể truy cập những thành viên của giao diện IStorable như thể là các thành viên
của lớp Document:
Document doc = new Document(“Test Document”);
doc.status = -1;
doc.Read();
hay là ta có thể tạo thể hiện của giao diện bằng cách gán đối tượng Document cho một kiểu
dữ liệu giao diện, và sau đó sử dụng giao diện này để truy cập các phương thức:
IStorable isDoc = (IStorable) doc;
isDoc.status = 0;
isDoc.Read();
Ghi chú: Cũng như đã nói trước đây, chúng ta không thể tạo thể hiện của giao diện một
cách trực tiếp.Do đó chúng ta không thể thực hiện như sau:
IStorable isDoc = new IStorable();
Tuy nhiên chúng ta có thể tạo thể hiện của lớp thực thi như sau:
Document doc = new Document(“Test Document”);
Sau đó chúng ta có thể tạo thể hiện của giao diện bằng cách gán đối tượng thực thi đến kiểu
dữ liệu giao diện, trong trường hợp này là IStorable:
IStorable isDoc = (IStorable) doc;
Chúng ta có thể kết hợp những bước trên như sau:
IStorable isDoc = (IStorable) new Document(“Test Document”);
Nói chung, cách thiết kế tốt nhất là quyết định truy cập những phương thức của giao diện
thông qua tham chiếu của giao diện. Do vậy cách tốt nhất là sử dụng isDoc.Read(), hơn là sử
dụng doc.Read() trong ví dụ trước. Truy cập thông qua giao diện cho phép chúng ta đối xử
giao diện một cách đa hình. Nói cách khác, chúng ta tạo hai hay nhiều hơn những lớp thực thi
giao diện, và sau đó bằng cách truy cập lớp này chỉ thông qua giao diện.
Gán đối tượng cho một giao diện
Trong nhiều trường hợp, chúng ta không biết trước một đối tượng có hỗ trợ một giao
diện đưa ra. Ví dụ, giả sử chúng ta có một tập hợp những đối tượng Document, một vài đối
tượng đã được lưu trữ và số còn lại thì chưa. Và giả sử chúng ta đã thêm giao diện giao diện
thứ hai, ICompressible cho những đối tượng để nén dữ liệu và truyền qua mail nhanh chóng:
interface ICompressible
{
187
.
Thực Thi Giao Diện
- . Ngôn Ngữ Lập Trình C#
void Compress();
void Decompress();
}
Nếu đưa ra một kiểu Document, và ta cũng không biết là lớp này có hỗ trợ giao diện
IStorable hay ICompressible hoặc cả hai. Ta có thể có đoạn chương trình sau:
Document doc = new Document(“Test Document”);
IStorable isDoc = (IStorable) doc;
isDoc.Read();
ICompressible icDoc = (ICompressible) doc;
icDoc.Compress();
Nếu Document chỉ thực thi giao diện IStorable:
public class Document : IStorable
phép gán cho ICompressible vẫn được biên dịch bởi vì ICompressible là một giao diện hợp
lệ. Tuy nhiên, do phép gán không hợp lệ nên khi chương trình chạy thì sẽ tạo ra một ngoại lệ
(exception):
A exception of type System.InvalidCastException was thrown.
Phần ngoại lệ sẽ được trình bày trong Chương 11.
Toán tử is
Chúng ta muốn kiểm tra một đối tượng xem nó có hỗ trợ giao diện, để sau đó thực hiện các
phương thức tương ứng. Trong ngôn ngữ C# có hai cách để thực hiện điều này. Phương pháp
đầu tiên là sử dụng toán tử is.
Cú pháp của toán tử is là:
is
Toán tử is trả về giá trị true nếu biểu thức thường là kiểu tham chiếu có thể được gán an toàn
đến kiểu dữ liệu cần kiểm tra mà không phát sinh ra bất cứ ngoại lệ nào. Ví dụ 8.3 minh họa
việc sử dụng toán tử is để kiểm tra Document có thực thi giao diện IStorable hay
ICompressible.
Ví dụ 8.3: Sử dụng toán tử is.
-----------------------------------------------------------------------------
using System;
interface IStorable
{
void Read();
void Write(object obj);
int Status { get; set; }
}
// giao diện mới
188
. Thực Thi Giao Diện
- .
Ngôn Ngữ Lập Trình C#
interface ICompressible
{
void Compress();
void Decompress();
}
// Document thực thi IStorable
public class Document : IStorable
{
public Document( string s)
{
Console.WriteLine(“Creating document with: {0}”, s);
}
// IStorable
public void Read()
{
Console.WriteLine(“Implementing the Read Method for IStorable”);
}
// IStorable.WriteLine()
public void Write( object o)
{
Console.WriteLine(“Implementing the Write Method for IStorable”);
}
// IStorable.Status
public int Status
{
get
{
return status;
}
set
{
status = value;
}
}
// bien thanh vien luu gia tri cua thuoc tinh Status
private int status = 0;
}
public class Tester
189
. Thực Thi Giao Diện
- .
Ngôn Ngữ Lập Trình C#
{
static void Main()
{
Document doc = new Document(“Test Document”);
// chỉ gán khi an toàn
if ( doc is IStorable )
{
IStorable isDoc = (IStorable) doc;
isDoc.Read();
}
// việc kiểm tra này sẽ sai
if ( doc is ICompressible )
{
ICompressible icDoc = (ICompressible) doc;
icDoc.Compress();
}
}
}
-----------------------------------------------------------------------------
Trong ví dụ 8.3, hàm Main() lúc này sẽ thực hiện việc gán với interface khi được kiểm tra
hợp lệ. Việc kiểm tra này được thực hiện bởi câu lệnh if:
if ( doc is IStorable )
Biểu thức điều kiện sẽ trả về giá trị true và phép gán sẽ được thực hiện khi đối tượng có thực
thi giao diện bên phải của toán tử is.
Tuy nhiên, việc sử dụng toán tử is đưa ra một việc không có hiệu quả. Để hiểu được điều này,
chúng ta xem đoạn chương trình được biên dịch ra mã IL. Ở đây sẽ có một ngoại lệ nhỏ, các
dòng bên dưới là sử dụng hệ thập lục phân:
IL_0023: isinst ICompressible
IL_0028: brfalse.s IL_0039
IL_002a: ldloc.0
IL_002b: castclass ICompressible
IL_0030: stloc.2
IL_0031: ldloc.2
IL_0032: callvirt instance void ICompressible::Compress()
IL_0037: br.s IL_0043
IL_0039: ldstr “Compressible not supported”
Điều quan trọng xảy ra là khi phép kiểm tra ICompressible ở dòng 23. Từ khóa isinst là mã
MSIL tương ứng với toán tử is. Nếu việc kiểm tra đối tượng (doc) đúng kiểu của kiểu bên
190
. Thực Thi Giao Diện
- .
Ngôn Ngữ Lập Trình C#
phải. Thì chương trình sẽ chuyển đến dòng lệnh 2b để thực hiện tiếp và castclass được gọi.
Điều không may là castcall cũng kiểm tra kiểu của đối tượng. Do đó việc kiểm tra sẽ được
thực hiện hai lần. Giải pháp hiệu quả hơn là việc sử dụng toán tử as.
Toán tử as
Toán tử as kết hợp toán tử is và phép gán bằng cách đầu tiên kiểm tra hợp lệ phép
gán (kiểm tra toán tử is trả về true) rồi sau đó phép gán được thực hiện. Nếu phép gán không
hợp lệ (khi phép gán trả ề giá trị false), thì toán tử as trả về giá trị null.
Ghi chú: Từ khóa null thể hiện một tham chiếu không tham chiếu đến đâu cả (null
reference). Đối tượng có giá trị null tức là không tham chiếu đến bất kỳ đối tượng nào.
Sử dụng toán tử as để loại bỏ việc thực hiện các xử lý ngoại lệ. Đồng thời cũng né tránh việc
thực hiện kiểm tra dư thừa hai lần. Do vậy, việc sử dụng tối ưu của phép gán cho giao diện là
sử dụng as.
Cú pháp sử dụng toán tử as như sau:
as
Đoạn chương trình sau thay thế việc sử dụng toán tử is bằng toán tử as và sau đó thực hiện
việc kiểm tra xem giao diện được gán có null hay không:
static void Main()
{
Document doc = new Document(“Test Document”);
IStorable isDoc = doc as IStorable;
if ( isDoc != null )
{
isDoc.Read();
}
else
{
Console.WriteLine(“IStorable not supported”);
}
ICompressible icDoc = doc as ICompressible;
if ( icDoc != null)
{
icDoc.Compress();
}
else
{
Console.WriteLine(“Compressible not supported”);
}
191
. Thực Thi Giao Diện
- . Ngôn Ngữ Lập Trình C#
}
Ta có thể so sánh đoạn mã IL sau với đoạn mã IL sử dụng toán tử is trước sẽ thấy đoạn mã
sau có nhiều hiệu quả hơn:
IL_0023: isinst ICompressible
IL_0028: stloc.2
IL_0029: ldloc.2
IL_002a: brfalse.s IL_0034
IL_002c: ldloc.2
IL_002d: callvirt instance void ICompressible::Compress()
Ghi chú: Nếu mục đích của chúng ta là kiểm tra một đối tượng có hỗ trợ một giao diện và
sau đó là thực hiện việc gán cho một giao diện, thì cách tốt nhất là sử dụng toán tử as là hiệu
quả nhất. Tuy nhiên, nếu chúng ta chỉ muốn kiểm tra kiểu dữ liệu và không thực hiện phép
gán ngay lúc đó. Có lẽ chúng ta chỉ muốn thực hiện việc kiểm tra nhưng không thực hiện
việc gán, đơn giản là chúng ta muốn thêm nó vào danh sách nếu chúng thực sự là một giao
diện. Trong trường hợp này, sử dụng toán tử is là cách lựa chọn tốt nhất.
Giao diện đối lập với lớp trừu tượng
Giao diện rất giống như các lớp trừu tượng. Thật vậy, chúng ta có thể thay thế khai
báo của IStorable trở thành một lớp trừu tượng:
abstract class Storable
{
abstract public void Read();
abstract public void Write();
}
Bây giờ lớp Document có thể thừa kế từ lớp trừu tượng IStorable, và cũng không có gì khác
nhiều so với việc sử dụng giao diện.
Tuy nhiên, giả sử chúng ta mua một lớp List từ một hãng thứ ba và chúng ta muốn kết hợp
với lớp có sẵn như Storable. Trong ngôn ngữ C++ chúng ta có thể tạo ra một lớp StorableList
kế thừa từ List và cả Storable. Nhưng trong ngôn ngữ C# chúng ta không thể làm được,
chúng ta không thể kế thừa từ lớp trừu tượng Storable và từ lớp List bởi vì trong C# không
cho phép thực hiện đa kế thừa từ những lớp.
Tuy nhiên, ngôn ngữ C# cho phép chúng ta thực thi bất cứ những giao diện nào và dẫn xuất
từ một lớp cơ sở. Do đó, bằng cách làm cho Storable là một giao diện, chúng ta có thể kế
thừa từ lớp List và cũng từ IStorable. Ta có thể tạo lớp StorableList như sau:
public class StorableList : List, IStorable
{
// phương thức List...
.....
192
.
Thực Thi Giao Diện
Thêm vào BST
Báo xấu
Download
Vui lòng tải xuống để xem tài liệu đầy đủ
