Short and ushort

The C# short type reduces the memory usage of integers. This compact type represents a number in 2 bytes—16 bits—half the size of an int.

Short is aliased to System.Int16, and this is part of the C# specification. Ushort, meanwhile, is aliased to System.UInt16. Unsigned numbers cannot be negative.

Short example

We use the short type as a storage location for positive or negative integers. The short type is aliased to the System.Int16 struct.

using System;

// Part 1: demonstrates a short value type used as local variable.
short number = 11;
Console.WriteLine(11);
number = -1; // Can be negative
Console.WriteLine(number);
Console.WriteLine(number == -1); // Can use == operator
Console.WriteLine(number + 100); // Can use + operator
Console.WriteLine(number.GetType());
Console.WriteLine(typeof(short));
Console.WriteLine(short.MinValue);
Console.WriteLine(short.MaxValue);

// Part 2: find the memory usage for a short value in a large array.
long bytes1 = GC.GetTotalMemory(false);
short[] array = new short[1000 * 1000];
array[0] = 1;
long bytes2 = GC.GetTotalMemory(false);
// Console.WriteLine(bytes1);
// Console.WriteLine(bytes2);
Console.WriteLine(((bytes2 - bytes1) / (1000 * 1000)).ToString() + " bytes per short");
11
-1
True
99
System.Int16
System.Int16
-32768
32767
2 bytes per short

Short range

Consider the values returned by short.MinValue and short.MaxValue. The smallest number a short can hold is -32768. And the largest is 32767.

short.MinValue = -32768
short.MaxValue =  32767
ushort.MinValue = 0
ushort.MaxValue = 65535

Parse shorts

This program uses 2 string literals as the input data: "100" and "100000." The value 100 can be stored in a short. The value 100000 cannot be.

using System;

const string value1 = "100";
const string value2 = "100000";

// Can use short.Parse.
short sh1 = short.Parse(value1);
Console.WriteLine("sh1 = {0}", sh1);

// Can use short.TryParse.
short sh2;
if (short.TryParse(value1, out sh2))
{
    Console.WriteLine("sh2 = {0}", sh2);
}

// Returns false: short.TryParse on number too large.
short sh3;
if (short.TryParse(value2, out sh3))
{
    Console.WriteLine("sh3 = {0}", sh3); // Never reached.
}
sh1 = 100
sh2 = 100

Ushort example

The ushort type is a value type. This means the actual value of the variable is stored in its storage location memory.

using System;

// Part 1: declare and initialize ushort value.
ushort value1 = 1000;

// This won't compile:
// value1 = -1;

// Write value.
Console.WriteLine(value1);

// Part 2: write type of ushort.
Console.WriteLine(typeof(ushort));

// Part 3: alternative syntax for declaring a ushort value.
UInt16 value2 = 1000;

// Write value.
Console.WriteLine(value2);

// Part 4: declare a ushort array.
ushort[] array1 = new ushort[2];
array1[0] = 5;

// Write array elements.
Console.WriteLine(array1[0]);
Console.WriteLine(array1[1]); // <-- Default is zero.

// Write minimum and maximum values.
Console.WriteLine("MIN: {0}", ushort.MinValue);
Console.WriteLine("MAX: {0}", ushort.MaxValue);
1000
System.UInt16
1000
5
0
MIN: 0
MAX: 65535

Ushort error

At compilation time, the C# compiler uses a checked context to check for overflow of numeric variables. It tries to detect an invalid program.

class Program
{
    static void Main()
    {
        ushort test = -1;
    }
}
Error CS0031
Constant value '-1' cannot be converted to a 'ushort'

Ushort performance

If a ushort is smaller than an int, is it also faster to use? This program tests the performance of incrementing and looping with a ushort.

using System;
using System.Diagnostics;
using System.Runtime.CompilerServices;

class Program
{
    const int _max = 1000000;
    static void Main()
    {
        // Version 1: use ushort method.
        var s1 = Stopwatch.StartNew();
        for (int i = 0; i < _max; i++)
        {
            Test1();
        }
        s1.Stop();
        // Version 2: use int method.
        var s2 = Stopwatch.StartNew();
        for (int i = 0; i < _max; i++)
        {
            Test2();
        }
        s2.Stop();
        Console.WriteLine(((double)(s1.Elapsed.TotalMilliseconds * 1000000) / _max).ToString("0.00 ns"));
        Console.WriteLine(((double)(s2.Elapsed.TotalMilliseconds * 1000000) / _max).ToString("0.00 ns"));
    }

    static void Test1()
    {
        ushort result = 0;
        for (ushort i = 0; i < 100; i++)
        {
            result++;
        }
    }

    static void Test2()
    {
        int result = 0;
        for (int i = 0; i < 100; i++)
        {
            result++;
        }
    }
}
62.54 ns    ushort method
35.68 ns    int method

Summary

In C# programs, short and ushort are sometimes useful. Shorts can be used like native integers as local variables. In large arrays they will save memory usage over other types.