C# Struct vs Class (Cómo funciona para los desarrolladores)

En C#, tanto los structs como las clases sirven como bloques de construcción fundamentales para organizar y almacenar datos, pero tienen características distintas que los hacen adecuados para diferentes escenarios. Comprender las diferencias entre **Estructuras y clases C# es crucial para tomar decisiones fundamentadas a la hora de diseñar sus aplicaciones C#.

En este artículo, exploraremos las distinciones clave entre structs y clases, discutiendo sus casos de uso, gestión de memoria e implicaciones de rendimiento. Además, hablaremos de cómo utilizar structs y clases con IronPDF para la creación de archivos PDF.

1. Visión general de estructuras y clases

1.1. Clases (tipos de referencia)

Tipos de referencia: Una clase en C# es un tipo de referencia que reside en el montón, lo que significa que cuando se crea una instancia de una clase, se almacena en memoria una referencia al objeto.

Asignación Heap: Las instancias de clase se asignan memoria en la asignación de memoria heap, proporcionando flexibilidad en el tamaño y permitiendo que los objetos sean compartidos entre diferentes partes del código.

Constructor por defecto: Las clases pueden tener un constructor por defecto, que se proporciona automáticamente si no se define ninguno explícitamente.

Herencia: Las clases soportan la herencia, permitiendo la creación de clases derivadas con características compartidas.

using System;
//  Definir una clase
public class MyClass
{
    //  Campos (miembros de datos)
    public int MyField;
    //  Constructor
    public MyClass(int value)
    {
        MyField = value;
    }
    //  Método
    public void Display()
    {
        Console.WriteLine($"Value in MyClass: {MyField}");
    }
}
class Program
{
    static void Main()
    {
        //  Crear una instancia de la clase
        MyClass myClassInstance = new MyClass(10);
        //  Campo de acceso y método de llamada
        myClassInstance.Display();
        //  Las clases son tipos de referencia, por lo que myClassInstance se refiere al mismo objeto en memoria
        MyClass anotherInstance = myClassInstance;
        anotherInstance.MyField = 20;
        //  Ambas instancias se refieren al mismo objeto, por lo que el cambio se refleja en ambas
        myClassInstance.Display();
        anotherInstance.Display();
    }
}

using System;
//  Definir una clase
public class MyClass
{
    //  Campos (miembros de datos)
    public int MyField;
    //  Constructor
    public MyClass(int value)
    {
        MyField = value;
    }
    //  Método
    public void Display()
    {
        Console.WriteLine($"Value in MyClass: {MyField}");
    }
}
class Program
{
    static void Main()
    {
        //  Crear una instancia de la clase
        MyClass myClassInstance = new MyClass(10);
        //  Campo de acceso y método de llamada
        myClassInstance.Display();
        //  Las clases son tipos de referencia, por lo que myClassInstance se refiere al mismo objeto en memoria
        MyClass anotherInstance = myClassInstance;
        anotherInstance.MyField = 20;
        //  Ambas instancias se refieren al mismo objeto, por lo que el cambio se refleja en ambas
        myClassInstance.Display();
        anotherInstance.Display();
    }
}

Imports System
'  Definir una clase
Public Class [MyClass]
	'  Campos (miembros de datos)
	Public MyField As Integer
	'  Constructor
	Public Sub New(ByVal value As Integer)
		MyField = value
	End Sub
	'  Método
	Public Sub Display()
		Console.WriteLine($"Value in MyClass: {MyField}")
	End Sub
End Class
Friend Class Program
	Shared Sub Main()
		'  Crear una instancia de la clase
		Dim myClassInstance As [MyClass] = New [MyClass](10)
		'  Campo de acceso y método de llamada
		myClassInstance.Display()
		'  Las clases son tipos de referencia, por lo que myClassInstance se refiere al mismo objeto en memoria
		Dim anotherInstance As [MyClass] = myClassInstance
		anotherInstance.MyField = 20
		'  Ambas instancias se refieren al mismo objeto, por lo que el cambio se refleja en ambas
		myClassInstance.Display()
		anotherInstance.Display()
	End Sub
End Class

1.2. Estructuras (tipos de valor)

Tipos de Valor: Los Structs son tipos de valor, lo que significa que los datos reales se almacenan donde se declara la variable, en lugar de en una ubicación separada en la memoria como los tipos primitivos. Esto también significa que al struct no se le puede asignar un valor nulo como su tipo de valor sin que se convierta en un tipo anulable con la etiqueta Nullable<>.

Asignación a la pila: Las instancias de las estructuras se asignan a la pila, lo que permite una asignación y desasignación más rápidas pero con limitaciones de tamaño y alcance.

Sin constructor por defecto: Los Structs no tienen constructor por defecto a menos que se defina uno explícitamente. Cada campo debe ser inicializado durante la instanciación.

Sin herencia: Los Structs no admiten herencia. Se utilizan principalmente para estructuras de datos ligeras.

using System;
//  Definir una estructura
public struct MyStruct
{
    //  Campos (miembros de datos)
    public int MyField;
    //  Constructor
    public MyStruct(int value)
    {
        MyField = value;
    }
    //  Método
    public void Display()
    {
        Console.WriteLine($"Value in MyStruct: {MyField}");
    }
}
class Program
{
    static void Main()
    {
        //  Crear una instancia de la estructura
        MyStruct myStructInstance = new MyStruct(10);
        //  Campo de acceso y método de llamada
        myStructInstance.Display();
        //  Structs son tipos de valor, por lo que myStructInstance es una copia
        MyStruct anotherInstance = myStructInstance;
        anotherInstance.MyField = 20;
        //  Los cambios en anotherInstance no afectan a myStructInstance
        myStructInstance.Display();
        anotherInstance.Display();
    }
}

using System;
//  Definir una estructura
public struct MyStruct
{
    //  Campos (miembros de datos)
    public int MyField;
    //  Constructor
    public MyStruct(int value)
    {
        MyField = value;
    }
    //  Método
    public void Display()
    {
        Console.WriteLine($"Value in MyStruct: {MyField}");
    }
}
class Program
{
    static void Main()
    {
        //  Crear una instancia de la estructura
        MyStruct myStructInstance = new MyStruct(10);
        //  Campo de acceso y método de llamada
        myStructInstance.Display();
        //  Structs son tipos de valor, por lo que myStructInstance es una copia
        MyStruct anotherInstance = myStructInstance;
        anotherInstance.MyField = 20;
        //  Los cambios en anotherInstance no afectan a myStructInstance
        myStructInstance.Display();
        anotherInstance.Display();
    }
}

Imports System
'  Definir una estructura
Public Structure MyStruct
	'  Campos (miembros de datos)
	Public MyField As Integer
	'  Constructor
	Public Sub New(ByVal value As Integer)
		MyField = value
	End Sub
	'  Método
	Public Sub Display()
		Console.WriteLine($"Value in MyStruct: {MyField}")
	End Sub
End Structure
Friend Class Program
	Shared Sub Main()
		'  Crear una instancia de la estructura
		Dim myStructInstance As New MyStruct(10)
		'  Campo de acceso y método de llamada
		myStructInstance.Display()
		'  Structs son tipos de valor, por lo que myStructInstance es una copia
		Dim anotherInstance As MyStruct = myStructInstance
		anotherInstance.MyField = 20
		'  Los cambios en anotherInstance no afectan a myStructInstance
		myStructInstance.Display()
		anotherInstance.Display()
	End Sub
End Class

2. Casos de uso y directrices

2.1. Cuándo utilizar las clases

Estado y comportamiento complejos: Utiliza clases cuando necesites modelar estructuras de datos complejas con estado y comportamiento. Las clases son adecuadas para representar objetos complejos con múltiples propiedades y métodos.

Semántica de referencia: Si desea compartir instancias de objetos y que los cambios se reflejen en diferentes partes de su código, las clases son la opción adecuada.

2.2. Cuándo utilizar estructuras

Estructuras de Datos Simples: Los Structs son ideales para estructuras de datos más simples que representan entidades ligeras como pequeñas estructuras de datos, tales como puntos, rectángulos, pares clave-valor, o si la estructura representa lógicamente un único valor, similar a los tipos primitivos.

Semántica de valores: Si prefieres la semántica de valores y quieres evitar la sobrecarga de la asignación al montón, los structs son una buena opción.

Consideraciones de rendimiento: En escenarios donde el rendimiento es crítico, especialmente para objetos pequeños de uso frecuente, los structs pueden ser más eficientes debido a la asignación de pila.

3. Diferencias en la asignación de memoria

3.1. Clases

Recuento de referencias: La memoria para las instancias de clase se gestiona mediante el recuento de referencias por el recolector de basura. Los objetos son susceptibles de ser recogidos cuando ya no hay referencias a ellos.

Posibilidad de fugas de memoria: Un manejo inadecuado de las referencias puede provocar fugas de memoria si los objetos no se eliminan correctamente cuando ya no se necesitan.

3.2. Estructuras

Sin Recogida de Basura: Los Structs no dependen de la recogida de basura ya que son tipos de valor y se gestionan de forma diferente. Se desasignan automáticamente cuando salen del ámbito de aplicación.

Sobrecarga de memoria limitada: Los Structs tienen una sobrecarga de memoria menor comparada con las clases, lo que los hace eficientes para escenarios donde el uso de memoria es una preocupación.

4. 4. Consideraciones sobre el rendimiento

Clases

Acceso indirecto: Dado que se accede a las instancias de clase a través de referencias, existe un nivel adicional de indirección, que puede introducir una ligera sobrecarga de rendimiento.

**La asignación dinámica de memoria en el heap puede prolongar los tiempos de creación y destrucción de objetos.

Estructuras

Acceso directo: Se accede directamente a los Structs, eliminando la necesidad de un nivel extra de indirección. Esto puede mejorar el rendimiento de los objetos pequeños de uso frecuente.

Asignación de pila: La asignación de pila de memoria proporciona una creación y destrucción más rápida de instancias struct.

5. Presentación de IronPDF

IronPDF es una sólida biblioteca de C# diseñada para generar, manipular y renderizar PDF sin problemas en aplicaciones .NET. Con IronPDF, los desarrolladores pueden crear, modificar e interactuar sin esfuerzo con documentos PDF, lo que la convierte en una herramienta esencial para tareas que van desde la generación dinámica de PDF a partir de contenido HTML hasta la extracción de datos de documentos existentes. Esta versátil biblioteca simplifica las funciones relacionadas con PDF, proporcionando un completo conjunto de características para los desarrolladores que trabajan en aplicaciones web, software de escritorio o cualquier proyecto .NET que requiera un manejo eficaz de PDF.

5.1. Instalación de IronPDF

Antes de sumergirse en los ejemplos de código, es necesario instalar IronPDF. Puede hacerlo utilizando la consola del gestor de paquetes NuGet o añadiendo una referencia a la biblioteca IronPDF en su proyecto. Los siguientes pasos describen el proceso de instalación:

1. Consola del Gestor de Paquetes NuGet:

    :ProductInstall

2. **Busque "IronPDF" en la interfaz de usuario del gestor de paquetes NuGet e instale la última versión.

   Una vez instalado IronPDF, estará listo para aprovechar sus funciones de gestión de archivos PDF en sus aplicaciones C#.

5.2. Uso de Struct y Class con IronPDF

using IronPdf;
using System;
//  Ejemplo de clase
class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}
//  Estructura de muestra
struct Point
{
    public int X { get; set; }
    public int Y { get; set; }
}
class Program
{
    static void Main()
    {
        //  Ejemplos de instancias de clase y estructura
        Person person = new Person { Name = "John Doe", Age = 30 };
        Point point = new Point { X = 10, Y = 20 };
        //  Crear un nuevo documento PDF
        var renderer = new ChromePdfRenderer();
        //  Añadir contenido con información de clase y estructura
        string content = $@"<!DOCTYPE html>
                            <html>
                            <body>
                                <h1>Information in IronPDF</h1>
                                <p>Name: {person.Name}</p>
                                <p>Age: {person.Age}</p>
                                <p>Point X: {point.X}</p>
                                <p>Point Y: {point.Y}</p>
                            </body>
                            </html>";
        //  Convertir contenido HTML en PDF
        var pdf = renderer.RenderHtmlAsPdf(content);
        //  Guardar el PDF en un archivo
        pdf.SaveAs("InformationDocument.pdf");
    }
}

using IronPdf;
using System;
//  Ejemplo de clase
class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}
//  Estructura de muestra
struct Point
{
    public int X { get; set; }
    public int Y { get; set; }
}
class Program
{
    static void Main()
    {
        //  Ejemplos de instancias de clase y estructura
        Person person = new Person { Name = "John Doe", Age = 30 };
        Point point = new Point { X = 10, Y = 20 };
        //  Crear un nuevo documento PDF
        var renderer = new ChromePdfRenderer();
        //  Añadir contenido con información de clase y estructura
        string content = $@"<!DOCTYPE html>
                            <html>
                            <body>
                                <h1>Information in IronPDF</h1>
                                <p>Name: {person.Name}</p>
                                <p>Age: {person.Age}</p>
                                <p>Point X: {point.X}</p>
                                <p>Point Y: {point.Y}</p>
                            </body>
                            </html>";
        //  Convertir contenido HTML en PDF
        var pdf = renderer.RenderHtmlAsPdf(content);
        //  Guardar el PDF en un archivo
        pdf.SaveAs("InformationDocument.pdf");
    }
}

Imports IronPdf
Imports System
'  Ejemplo de clase
Friend Class Person
	Public Property Name() As String
	Public Property Age() As Integer
End Class
'  Estructura de muestra
Friend Structure Point
	Public Property X() As Integer
	Public Property Y() As Integer
End Structure
Friend Class Program
	Shared Sub Main()
		'  Ejemplos de instancias de clase y estructura
		Dim person As New Person With {
			.Name = "John Doe",
			.Age = 30
		}
		Dim point As New Point With {
			.X = 10,
			.Y = 20
		}
		'  Crear un nuevo documento PDF
		Dim renderer = New ChromePdfRenderer()
		'  Añadir contenido con información de clase y estructura
		Dim content As String = $"<!DOCTYPE html>
                            <html>
                            <body>
                                <h1>Information in IronPDF</h1>
                                <p>Name: {person.Name}</p>
                                <p>Age: {person.Age}</p>
                                <p>Point X: {point.X}</p>
                                <p>Point Y: {point.Y}</p>
                            </body>
                            </html>"
		'  Convertir contenido HTML en PDF
		Dim pdf = renderer.RenderHtmlAsPdf(content)
		'  Guardar el PDF en un archivo
		pdf.SaveAs("InformationDocument.pdf")
	End Sub
End Class

• Persona es una clase de ejemplo que representa a una persona con las propiedades Nombre y Edad.
• Point es una estructura de ejemplo que representa un punto en un sistema de coordenadas 2D con propiedades X y Y.
• Se crean instancias de la clase Persona y de la estructura Punto.
• A continuación, el contenido HTML se renderiza en el documento PDF, que se guarda como "DocumentoInformacion.pdf".

5.2.1. Archivo PDF de salida

6. Conclusión

En conclusión, la elección entre utilizar structs y clases de C# depende de los requisitos y características específicos de su aplicación. Las clases, al ser tipos de referencia, son adecuadas para modelar entidades complejas con estado y comportamiento, soportar la herencia y facilitar las instancias compartidas. Por otro lado, los structs, como tipos de valor, son ideales para estructuras de datos ligeras con semántica de valor, ofreciendo ventajas de rendimiento en términos de asignación de pila y acceso directo.

IronPDF ofrece un **licencia de prueba gratuita para los usuarios, que es una buena oportunidad para conocer las características y funcionalidades de IronPDF. Para obtener más información sobre IronPDF, visite **Enlace y un tutorial detallado para crear archivos PDF utilizando IronPDF está disponible en la siguiente dirección **Enlace.