Что происходит, когда вы выполняете преобразование из short в byte в C#?

Short — это 2-байтовый тип, а byte — это один байт. Когда вы преобразуете два байта в один, вы заставляете систему подстраиваться, и один из исходных байтов (наиболее значимый) отбрасывается, а данные теряются. То, что осталось от значения 23948 (двоичное: 0101 1101 1000 1100), равно 140, что в двоичном переводе равно 1000 1100. Итак, вы исходите из:

0101 1101 1000 1100 (2 byte decimal value 23948)

to:

          1000 1100 (1 byte decimal value 140)

Вы можете сделать это только с явным приведением. Если вы попытаетесь назначить шорт байту без приведения, компилятор выдаст ошибку из-за возможности потери данных:

Невозможно неявно преобразовать тип "short" в "byte". Существует явное преобразование (вам не хватает приведения?)

С другой стороны, если вы преобразуете байт в короткий, вы можете сделать это неявно, поскольку никакие данные не будут потеряны.

using System;
public class MyClass
{
    public static void Main()
    {
        short myShort = 23948;
        byte myByte = (byte)myShort; // ok
        myByte = myShort; // error: 

        Console.WriteLine("Short: " + myShort);
        Console.WriteLine("Byte:  " + myByte);

        myShort = myByte; // ok

        Console.WriteLine("Short: " + myShort);
    }
}

С арифметическим переполнением и непроверенным контекстом:

using System;
public class MyClass {
    public static void Main() {
        unchecked {
            short myShort = 23948;
            byte myByte = (byte)myShort; // ok
            myByte = myShort; // still an error
            int x = 2147483647 * 2; // ok since unchecked
        }   
    }
}

По сути, это просто занимает последние 8 бит... но в целом, когда вы обнаружите какое-то поведение, которое вас удивляет, следующим шагом должно быть обращение к спецификации. Из раздела 6.2.1, с дополнительным акцентом мой, для ситуации, которая уместна в данном случае.

Для преобразования из целочисленного типа в другой целочисленный тип обработка зависит от контекста проверки переполнения (§7.6.12), в котором происходит преобразование:

• В проверенном контексте преобразование завершается успешно, если значение исходного операнда находится в пределах диапазона целевого типа, но создает исключение System.OverflowException, если значение исходного операнда выходит за пределы диапазона целевого типа.
• In an unchecked context, the conversion always succeeds, and proceeds as follows.
  • If the source type is larger than the destination type, then the source value is truncated by discarding its “extra” most significant bits. The result is then treated as a value of the destination type.
  • Если исходный тип меньше целевого типа, то исходное значение либо дополняется знаком, либо дополняется нулями, так что оно имеет тот же размер, что и конечный тип. Sign-extension используется, если исходный тип является подписанным; нулевое расширение используется, если исходный тип не имеет знака. Затем результат обрабатывается как значение целевого типа.
  • Если исходный тип имеет тот же размер, что и целевой тип, то исходное значение рассматривается как значение целевого типа.

Это зависит; в контексте checked вы получите большое исключение; в контексте unchecked (по умолчанию) вы можете сохранить данные из последнего байта, как если бы вы это сделали:

byte b = (byte)(value & 255);

В вашем конкретном случае поведение довольно резкое и сухое, когда вы смотрите на биты для значения:

short myShort = 0x5D8C; // 23948
byte myByte = (byte)myShort; // myShort & 0xFF

Console.WriteLine("0x{0:X}", myByte); // 0x8C or 140

Сохраняются только последние 8 бит. 23948 в двоичном формате равно 101110110001100b. Последние 8 бит 10001100b, что равно 140.

Когда вы приводите целочисленный тип к «меньшему» целочисленному типу, учитываются только биты с меньшим весом. Математически это как если бы вы использовали операцию по модулю. Таким образом, вы получаете значение 140, потому что 23948 по модулю 256 равно 140.

Приведение long к int будет использовать тот же механизм.

Результат тот же, когда вы делаете:

byte myByte = (byte)(myShort & 0xFF);

Все, что выше восьмибитного, просто выбрасывается. Младшие восемь битов 23948 (0x5D8C) равны 140 (0x8C).

Хм... потому что, когда вы переводите короткий (2 байта) в байт (1 байт), он получает только первый байт, а первый байт 23948 представляет 140.

23948 % 256 = 140, самые значащие байты были потеряны после преобразования, поэтому результат равен 140.

Это как когда у вас есть двузначное число «97» и вы конвертируете его в однозначное число, вы теряете 9 и сохраняете только «7».