使用泛型方法创建接口

Question

I am trying to design an interface, so that it has a generic type of id and a generic method that returns the type of the class that implements this interface. For example:

public interface IEntity <IDType, MethodReturnType>
{
     IDType ID {get; set;}
     MethodReturnType Get();
}

public class Model : IEntity<int, Model>
{
     int ID {get; set; }
     Model Get() { // do something }
}

My question is, it seems silly to put in Model as the second type parameter of IEntity, because I am already in a Model's class, it should be some intelligence way to figure out what type it is (although using generic type requires it to be determined before compile time).

Is it any other solution that can help me to get rid of the Model type while retain the Get method definition in the interface?

Answer 1

You can determine the inherited class type with this.GetType() but that will not allow you to create generic functions/parameters/etc as you are doing.

So to your answer, no, you can't unless you will not use that type in any way (you can still get the base type of the class and use it but cannot set it as return type/param type/etc).

Answer 2

In this context, there are two typical ways to go about designing your classes and interfaces. I'll stray slightly from your exact example to try to make the answer more general.

Which option to choose really depends on how you want your classes and interfaces to be used.

Option 1

Make your interface generic, so that the interface members have knowledge of the exact type.

public interface IEntity<TDescription>
{
    TDescription Get();
}

public class MyModel : IEntity<MyDescription>
{
     MyDescription Get() { ... }
}

public class MyDescription { ... }

This means that when you use your interface IEntity<TDescription> you need to know TDescription at the time of use. The benefit is that you get more compile-time type checking.

Option 2

Do not make your interface generic and instead have your interface members use interfaces as well.

public interface IEntity
{
    IDescription Get();
}

public interface IDescription { ... }

public class MyModel : IEntity
{
    MyDescription Get() { ... }
    IDescription IEntity.Get() { return this.Get(); }
}

public class MyDescription : IDescription { ... }

This is more flexible, but it also means less compile-time type checking.