为什么我不能将泛型类型的一个实例转换为另一个实例？

Question

我怎样才能实现一个结构，以便可以执行以下转换？

var a = new StatusedValue<double>(1, false);
var b = (StatusedValue<int>)a;

我的实现应该与Nullable<T> 类似，它工作正常。但是，此代码因System.InvalidCastException 而失败：

public struct StatusedValue<T>  where T : struct
{
    public StatusedValue(T value) : this(value, true)
    {

    }

    public StatusedValue(T value, bool isValid)
    {
        this.value = value;
        this.isValid = isValid;
    }

    private T value;
    private bool isValid;

    public static implicit operator StatusedValue<T>(T value)
    {
        return new StatusedValue<T>(value);
    }

    public static explicit operator T(StatusedValue<T> value)
    {
        return value.value;
    }
}

结果：

无法将“StatusedValue`1[System.Double]”类型的对象转换为类型 'StatusedValue`1[System.Int32]'。

Answer 1

这适用于Nullable<T> 类型，因为它们得到了编译器的特殊处理。这称为“提升的转换运算符”，您无法定义自己的。

来自the C# Specification 的第 6.4.2 节：

6.4.2 提升的转换运算符

给定一个用户定义的转换运算符，它将一个不可为空的值类型 S 转换为一个 不可为空的值类型 T，存在提升的转换运算符 从 S?到T?。这个提升的转换运算符执行 从 S 展开？到 S 后跟从 S 的用户定义转换 到 T 后跟从 T 到 T? 的换行，除了 null 值 年代？直接转换为空值 T?。提升的转换运算符 具有与其基础相同的隐式或显式分类 用户定义的转换运算符。术语“用户定义的转换” 适用于用户定义和提升转换的使用 运营商

Answer 2

如果您对调用方法感到满意，请尝试

public StatusedValue<U> CastValue<U>() where U : struct
{
    return new StatusedValue<U>((U)Convert.ChangeType(value, typeof(U)), isValid);
}

如果T 无法转换为U，这将很遗憾在运行时 而不是编译时抛出。

编辑：如下所述，如果您限制为IConvertible 以及/而不是struct，那么理论上每次转换都可以在编译时进行，您只会得到一个由于运行时值错误而导致运行时失败。

Answer 3

Nullables是编译器专门处理的，不知道这里是不是这样。

您的运营商会允许这样做：

StatusedValue<int> b = (int)a;

这可能不是你想要的，因为IsValid 不是这样复制的。

你可以像这样实现一个扩展方法：

 public static StatusedValue<TTarget> Cast<TSource, TTarget>(this StatusedValue<TSource> source)
    where TTarget : struct
    where TSource : struct
  {
    return new StatusedValue<TTarget>(
      (TTarget)Convert.ChangeType(
        source.Value, 
        typeof(TTarget)),
      source.IsValid);
  }


  b = a.Cast<int>();

但是编译器无法检查类型是否兼容。 ChangeType 还返回一个对象，从而将您的值装箱。

Answer 4

为什么的答案已经发布并标记为答案。

但是，您可以简化语法，使其更容易、更清晰地执行此操作，同时保持编译时类型安全。

首先，编写一个帮助类以避免必须指定冗余类型参数：

public static class StatusedValue
{
    public static StatusedValue<T> Create<T>(T value, bool isValid = true) where T: struct
    {
        return new StatusedValue<T>(value, isValid);
    }
}

接下来，您需要使用 Value 属性公开基础值（否则您无法从代码中强制转换它）。

最后你可以改变你原来的代码：

var a = new StatusedValue<double>(1, false);
var b = (StatusedValue<int>)a;

到这里：

var a = StatusedValue.Create(1.0, false);
var b = StatusedValue.Create((int)a.Value, false); 

您在a.Value 上进行简单演员表。

Answer 5

作为一种解决方法，您需要提供一种从一种基础类型转换为另一种的方法，因为编译器无法解决这个问题：

public StatusedValue<TResult> To<TResult>(Func<T, TResult> convertFunc)
where TResult : struct {
   return new StatusedValue<TResult>(convertFunc(value), isValid);
}

你可以这样做：

var a = new StatusedValue<double>(1, false);
var b = a.To(Convert.ToInt32);

通过一些反思，您可以构建Convert 方法的查找表，并根据类型参数查找正确的方法，然后您可以将转换函数默认为null，如果未提供，请尝试自动查找正确的转换。这将删除笨拙的Convert.ToInt32 部分，只需执行var b = a.To<int>();

正如 Rawling 指出的，Convert.ChangeType 可以使用。这将使我的方法看起来像：

public StatusedValue<T2> To<T2>(Func<T, T2> convertFunc = null)
where T2 : struct {
   return new StatusedValue<T2>(
      convertFunc == null
         ? (T2)Convert.ChangeType(value, typeof(T2))
         : convertFunc(value),
      isValid
   );
}

Answer 6

如果你不需要强制转换，你可以添加这样的方法：

    public StatusedValue<int> ConvertToStatusedInt() {
        return new StatusedValue<int>(Convert.ToInt32(value), isValid);
    }

如评论中所建议：

    public StatusedValue<Q> ConvertTo<Q>() where Q:struct {
        return new StatusedValue<Q>((Q)Convert.ChangeType(value, typeof(Q)), isValid);
    }