Generische Typspezifikationsargumente - manchmal optional, aber nicht immer

Question

Bei dieser Frage geht es um die Angabe generischer Typspezifikationsargumente. Es ist ein bisschen lang, also bitte ertragen Sie es.

Wenn Sie die folgenden (erfundene) Klassen haben ...

public abstract class UserBase 
{ 
    public void DoSomethingWithUser() { } 
} 

public class FirstTimeUser : UserBase 
{ 
    /* TODO: some implementation */ 
} 

Die folgende Methode ...

private static void DoThingsWithUser<TUser>(TUser user) where TUser : UserBase 
{ 
    user.DoSomethingWithUser(); 
} 

Kann mit oder ohne auf den Typ Argument TUser aufgerufen werden. ..

var user = new FirstTimeUser(); 

DoThingsWithUser<FirstTimeUser>(user); 
DoThingsWithUser(user); // also valid, and less typing required! 

So weit, so gut.

Aber wenn Sie ein paar mehr hinzuzufügen (auch hier erfundene) Klassen ...

public abstract class UserDisplayBase<T> where T : UserBase 
{ 
    public T User { get; protected set; } 
} 

public class FirstTimeUserDisplay : UserDisplayBase<FirstTimeUser> 
{ 
    public FirstTimeUserDisplay() 
    { 
     User = new FirstTimeUser(); 
    } 
} 

und ein Verfahren ...

private static void DoThingsWithUserDisplay<TDisplay, TUser>(TDisplay userDisplay) 
    where TDisplay : UserDisplayBase<TUser> 
    where TUser : UserBase 
{ 
    userDisplay.User.DoSomethingWithUser(); 
} 

Bei Aufruf dieser Methode ist es obligatorisch umfassen die Typargumente ...

var userDisplay = new FirstTimeUserDisplay(); 
DoThingsWithUserDisplay<FirstTimeUserDisplay, FirstTimeUser>(userDisplay); // Type arguments required! 

Wenn Sie nicht die Art a angeben rguments erhalten Sie einen Compilerfehler von

Die Typ Argumente für die Methode 'DoThingsWithUserDisplay (TDisplay)' kann nicht aus der Verwendung abgeleitet werden. Versuchen Sie, die Typargumente explizit anzugeben.

ich denken, dass der Compiler könnte/sollte klug genug sein, dies ... um herauszufinden, oder gibt es einen subtilen Grund, warum nicht?

Answer 1

Als Compiler die Typen analysiert zu folgern, es erreicht eine Sackgasse, wenn sie bei DoThingsWithUserDisplay(userDisplay);

suchen Sie findet, dass TDisplayFirstTimeUserDisplay vom Typ sein muss, was gut ist. Dann besagt die Einschränkung, dass TDisplay von UserDisplayBase<TUser> erben muss.

Da weiß er nicht der Typ für TUser kann es nicht bestimmen, ob FirstTimeUserDisplay erbt von UserDisplayBase<TUser> und es kann auch nicht daraus schließen, dass die TUser Parameter sollen unabhängig von der Art in den generischen UserDisplayBase<TUser> ist.

Bearbeiten: Übrigens können Sie die Typ-Inferenz, die Sie suchen, mit einer Schnittstelle mit einer Variante erhalten. In diesem Fall stellt die Schnittstellendefinition ausreichende Vererbungsinformationen bereit, damit die Einschränkungen erfüllt werden.

public abstract class UserDisplayBase<T> : IUserDisplayBase<T> 
    where T : UserBase 
{ 
    public T User { get; protected set; } 
} 

public interface IUserDisplayBase<out T> 
    where T : UserBase 
{ 
    T User { get; } 
} 

private static void DoThingsWithUserDisplay<TDisplay>(TDisplay userDisplay) 
    where TDisplay : IUserDisplayBase<UserBase> 
{ 
    userDisplay.User.DoSomethingWithUser(); 
} 

mit

var userDisplay = new FirstTimeUserDisplay(); 
DoThingsWithUserDisplay(userDisplay);