implícitamente lanzar un genérico <T> de nuevo a T

Question

Si escribo una clase genérica como la clase MyGeneric<T> es posible escribir una conversión implícita de tipo T, por lo que puedo hacer cosas como:

public class MyGeneric<T> 
{ 
... 
} 

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

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

¿Es posible hacer eso al sobrecargar a los operadores? Sé que podría hacerse si mi clase no fuera genérica ...

Answer 1

Bueno, sí, pero por el amor de Jesús zombie NO hagas eso. Es realmente confuso Estás malinterpretando un poco el propósito de los genéricos, creo. No se usa para "convertir" una clase en ese tipo, se usa para que ese tipo (MyGenericString) sea "consciente" del tipo que desea, para varios propósitos (generalmente, esos son propósitos basados ​​en la recolección).

Answer 2

sip ... pero no se exceda, esto tiende a confundir a las personas. solo lo usaría para los tipos de envoltura.

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 3

Sí, es posible utilizando implícita 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; 
    } 
} 

Answer 4

Como han dicho otros, es legal pero peligroso. Hay muchas trampas en las que puede caer. Por ejemplo, supongamos que ha definido un operador de conversión definida por el usuario entre C<T> y T. Entonces usted dice

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

¿Qué ocurre? ¿se ejecuta o no la conversión definida por el usuario? No, porque c ya es un objeto.

Como he dicho, hay situaciones locas que puede ingresar cuando intenta definir operadores de conversión genéricos; no lo haga a menos que tenga una comprensión profunda y detallada de la sección 10.10.3 de la especificación.