Qué son y cómo usar structs en C#

Una struct en C# es una estructura de datos que representa un conjunto de campos que se agrupan bajo un solo nombre.

Las estructuras son tipos de valor, lo que significa que pueden ser almacenas directamente en la pila de memoria y no en el heap como las clases.

Los structs son especialmente útiles cuando se trabaja con tipos de datos simples que tienen un tamaño predecible y se utilizan principalmente para representar datos de valor.

Sintaxis de las structs

La sintaxis básica para definir una estructura en C# es la siguiente:

struct NombreDeLaEstructura
{
    // Definición de campos
    public TipoDeDato Campo1;
    public TipoDeDato Campo2;

    // Definición de métodos, propiedades, etc.
}

• NombreDeLaEstructura: Es el nombre único que se le da a la estructura.
• TipoDeDato: Especifica el tipo de datos de los campos dentro de la estructura.

Ejemplo Básico

A continuación, se muestra un ejemplo básico de cómo definir y utilizar una estructura en C#:

struct Punto
{
    public int X;
    public int Y;

    public Punto(int x, int y)
    {
        X = x;
        Y = y;
    }

    public void ImprimirCoordenadas()
    {
        Console.WriteLine($"Coordenadas: ({X}, {Y})");
    }
}

// uso
Punto punto = new Punto(3, 5);
punto.ImprimirCoordenadas();

Uso de structs

Declaración e inicialización

Las estructuras se declaran e inicializan de manera similar a las variables de otros tipos de datos.

Punto punto;
punto.X = 3;
punto.Y = 5;

También se pueden inicializar si disponen de un constructor definido.

Punto punto = new Punto(3, 5);

Acceso a campos

Los campos de una estructura se acceden utilizando la notación de punto (.).

int x = punto.X;

Pasaje por valor

Cuando se pasa una estructura como argumento a un método o se asigna a otra variable, se pasa una copia del valor de la estructura en lugar de una referencia.

Por ejemplo, supongamos el siguiente caso,

Punto punto1 = new Punto(3, 5);
Punto punto2 = punto1; // Se copia el valor de punto1 en punto2

punto2.y = 10;
// ahora punto1.y vale 5, y punto2.y vale 10;

Si Punto fuera una clase en lugar de una struct, tanto punto1.y habría cambiado a 10. Esto es así porque en C# las struct son de tipo valor, y las clases son de tipo referencia.

Ejemplos prácticos

Representación de un Punto en un Plano Cartesiano

En este ejemplo, se muestra cómo definir una estructura que representa un punto en un plano cartesiano.

// Definición de la estructura Punto
struct Punto
{
    public int X; // Coordenada X del punto
    public int Y; // Coordenada Y del punto

    // Constructor para inicializar las coordenadas del punto
    public Punto(int x, int y)
    {
        X = x;
        Y = y;
    }
}

// Uso
Punto punto = new Punto(3, 4); // Crear una instancia de la estructura Punto
Console.WriteLine($"Punto: ({punto.X}, {punto.Y})"); // Imprimir las coordenadas del punto

Representación de un Color RGB

En este ejemplo, se muestra cómo definir una estructura que representa un color en formato RGB.

// Definición de la estructura ColorRGB
struct ColorRGB
{
    public byte Rojo; // Componente roja del color
    public byte Verde; // Componente verde del color
    public byte Azul; // Componente azul del color

    // Constructor para inicializar los componentes del color
    public ColorRGB(byte rojo, byte verde, byte azul)
    {
        Rojo = rojo;
        Verde = verde;
        Azul = azul;
    }
}

// Uso
ColorRGB color = new ColorRGB(255, 0, 0); // Crear una instancia de la estructura ColorRGB para el color rojo
Console.WriteLine($"Color RGB: ({color.Rojo}, {color.Verde}, {color.Azul})"); // Imprimir los componentes del color

Representación de una Fecha

En este ejemplo, se muestra cómo definir una estructura que representa una fecha.

// Definición de la estructura Fecha
struct Fecha
{
    public int Dia; // Día del mes
    public int Mes; // Mes del año
    public int Año; // Año

    // Constructor para inicializar la fecha
    public Fecha(int dia, int mes, int año)
    {
        Dia = dia;
        Mes = mes;
        Año = año;
    }
}

// Uso
Fecha fecha = new Fecha(5, 6, 2023); // Crear una instancia de la estructura Fecha
Console.WriteLine($"Fecha: {fecha.Dia}/{fecha.Mes}/{fecha.Año}"); // Imprimir la fecha

Representación de un Rectángulo

En este ejemplo, se muestra cómo definir una estructura que representa un rectángulo.

// Definición de la estructura Rectangulo
struct Rectangulo
{
    public int Ancho; // Ancho del rectángulo
    public int Alto; // Alto del rectángulo

    // Constructor para inicializar el rectángulo
    public Rectangulo(int ancho, int alto)
    {
        Ancho = ancho;
        Alto = alto;
    }

    // Método para calcular el área del rectángulo
    public int CalcularArea()
    {
        return Ancho * Alto;
    }
}

// Uso
Rectangulo rectangulo = new Rectangulo(5, 10); // Crear una instancia de la estructura Rectangulo
int area = rectangulo.CalcularArea(); // Calcular el área del rectángulo
Console.WriteLine($"Área del rectángulo: {area}"); // Imprimir el área del rectángulo