Quelle est la différence entre la boxe/unboxing et le casting de type?

la Boxe se réfère à une conversion d'un non nullable-type de la valeur dans un type de référence ou de la conversion d'un type de valeur de certains de l'interface qu'elle met en œuvre (dire int à IComparable<int> ). De plus, la conversion d'un type de valeur sous-jacent en un type nul est aussi une conversion boxe. (Mise en garde: la plupart des discussions sur ce sujet ignoreront les deux derniers types de conversions.)

par exemple,

int i = 5;
object o = i;

convertis i à une instance de type object .

Unboxing se réfère à une conversion explicite à partir d'une instance de object ou ValueType non nullable-type de la valeur, de la conversion d'un type d'interface à un non nullable-type de la valeur (par exemple, IComparable<int> à int ). En outre, la conversion d'un type nullable en type sous-jacent est également une conversion unboxing. (Mise en garde: la plupart des discussions sur ce sujet ignoreront les deux derniers types de conversions.)

par exemple,

object o = (int)5;
int i = (int)o;

convertit l'entier encadré dans o en une instance de type int .

une fonte de type est une conversion explicite d'une expression en un type donné. Ainsi

(type) expression

convertit explicitement expression en un objet de type type .

Boxing and unboxing est un sous-ensemble de moulages de type. La boxe est le fait de traiter un type de valeur comme type de référence (ce qui, dans la pratique, implique de copier le contenu de ce type de valeur (à partir de la pile) vers le tas et de retourner une référence à cet objet). Cela permet à un type de valeur d'être passé partout où un type de référence compatible est attendu. Il permet également des appels de méthode virtuels et d'autres caractéristiques de types de référence à effectuer sur le type de valeur. Le déballage est l'inverse de cette opération (récupérer un type de valeur d'un objet encadré).

type moulé est le terme utilisé pour tout type de conversion d'une variable de type spécifique à une autre. C'est un concept plus large.

il y a quelques minutes j'ai répondu à une question connexe qui couvre cette différence . En résumé, j'ai classé différents types D'instructions IL générées par l'opérateur c # cast:

1. Boxe ( box il instruction) et unboxing ( unbox IL instruction)
2. lancer à travers la hiérarchie de l'héritage (comme dynamic_cast<Type> en C++, utilise castclass instruction IL pour vérifier)
3. moulage entre types primitifs (comme static_cast<Type> en C++, il y a beaucoup D'instructions IL pour différents types de moulages entre types primitifs)
4. appelant opérateurs de conversion définis par l'utilisateur (au niveau IL ils sont la méthode juste appelle à la méthode appropriée op_XXX ).

la Boxe est le terme pour le tournage d'un type de valeur (int, double, float, Guid, etc.) dans un type de référence (système.Objet Du Système.Chaîne de caractères, etc.). Faire cette opération de boxe permet d'attribuer la mémoire sur le tas (que le collecteur d'ordures aura éventuellement besoin de récupérer). Unboxing est l'inverse de ce processus, en prenant un type de référence et le transformer en un type de valeur.

Coulée est de prendre un type (par exemple, Système.Objet) et le traiter comme un autre type (par exemple, Système.Chaîne.)

quand vous emballez quelque chose en C#, vous le moulez à un autre type. la différence est qu'il attribue la mémoire supplémentaire comme un nouveau type de référence est créé .

ligne de fond: la boxe est un type spécial de distribution qui convertit un type de valeur à un type de référence, ce qui nécessite l'attribution d'un nouveau type de référence.

Boxing / unboxing et type casting sont deux opérations différentes, mais elles utilisent la même syntaxe.

ils ne sont utilisés de façon interchangeable que lorsque la personne qui en parle ne sait pas ce qui se passe réellement...

Boxing stocke un type de valeur comme un objet sur le tas, et unboxing lit la valeur de l'objet. Vous ne pouvez décompiler la valeur que si elle correspond au type exact.

Casting est quand vous convertissez un type de base à un autre type de base (comme d'un int à un long ), ou quand vous changez le type d'une référence (comme de List<int> à IEnumerable<int> ).

la Boxe est la conversion d'une variable de type valeur (c'est à dire un entier) à un type de référence. Le déballage est l'inverse de cela, en utilisant le moulage par type. Dans le monde. net, tout dérive du type" objet " en un mot.

par exemple (c # example):

int myInt = 0;                 // original variable (unboxed to begin with)
object boxed = myInt;          // box it up
int myIntUnBoxed = (int)boxed; // and unbox it again using type casting

l'élément à retenir est l'unification du système de type, qui permet de traiter les types-valeurs comme des types de référence. cet article a regardez boxing / unboxing.