泛型和显式/隐式运算符

Question

考虑以下场景。

我有一个返回ISomething 的方法，但它可能是Something 或Wrapped<Something>。 因此，我将结果转换为 Something 以使用它，但它失败了，任何关于为什么或如何解决它的帮助将不胜感激。

class Program
{
    static void Main(string[] args)
    {
        var a = new DerivedSomething();
        var b = (DerivedSomething)new Wrapped<DerivedSomething>(a); //success
        var c = (DerivedSomething)_GetSomething(false); //success, obsiously!
        var d = (DerivedSomething)_GetSomething(true); //Unable to cast object of type 'test_bed.Wrapped`1[test_bed.DerivedSomething]' to type 'test_bed.DerivedSomething'.
        var e = (DerivedSomething)(ISomething)new Wrapped<DerivedSomething>(a);  //Unable to cast object of type 'test_bed.Wrapped`1[test_bed.DerivedSomething]' to type 'test_bed.DerivedSomething'.

        var works = ((DerivedSomething)_GetSomething(false)).DoSomethingElse(); 
        var fails = ((DerivedSomething)_GetSomething(true)).DoSomethingElse(); //cast exception
    }

    private static ISomething _GetSomething(bool wrap)
    {
        var something = new DerivedSomething();
        return wrap ? new Wrapped<DerivedSomething>(something) : (ISomething)something;
    }
}

public interface ISomething
{
    void DoSomething();
}

public abstract class Something : ISomething
{
    public void DoSomething()
    {
        //some code
    }
}

public class DerivedSomething : Something
{
    public void DoSomething()
    {
        //some code
    }

    public void DoSomethingElse()
    {
        //some code
    }
}

public class Wrapped<T> : ISomething
    where T : ISomething
{
    private readonly T _something;

    public Wrapped(T something)
    {
        _something = something;
    }

    public void DoSomething()
    {
        _something.DoSomething();
    }

    public static explicit operator T(Wrapped<T> wrapped)
    {
        return wrapped._something;
    }
}

看来如果在尝试强制转换时类型暴露为接口，那么操作符就找不到了？

“简单”的解决方案是编写一个“解包”函数，该函数可以选择将Wrapped<Something> 解包到Something，但如果可能的话，我更喜欢使用运算符。

编辑

我认为问题的症结在于：在_GetSomething()之外，我不知道Something或Wrapped<Something>是否会被退回。

Answer 1

显式转换是在编译时绑定的（一个额外的提示是转换运算符是静态的）。

试试

var f = (Something)(Wrapped<Something>)_GetSomething(true);

成功了

在您的情况下，编译器只知道您的类型是ISomething，并且不知道如何将ISomething 转换为Something，除非它已经是Something。

通过将public class Wrapped<T> : ISomething 更改为public class Wrapped<T> : Something，您的示例可以正常执行，但是由于Wrapped<T> 已经是T，因此不会调用您的演员表。

注意：
explicit operator 不是强制转换，而是类型转换，它是一个调用的方法，并且该方法根据编译时类型（在您的情况下为 ISomething）进行解析。类型转换与类型转换具有相同的语法，这是一个令人困惑的根源。转换只是将现有对象分配给兼容类型的不同变量，而类型转换实际上返回一个新对象。

Answer 2

你的演员看起来像这样：

public static explicit operator T(Wrapped<T> wrapped)
{
        return wrapped._something;
}

你的投射像

var d = (Something)_GetSomething(true); //FAILS!

您不能转换为 Something，因为 Something 是 T:ISomething 的具体实现。要完成这项工作，您需要编写：

var d = (ISomething)_GetSomething(true); //SUCCESS!

或

如果你真的想使用具体的类型，你可以定义泛型如：

public class Wrapped<T> : Something //Something and NOT ISomething 
    where T : ISomething
{
    .....
    .....
}

Answer 3

var d = (Something)(Wrapped<Something>)_GetSomething(true); 
var e = (Something)new Wrapped<Something>(a);