Warum können objects mit einem Werttypen, nicht in einen anderen Werttypen gecastet werden?

Servus,

ich hab eine Verständnis frage:

Ursprünglich wollte ich folgendes machen:

C#-Code:

List<uint> l1 = new List<uint> { 1, 2, 3 }; var l2 = l1.Cast<int>().ToList();

Das wirft

Fehlermeldung:

System.InvalidCastException: "Unable to cast object of type 'System.UInt32' to type 'System.Int32'."

Nun ja, das lässt sich ja einfach mit

C#-Code:

var l2 = l1.Select(i => (int)i).ToList();

ersetzen, kein Problem.

Aber irgenwie hat mir das keine Ruhe gelassen, IEnumerable<T> Cast<T> ist folgendermaßen implementiert:

C#-Code:

public static IEnumerable<T> Cast<T>(this IEnumerable source) {     foreach (object o in source)         yield return (T)o; }

Das Problem ist, dass der Wert in ein object gesteckt wird, dieser Code wirft die gleiche Exception:

C#-Code:

uint i = 42; object o = i; int j = (int)o;

Erst dachte ich, Werttypen können nicht aus einem object zurück gecastet werden, aber folgerndes funktioniert:

C#-Code:

int i = 42; object o = i; int j = (int)o;

Warum können objects, mit einem Werttypen, nicht in einen anderen Werttypen gecastet werden? Vor allem da ja in der Exception die korrekten Typen genannt werden, also warum kann er den Cast nicht ausführen?

Bei der "Umwandlung" von uint auf int handelt es sich im Endeffekt nicht um ein Cast sondern um ein Reassigment.
Hier brauchst Du die Convert.To-Methoden.

Zitat:

Das Problem ist, dass der Wert in ein object gesteckt wird, dieser Code wirft die gleiche Exception:

Die Exception selbst kommt im Prinzip vom Unboxing:
Deine Quelle ist uint; aber das Unboxing erfolgt auf int - daher knallts.

Bezogen auf Dein Beispiel bräuchtest Du einen zusätzlichen Cast; dann klappts.
=> uint -> object -> uint -> int

C#-Code:

uint i = 42; object o = i; int j = (int)(uint)o;

Aber => uint -> object -> int knallt.
Dass der "Cast" von unit auf int funktioniert liegt am expliziten Operator.

C#-Code:

public static implicit operator int(uint value) => Convert.ToInt32(value);

Dein Szenario deckt aber so Cast<T> nicht ab.
Cast ist eigentlich dafür da, dass Du zB. eine Collection eines Interfaces hast, das dann wiederum verschiedene Instanzen von Implementierungen hast, und dann durch das Cast die Implementierungen raus ziehen kannst.

@MrSparkle:
Ich weiß, es mir nur klar zu machen um was es mir geht.

@Abt:
Super danke, an das Unboxing hab ich nicht gedacht.