byte (C# Reference)

The byte keyword denotes an integral type that stores values as indicated in the following table.

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

Concepts

C# Programming Guide

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

Other Resources

C# Reference