Este documento presenta una introducción a las estructuras en C# y Visual Studio .NET 2003. Explica las diferencias entre estructuras y clases, como las estructuras se almacenan en la pila en lugar del montón y se pasan por valor. Incluye dos ejemplos que muestran cómo declarar y usar estructuras y cómo difieren del paso de instancias de clases a métodos. También cubre temas como constructores, herencia y atributos en estructuras.

1. Tutorial de estructuras
Visual Studio .NET 2003
Personas que lo han encontrado útil: 6 de 8 - Valorar este tema
Este tutorial presenta la sintaxis y el modo de uso de las estructuras. Asimismo, trata las diferencias
principales entre clases y estructuras.
Archivos de ejemplo
Vea Ejemplo de estructuras para descargar y generar los archivos de ejemplo que se utilizan en este
tutorial.
Información adicional
 struct
 1.8 Estructuras
 Gramática de estructuras en C. Gramática
 Tipos de valor
 Atributos de C#
 17. Atributos
 StructLayoutAttribute (Clase)
Tutorial
Este tutorial incluye dos ejemplos. El primer ejemplo muestra cómo declarar y utilizar las estructuras;
el segundo ilustra la diferencia entre estructuras y clases cuando se pasan instancias a los métodos.
Esta sección también presenta los siguientes temas:
 Estructuras frente a clases
 ¿Montón o pila?
 Constructores y herencia
 Atributos en estructuras
Ejemplo 1
En este ejemplo, se declara una estructura con tres miembros: una propiedad, un método y un
campo privado. Se crea una instancia de la estructura y se pone en uso:
// struct1.cs
using System;
struct SimpleStruct
{
private int xval;
public int X
{
get
{
return xval;
}

2. set
{
if (value < 100)
xval = value;
}
}
public void DisplayX()
{
Console.WriteLine("The stored value is: {0}", xval);
}
}
class TestClass
{
public static void Main()
{
SimpleStruct ss = new SimpleStruct();
ss.X = 5;
ss.DisplayX();
}
}
Resultado
The stored value is: 5
Estructuras frente a clases
Las estructuras pueden parecer muy similares a las clases, pero existen importantes diferencias que
se deben tener en cuenta. En primer lugar, las clases son tipos de referencia mientras que las
estructuras son tipos de valor. Mediante las estructuras, se pueden crear objetos que se comportan
como los tipos integrados y aprovechar sus beneficios.
¿Montón o pila?
Cuando se realiza una llamada con el operador New sobre una clase, se asigna espacio en el
montón. Sin embargo, cuando se crea una instancia de una estructura, el espacio se asigna en la
pila. De esta forma, se consigue mejorar el rendimiento. Además, a diferencia de las clases, no
tendrá que tratar con referencias a instancias de estructuras. Se trabaja directamente con la
instancia de la estructura. Debido a esto, cuando se pasa una estructura a un método, se pasa por
valor en vez de como una referencia.
Ejemplo 2
Este ejemplo muestra que cuando una estructura se pasa a un método, lo que se pasa realmente es
una copia de la estructura; sin embargo, cuando se pasa una instancia de una clase, lo que se pasa
es una referencia.
// struct2.cs
using System;
class TheClass
{
public int x;
}

3. 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);
}
}
Resultado
a.x = 1
b.x = 5
Descripción del código
El resultado del ejemplo muestra que, cuando se pasa la instancia de clase al método classtaker,
sólo cambia el valor del campo de la clase. Sin embargo, el campo de una estructura no cambia al
pasar su instancia al método structtaker. Esto es debido a que lo que se pasa al
método structtaker es una copia de la estructura mientras que lo que se pasa al
método classtaker es una referencia a la clase.
Constructores y herencia
Las estructuras pueden declarar constructores, pero deben utilizar parámetros. Es un error declarar
un constructor predeterminado (sin parámetros) para una estructura. Los miembros de una
estructura no pueden tener inicializadores. Siempre existe un constructor predeterminado que
inicializa los miembros de la estructura con sus valores predeterminados.
Cuando se crea un objeto struct mediante el operador new, se crea y se llama al constructor
apropiado. A diferencia de las clases, se pueden crear instancias de las estructuras sin utilizar el
operador New. Si no se utiliza New, los campos permanecerán sin asignar y el objeto no se podrá
utilizar hasta haber inicializado todos los campos.

4. A diferencia de las clases, para las estructuras no existe herencia. Una estructura no puede heredar
de otra estructura o clase, ni puede ser la base de una clase. Sin embargo, las estructuras heredan
de la clase base object. Una estructura puede implementar interfaces del mismo modo que las
clases. Éste es un fragmento de código de una estructura que implementa una interfaz:
interface IImage
{
void Paint();
}
struct Picture : IImage
{
public void Paint()
{
// painting code goes here
}
private int x, y, z; // other struct members
}
Atributos en estructuras
Mediante los atributos, es posible personalizar cómo se organizan las estructuras en la memoria.
Por ejemplo, se puede crear lo que se conoce en C/C++ como unión mediante los
atributos StructLayout(LayoutKind.Explicit) y FieldOffset.
using System.Runtime.InteropServices;
[StructLayout(LayoutKind.Explicit)]
struct TestUnion
{
[FieldOffset(0)]
public int i;
[FieldOffset(0)]
public double d;
[FieldOffset(0)]
public char c;
[FieldOffset(0)]
public byte b1;
}
En el segmento de código anterior, todos los campos de TestUnion comienzan en la misma
ubicación de la memoria.
A continuación se da otro ejemplo donde los campos comienzan en diferentes ubicaciones
establecidas de manera explícita:
using System.Runtime.InteropServices;
[StructLayout(LayoutKind.Explicit)]
struct TestExplicit
{
[FieldOffset(0)]
public long lg;
[FieldOffset(0)]
public int i1;
[FieldOffset(4)]

5. public int i2;
[FieldOffset(8)]
public double d;
[FieldOffset(12)]
public char c;
[FieldOffset(14)]
public byte b1;
}
Los dos campos int, i1 e i2, comparten las mismas posiciones de memoria que lg. Esta clase de
control sobre la organización de una estructura es útil cuando se utilizan llamadas de la plataforma.
Conclusión
Las estructuras son sencillas de utilizar y pueden resultar muy útiles en ocasiones. Simplemente,
tenga en cuenta que se crean en la pila y que no se utilizan referencias a ellas, sino que se trata
directamente con ellas. Siempre que necesite un tipo que se utilice a menudo y que trate con
valores de datos, las estructuras constituyen una excelente opción.