byte (C# Reference)
The byte keyword denotes an integral type that stores values as indicated in the following table.
| Type | Range | Size | .NET Framework type |
|---|---|---|---|
byte |
0 to 255 |
Unsigned 8-bit integer |
Literals
You can declare and initialize a byte variable like this example:
byte myByte = 255;
In the preceding declaration, the integer literal 255 is implicitly converted from int to byte. If the integer literal exceeds the range of byte, a compilation error will occur.
Conversions
There is a predefined implicit conversion from byte to short, ushort, int, uint, long, ulong, float, double, or decimal.
You cannot implicitly convert non-literal numeric types of larger storage size to byte. For more information on the storage sizes of integral types, see Integral Types Table (C# Reference). Consider, for example, the following two byte variables x and y:
byte x = 10, y = 20;
The following assignment statement will produce a compilation error, because the arithmetic expression on the right-hand side of the assignment operator evaluates to int by default.
// Error: conversion from int to byte:
byte z = x + y;
To fix this problem, use a cast:
// OK: explicit conversion:
byte z = (byte)(x + y);
It is possible though, to use the following statements where the destination variable has the same storage size or a larger storage size:
int x = 10, y = 20;
int m = x + y;
long n = x + y;
Also, there is no implicit conversion from floating-point types to byte. For example, the following statement generates a compiler error unless an explicit cast is used:
// Error: no implicit conversion from double:
byte x = 3.0;
// OK: explicit conversion:
byte y = (byte)3.0;
When calling overloaded methods, a cast must be used. Consider, for example, the following overloaded methods that use byte and int parameters:
public static void SampleMethod(int i) {}
public static void SampleMethod(byte b) {}
Using the byte cast guarantees that the correct type is called, for example:
// Calling the method with the int parameter:
SampleMethod(5);
// Calling the method with the byte parameter:
SampleMethod((byte)5);
For information on arithmetic expressions with mixed floating-point types and integral types, see float and double.
For more information on implicit numeric conversion rules, see the Implicit Numeric Conversions Table (C# Reference).
C# Language Specification
For more information, see the following sections in the C# Language Specification:
1.3 Types and Variables
4.1.5 Integral Types
See Also
Reference
C# Keywords
Integral Types Table (C# Reference)
Built-In Types Table (C# Reference)
Implicit Numeric Conversions Table (C# Reference)
Explicit Numeric Conversions Table (C# Reference)
Byte