C# triển khai giao diện một phần tốt nhất trong lớp cơ sở/trừu tượng

Question

.net không cho phép triển khai giao diện một phần trong các lớp cơ sở. Như một giảm thiểu tôi đã đến 3 giải pháp thay thế. Hãy giúp tôi quyết định cái nào phổ quát hơn về tái cấu trúc, biên dịch/chạy các lỗi thời gian, dễ đọc. Nhưng trước tiên là một vài ý kiến.

• Tất nhiên bạn luôn có thể truyền đối tượng đến IFoo và gọi bất kỳ phương thức nào mà không có bất kỳ cảnh báo trình biên dịch nào. Nhưng nó không hợp lý, bạn sẽ không làm điều đó bình thường. Cấu trúc này sẽ không xảy ra do tái cấu trúc.
• Tôi muốn tách biệt tối đa. Hợp đồng lớp trực tiếp (các phương thức và thuộc tính công khai) nên được tách riêng với các triển khai giao diện. Tôi sử dụng giao diện rất nhiều để tách các giao diện đối tượng.

so sánh của tôi:

1. BaseClass1/MyClass1:
   • con: Phải tạo trừu tượng ảo trong BaseClass1 cho mỗi phương pháp không được thực hiện các IFoo.
   • con: Bọc phương pháp bổ sung - tác động năng suất nhẹ khi chạy.
2. BaseClass2/MyClass2:
   • con: không có cảnh báo trình biên dịch nếu không thực hiện Method2 trong MyClass2. Thay vào đó, ngoại lệ thời gian chạy. Tái cấu trúc với vùng phủ sóng thử nghiệm đơn vị kém có khả năng làm mất ổn định mã.
   • con: phải đặt thêm cấu trúc lỗi thời để ngăn chặn cuộc gọi phương thức trực tiếp từ các lớp con.
   • con: Phương pháp 2 là công khai cho BaseClass1 vì vậy nó là một phần của hợp đồng lớp học ngay bây giờ. Phải đặt cấu trúc "lỗi thời" để ngăn chặn cuộc gọi trực tiếp, không thông qua IFoo.
3. BaseClass3/MyClass3:
   • pro: (So với # 2). Dễ đọc hơn. Bạn thấy rằng MyClass2.Method2 là IFoo thực hiện, không chỉ là một số phương pháp overriden.

public interface IFoo 
{ 
    void Method1(); 
    void Method2(); 
} 

public abstract class BaseClass1 : IFoo 
{ 
    void IFoo.Method1() 
    { 
     //some implementation 
    } 

    void IFoo.Method2() 
    { 
     IFooMethod2(); 
    } 

    protected abstract void IFooMethod2(); 
} 

public class MyClass1 : BaseClass1 
{ 
    [Obsolete("Prohibited direct call from child classes. only inteface implementation")] 
    protected override void IFooMethod2() 
    { 
     //some implementation 
    } 
} 

public abstract class BaseClass2 : IFoo 
{ 
    void IFoo.Method1() 
    { 
     //some implementation 
    } 

    [Obsolete("Prohibited direct call from child classes. only inteface implementation")] 
    public virtual void Method2() 
    { 
     throw new NotSupportedException(); 
    } 
} 

public abstract class MyClass2 : BaseClass2 
{ 
    public override void Method2() 
    { 
     //some implementation 
    } 
} 

public abstract class BaseClass3 : IFoo 
{ 
    void IFoo.Method1() 
    { 
     //some implementation 
    } 

    void IFoo.Method2() 
    { 
     throw new NotSupportedException(); 
    } 
} 

public abstract class MyClass3 : BaseClass3, IFoo 
{ 
    void IFoo.Method2() 
    { 
     //some implementation 
    } 
} 

Answer 1

Ok, bạn có thể thử cách sau như BaseClass là trừu tượng:

public interface IFoo 
{ 
    void Method1(); 

    void Method2(); 
} 

public abstract class BaseClass : IFoo 
{ 
    public void Method1() 
    { 
     // Common stuff for all BaseClassX classes 
    } 

    // Abstract method: it ensures IFoo is fully implemented 
    // by all classes that inherit from BaseClass, but doesn't provide 
    // any implementation right here. 
    public abstract void Method2(); 
} 

public class MyClass1 : BaseClass 
{ 
    public override void Method2() 
    { 
     // Specific stuff for MyClass1 
     Console.WriteLine("Class1"); 
    } 
} 

public class MyClass2 : BaseClass 
{ 
    public override void Method2() 
    { 
     // Specific stuff for MyClass2 
     Console.WriteLine("Class2"); 
    } 
} 

private static void Main(string[] args) 
{ 
    IFoo test1 = new MyClass1(); 
    IFoo test2 = new MyClass2(); 

    test1.Method2(); 
    test2.Method2(); 

    Console.ReadKey(); 
} 

Answer 2

Nó là vô cùng xấu để thiết kế một lớp điều đó không không triển khai định nghĩa đúng d hợp đồng. Nó là cực đoan bởi vì trước tiên bạn nói rằng một lớp học có khả năng làm điều gì đó. Bạn rõ ràng làm nổi bật rằng lớp có thể làm công cụ, nhưng sau đó trong mã bạn nói nahh, vặn nó, lớp này có thể sống mà không cần thực hiện. Trình biên dịch rất khôn ngoan yêu cầu bạn thực hiện hợp đồng, nhưng nó được để bạn quyết định.

Dưới đây là một số giải pháp chung

Bad giải pháp

• Ném một ngoại lệ (NonImplementedException hoặc NotSupportedException, xem sample)
• Khai báo nó như là lỗi thời (thiết kế nó tốt ngay từ đầu)

Tốt hơn giải pháp

• Explicit giao diện thực hiện, nhưng bạn vẫn thực hiện nó (chỉ loại giấu nó)

giải pháp tốt nhất

• Sử dụng giao diện phân (chia giao diện chất béo của bạn thành mỏng và những người có thể quản lý nhiều hơn)

Answer 3

Tôi muốn đề nghị có lớp cơ sở trừu tượng thực hiện giao diện với các phương thức gọi phương thức protected abstract, như trong ví dụ đầu tiên của bạn, ngoại trừ các phương thức mà một số lớp dẫn xuất có thể không thực hiện (theo sau "ném mọi thứ vào IList nhưng không có tất cả các phương pháp thực sự làm việc "mô hình"; những thứ đó có thể là số protected virtual khai quật để ném NotSupportedException.

Lưu ý rằng tùy thuộc vào lớp con có thể hiển thị bất kỳ thành viên cụ thể nào của giao diện dưới dạng thành viên công khai được đặt tên (có thể gọi thành viên trừu tượng thích hợp) không.

Mẫu thích hợp trong VB.net sẽ giống như MustOverride Sub IFoo_Method1() Implements IFoo.Method1, điều này sẽ tránh được phí gọi hàm bổ sung, nhưng C# không cung cấp bất kỳ phương tiện nào để triển khai giao diện với thành viên được bảo vệ. Sử dụng cách thực hiện giao diện rõ ràng cho bất kỳ phương thức nào có thể phải ghi đè trong lớp con là hơi khốc liệt, vì không thể thực hiện lại giao diện của con để chuỗi triển khai thực hiện của cha mẹ.

Answer 4

Tôi thích phiên bản này, lớp cơ sở không thể được khởi tạo vì trừu tượng của nó, lớp dẫn xuất phải liệt kê IFoo trong khai báo của nó hoặc người khác sẽ không triển khai giao diện và sau đó tự chịu trách nhiệm thực hiện phần còn lại của giao diện. Một nhược điểm tôi có thể thấy là bạn không thể thực hiện một cách rõ ràng các phương thức giao diện trong lớp cơ sở (tức là không có IFoo: Method1), nhưng nếu không thì đây là phiên bản khá thấp.

public interface IFoo 
{ 
    void Method1(); 
    void Method2(); 
} 

public abstract class BaseClass1 
{ 
    public void Method1() 
    { 
     //some implementation 
    } 
} 

public class MyClass1 : BaseClass1, IFoo 
{ 
    public void Method2() 
    { 
     //some implementation 
    } 
}