This documentation is archived and is not being maintained.

Fixed Size Buffers (C# Programming Guide)

In C# 2.0, you can us the fixed statement to create a with a fixed size array in a data structure. This is useful when working with existing code, such as code written in other languages, pre-existing DLLs or COM projects. The fixed array can take any of the attributes or modifiers that are allowed for regular struct members. The only restriction is that the array type must be bool, byte, char, short, int, long, sbyte, ushort, uint, ulong, float, or double.

private fixed char name[30];

In previous versions of C#, declaring a C++ style fixed-size structure was difficult because a C# struct containing an array does not contain the array elements, but instead contains a reference to the elements.

C# 2.0 adds the ability to embed an array of fixed size in a struct when used in an unsafe code block.

For example, prior to C# 2.0, the following struct would be 8 bytes in size where the pathName array is a reference to the heap-allocated array:

public struct MyArray
    public char[] pathName;
    private int reserved;

In C# 2.0, a struct can be declared with an embedded array:

public struct MyArray // This code must appear in an unsafe block
    public fixed char pathName[128];

In this structure, the pathName array is of fixed size and location, and can therefore be used with other unsafe code.

The size of the 128 element char array is 256 bytes. Fixed size char buffers always take two bytes per character, irrespective of the encoding. This is true even when char buffers are marshaled to API methods or structs with CharSet = CharSet.Auto or CharSet = CharSet.Ansi. For more information, see CharSet.

Another common fixed-size array is the bool array. The elements in a bool array are always one byte in size. bool arrays are not suitable for creating bit arrays or buffers.


Except for memory created with stackalloc, the C# compiler and the common language runtime (CLR) do not perform any security buffer overrun checks. As with all unsafe code, use caution.

Unsafe buffers are different from normal arrays in the following ways:

  • You can only use unsafe buffers in an unsafe context.

  • Unsafe buffers are always vectors, or one-dimensional arrays.

  • The declaration of the array should include a count, such as char id[8]. You cannot use char id[] instead.

  • Unsafe buffers can only be instance fields of structs in an unsafe context.