将无约束传递的泛型类型与受约束的泛型类型一起使用

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();
}

编译时会引发以下错误：

CS0314 类型"T"不能用作泛型类型或方法"UserQuery.ComparableFrobnicator"中的类型参数"T"。没有从"T"到"System.IComparable"的装箱转换或类型参数转换。

我不能用new ComparableFrobnicator<IComparable<T>>替换new ComparableFrobnicator <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

尝试扩展方法，方式值。MakeFrobnicator（）的实现有助于解决泛型类型参数问题

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();
}

我不记得这是否有效。无论哪种方式，它都不是很开放/封闭。您可以改为编写一个转换器列表，每个转换器都决定它们是否适合进行转换。