C# 如何在隐式运算符中使用泛型？ 我有一个C++类，非常简单： struct Pt_t { T x, y; template <class T2> operator Pt_t<T2>() { Pt_t<T2> pt = {x, y}; return pt; } }; struct Pt\t { tx，y； 模板运算符Pt_t（）{Pt_t Pt={x，y}；返回Pt；} };

这允许我创建一个pt，它的T是我想要的任何类型。我也可以做

Pt\u t=Pt\u t没有问题。我如何在C#中实现同样的效果？我尝试了以下操作，但出现了一个错误：

    class Pt<T>
    {
        public T x, y;
        //between operator and <T2>, error CS1031: Type expected
        public static implicit operator<T2> Pt<T>(Pt<T2> v) {
            Pt<T> r = new Pt<T>();
            r.x = v.x;
            r.y = v.y;
            return r; 
        }
    }

Pt类
{
公共T x，y；
//在运算符和之间，错误CS1031:应为类型
公共静态隐式运算符Pt（Pt v）{
Pt r=新的Pt（）；
r、 x=v.x；
r、 y=v.y；
返回r；
}
}
不，我认为那是不可能的。您可能需要添加一个方法，例如
到

下一个问题是“如何从
T2
到
T
——您不能只分配它们。一个选项可能是转换委托：

public Pt<TDestination> To<TDestination>(
    Converter<T, TDestination> converter)
{
    if (converter == null) throw new ArgumentNullException("converter");
    Pt<TDestination> t = new Pt<TDestination>();
    t.x = converter(x);
    t.y = converter(y);
    return t;
}
...
var p = new Pt<int> { x = 1, y = 2 };
var p2 = p.To(t => t.ToString()); // a Pt<string>

public Pt To(
转换器（转换器）
{
如果（converter==null）抛出新的ArgumentNullException（“converter”）；
Pt t=新的Pt（）；
t、 x=转换器（x）；
t、 y=转换器（y）；
返回t；
}
...
var p=新的Pt{x=1，y=2}；
var p2=p.To（t=>t.ToString（））；//一个Pt
您可以使用Nemerle:（）：


输出：

A`1[Derived] A`1[Base]

代码的反射器：

internal class A<T>
{
    public static implicit operator A<T><From>(A<From> x)
    {
        return new A<T>();
    }
}

public class a
{
    public static void Main()
    {
        A<Derived> a = new A<Derived>();
        A<Base> a2 = (A<Base>) a;
        Console.WriteLine(Convert.ToString(a) + " " + Convert.ToString(a2));
    }
}

内部A类
{
公共静态隐式运算符A（A x）
{
返回新的A（）；
}
}
公共a类
{
公共静态void Main（）
{
A=新的A（）；
A a2=（A）A；
Console.WriteLine（Convert.ToString（a）+“”+Convert.ToString（a2））；
}
}
代码不是C++中的操作符符号……在它被篡改之前（C++中以及C++中），你试图写什么？@ PunTube——它试图成为一个转换操作符……到Pt，用不同的泛型类型AgMuthA:一个类名——应该仔细阅读！多谢。我可以从这里看到该去向何处。（toShort、toUshort，均使用简单的单线转换器或用户至（OwnConv）；
internal class A<T>
{
    public static implicit operator A<T><From>(A<From> x)
    {
        return new A<T>();
    }
}

public class a
{
    public static void Main()
    {
        A<Derived> a = new A<Derived>();
        A<Base> a2 = (A<Base>) a;
        Console.WriteLine(Convert.ToString(a) + " " + Convert.ToString(a2));
    }
}