C# Struct vs Class (Cómo Funciona para Desarrolladores)

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 una referencia al objeto en la memoria.

Asignación en el Montón: Las instancias de las clases son asignadas en la memoria del montón, proporcionando flexibilidad en tamaño y permitiendo que los objetos sean compartidos entre diferentes partes del código.

Constructor Predeterminado: Las clases pueden tener un constructor predeterminado, que es proporcionado automáticamente si no se define explícitamente.

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

using System;

// Define a class
public class MyClass
{
    // Fields (data members)
    public int MyField;

    // Constructor
    public MyClass(int value)
    {
        MyField = value;
    }

    // Method to display the value
    public void Display()
    {
        Console.WriteLine($"Value in MyClass: {MyField}");
    }
}

class Program
{
    static void Main()
    {
        // Create an instance of the class
        MyClass myClassInstance = new MyClass(10);

        // Access field and call method
        myClassInstance.Display();

        // Classes are reference types, so myClassInstance refers to the same object in memory
        MyClass anotherInstance = myClassInstance;
        anotherInstance.MyField = 20;

        // Both instances refer to the same object, so the change is reflected in both
        myClassInstance.Display();
        anotherInstance.Display();
    }
}

using System;

// Define a class
public class MyClass
{
    // Fields (data members)
    public int MyField;

    // Constructor
    public MyClass(int value)
    {
        MyField = value;
    }

    // Method to display the value
    public void Display()
    {
        Console.WriteLine($"Value in MyClass: {MyField}");
    }
}

class Program
{
    static void Main()
    {
        // Create an instance of the class
        MyClass myClassInstance = new MyClass(10);

        // Access field and call method
        myClassInstance.Display();

        // Classes are reference types, so myClassInstance refers to the same object in memory
        MyClass anotherInstance = myClassInstance;
        anotherInstance.MyField = 20;

        // Both instances refer to the same object, so the change is reflected in both
        myClassInstance.Display();
        anotherInstance.Display();
    }
}

Imports System

' Define a class
Public Class [MyClass]
	' Fields (data members)
	Public MyField As Integer

	' Constructor
	Public Sub New(ByVal value As Integer)
		MyField = value
	End Sub

	' Method to display the value
	Public Sub Display()
		Console.WriteLine($"Value in MyClass: {MyField}")
	End Sub
End Class

Friend Class Program
	Shared Sub Main()
		' Create an instance of the class
		Dim myClassInstance As [MyClass] = New [MyClass](10)

		' Access field and call method
		myClassInstance.Display()

		' Classes are reference types, so myClassInstance refers to the same object in memory
		Dim anotherInstance As [MyClass] = myClassInstance
		anotherInstance.MyField = 20

		' Both instances refer to the same object, so the change is reflected in both
		myClassInstance.Display()
		anotherInstance.Display()
	End Sub
End Class

1.2. Estructuras (tipos de valor)

Tipos de Valor: Las estructuras 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 la estructura no puede recibir un valor nulo como tipo de valor a menos que se haga un tipo nullable con la etiqueta Nullable<>.

Asignación en la Pila: Las instancias de las estructuras son asignadas en la memoria de la pila, llevando a asignaciones y liberaciones más rápidas pero con limitaciones en tamaño y alcance.

Sin Constructor Predeterminado: Las estructuras no tienen un constructor predeterminado a menos que uno sea definido explícitamente. Cada campo debe ser inicializado durante la instanciación.

Sin Herencia: Las estructuras no soportan herencia. Son utilizadas principalmente para estructuras de datos ligeras.

using System;

// Define a struct
public struct MyStruct
{
    // Fields (data members)
    public int MyField;

    // Constructor
    public MyStruct(int value)
    {
        MyField = value;
    }

    // Method to display the value
    public void Display()
    {
        Console.WriteLine($"Value in MyStruct: {MyField}");
    }
}

class Program
{
    static void Main()
    {
        // Create an instance of the struct
        MyStruct myStructInstance = new MyStruct(10);

        // Access field and call method
        myStructInstance.Display();

        // Structs are value types, so myStructInstance is a copy
        MyStruct anotherInstance = myStructInstance;
        anotherInstance.MyField = 20;

        // Changes to anotherInstance do not affect myStructInstance
        myStructInstance.Display();
        anotherInstance.Display();
    }
}

using System;

// Define a struct
public struct MyStruct
{
    // Fields (data members)
    public int MyField;

    // Constructor
    public MyStruct(int value)
    {
        MyField = value;
    }

    // Method to display the value
    public void Display()
    {
        Console.WriteLine($"Value in MyStruct: {MyField}");
    }
}

class Program
{
    static void Main()
    {
        // Create an instance of the struct
        MyStruct myStructInstance = new MyStruct(10);

        // Access field and call method
        myStructInstance.Display();

        // Structs are value types, so myStructInstance is a copy
        MyStruct anotherInstance = myStructInstance;
        anotherInstance.MyField = 20;

        // Changes to anotherInstance do not affect myStructInstance
        myStructInstance.Display();
        anotherInstance.Display();
    }
}

Imports System

' Define a struct
Public Structure MyStruct
	' Fields (data members)
	Public MyField As Integer

	' Constructor
	Public Sub New(ByVal value As Integer)
		MyField = value
	End Sub

	' Method to display the value
	Public Sub Display()
		Console.WriteLine($"Value in MyStruct: {MyField}")
	End Sub
End Structure

Friend Class Program
	Shared Sub Main()
		' Create an instance of the struct
		Dim myStructInstance As New MyStruct(10)

		' Access field and call method
		myStructInstance.Display()

		' Structs are value types, so myStructInstance is a copy
		Dim anotherInstance As MyStruct = myStructInstance
		anotherInstance.MyField = 20

		' Changes to anotherInstance do not affect myStructInstance
		myStructInstance.Display()
		anotherInstance.Display()
	End Sub
End Class

2.1. Cuándo usar clases

Estado y Comportamiento Complejo: Usa 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 deseas compartir instancias de objetos y reflejar cambios a través de diferentes partes de tu código, las clases son la elección adecuada.

2.2. Cuándo utilizar estructuras

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

Semántica de Valor: Cuando prefieres la semántica de valor y quieres evitar la sobrecarga de la asignación en el montón, las estructuras son una buena opción.

Consideraciones de Rendimiento: En escenarios donde el rendimiento es crítico, especialmente para objetos pequeños que se usan frecuentemente, las estructuras pueden ser más eficientes debido a la asignación en la pila.

3.1. Clases

Conteo de Referencias: La memoria para las instancias de clase es gestionada a través del conteo de referencias por el recolector de basura. Los objetos son elegibles para la recolección de basura cuando no hay más referencias a ellos.

Potencial de Fugas de Memoria: El manejo incorrecto de referencias puede llevar a fugas de memoria si los objetos no se eliminan adecuadamente cuando ya no se necesitan.

3.2. Estructuras

Sin Recolección de Basura: Las estructuras no dependen de la recolección de basura ya que son tipos de valor y se gestionan de manera diferente. Se desasignan automáticamente cuando salen del alcance.

Limitada Sobrecarga de Memoria: Las estructuras tienen una menor sobrecarga de memoria en comparación con las clases, haciendo de ellas eficientes para escenarios donde el uso de memoria es una preocupación.

Clases

Acceso Indirecto: Dado que las instancias de clase se acceden mediante referencias, hay un nivel adicional de indirección, que puede introducir una leve sobrecarga de rendimiento.

Asignación en el Montón: La asignación dinámica de memoria en el montón puede llevar a tiempos más largos de creación y destrucción de objetos.

Estructuras

Acceso Directo: Se accede a las estructuras directamente, eliminando la necesidad de un nivel extra de indirección. Esto puede resultar en un mejor rendimiento para objetos pequeños que se utilizan frecuentemente.

Asignación en la Pila: La asignación de memoria en la pila proporciona una creación y destrucción más rápida de las instancias de estructuras.

5.1. Instalación de IronPDF

Antes de entrar en los ejemplos de código, necesitas instalar IronPDF. Puedes hacerlo usando la Consola de Administrador de Paquetes NuGet o agregando una referencia a la biblioteca de IronPDF en tu proyecto. Los siguientes pasos describen el proceso de instalación:

1. Consola de Administrador de Paquetes NuGet:

   Install-Package IronPdf

2. Interfaz de Usuario del Administrador de Paquetes: Busca "IronPDF" en la Interfaz de Usuario del Administrador de Paquetes NuGet e instala la última versión.

Una vez instalado IronPDF, estás listo para aprovechar sus capacidades para el manejo de archivos PDF en tus aplicaciones C#.

5.2.1. Archivo PDF de salida