C# Struct vs Class (jak to działa dla programistów)

1.1. Klasy (typy referencyjne)

Typy referencyjne: Klasa w języku C# jest typem referencyjnym znajdującym się w stercie, co oznacza, że po utworzeniu instancji klasy odwołanie do obiektu jest przechowywane w pamięci.

Alokacja w stercie: Instancje klas są alokowane w pamięci sterty, co zapewnia elastyczność pod względem rozmiaru i umożliwia współdzielenie obiektów między różnymi częściami kodu.

Konstruktor domyślny: Klasy mogą posiadać konstruktor domyślny, który jest automatycznie udostępniany, jeśli żaden nie został jawnie zdefiniowany.

Dziedziczenie: Klasy obsługują dziedziczenie, umożliwiając tworzenie klas pochodnych o wspólnych cechach.

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. Struktury (typy wartościowe)

Typy wartości: Struktury są typami wartości, co oznacza, że rzeczywiste dane są przechowywane w miejscu zadeklarowania zmiennej, a nie w oddzielnej lokalizacji w pamięci, jak w przypadku typów pierwotnych. Oznacza to również, że strukturze nie można przypisać wartości null jako typu wartości, chyba że zostanie ona ustawiona jako typ nullable za pomocą tagu Nullable<>.

Alokacja na stosie: Instancje struktur są alokowane w pamięci na stosie, co prowadzi do szybszej alokacji i zwolnienia pamięci, ale wiąże się z ograniczeniami dotyczącymi rozmiaru i zakresu.

Brak konstruktora domyślnego: Struktury nie mają konstruktora domyślnego, chyba że zostanie on wyraźnie zdefiniowany. Każde pole musi zostać zainicjowane podczas instancjonowania.

Brak dziedziczenia: Struktury nie obsługują dziedziczenia. Są one wykorzystywane przede wszystkim do tworzenia lekkich struktur danych.

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. Kiedy używać klas

Złożony stan i zachowanie: Używaj klas, gdy chcesz modelować złożone struktury danych z uwzględnieniem stanu i zachowania. Klasy nadają się do reprezentowania złożonych obiektów z wieloma właściwościami i metodami.

Semantyka odniesień: Jeśli chcesz współdzielić instancje obiektów i chcesz, aby zmiany były odzwierciedlane w różnych częściach kodu, klasy są właściwym wyborem.

2.2. Kiedy stosować struktury

Proste struktury danych: Struktury są idealne dla prostszych struktur danych, które reprezentują lekkie jednostki, takie jak małe struktury danych, np. punkty, prostokąty, pary klucz-wartość, lub jeśli struktura logicznie reprezentuje pojedynczą wartość, podobnie jak typy pierwotne.

Semantyka wartości: Jeśli preferujesz semantykę wartości i chcesz uniknąć obciążenia związanego z alokacją w stercie, struktury są dobrym rozwiązaniem.

Kwestie związane z wydajnością: W sytuacjach, w których wydajność ma kluczowe znaczenie, zwłaszcza w przypadku małych, często używanych obiektów, struktury mogą być bardziej wydajne ze względu na alokację w stosie.

3.1. Klasy

Liczenie referencji: Pamięć dla instancji klas jest zarządzana przez moduł czyszczący pamięć za pomocą liczenia referencji. Obiekty kwalifikują się do zbierania śmieci, gdy nie ma już do nich żadnych odwołań.

Ryzyko wycieków pamięci: Niewłaściwa obsługa odwołań może prowadzić do wycieków pamięci, jeśli obiekty nie zostaną prawidłowo usunięte, gdy nie są już potrzebne.

3.2. Struktury

Brak zbierania śmieci: Struktury nie opierają się na zbieraniu śmieci, ponieważ są typami wartościowymi i są zarządzane w inny sposób. Są one automatycznie zwalniane, gdy wykraczają poza zakres.

Ograniczone obciążenie pamięci: Struktury mają mniejsze obciążenie pamięci w porównaniu z klasami, co sprawia, że są wydajne w scenariuszach, w których zużycie pamięci ma znaczenie.

Klasy

Dostęp pośredni: Ponieważ dostęp do instancji klas odbywa się poprzez referencje, istnieje dodatkowy poziom pośrednictwa, co może powodować niewielkie obciążenie wydajności.

Alokacja w stercie: Dynamiczna alokacja pamięci w stercie może prowadzić do wydłużenia czasu tworzenia i niszczenia obiektów.

Struktury

Bezpośredni dostęp: Dostęp do struktur odbywa się bezpośrednio, co eliminuje potrzebę stosowania dodatkowego poziomu pośrednictwa. Może to skutkować lepszą wydajnością w przypadku małych, często używanych obiektów.

Alokacja stosu: Alokacja pamięci w stosie zapewnia szybsze tworzenie i niszczenie instancji struktur.

5.1. Instalacja IronPDF

Zanim przejdziesz do przykładów kodu, musisz zainstalować IronPDF. Można to zrobić za pomocą konsoli NuGet Package Manager Console lub dodając odwołanie do biblioteki IronPDF w swoim projekcie. Poniższe kroki opisują proces instalacji:

1. Konsola menedżera pakietów NuGet:

   Install-Package IronPdf

2. Interfejs menedżera pakietów: Wyszukaj "IronPDF" w interfejsie menedżera pakietów NuGet i zainstaluj najnowszą wersję.

Po zainstalowaniu IronPDF możesz zacząć korzystać z jego możliwości w zakresie obsługi plików PDF w swoich aplikacjach napisanych w języku C#.

5.2.1. Plik wyjściowy PDF