C# Generika Methoden und Liste

Question

Ich möchte verstehen, warum der Code unten nicht funktioniert und wie man es beheben kann.

wenn T doppelt oder lang ist Warum T nicht akzeptiert, doppelt oder lang zu werfen?

private IList<T> GetGenericList<T>(bool isDouble) where T : double, long 
    { 
     IList<T> Result = new List<T>(); 

     if (isDouble) 
     { 
      T Value = 2.5; // does not compile 
      Result.Add(Value); 
     } 
     else 
     { 
      T Value = 2; // does not compile 
      Result.Add(Value); 
     } 

     return Result; 
    } 

[UPDATE] Ok Leute nicht nervös sein! Lass mich verstehen, was du gesagt hast! :)

Was ist das Prinzip der Generika in C#?

Wenn ich de-Code in das folgende Beispiel ändern? (Get out of the box, es ist nur ein Beispiel, ignorieren Sie de Regeln (if (isDouble), was auch immer)

private IList<T> GetGenericList<T>(//whatever you want of param... 
) where T : double 
{ 
    IList<T> Result = new List<T>(); 
    T Value = 2.5; // does not compile 
    Result.Add(Value); 
    return Result; 
} 

Dank

Answer 1

Es gibt drei Grund, warum Ihr Code wird nicht funktionieren..

1. Ihre generische Einschränkung erfordert, dass die Art sowohl erbt von double und long die
nicht möglich ist
2. double und long können nicht als generische Einschränkungen verwendet werden, weil sie verschlossen sind.
3. Es gibt keine implizite Konvertierung von double an einen unbekannten Typ

Es gibt kein „fix“ für die ersten beiden. Das Update für das letzte wäre object zuerst zu werfen:

if (isDouble) 
    { 
     T Value = (T)(object)2.5; // does not compile 
     Result.Add(Value); 
    } 
    else 
    { 
     T Value = (T)(object)2; // does not compile 
     Result.Add(Value); 
    } 

Es gibt keine Möglichkeit, die Methode zu bekommen genau so, wie Sie es wollen arbeiten, weil es keine Möglichkeit gibt T zu beschränken entweder double zu sein oder long. Sie könnte inspizieren den Typ mit Reflektion und eine Ausnahme auslösen, wenn es nicht einer von diesen ist, aber es gibt keine Möglichkeit, das zum Zeitpunkt der Kompilierung erzwingen.

Das Kernproblem ist, dass Ihr Code nicht generisch ist. Wahrer generischer Code interessiert nicht, was T ist (modulo einige sehr breite Parameter, wie es einige Schnittstelle implementieren muss). Die Anrufer bekommt zu bestimmen, was T ist, nicht die Methode, so dass alles, was unterschiedliche Logik basierend auf der tatsächlichen Art von T ist in der Regel ein Code Geruch. Dies scheint nur eine Lernübung zu sein, aber wenn Sie diese Funktion im wirklichen Leben benötigt würde ich empfehlen, zwei verschiedene Methoden mit:

private IList<double> GetDoubleList() 
{ 
    IList<double> Result = new List<double>(); 

    double Value = 2.5; 
    Result.Add(Value); 

    return Result; 
} 
private IList<long> GetLongList() 
{ 
    IList<long> Result = new List<long>(); 

    long Value = 2; 
    Result.Add(Value); 

    return Result; 
} 

Es ist nicht , die viel mehr als das, was Sie begann mit, es ist ein bisschen von der Wiederholung, aber nicht viel, es ist völlig typsicher, und es gibt keine Art Ambiguität innerhalb der Methoden.

Als nächstes können Sie den redundanten Code in eine generische Methode Refactoring (in diesem Fall brauchen Sie es nicht zu beschränken, da Sie die Typen aus dem Rufmethode steuern):

private IList<T> GetList<T>(T Value) 
{ 
    IList<T> Result = new List<T>(); 

    Result.Add(Value); 

    return Result; 
} 
private IList<double> GetDoubleList() 
{ 
    return GetList<double>(2.5); 
} 
private IList<long> GetLongList() 
{ 
    return GetList<long>(2); 
} 

Answer 2

isDouble Wert zur Laufzeit angegeben. Beide Aufgaben müssen sinnvoll zur Compile-Zeit unabhängig von Verzweigung

Sie versuchen, etwas mit Generika zu tun, die im Prinzip nicht getan werden können

Answer 3

Ihre Antwort zu beantworten siehe: Introduction to Generics (C# Programming Guide)

soweit Ihr aktuelles Problem, wo man nur double oder long will behandelt werden, Sie tun können, als D Stanley vorgeschlagen und nur etwas mit den anderen Typen. Hier ein Beispiel:

private IList<T> GetGenericList<T>() 
    { 
    Type parmType = typeof(T); 
    if (!parmType.Equals(typeof(double)) && !parmType.Equals(typeof(long))) 
    { 
     return null; 
    } 
    else 
    { 
     IList<T> Result = new List<T>(); 

     if (parmType.Equals(typeof(double))) 
     { 
      T Value = (T)(object)2.5; 
      Result.Add(Value); 
     } 
     else 
     { 
      T Value = (T)(object)2L; 
      Result.Add(Value); 
     } 

     return Result; 
    } 
    } 

Nun, wenn ich es wie folgt verwenden:

 List<double> lDbl = (List<double>)GetGenericList<double>(); 
    List<long> lLng = (List<long>)GetGenericList<long>(); 
    List<string> lStr = (List<string>)GetGenericList<string>(); 

ich am Ende mit den erwarteten Werten in lDbl und lLng, einschließlich der korrekten Datentypen. lStr ist jedoch auf null eingestellt, weil ich damit andere Handlingtypen als double oder long habe. Sie könnten genauso gut eine Ausnahme dort hineinwerfen.