Comment spécifier une constante int courte sans casting?

Question

Est-il possible de spécifier que ma variable est un int court? Je cherche quelque chose de similaire au suffixe M pour les nombres décimaux. Pour les nombres décimaux, je n'ai pas à dire

 var d = (decimal)1.23;
 

Je peux juste écrire comme suit:

 var d = 1.23M;
 

Y a-t-il un moyen d'écrire ceci

    var s  = SomeLiteralWithoutCast
 

de sorte que s est impliqué pour être court int?

Answer 1

Réponse courte, Pas de. En C#, il n'y a pas de lettre d' S qui pourraient être utilisés comme var a = 123S pour indiquer que l' a est de type short. Il y a L pour long, F pour float, D pour double, M pour decimal, mais pas S. Ce serait bien si il y en avait, mais il n'y en a pas.

var a = 1M;  // decimal
var a = 1L;  // long
var a = 1F;  // float
var a = 1D;  // double
var a = 1;   // int

var a = 1U;  // uint
var a = 1UL; // ulong

mais pas

var a = 1S; // not possible, you must use (short)1;

Answer 2

La question est un peu déroutant. Nous allons définir quelques termes:

Une expression constante est (en gros) une expression connue du compilateur à une valeur constante.

Un littéral est une forme particulière de l'expression constante; 123 et Math.PI sont à la fois des expressions constantes. Le premier est un littéral, le second ne l'est pas.

Un champ constant est un membre d'un type qui est initialisé avec une expression constante, et peut ensuite être utilisé comme une expression constante ailleurs. Math.PI est un exemple d'un champ constant.

Une constante locale , c'est comme un champ constant, mais limitées à un bloc. (Tout comme une variable locale est limitée à un bloc.)

Champs constants et constantes locales sont tenus d'indiquer leur type explicitement; il n'y a pas de "var" formulaire pour les constantes. (L'idée même fait frissonner; un "const var" est évidemment un oxymore.)

Les variables locales ne sont pas tenus d'indiquer leur type; le type peut être inférée à partir de l'initialiseur. Une telle variable locale est appelée un "implicitement tapé la variable locale".

Si votre question est "est-il un moyen d'écrire une constante littérale de l'expression de type court qui peut être utilisé pour initialiser une tapée implicitement variable locale de type court?"

Non, il n'est pas. Vous pouvez explicitement le type de la variable locale:

short s1 = 123;

Vous pouvez taper une constante locale:

const short s2 = 123;

Ou vous pouvez faire une expression constante qui contient un casting pour court:

var s3 = (short)123;

Ou vous pouvez faire un local ou d'un champ constant et utiliser son nom pour l'initialiseur de la tapée implicitement local:

var s4 = s2;

Mais il n'y a pas moyen de contourner cela; short doit apparaître quelque part, soit dans un champ ou un local de la déclaration ou de la distribution.

Answer 3

Il n'y a pas de suffixe pour le type de données short en C #. Si vous souhaitez qu'un littéral entier soit court, vous devez indiquer explicitement le type et fournir un littéral compris dans la plage.

 short s = 123;
 

Answer 4

Deux options; ni idéal:

1. Supprimez les var , en spécifiant explicitement le type:

    short s = 123;
    

2. Utilisez la syntaxe de transtypage (en notant qu'il s'agit d'une opération de compilation, et non d'exécution):

    var s = (short)123;
    

C'est la seule option pour spécifier un court littéral.

Answer 5

Vous pouvez utiliser les éléments suivants:

 var value = (short)123;
 

Bien sûr, cela n’a pas vraiment de sens puisque l’important de var est de ne pas écrire le type.