Wie überprüft man, ob eine implizite oder explizite Umwandlung existiert?

Question

Ich habe eine generische Klasse und möchte erzwingen, dass Instanzen des Typparameters immer "cast-fähig"/konvertierbar von String sind. Ist es möglich ohne eine Schnittstelle zu verwenden?

Mögliche Umsetzung:

public class MyClass<T> where T : IConvertibleFrom<string>, new() 
{ 
    public T DoSomethingWith(string s) 
    { 
     // ... 
    } 
} 

Ideal Umsetzung:

public class MyClass<T> 
{ 
    public T DoSomethingWith(string s) 
    { 
     // CanBeConvertedFrom would return true if explicit or implicit cast exists 
     if(!typeof(T).CanBeConvertedFrom(typeof(String)) 
     { 
      throw new Exception(); 
     } 
     // ... 
    } 
} 

Der Grund, warum ich diese "idealen" Implementierung vorziehen würde, ist in erster Linie, um alle Ts nicht zu zwingen, zu implementieren IConvertibleFrom <> .

Answer 1

Vorausgesetzt, dass Sie aus dem abgedichteten Typ String konvertieren möchten, können Sie mögliche nullable, Boxen, Referenz- und explizite ignorieren Konvertierungen. Nur op_Implicit() qualifiziert. Ein generischer Ansatz wird durch die System.Linq.Expressions.Expression-Klasse:

using System.Linq.Expressions; 
... 
    public static T DoSomethingWith(string s) 
    { 
     var expr = Expression.Constant(s); 
     var convert = Expression.Convert(expr, typeof(T)); 
     return (T)convert.Method.Invoke(null, new object[] { s }); 
    } 

Passen Sie die Kosten für die Reflexion.

Answer 2

Warum können Sie so etwas nicht tun?

public class MyClass<T> where T : string 
{ 
    public T DoSomethingWith(string s) 
    { 
     // ... 
    } 
} 

Auf diese Weise können Sie überprüfen, ob s-T im DoSomethingWith Code umwandelbar ist. Von dort können Sie Ausnahme auslösen, wenn es nicht kann, oder das Gießen tun, wenn es kann

Answer 3

if(!typeof(T).IsAssignableFrom(typeof(String))) { 
    throw new Exception(); 
}