Una estructura es similar a una clase. Se declaran utilizando la palabra clave struct. Las principales diferencias con una clase son:

• Una clase es un tipo referencia mientras que una estructura es un tipo valor. En consecuencia, las estructuras suelen utilizarse para declarar tipos simples en que la semántica de tipo-valor sea deseable.
• Una estructura no puede heredar de una clase ni de otra estructura. Tampoco puede ser la base de una clase. Sin embargo, heredan de la clase object. Al igual que las clases, las estructuras pueden implementar interfaces.
• Las clases pueden tener destructores, pero las estructuras no.
• Las clases pueden tener constructores sin parámetros y además inicializar los campos de una instancia, y en cambio, una estructura no. El constructor por defecto sin parámetros de las estructuras inicializa cada campo con el valor por defecto que le corresponda, y si declara un constructor, a todos los campos debe asignarsele un valor.

// struct1.cs

using System;

struct SimpleStruct

{

    private int xval;

    public int X

    {

        get { return xval; }

        set { if (value < 100) xval = value; }

    }

    public void DisplayX()

    {

        Console.WriteLine("El valor almacenado es: {0}", X);

    }

}

class TestClass

{

    public static void Main()

    {

        SimpleStruct ss = new SimpleStruct();

        ss.X = 5;

        ss.DisplayX();

    }

}

A causa de que son tipos valor, cuando son pasados a un método, se pasan por valor en lugar de por referencia como ocurre con las clases.

// struct2.cs

using System;

class TheClass

{

    public int x;

}

struct TheStruct

{

    public int x;

}

class TestClass

{

    public static void structtaker(TheStruct s)

    {

        s.x = 5;

    }

    public static void classtaker(TheClass c)

    {

        c.x = 5;

    }

    public static void Main()

    {

        TheStruct a = new TheStruct();

        TheClass b = new TheClass();

        a.x = 1;

        b.x = 1;

        structtaker(a);

        classtaker(b);

        Console.WriteLine("a.x = {0}", a.x);

        Console.WriteLine("b.x = {0}", b.x);

    }

}

Podemos utilizar los atributos StructLayout(LayoutKind.Explicit) and FieldOffset para indicar como deben colocarse en memoria los diferentes campos de una estructura. De esta forma podemos conseguir el equivalente de una union de C/C++.

using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Explicit)]

struct PosicionExplicita 

{

    [FieldOffset(0)]

    public byte b0;

    [FieldOffset(1)]

    public byte b1;

    [FieldOffset(2)]

    public byte b2;

    [FieldOffset(3)]

    public byte b3;

    [FieldOffset(0)]  

    public int i0;

    [FieldOffset(1)] 

    public int i1;

    [FieldOffset(0)] 

    public long l;

}