C# Inicjalizacja tablicy (jak to działa dla programistów)

1.1. Deklaracja i inicjalizacja

Najprostszym sposobem inicjalizacji tablic jest zadeklarowanie ich i przypisanie wartości w momencie tworzenia. Oto przykład inicjalizacji tablicy liczb całkowitych przy użyciu nawiasów kwadratowych:

int[] numbers = { 1, 2, 3, 4, 5 };

int[] numbers = { 1, 2, 3, 4, 5 };

Dim numbers() As Integer = { 1, 2, 3, 4, 5 }

W tym przykładzie zadeklarowano tablicę o nazwie numbers i zainicjowano ją pięcioma wartościami całkowitymi. C# automatycznie wnioskuje rozmiar tablicy na podstawie liczby podanych elementów.

1.2. Określanie rozmiaru podczas inicjalizacji

Możliwe jest zainicjowanie tablicy poprzez jawne określenie jej rozmiaru, a następnie przypisanie wartości w późniejszym czasie. Takie podejście jest przydatne, gdy konieczna jest dynamiczna zmiana rozmiaru tablicy. Na przykład:

int[] dynamicArray = new int[5];
// The array is initialized with size 5, and the elements are [0, 0, 0, 0, 0]
// Later in the code...
dynamicArray[2] = 42;
// Now the array becomes [0, 0, 42, 0, 0]

int[] dynamicArray = new int[5];
// The array is initialized with size 5, and the elements are [0, 0, 0, 0, 0]
// Later in the code...
dynamicArray[2] = 42;
// Now the array becomes [0, 0, 42, 0, 0]

Dim dynamicArray(4) As Integer
' The array is initialized with size 5, and the elements are [0, 0, 0, 0, 0]
' Later in the code...
dynamicArray(2) = 42
' Now the array becomes [0, 0, 42, 0, 0]

1.3. Wartości domyślne

Jeśli tablica zostanie zadeklarowana, ale nie zostanie jawnie zainicjowana, jej elementom zostaną przypisane wartości domyślne w oparciu o ich typy danych. W przypadku typów numerycznych wartością domyślną jest 0, a w przypadku typów referencyjnych — null. Na przykład:

int[] uninitializedArray = new int[3];
// The elements of uninitializedArray are [0, 0, 0]

int[] uninitializedArray = new int[3];
// The elements of uninitializedArray are [0, 0, 0]

Dim uninitializedArray(2) As Integer
' The elements of uninitializedArray are [0, 0, 0]

2.1. Składnia inicjalizatora tablicy

C# udostępnia zwięzłą składnię zwaną inicjalizatorem tablicy, służącą do inicjalizacji tablic o określonych wartościach. Ta składnia pozwala na określenie wartości bezpośrednio w nawiasach klamrowych. Na przykład tablice ciągów znaków można zainicjować w następujący sposób:

string[] names = { "Alice", "Bob", "Charlie" };

string[] names = { "Alice", "Bob", "Charlie" };

Dim names() As String = { "Alice", "Bob", "Charlie" }

Tworzy to tablicę o nazwie names zawierającą trzy elementy, z których każdy jest zainicjowany wartością typu string.

2.2. Tabele wielowymiarowe

Oprócz tablicy jednowymiarowej język C# obsługuje tablice wielowymiarowe. Na przykład tablica dwuwymiarowa może zostać zainicjowana w następujący sposób:

int[,] matrix = { { 1, 2, 3 }, { 4, 5, 6 } };

int[,] matrix = { { 1, 2, 3 }, { 4, 5, 6 } };

Dim matrix(,) As Integer = {
	{ 1, 2, 3 },
	{ 4, 5, 6 }
}

W tym przypadku macierz jest tablicą liczb całkowitych o wymiarach 2x3, zainicjowaną konkretnymi wartościami.

3.1. Korzystanie z Enumerable.Range

W sytuacjach, w których chcesz zainicjować tablicę z zakresem wartości sekwencyjnych, przydatna może być klasa Enumerable.Range. Generuje sekwencję liczb w określonym zakresie. Rozważmy następujący przykład:

using System.Linq;

int[] rangeArray = Enumerable.Range(1, 5).ToArray();
// The int array is initialized with values [1, 2, 3, 4, 5]

using System.Linq;

int[] rangeArray = Enumerable.Range(1, 5).ToArray();
// The int array is initialized with values [1, 2, 3, 4, 5]

Imports System.Linq

Private rangeArray() As Integer = Enumerable.Range(1, 5).ToArray()
' The int array is initialized with values [1, 2, 3, 4, 5]

Jest to szczególnie przydatne, gdy potrzebujesz sekwencji liczb zamiast określania każdej wartości osobno.

3.2. Korzystanie z LINQ

LINQ (Language-Integrated Query) zapewnia zaawansowane możliwości tworzenia zapytań w języku C#. Można użyć LINQ do zainicjowania tablicy na podstawie wyrażenia zapytania. Na przykład:

using System.Linq;

int[] evenNumbers = (from number in Enumerable.Range(1, 10)
                     where number % 2 == 0
                     select number).ToArray();
// The array is initialized with even values [2, 4, 6, 8, 10]

using System.Linq;

int[] evenNumbers = (from number in Enumerable.Range(1, 10)
                     where number % 2 == 0
                     select number).ToArray();
// The array is initialized with even values [2, 4, 6, 8, 10]

Imports System.Linq

Private evenNumbers() As Integer = (from number in Enumerable.Range(1, 10) where number Mod 2 = 0 select number).ToArray()
' The array is initialized with even values [2, 4, 6, 8, 10]

Takie podejście jest bardziej wyraziste i pozwala na złożone filtrowanie oraz przekształcanie podczas inicjalizacji tablicy.

4.1. Instalacja IronPDF

Aby zainstalować IronPDF w projekcie C# za pomocą konsoli menedżera pakietów NuGet, otwórz program Visual Studio, przejdź do konsoli menedżera pakietów z menu Widok i upewnij się, że wybrano właściwy projekt. Uruchom polecenie:

Install-Package IronPdf

Poczekaj na zakończenie procesu instalacji i sprawdź, czy zakończył się sukcesem, na podstawie komunikatu potwierdzającego w konsoli oraz sekcji "Odwołania" w Eksploratorze rozwiązań. IronPDF jest teraz gotowy do użycia w aplikacji C#, oferując zaawansowane możliwości generowania i edycji plików PDF.

4.2. IronPDF: Tworzenie plików PDF przy użyciu dynamicznej inicjalizacji PDF

using IronPdf;
using System;

class Program
{
    static void Main()
    {
        // Number of PDFs to generate
        int numberOfPDFs = 3;
        // Array to store PdfDocument objects
        PdfDocument[] pdfArray = new PdfDocument[numberOfPDFs];
        // Content for the PDFs
        string[] names = { "Alice", "Bob", "Charlie" };
        string[] ages = { "25", "30", "22" };
        // Instantiate ChromePdfRenderer
        var renderer = new ChromePdfRenderer();
        // Loop to create and customize each PdfDocument in the array
        for (int i = 0; i < numberOfPDFs; i++)
        {
            // Creating dynamic content using string interpolation
            string content = $@"<html>
                                <body>
                                    <h1>Hello, {names[i]}!</h1>
                                    <p>You are {ages[i]} years old.</p>
                                    <p>This is a dynamically generated PDF.</p>
                                </body>
                                </html>";
            // Create a PDF from HTML using ChromePdfRenderer
            pdfArray[i] = renderer.RenderHtmlAsPdf(content);
        }
        // Save each PDF to a file
        for (int i = 0; i < numberOfPDFs; i++)
        {
            pdfArray[i].SaveAs($"GeneratedPDF_{i + 1}.pdf");
        }
        Console.WriteLine("PDFs generated successfully!");
    }
}

using IronPdf;
using System;

class Program
{
    static void Main()
    {
        // Number of PDFs to generate
        int numberOfPDFs = 3;
        // Array to store PdfDocument objects
        PdfDocument[] pdfArray = new PdfDocument[numberOfPDFs];
        // Content for the PDFs
        string[] names = { "Alice", "Bob", "Charlie" };
        string[] ages = { "25", "30", "22" };
        // Instantiate ChromePdfRenderer
        var renderer = new ChromePdfRenderer();
        // Loop to create and customize each PdfDocument in the array
        for (int i = 0; i < numberOfPDFs; i++)
        {
            // Creating dynamic content using string interpolation
            string content = $@"<html>
                                <body>
                                    <h1>Hello, {names[i]}!</h1>
                                    <p>You are {ages[i]} years old.</p>
                                    <p>This is a dynamically generated PDF.</p>
                                </body>
                                </html>";
            // Create a PDF from HTML using ChromePdfRenderer
            pdfArray[i] = renderer.RenderHtmlAsPdf(content);
        }
        // Save each PDF to a file
        for (int i = 0; i < numberOfPDFs; i++)
        {
            pdfArray[i].SaveAs($"GeneratedPDF_{i + 1}.pdf");
        }
        Console.WriteLine("PDFs generated successfully!");
    }
}

Imports IronPdf
Imports System

Friend Class Program
	Shared Sub Main()
		' Number of PDFs to generate
		Dim numberOfPDFs As Integer = 3
		' Array to store PdfDocument objects
		Dim pdfArray(numberOfPDFs - 1) As PdfDocument
		' Content for the PDFs
		Dim names() As String = { "Alice", "Bob", "Charlie" }
		Dim ages() As String = { "25", "30", "22" }
		' Instantiate ChromePdfRenderer
		Dim renderer = New ChromePdfRenderer()
		' Loop to create and customize each PdfDocument in the array
		For i As Integer = 0 To numberOfPDFs - 1
			' Creating dynamic content using string interpolation
			Dim content As String = $"<html>
                                <body>
                                    <h1>Hello, {names(i)}!</h1>
                                    <p>You are {ages(i)} years old.</p>
                                    <p>This is a dynamically generated PDF.</p>
                                </body>
                                </html>"
			' Create a PDF from HTML using ChromePdfRenderer
			pdfArray(i) = renderer.RenderHtmlAsPdf(content)
		Next i
		' Save each PDF to a file
		For i As Integer = 0 To numberOfPDFs - 1
			pdfArray(i).SaveAs($"GeneratedPDF_{i + 1}.pdf")
		Next i
		Console.WriteLine("PDFs generated successfully!")
	End Sub
End Class