Question

如果我编写类MyGeneric<T>之类的泛型类，可以将一个隐式转换写入类型T，所以我可以这样做：

public class MyGeneric<T>
{
...
}

public class GenericProperties
{
   public MyGeneric<string> MyGenericString {get;set;}

   public void UseMyGeneric()
   {
       string sTest = MyGenericString;
       MyGenericString = "this is a test";
   }
}

是否可以通过重载运算符来实现？我知道如果我的班级不是通用的话可以做到......

Answer 1

是的，但是不要过度，这往往会让人感到困惑。我只会将它用于包装类型。

class Wrapper<T>
{
    public T Value {get; private set;}
    public Wrapper(T val) {Value = val;}

    public static implicit operator T(Wrapper<T> wrapper) {return wrapper.Value;}
    public static implicit operator Wrapper<T>(T val) {return new Wrapper<T>(val);}
}



var intWrapper = new Wrapper<int>(7);
var usingIt = 7 * intWrapper; //49

Wrapper<int> someWrapper = 9; //woohoo

Answer 2

嗯，是的，但是对于僵尸耶稣的爱，不要这样做。这真的令人困惑。我认为你有点误解了仿制药的目的。它不习惯将类“转”为该类型，它曾经用于使该类型（MyGenericString）“了解”您想要的类型，出于各种目的（通常是基于集合的目的）。

Answer 3

正如其他人所说，那是合法，但危险。你可能陷入许多陷阱。例如，假设您在C<T>和T之间定义了一个用户定义的转换运算符。那么您说

C<object> c = new C<object>("hello");
object o = (object) c;

会发生什么？您的用户定义转换是否运行？ 不，因为c已经是一个对象。

就像我说的那样，当你尝试定义泛型转换运算符时，你会遇到疯狂的情况; 除非您对规范第10.10.3节有深入细致的理解，否则不要这样做。

Answer 4

是的，可以使用隐式Conversion Operator Overloading

class Program
{
    static void Main(string[] args)
    {
        myclass<string> a = new myclass<string>();
        a.inner = "Hello";
        string b = a;
        Console.WriteLine(b);
    }
}

class myclass<T>
{
    public T inner;
    public myclass()
    {

    }
    public static implicit operator T(myclass<T> arg1)
    {
        return arg1.inner;
    }
}

隐式地将泛型<t>转换回T </t>

4 个答案: