Constantes en C #

9

Pourquoi le compilateur stocke-t-il des valeurs constantes dans les métadonnées d'assembly? Sont-ils directement intégrés au code du langage intermédiaire à partir des métadonnées d'assembly?

c# clr compilation Arun
la source
1
cela ne répond pas vraiment au «pourquoi» mais est néanmoins intéressant: stackoverflow.com/a/2128633/128384
stijn
Je suis confus par cette question. Où seraient-ils stockés sinon dans des métadonnées? Pouvez-vous clarifier la question?
Eric Lippert

Réponses:

4

La meilleure façon d'y penser est la suivante: au moment de la compilation, un const est converti en un littéral où il est utilisé.

La seule raison pour laquelle il entre dans le manifeste de l'assemblage dans lequel il a été défini était de le rendre accessible aux consommateurs. Il fait partie d'un type donné et les métadonnées de ce type sont stockées dans son assembly, et non dans les assemblys qui le consomment.

Il s'agit donc d'un littéral en ligne de consommation et d'une propriété ou d'un champ encapsulé de type consommable dans les métadonnées.

Jimmy Hoffa
la source
2

Je me suis longuement renseigné et j'ai découvert dans un livre que cela pouvait être la raison ...

Étant donné que les valeurs constantes ne changent jamais, les constantes sont considérées comme faisant partie du type de définition. Par conséquent, la définition de constantes crée des métadonnées.

Arun
la source
1

Je pense que vous mélangez deux assemblées.

La constante n'est stockée que dans les métadonnées de l' assembly où elle est définie . Les métadonnées contiennent des informations sur tous les types et membres d'un assemblage et les constantes sont des membres.

Aucune information sur la constante n'est stockée dans l' assembly où elle est utilisée . La valeur constante est utilisée directement dans l'IL comme si vous aviez écrit le nombre constant ou la chaîne directement dans la source.

Un exemple: une de mes applications utilise de nombreuses constantes pour identifier les tables et les champs de la base de données. J'ai un assemblage qui ne contient que toutes les constantes.

Lorsque je crée l'application, j'ajoute une référence à l'assembly "constantes" dans Visual Studio. Étant donné que l'assembly contient uniquement des constantes, il n'y a aucune référence à celui-ci dans mon application et l'assembly "constantes" n'est pas nécessaire au moment de l'exécution.

adrianm
la source
2
Cela n'explique cependant pas vraiment pourquoi les constantes sont stockées dans les métadonnées. Il danse autour de pourquoi, mais je ne pense pas que l'OP confonde deux assemblées. Vous voyez cela comme un problème de deux assemblages parce que vous utilisez deux assemblys, mais je ne pense pas que la pratique soit courante; les constantes sont généralement définies dans le même assemblage où elles sont utilisées.
Robert Harvey
@RobertHarvey Votre présomption du cas typique surestime la compétence de beaucoup de nos collègues C # d'entreprise, j'ai souvent dû expliquer ce qu'est un const à des collègues et pourquoi vous ne les appelez pas entre les assemblys.
Jimmy Hoffa
1

Les constantes sont connues au moment de la compilation, puis elles sont stockées dans les métadonnées de l'assembly. Cela signifie que vous ne pouvez définir des constantes que pour les types primitifs.

Oui, ils sont directement chargés à partir des métadonnées. Il n'y aurait pas d'allocation de mémoire au moment de l'exécution.

Le buteur
la source
1
Decimal n'est pas un type primitif mais vous pouvez créer des constantes décimales. Et vous pouvez créer des constantes de n'importe quel type de référence à condition que la constante soit nulle.
Eric Lippert