C# XOR sur deux variables byte ne compilera pas sans cast [dupliquer]

Je ne peux pas vous donner la raison, mais je peux dire pourquoi le compilateur a ce comportement du point de vue des règles que le compilateur doit suivre (ce qui pourrait ne pas être vraiment ce que vous êtes intéressant à savoir).

D'une ancienne copie de la c # spec( je devrais probablement télécharger une nouvelle version), emphasis added:

14.2.6.2 promotions numériques binaires cette clause est informative.

binaire la promotion numérique se produit pour les opérandes des prédéfinis + , ? , * , / , % , & , | , ^ , == , != , > , < , >= , et <= opérateurs binaires. Binaire conversion implicite de la promotion numérique les deux opérandes à un type commun qui, dans le cas du non-relationnel opérateurs, devient aussi le résultat type de l'opération. Binaire numérique la promotion consiste à appliquer les règles suivantes, dans l'ordre qu'ils

• si l'un des opérandes est de type décimal, l'autre opérande est converti en type décimal, ou a erreur de compilation se produit si l'autre operand est de type float ou double.
• Sinon, si l'un des opérandes est de type double, l'autre opérande est converti en type double.
• autrement, si l'un ou l'autre des opérandes est de type float, l'autre opérande est converti en type flottant.
• Sinon, si l'un des opérandes est de type ulong, l'autre opérande est converti en ulong de type, ou un erreur de compilation se produit si l'autre l'opérande est de type sbyte, short, int, ou long.
• Sinon, si l'un des opérandes est de type long, l'autre opérande est converti en type long.
• dans les autres cas, si l'une ou l'autre des opérandes est de type uint et que la autre opérande est de type sbyte, court, ou int, les deux les opérandes sont converties en type long.
• Sinon, si l'un des opérandes est de type uint, l'autre opérande est converti en uint de type.
• sinon, les deux opérandes sont converties en type int .

donc, essentiellement des opérandes plus petites qu'un int seront converties en int pour ces opérateurs (et le résultat sera un int pour les ops non relationnelles).

j'ai dit que je ne pouvais pas vous donner une raison; cependant, je vais faire une conjecture à un - je pense que les concepteurs de C# ont voulu s'assurer que les opérations qui pourraient perdre de l'information Si rétrécie devrait avoir cette opération de rétrécissement Rendu explicite par le programmeur sous la forme d'un plâtre. Par exemple:

byte a = 200;
byte b = 100;

byte c = a + b;  // value would be truncated

alors que ce genre de troncature ne se produirait pas lors de l'exécution d'une opération xor entre deux opérandes byte, je pense que les concepteurs du langage ne voulaient probablement pas d'un ensemble plus complexe de règles où certaines opérations auraient besoin de moulages explicites et d'autres pas.

juste une petite note: la citation ci-dessus est "informative" pas "normative", mais il couvre tous les cas dans une forme facile à lire. Strictement parlant (au sens normatif), la raison pour laquelle l'opérateur ^ se comporte de cette manière est parce que la surcharge la plus proche pour cet opérateur dans le cadre des opérandes byte est (à partir de 14.10.1 "opérateurs logiques entiers"):

int operator ^(int x, int y); 

par conséquent, comme l'explique le texte informatif, les opérandes sont promues à int et un résultat int est produit.