implizit eine allgemeine <T> zurück zu T Casting

Question

Wenn ich eine generische Klasse wie Klasse schreiben MyGeneric<T> ist es möglich, eine implizite Umwandlung zu schreiben T zu geben, so kann ich wie Dinge tun:

public class MyGeneric<T> 
{ 
... 
} 

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

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

Ist es möglich, Tun Sie das, indem Sie die Operatoren überlasten? Ich weiß, es könnte getan werden, wenn meine Klasse kein Generikum wäre ...

Answer 1

Nun, ja, aber für die Liebe von Zombie Jesus tun Sie das NICHT. Es ist wirklich verwirrend. Sie verstehen den Zweck von Generika leicht falsch, denke ich. Es wird nicht verwendet, um eine Klasse in diesen Typ zu "verwandeln". Es wird verwendet, damit dieser Typ (MyGenericString) den gewünschten Typ für verschiedene Zwecke "kennt" (normalerweise sind dies sammlungsbasierte Zwecke).

Answer 2

yep..aber nicht zu viel tun, dies neigt dazu, Menschen zu verwirren. Ich würde es nur für Wrapper-Typen verwenden.

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

Ja, es ist möglich, mit impliziten 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

Wie andere gesagt haben, das heißt Rechts aber gefährlich. Es gibt viele Fallen, in die Sie fallen können. Zum Beispiel: Angenommen, Sie einen benutzerdefinierten Konvertierungsoperator zwischen C<T> und T. definiert Dann sagen Sie

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

Was passiert? Läuft Ihre benutzerdefinierte Conversion oder nicht? Nein, weil c bereits ein Objekt ist.

Wie ich schon sagte, gibt es verrückt Situationen, in die Sie geraten können, wenn Sie versuchen, generische Konvertierungsoperatoren zu definieren; tun Sie es nicht, wenn Sie ein tiefes und detailliertes Verständnis von Abschnitt 10.10.3 der Spezifikation haben.