Estruturas vs. Classes em C# (Como funciona para desenvolvedores)

1.1. Classes (Tipos de Referência)

Tipos de referência: Uma classe em C# é um tipo de referência que reside no heap, o que significa que, quando uma instância de uma classe é criada, uma referência ao objeto é armazenada na memória.

Alocação de memória heap: As instâncias de classe recebem alocação de memória heap, proporcionando flexibilidade de tamanho e permitindo que os objetos sejam compartilhados entre diferentes partes do código.

Construtor padrão: As classes podem ter um construtor padrão, que é fornecido automaticamente caso nenhum seja definido explicitamente.

Herança: As classes suportam herança, permitindo a criação de classes derivadas com características compartilhadas.

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. Estruturas (Tipos de Valor)

Tipos de Valor: Structs são tipos de valor, o que significa que os dados reais são armazenados onde a variável é declarada, em vez de em um local separado na memória como os tipos primitivos. Isso também significa que a struct não pode receber um valor nulo como seu tipo de valor sem que ela seja declarada como um tipo anulável com a tag Nullable<>.

Alocação na pilha: instâncias de structs têm a memória alocada na pilha, o que resulta em alocação e desalocação mais rápidas, porém com limitações de tamanho e escopo.

Construtor não padrão: as structs não possuem um construtor padrão, a menos que um seja definido explicitamente. Todos os campos devem ser inicializados durante a instanciação.

Sem herança: Structs não suportam herança. São utilizadas principalmente para estruturas de dados leves.

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. Quando usar classes

Estado e comportamento complexos: Utilize classes quando precisar modelar estruturas de dados complexas com estado e comportamento. As classes são adequadas para representar objetos complexos com múltiplas propriedades e métodos.

Semântica de Referência: Se você deseja compartilhar instâncias de objetos e ter as alterações refletidas em diferentes partes do seu código, as classes são a escolha apropriada.

2.2. Quando usar structs

Estruturas de dados simples: Structs são ideais para estruturas de dados mais simples que representam entidades leves, como pequenas estruturas de dados, como pontos, retângulos, pares chave-valor, ou se a struct representa logicamente um único valor, semelhante a tipos primitivos.

Semântica de valor: Quando você prefere a semântica de valor e deseja evitar a sobrecarga da alocação de memória dinâmica (heap), as structs são uma boa opção.

Considerações sobre desempenho: Em cenários onde o desempenho é crítico, especialmente para objetos pequenos e frequentemente usados, as structs podem ser mais eficientes devido à alocação de pilha.

3.1. Classes

Contagem de referências: a memória para instâncias de classe é gerenciada por meio da contagem de referências pelo coletor de lixo. Os objetos tornam-se elegíveis para coleta de lixo quando não houver mais referências a eles.

Potencial para Vazamentos de Memória: O gerenciamento inadequado de referências pode levar a vazamentos de memória se os objetos não forem descartados corretamente quando não forem mais necessários.

3.2. Estruturas

Sem coleta de lixo: as structs não dependem de coleta de lixo, pois são tipos de valor e são gerenciadas de forma diferente. Eles são automaticamente desalocados quando saem do escopo.

Sobrecarga de memória limitada: as structs têm uma sobrecarga de memória menor em comparação com as classes, tornando-as eficientes para cenários em que o uso de memória é uma preocupação.

Aulas

Acesso indireto: Como as instâncias de classe são acessadas por meio de referências, existe um nível adicional de indireção, o que pode introduzir uma pequena sobrecarga de desempenho.

Alocação de memória dinâmica (heap): A alocação dinâmica de memória no heap pode levar a tempos mais longos de criação e destruição de objetos.

Estruturas

Acesso direto: as estruturas são acessadas diretamente, eliminando a necessidade de um nível extra de indireção. Isso pode resultar em melhor desempenho para objetos pequenos e usados ​​com frequência.

Alocação de pilha: A alocação de memória na pilha proporciona uma criação e destruição mais rápidas de instâncias de structs.

5.1. Instalando o IronPDF

Antes de analisar os exemplos de código, você precisa instalar o IronPDF. Você pode fazer isso usando o Console do Gerenciador de Pacotes NuGet ou adicionando uma referência à biblioteca IronPDF em seu projeto. Os passos a seguir descrevem o processo de instalação:

1. Console do Gerenciador de Pacotes NuGet :

   Install-Package IronPdf

2. Interface do Gerenciador de Pacotes: Pesquise por "IronPDF" na interface do Gerenciador de Pacotes NuGet e instale a versão mais recente.

Após a instalação do IronPDF , você estará pronto para aproveitar seus recursos de manipulação de arquivos PDF em seus aplicativos C#.

5.2.1. Arquivo PDF de saída