Wie kann ich Generic in einem impliziten Operator verwenden?

Question

Ich habe eine C++ Klasse, die sehr einfach ist:

struct Pt_t 
{ 
    T x, y; 
    template <class T2> operator Pt_t<T2>() { Pt_t<T2> pt = {x, y}; return pt; } 
}; 

, die ich pt erstellen kann, die T als jede Art hat ich will. Ich kann auch Pt_t<s8> = Pt_t<u64>; ohne ein Problem tun. Wie mache ich das gleiche in C#? Ich habe versucht, die unten und bekam eine Fehlermeldung:

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

Answer 1

Nein, ich glaube nicht, dass möglich ist. Möglicherweise müssen Sie eine Methode hinzufügen, z. B. .

wird das nächste Problem „sein, wie T2-T zu bekommen - man kann sie nicht einfach zuordnen Eine Möglichkeit eine Umwandlung Delegierten sein könnte:

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> 

Answer 2

Sie verwenden Nemerle: (http://github.com/rsdn/nemerle):.

using System.Console; 

class A[T] 
{ 
    public static @:[From](x : A[From]) : A[T] 
    { 
     A() 
    } 
} 


class Base{} 
class Derived{} 


def a = A.[Derived](); 
def b : A[Base] = a; 

WriteLine($"$a $b"); 

---

Ausgang:

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

Reflektor für Code:

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