Die Regeln von Generika und Typ Einschränkungen

Question

Nur aus Neugier, warum behandelt der Compiler eine unbeschränkte generische Art anders als es typeof (Objekt) würde?

In den oben genannten, Casting "T Ding" zu Bar führt zu einem Compiler-Fehler. Das "Objekt-Ding" zu Bar zu bringen, ist etwas, was der Compiler mir erlaubt, natürlich auf mein eigenes Risiko.

Was ich nicht sehe, ist warum. In .net-Objekt nach allem ist ein Catch-All und der Laufzeittyp könnte ein Boxed-Wert oder ein Objekt eines beliebigen Typs sein. Ich sehe also nicht, welchen logischen Grund es für den Compiler gibt, zwischen den beiden Fällen zu unterscheiden. Das Beste, was ich tun kann, ist so etwas wie "Der Programmierer würde erwarten, dass der Compiler Typtests mit generischen Typen durchführt, aber nicht mit Objekten". :) Ist das alles da?

Btw, ich bin mir bewusst, dass ich immer noch meine Besetzung im Foo Fall durch einfaches Schreiben erledigen

((Bar)(object)thing).ToString(); 

Ich möchte nur verstehen, warum die Compiler dies tun ...

Answer 1

Die Bedeutung hier ist object. Wenn das erste Beispiel etwas anderes als object wäre, würde es sich gleich verhalten. Im Grunde, was Sie im Moment sagen hier:

(Bar)thing 

ist: "ein T zu einem Bar konvertieren"; was im allgemeinen Fall nicht annähernd legal ist. Durch object Hinzufügen Sie es machen:

(Bar)(object)thing 

die „convert eine T zu einem object ...“ ist - was immer legal ist, da object die Wurzel aller verwalteten Typen ist; und beachten Sie, dass dies eine Box einfügen kann - "... und dann die object als Bar" - wiederum; Es ist immer zur Kompilierzeit legal und beinhaltet eine Typüberprüfung ("unbox-any") zur Laufzeit.

Zum Beispiel: Angenommen, TDateTime ist ...

DateTime thing = ... 
Bar bar = (Bar)(object)thing; 

perfekt gültig ist; Sicher, es wird zur Laufzeit scheitern, aber: Dies ist das Szenario, das Sie im Auge behalten müssen.

Answer 2

Es kommt auf die Semantik und den Zweck der Erstellung von Generika. Wenn Sie einen allgemeinen Typ T haben, lässt der Compiler Sie nicht beliebig direkt auf ein anderes Objekt umwandeln. Dies ist sinnvoll, da der Zweck von T darin besteht, den Programmierer zu zwingen, zu spezifizieren, welcher Typ T tatsächlich ist. Es wird nicht "Objekt" sein, sondern ein bestimmter Objekttyp. Zur Kompilierzeit kann der Compiler nicht wissen, was in T sein wird und kann daher nicht umwandeln.

Das Umwandeln von Objekt funktioniert, da es ein anonymes Objekt ist - im Gegensatz zu einem KNOWN-Objekttyp, der in seiner Verwendung definiert wird.

Dies kann mit der Where-Klausel erweitert werden. Z.B., können Sie angeben, dass T vom Typ IBar sein muss;

interface IBar { } 

class Bar : IBar { } 

class Foo<T> 
    where T : IBar 
{ 
    void foo(T thing) 
    { 
     ((IBar)thing).ToString(); 
    } 
} 

Vererbung funktioniert auch mit der where-Klausel;

class Bar { } 

class Foo<T> 
    where T : Bar 
{ 
    void foo(T thing) 
    { 
     // now you don't need to cast at all as the compiler knows 
     // exactly what type T is (at a parent level at least) 
     thing.ToString(); 
    } 
}