C＃继承Open Generics Compile

Question

Today my brain went dead, and I couldn't figure out a clean way of forcing the compiler to use inheritance for Generic inference.

Imagine the following 4 classes

Models

public abstract class Model
{

}

public class CodePerfModel : Model
{

}

Entities

public abstract class ModelEntity<TModel> where TModel : Model
{
    public TModel Model { get; set; }

}

public class CodePerfEntity : ModelEntity<CodePerfModel>
{

}

Now to me logically I should take for granted that when I take something that inherits from ModelEntity<> (it will specify the type of TModel ) via inheritance, because any class that inherits from ModelEntity<> will have to specify it.

Is there anyway to force the compiler to figure this out for me?

Eg

If I currently want to use ModelEntity<> , I have to specify a type for it. Such as the following:

public class CallerClass<TEntity, TModel>
    where TEntity : ModelEntity<TModel>
    where TModel : Model
{

}

How can I get rid of the TModel argument everywhere? While still having access to the TModel type at compile time? Eg via the base Model property.

To me, something like the following:

public class CallerClass<TEntity>
    where TEntity : ModelEntity<>
{

}

Would make perfect sense as when calling it all I should have to speicfy is eg

SomeCall<CodePerfEntity>();

rather than

SomeCall<CodePerfEntity, CodePerfModel>();

Is this something that is currently possible?

Would this be worth raising for C# 6/7?

Answer 1

You mention you would like to access TModel at compilation time, while not explicitly specifying this type when deriving a class. Letting go of your example, and moving to a more general case, this means you would like the semantics to remain the same, however you would not like to explicitly declare the type parameter's own type parameters when declaring a generic constraint.

In essence, you are asking why a specific syntax sugar feature is not implemented.

Let's consider another example:

public class CallerX<A, B> where A : ModelEntity<> where B : ModelEntity<>

From the example in your question, the compiler should insert TModel'1 and TModel'2 as type parameters for A and B respectively. Let's say the feature is implemented. This means that we have created the default situation that TModel'1 and TModel'2 are different types, each having constraints that match the single type. What if I would like to add more constraints to either TModel'1 or TModel'2 , or force them to be the same type? Why is this case so special that it deserves its own syntax?

From what I know of the C# team, they have the policy that each new feature starts with "-100 points" and should be really great in order to be considered (see UserVoice for C#).

To summarize:

• New language features are expensive and add complexity.
• You are asking for an implicit syntax for which it is unlikely/unclear that it will be the desired situation in most of the cases.
• Developers will have to learn and understand that an open generic type as a type parameter constraint will insert a hidden and anonymous extra parameter. To me, it is not intuitive that some other type parameter has been added to my type without me having declared it.