Thực thi giao diện

Cú pháp để định nghĩa một giao diện như sau:

[thuộc tính] [bổ sung truy cập] interface <tên giao diện> [: danh sách cơ sở]
    {
    <phần thân giao diện>
    }
    

Phần thuộc tính chúng ta sẽ đề cập sau. Thành phần bổ sung truy cập bao gồm: public, private, protected, internal, và protected internal đã được nói đến trong Chương 4, ý nghĩa tương tự như các bổ sung truy cập của lớp.

Theo sau từ khóa interface là tên của giao diện. Thông thường tên của giao diện được bắt đầu với từ I hoa (điều này không bắt buộc nhưng việc đặt tên như vậy rất rõ ràng và dễ hiểu, tránh nhầm lẫn với các thành phần khác). Ví dụ một số giao diện có tên như sau:

Danh sách cơ sở là danh sách các giao diện mà giao diện này mở rộng, phần này sẽ được trình bày trong phần thực thi nhiều giao diện của chương. Phần thân của giao diện chính là phần thực thi giao diện sẽ được trình bày bên dưới.

Giả sử chúng ta muốn tạo một giao diện nhằm mô tả những phương thức và thuộc tính của một lớp cần thiết để lưu trữ và truy cập từ một cơ sở dữ liệu hay các thành phần lưu trữ dữ liệu khác như là một tập tin. Chúng ta quyết định gọi giao diện này là IStorage.

Trong giao diện này chúng ta xác nhận hai phương thức: Read() và Write(), khai báo này sẽ được xuất hiện trong phần thân của giao diện như sau:

interface IStorable
    {
    void Read();
    void Write(object);
    }
    

Mục đích của một giao diện là để định nghĩa những khả năng mà chúng ta muốn có trong một lớp. Ví dụ, chúng ta có thể tạo một lớp tên là Document, lớp này lưu trữ các dữ liệu trong cơ sở dữ liệu, do đó chúng ta quyết định lớp này này thực thi giao diện IStorable.

Để làm được điều này, chúng ta sử dụng cú pháp giống như việc tạo một lớp mới Document được thừa kế từ IStorable bằng dùng dấu hai chấm (:) và theo sau là tên giao diện:

public class Document : IStorable
    {
    public void Read()
    {
    ....
    }
    public void Write()
    {
    ....
    }
    }
    

Bây giờ trách nhiệm của chúng ta, với vai trò là người xây dựng lớp Document phải cung cấp một thực thi có ý nghĩa thực sự cho những phương thức của giao diện IStorable. Chúng ta phải thực thi tất cả các phương thức của giao diện, nếu không trình biên dịch sẽ báo một lỗi. Sau đây là đoạn chương trình minh họa việc xây dựng lớp Document thực thi giao diện IStorable.

using System;
    // khai báo giao diện interface IStorable
    {
    // giao diện không khai báo bổ sung truy cập
    // phương thức là public và không thực thi 
    void Read();
    void Write(object obj);
    int Status
    {
    get;
    set;
    }
    }
    // tạo một lớp thực thi giao diện Istorable
    public class Document : IStorable
    {
    public Document( string s)
    {
    Console.WriteLine("Creating document with: {0}", s);
    }
    // thực thi phương thức Read()
    public void Read()
    {
    Console.WriteLine("Implement the Read Method for IStorable");
    }
    // thực thi phương thức Write 
    public void Write( object o)
    {
    Console.WriteLine("Impleting the Write Method for IStorable");
    }
    // thực thi thuộc tính 
    public int Status
    {
    get
    {
    return status;
    }
    set
    {
    status=value;
    }
    }
    // lưu trữ giá trị thuộc tính 
    private int status = 0;
    }
    public class Tester
    {
    static void Main()
    {
    // truy cập phương thức trong đối tượng Document 
    Document doc = new Document("Test Document"); 
    doc.Status = -1;
    doc.Read();
    Console.WriteLine("Document Status: {0}", doc.Status);
    // gán cho một giao diện và sử dụng giao diện
    IStorable isDoc = (IStorable) doc;
    isDoc.Status = 0;
    isDoc.Read();
    Console.WriteLine("IStorable Status: {0}", isDoc.Status);
    }
    }
    

Ví dụ trên định nghĩa một giao diện IStorable với hai phương thức Read(), Write() và một thuộc tính tên là Status có kiểu là số nguyên.. Lưu ý rằng trong phần khai báo thuộc tính không có phần thực thi cho get() và set() mà chỉ đơn giản là khai báo có hành vi là get() và set():

int Status { get; set;}

Ngoài ra phần định nghĩa các phương thức của giao diện không có phần bổ sung truy cập (ví dụ như: public, protected, internal, private). Việc cung cấp các bổ sung truy cập sẽ tạo ra một lỗi. Những phương thức của giao diện được ngầm định là public vì giao diện là những ràng buộc được sử dụng bởi những lớp khác. Chúng ta không thể tạo một thể hiện của giao diện, thay vào đó chúng ta sẽ tạo thể hiện của lớp có thực thi giao diện.

Một lớp thực thi giao diện phải đáp ứng đầy đủ và chính xác các ràng buộc đã khai báo trong giao diện. Lớp Document phải cung cấp cả hai phương thức Read() và Write() cùng với thuộc tính Status. Tuy nhiên cách thực hiện những yêu cầu này hoàn toàn phụ thuộc vào lớp Document. Mặc dù IStorage chỉ ra rằng lớp Document phải có một thuộc tính là Status nhưng nó không biết hay cũng không quan tâm đến việc lớp Document lưu trữ trạng thái thật sự của các biến thành viên, hay việc tìm kiếm trong cơ sở dữ liệu. Những chi tiết này phụ thuộc vào phần thực thi của lớp.

Trong ngôn ngữ C# cho phép chúng ta thực thi nhiều hơn một giao diện. Ví dụ, nếu lớp Document có thể được lưu trữ và dữ liệu cũng được nén. Chúng ta có thể chọn thực thi cả hai giao diện IStorable và ICompressible. Như vậy chúng ta phải thay đổi phần khai báo trong danh sách cơ sở để chỉ ra rằng cả hai giao diện điều được thực thi, sử dụng dấu phẩy (,) để phân cách giữa hai giao diện:

public class Document : IStorable, Icompressible

Do đó Document cũng phải thực thi những phương thức được xác nhận trong giao diện

ICompressible:
    public void Compress()
    {
    Console.WriteLine("Implementing the Compress Method");
    }
    public void Decompress()
    {
    Console.WriteLine("Implementing the Decompress Method");
    }
    

Bổ sung thêm phần khai báo giao diện ICompressible và định nghĩa các phương thức của giao diện bên trong lớp Document. Sau khi tạo thể hiện lớp Document và gọi các phương thức từ giao diện ta có kết quả tương tự như sau:

Creating document with: Test Document Implementing the Read Method for IStorable Implementing Compress

interface ILoggedCompressible : ICompressible
    {
    void LogSavedBytes();
    }
    

interface IStorableCompressible : IStoreable, ILoggedCompressible

{

void LogOriginalSize();

}

using System;
    interface IStorable
    {
    void Read();
    void Write(object obj);
    int Status { get; set;}
    }
    // giao diện mới interface ICompressible
    {
    void Compress();
    void Decompress();
    }
    // mở rộng giao diện
    interface ILoggedCompressible : ICompressible
    {
    void LogSavedBytes();
    
    }
    
    // kết hợp giao diện
    interface IStorableCompressible : IStorable, ILoggedCompressible
    {
    void LogOriginalSize();
    }
    interface IEncryptable
    {
    void Encrypt();
    void Decrypt();
    }
    public class Document : IStorableCompressible, Iencryptable
    {
    // 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");
    }
    // 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();
    }
    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");
    }
    }
    }
    

ILoggedCompressible ilcDoc = doc as ILoggedCompressible;
    if ( ilcDoc != null )
    {
    ilcDoc.LogSavedBytes();
    ilcDoc.Compress();
    // ilcDoc.Read(); // không thể gọi được
    }
    

if ( isc != null )
    {
    isc.LogOriginalSize();// IStorableCompressible
    isc.LogSaveBytes(); // ILoggedCompressible
    isc.Compress(); // ICompress 
    isc.Read();// IStorable
    }