Giao diện cho phương thức trả về kiểu riêng của mình

Question

Tôi có một tình huống mà tôi có một lớp

class Foo 
{ 
    Foo Bar() 
    { 
     return new Foo(); 
    } 
} 

Bây giờ tôi wan tot tạo một giao diện cho nó

class IFoo 
{ 
    ??? Bar(); 
} 

gì nên ở vị trí của dấu chấm hỏi? Mỗi lớp phải trả về kiểu riêng của nó, không phải Foo.

Các giải pháp dưới đây hoạt động nhưng không có vẻ sạch sẽ. Tôi không hiểu tại sao tôi phải chỉ định cùng lớp hai lần, và không có gì giống như "này" cho các loại hình hiện tại

Đây là cách tôi đang sử dụng nó sau này

class GenericClass<T> where T : IFoo 
{ 
    T foo = new T(); 
    T item = foo.Bar(); 
} 

Answer 1

Bạn hỏi:

Các giải pháp bel ow làm việc nhưng không trông sạch sẽ. Tôi không hiểu tại sao tôi phải chỉ định cùng một lớp hai lần và không có gì giống như "này" cho loại hiện tại

Lý do tại sao bạn phải chỉ định hai lần là vì C# thiếu tính năng mà bạn nhu cầu. gì bạn muốn là một cái gì đó như thế này:

interface IFoo 
{ 
    IFoo Bar(); 
} 

class Foo : IFoo 
{ 
    Foo Bar() // should work since Foo is an IFoo, but it's not supported by C# 
    { 
     return new Foo(); 
    } 
} 

Từ một điểm kiểu an toàn, điều này nên làm việc (nó được gọi là return type covariance). Trên thực tế, các ngôn ngữ lập trình khác như C++ hoặc Java hỗ trợ điều này, xem this example on Wikipedia. Thật không may, phương thức trả về kiểu trả về không được hỗ trợ bởi C# (thậm chí không C# 4.0, mà giới thiệu hiệp phương sai cho generics), đó là lý do tại sao bạn phải sử dụng "workaround generics" minh họa trong các câu trả lời khác.

kiểu trả về hiệp biến cũng như một "này" loại được tính năng đề xuất cho phiên bản mới của C#:

• Champion "Covariant Return Types"
• Proposal: support "type of the current object" as declared return type.

Answer 2

Bạn có thể thêm một kiểu generic và hạn chế nó bằng cách sử dụng loại giao diện:

public interface IFoo<T> 
{ 
    T Bar(); 
} 

Bạn muốn thực hiện điều này như sau:

public class Foo : IFoo<Foo> 
{ 
    public Foo Bar() 
    { 
     return new Foo(); 
    } 
} 

public class Cheese : IFoo<Cheese> 
{ 
    public Cheese Bar() 
    { 
     return new Cheese(); 
    } 
} 

Cập nhật, nếu bạn không bao giờ quan tâm đến kiểu trả về bê tông của Foo, sau đó bạn có thể làm như sau:

public interface IFoo 
{ 
    IFoo Bar(); 
} 

nào được thực hiện như:

public class Foo : IFoo 
{ 
    public IFoo Bar() 
    { 
     return new Foo(); 
    } 
} 

Sau đó, trong lớp generic của bạn:

public class GenericClass<T> where T : class, IFoo, new() 
{ 
    public T Rar() 
    { 
     T foo = new T(); 
     T item = foo.Bar() as T; 
     return item; 
    } 
} 

GenericClass<Foo>.Rar(); sẽ thực hiện cụ thể Foo.

Answer 3

public interface IFoo<T> 
{ 
    T Bar(); 
} 

thực hiện của bạn sau đó sẽ là:

class Foo : IFoo<Foo> 
{ 
    Foo Bar() 
    { 
     return new Foo(); 
    } 
} 

class Baz : IFoo<Baz> 
{ 
    Baz Bar() 
    { 
     return new Baz(); 
    } 
} 

Answer 4

Bạn cần phải thực hiện giao diện chung chung, như thế này:

interface IFoo<TClass> where TClass : IFoo<TClass>, class { 
    TClass Bar(); 
} 

Answer 5

Bạn có thể sử dụng một lớp cơ sở trừu tượng cộng với thực hiện thành viên rõ ràng để đạt được điều này. Thứ nhất, tuyên bố giao diện của bạn như thế này:

interface IFoo 
{ 
    IFoo Bar(); 
} 

Sau đó, khai báo một lớp trừu tượng chung chung mà thực hiện IFoo một cách rõ ràng, và cũng có thể tuyên bố một phương pháp trừu tượng mà loại "quá tải" Bar(), nhưng trong một generic cách:

abstract class BaseFooImpl<T> : IFoo where T : BaseFooImpl 
{ 
    public abstract T Bar(); 

    IFoo IFoo.Bar() 
    { 
     return Bar(); // this will call the abstract Bar() 
    } 
} 

Bây giờ, định nghĩa các lớp bê tông của bạn như thế này:

class ConcreteFoo : BaseFooImpl<ConcreteFoo> 
{ 
    public override ConcreteFoo Bar() 
    { 
     return this; // for example, of course. 
    } 
} 

Ưu điểm của phương pháp này là bạn luôn có thể sử dụng tham khảo IFoo không chung chung để giữ các thể hiện cụ thể.Nếu bạn thực hiện giao diện của bạn chung chung, bạn có thể không, ví dụ, tuyên bố sau đây:

IFoo mammalInstance, fishInstance; // Instead of IFoo<Mammal> mammalInstance; IFoo<Fish> fishInstance; 
List<IFoo> manyInstances; // Instead of List<IFoo<IFoo>>, which doesn't even work AFAIK 

Answer 6

Không chắc chắn những gì bạn đang cố gắng để hoàn thành nhưng nó có thể được thực hiện theo cách này:

interface IFoo<T> 
{ 
    T Bar(); 
} 



    class Foo:IFoo<Foo> 
    { 

     #region IFoo<Foo> Members 

     public Foo Bar() 
     { 
      return new Foo(); 
     } 

     #endregion 
    } 

Hoặc Giống như này:

interface IFoo 
    { 
     IFoo Bar(); 
    } 

class Foo : IFoo 
    { 

     #region IFoo Members 

     public IFoo Bar() 
     { 
      return new Foo(); 
     } 

     #endregion 
    } 

Answer 7

Tôi nghĩ rằng câu hỏi thực sự là: tại sao bạn cần loại có nguồn gốc trong giao diện? Giao diện chính xác vì lý do đó - trừu tượng hóa từ các lớp cụ thể. Nếu nó chỉ thuận tiện, vì vậy bạn không phải truyền đến Foo sau khi gọi cho Bar(), bạn có thể triển khai giao diện rõ ràng:

Tự hỏi mình câu hỏi: tại sao bạn giới thiệu giao diện khi bạn muốn loại bê tông?