Использование универсального типа передается без ограничений с ограничениями общего типа

Question

Допустим, мы имеем следующие классы:

public interface IFrobnicator<T> { } 

class ComparableFrobnicator<T> : IFrobnicator<T> where T : IComparable<T> 
{ 
    public ComparableFrobnicator(T value) { } 
} 

class EquatableFrobnicator<T> : IFrobnicator<T> where T : IEquatable<T> 
{ 
    public EquatableFrobnicator(T value) { } 
} 

Вы можете написать методы

public IFrobnicator<T> MakeFrobnicatorFromComparable<T>(T value) where T : IComparable<T> 
{ 
    return new ComparableFrobnicator<T>(value); 
} 

public IFrobnicator<T> MakeFrobnicatorFromEquatable<T>(T value) where T : IEquatable<T> 
{ 
    return new EquatableFrobnicator<T>(value); 
} 

Если бы я хотел, чтобы объединить это в один метод, наиболее очевидный способ не скомпилируется:

public IFrobnicator<T> MakeFrobnicator<T>(T value) 
{ 
    if (value is IComparable<T>) 
    { 
     return new ComparableFrobnicator<T>(value); 
    } 
    else if (value is IEquatable<T>) 
    { 
     return new EquatableFrobnicator<T>(value); 
    } 
    else throw new ArgumentException(); 
} 

Это вызывает следующую ошибку при компиляции led:

CS0314 Тип 'T' не может использоваться как параметр типа 'T' в общем типе или методе 'UserQuery.ComparableFrobnicator'. Нет конверсии бокса или преобразования параметров типа из «T» в «System.IComparable».

Я не могу заменить new ComparableFrobnicator <T> с new ComparableFrobnicator<IComparable<T>> потому, что вызывает проблемы по линии с получением value обратно - вы не можете отбрасывать от типа интерфейса для конкретного типа.

Так вместо этого, я пошел по пути отражения:

public IFrobnicator<T> MakeFrobnicator<T>(T value) 
{ 
    if (value is IComparable<T>) 
    { 
     var constructor = typeof(ComparableFrobnicator<>).MakeGenericType(typeof(T)).GetConstructor(new[] { typeof(T) }); 
     return (IFrobnicator<T>)constructor.Invoke(new object[] { value}); 
    } 
    else if (value is IEquatable<T>) 
    { 
     var constructor = typeof(EquatableFrobnicator<>).MakeGenericType(typeof(T)).GetConstructor(new[] { typeof(T) }); 
     return (IFrobnicator<T>)constructor.Invoke(new object[] { value }); 
    } 
    else throw new ArgumentException(); 
} 

Это, кажется, работает отлично, но выглядит как шаг назад в языке с такими умозаключениями мощного типа, как я привык. Есть что-то, чего я пропускаю, или лучшая техника, которую я пропустил?

Answer 1

Попробуйте подход методы удлинители, Путь value.MakeFrobnicator() реализован помогает решить родового типа Params Issue

public interface IFrobnicator<T> { } 

public class ComparableFrobnicator<T> :IFrobnicator<T> 
           where T :IComparable<T> 
{ 
    public ComparableFrobnicator(T param) { } 
} 

public class EquatableFrobnicator<T> :IFrobnicator<T> 
           where T : IEquatable<T> 
{ 
    public EquatableFrobnicator(T value) { } 
} 

public static class FrobnicatorExtentions 
{ 
    public static IFrobnicator<T> 
      MakeFrobnicatorFromComparable<T>(this T value) 
    where T: IComparable<T> 
    {                
     //return new ComparableFrobnicator<T>(value);  
    return value.MakeFrobnicator(); 
    } 

    public static IFrobnicator<T> 
      MakeFrobnicatorFromEquatable<T>(this T value) 
    where T : IEquatable<T> 
    { 
     // return new EquatableFrobnicator<T>(value); 
    return value.MakeFrobnicator(); 
    } 

    public static IFrobnicator<T> 
        MakeFrobnicator<T>(this IEquatable<T> value) 
    where T: IEquatable<T> 
    { 
     if (value is T) 
     { 
     if (value is IEquatable<T>) 
     { 
      return new EquatableFrobnicator<T>((T)value); 
     } 
     } 

    throw new InvalidCastException(); 
    } 

    public static IFrobnicator<T> 
       MakeFrobnicator<T>(this IComparable<T> value) 
    where T : IComparable<T> 
    { 
    if (value is T) 
    { 
     if (value is IComparable<T>) 
     { 
     return new ComparableFrobnicator<T>((T)value); 
     } 
    } 

    throw new InvalidCastException(); 
    } 

} 

Answer 2

Вы пробовали делать актеры?

public IFrobnicator<T> MakeFrobnicator<T>(T value) 
{ 
    if (value is IComparable<T>) 
    { 
     return new ComparableFrobnicator<T>((IComparable<T>)value); 
    } 
    else if (value is IEquatable<T>) 
    { 
     return new EquatableFrobnicator<T>((IEquatable<T>)value); 
    } 
    else throw new ArgumentException(); 
} 

Я не могу вспомнить с головы, если это действительно так. В любом случае, это не очень открыто/закрыто. Вместо этого вы можете написать список конвертеров, каждый из которых решит, являются ли они подходящим типом для преобразования.