¿Por qué este desbordamiento operación específica (cf. CS0220) en C #?

Question

Trato de construir una gran Int64 con la información almacenada en bytes mordisco.

Las siguientes líneas de código como se espera:

Console.WriteLine("{0:X12}", (Int64)(0x0d * 0x100000000));
Console.WriteLine("{0:X12}", (Int64)(0x0d * 0x1000000));
Console.WriteLine("{0:X12}", (Int64)(0x0d * 0x100000));

¿Por qué la siguiente línea de plomo a un error de compilación CS0220 "La operación se desborda en tiempo de compilación en el modo de marcado" y los otros no lo hacen?

Console.WriteLine("{0:X12}", (Int64)(0x0d * 0x10000000));

El resultado sería:

FFFFFFFFD0000000

en lugar de:

0000D0000000

¿Alguien puede explicar esto? Ahora voy a convertir con operadores de desplazamiento, pero aún curioso por qué este enfoque no funciona!

Actualización:. El error también se produce cuando se utiliza (Int64) (0x0D << 28)

Answer 1

Es necesario para marcar los valores constantes específicamente como largos (Int64s) o posiblemente ulongs (UInt64s), de otro modo por defecto serán intérprete como enteros (es decir Int32s), causando claramente desbordamientos. Fundición después de la operación de multiplicación no le hará ningún bien en este caso.

No he probado, pero este código debería funcionar:

Console.WriteLine("{0:X12}", 0x0dL * 0x100000000L);
Console.WriteLine("{0:X12}", 0x0dL * 0x1000000L);
Console.WriteLine("{0:X12}", 0x0dL * 0x100000L);

Answer 2

Los literales enteros tienen el tipo Int32 (aunque en hexadecimal). Utilizar el sufijo "L" para que sean largos (Int64).

Console.WriteLine("{0:X12}", 0x0dL * 0x100000000L);

Answer 3

A primera vista supongo que está haciendo la multiplicación con un Int32, y desbordante. Es necesario para emitir los operandos individuales a Int64 luego multiplicar esos. En este momento sólo está echando el resultado.

Dicho esto, yo no sé por qué sólo se encontraría con el problema de que una línea y no es la primera que tiene el número más grande.

ND