Tại sao trình biên dịch C # phàn nàn rằng "các kiểu có thể thống nhất" khi chúng bắt nguồn từ các lớp cơ sở khác nhau?

Mã không biên dịch hiện tại của tôi tương tự như sau:

public abstract class A { }

public class B { }

public class C : A { }

public interface IFoo<T>
{
    void Handle(T item);
}

public class MyFoo<TA> : IFoo<TA>, IFoo<B>
    where TA : A
{
    public void Handle(TA a) { }
    public void Handle(B b) { }
}

Trình biên dịch C # từ chối biên dịch điều này, trích dẫn quy tắc / lỗi sau:

'MyProject.MyFoo <TA>' không thể triển khai cả 'MyProject.IFoo <TA>' và 'MyProject.IFoo <MyProject.B>' vì chúng có thể thống nhất đối với một số thay thế tham số kiểu

Tôi hiểu lỗi này có nghĩa là gì; nếu TAcó thể là bất cứ thứ gì thì về mặt kỹ thuật, nó cũng có thể là một Bthứ sẽ dẫn đến sự mơ hồ về hai cách Handletriển khai khác nhau .

Nhưng TA không thể là gì cả. Dựa trên hệ thống phân cấp kiểu, TA không thể là B- ít nhất, tôi không nghĩ nó có thể. TAphải bắt nguồn từ A, không bắt nguồn từ B, và rõ ràng là không có nhiều lớp kế thừa trong C # /. NET.

Nếu tôi xóa tham số chung và thay thế TAbằng C, hoặc thậm chí A, tham số đó sẽ biên dịch.

Vậy tại sao tôi lại gặp lỗi này? Đó có phải là một lỗi trong hoặc sự thiếu thông minh chung của trình biên dịch, hay là tôi đang thiếu thứ gì khác?

Có cách giải quyết nào không hay tôi sẽ phải triển khai lại MyFoolớp chung chung như một lớp không chung chung riêng biệt cho mọi TAkiểu dẫn xuất có thể có?

Đây là hệ quả của mục 13.4.2 của đặc tả C # 4, trong đó nêu rõ:

Nếu bất kỳ kiểu được xây dựng nào có thể được tạo ra từ C, sau khi các đối số kiểu được thay thế thành L, khiến hai giao diện trong L giống hệt nhau, thì việc khai báo C không hợp lệ. Khai báo ràng buộc không được xem xét khi xác định tất cả các kiểu cấu trúc có thể có.

Lưu ý rằng câu thứ hai ở đó.

Do đó, nó không phải là một lỗi trong trình biên dịch; trình biên dịch là chính xác. Người ta có thể cho rằng đó là một lỗ hổng trong đặc tả ngôn ngữ.

Nói chung, các ràng buộc bị bỏ qua trong hầu hết mọi tình huống trong đó một thực tế phải được suy ra về một loại chung chung. Các ràng buộc chủ yếu được sử dụng để xác định lớp cơ sở hiệu quả của một tham số kiểu chung, và một số ít khác.

Thật không may, điều đó đôi khi dẫn đến những tình huống mà ngôn ngữ khắt khe một cách không cần thiết, như bạn đã phát hiện.

Nói chung, việc thực thi giao diện "giống nhau" hai lần sẽ rất tệ, theo một cách nào đó, chỉ được phân biệt bằng các đối số kiểu chung. Chẳng hạn, thật kỳ lạ khi có class C : IEnumerable<Turtle>, IEnumerable<Giraffe>- C là gì khi nó vừa là chuỗi rùa, vừa là chuỗi hươu cao cổ, cùng một lúc ? Bạn có thể mô tả điều thực tế mà bạn đang cố gắng làm ở đây không? Có thể có một mô hình tốt hơn để giải quyết vấn đề thực sự.

Nếu thực tế giao diện của bạn đúng như bạn mô tả:

interface IFoo<T>
{
    void Handle(T t);
}

Sau đó, đa kế thừa của giao diện lại xuất hiện một vấn đề khác. Bạn có thể quyết định một cách hợp lý để làm cho giao diện này trở nên trái ngược:

interface IFoo<in T>
{
    void Handle(T t);
}

Bây giờ giả sử bạn có

interface IABC {}
interface IDEF {}
interface IABCDEF : IABC, IDEF {}

Và

class Danger : IFoo<IABC>, IFoo<IDEF>
{
    void IFoo<IABC>.Handle(IABC x) {}
    void IFoo<IDEF>.Handle(IDEF x) {}
}

Và bây giờ mọi thứ trở nên thực sự điên rồ ...

IFoo<IABCDEF> crazy = new Danger();
crazy.Handle(null);

Quá trình triển khai nào của Xử lý được gọi ???

Xem bài viết này và các bình luận để biết thêm suy nghĩ về vấn đề này:

http://blogs.msdn.com/b/ericlippert/archive/2007/11/09/covariance-and-contravariance-in-c-part-ten-dealing-with-ambiguity.aspx

Rõ ràng nó là do thiết kế như đã thảo luận tại Microsoft Connect:

• Cho phép triển khai cùng một giao diện chung để có thêm một tham số kiểu trong lớp chung trong một số điều kiện

Và cách giải quyết là, xác định một giao diện khác là:

public interface IIFoo<T> : IFoo<T>
{
}

Sau đó, thực hiện điều này thay thế như:

public class MyFoo<TA> : IIFoo<TA>, IFoo<B>
    where TA : A
{
    public void Handle(TA a) { }
    public void Handle(B b) { }
}

Bây giờ nó biên dịch tốt, bằng đơn âm .

Bạn có thể chụp lén nó dưới radar nếu bạn đặt một giao diện trên một lớp cơ sở.

public interface IFoo<T> {
}

public class Foo<T> : IFoo<T>
{
}

public class Foo<T1, T2> : Foo<T1>, IFoo<T2>
{
}

Tôi nghi ngờ điều này hoạt động vì nếu các kiểu "thống nhất" thì rõ ràng việc triển khai của lớp dẫn xuất sẽ thắng.

Xem câu trả lời của tôi cho câu hỏi cơ bản tương tự tại đây: https://stackoverflow.com/a/12361409/471129

Ở một mức độ nào đó, điều này có thể được thực hiện! Tôi sử dụng một phương pháp phân biệt, thay vì (các) định tính giới hạn các loại.

Nó không thống nhất, trên thực tế, nó có thể tốt hơn nếu nó đã làm vì bạn có thể tách rời các giao diện riêng biệt.

Xem bài đăng của tôi ở đây, với một ví dụ hoạt động đầy đủ trong ngữ cảnh khác. https://stackoverflow.com/a/12361409/471129

Về cơ bản, những gì bạn làm là thêm một tham số kiểu khác vào IIndexer , để nó trở thành IIndexer <TKey, TValue, TDifferentiator>.

Sau đó, khi bạn sử dụng nó hai lần, bạn chuyển "First" cho lần sử dụng đầu tiên và "Second" cho lần sử dụng thứ hai

Vì vậy, lớp Kiểm tra trở thành: lớp Test<TKey, TValue> : IIndexer<TKey, TValue, First>, IIndexer<TValue, TKey, Second>

Vì vậy, bạn có thể làm new Test<int,int>()

trong đó Thứ nhất và Thứ hai là tầm thường:

interface First { }

interface Second { }

Tôi biết nó đã được một thời gian kể từ khi chủ đề được đăng nhưng cho những người xuống chủ đề này thông qua công cụ tìm kiếm để được giúp đỡ. Lưu ý rằng 'Cơ sở' là viết tắt của lớp cơ sở cho TA và B ở bên dưới.

public class MyFoo<TA> : IFoo<Base> where TA : Base where B : Base
{
    public void Handle(Base obj) 
    { 
       if(obj is TA) { // TA specific codes or calls }
       else if(obj is B) { // B specific codes or calls }
    }

}

Hãy đoán ngay bây giờ ...

Không thể khai báo A, B và C trong các tập hợp bên ngoài, nơi mà hệ thống phân cấp kiểu có thể thay đổi sau khi biên dịch MyFoo <T>, đưa sự tàn phá vào thế giới?

Cách giải quyết dễ dàng chỉ là triển khai Xử lý (A) thay vì Xử lý (TA) (và sử dụng IFoo <A> thay vì IFoo <TA>). Dù sao thì bạn cũng không thể làm được nhiều hơn với Handle (TA) so với các phương thức truy cập từ A (do ràng buộc A: TA).

public class MyFoo : IFoo<A>, IFoo<B> {
    public void Handle(A a) { }
    public void Handle(B b) { }
}

Hmm, những gì về điều này:

public class MyFoo<TA> : IFoo<TA>, IFoo<B>
    where TA : A
{
    void IFoo<TA>.Handle(TA a) { }
    void IFoo<B>.Handle(B b) { }
}