Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. C# Initialiser Tableau
.NET AIDE

C# Initialize Array (Comment ça fonctionne pour les développeurs)

Curtis Chau
Curtis Chau
Mis à jour:

Les tableaux sont une fonctionnalité essentielle en C# qui permet aux développeurs de stocker et de manipuler efficacement des collections de données. Initialiser un tableau est le processus d'attribution de valeurs initiales à ses éléments. Ce guide explore diverses techniques et meilleures pratiques pour initialiser des tableaux en C#, offrant des perspectives sur des scénarios d'initialisation de tableaux basiques et avancés.

Un tableau est une collection d'éléments de même type, stockés dans des emplacements mémoire contigus. En C#, les tableaux sont utilisés pour représenter et manipuler des données structurées efficacement. Ils permettent un accès direct aux éléments individuels du tableau, ce qui facilite l'exécution d'opérations telles que le tri, la recherche et l'itération.

Dans cet article, nous verrons comment initialiser une variable de tableau dans le langage de programmation C#, et nous verrons également comment créer un tableau de documents PDF en utilisant IronPDF pour les développeurs C#.

1. Initialisation de tableau basique

1.1. Déclaration et initialisation

La façon la plus simple d'initialiser des tableaux est de les déclarer et d'attribuer des valeurs au moment de la création. Voici un exemple d'initialisation d'un tableau d'entiers en utilisant des crochets :

int[] numbers = { 1, 2, 3, 4, 5 };
int[] numbers = { 1, 2, 3, 4, 5 };
Dim numbers() As Integer = { 1, 2, 3, 4, 5 }
$vbLabelText   $csharpLabel

Dans cet exemple, un tableau nommé numbers est déclaré et initialisé avec cinq valeurs entières. C# infère automatiquement la taille du tableau en fonction du nombre d'éléments fournis.

1.2. Spécification de la taille à l'initialisation

Il est possible d'initialiser un tableau en spécifiant explicitement sa taille, puis en attribuant les valeurs plus tard. Cette approche est utile quand le tableau doit être redimensionné dynamiquement. L'extraction de données, comme l'extraction d'images, de tableaux et de texte des documents PDF, est fournie par la bibliothèque pdf2Data.

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]
$vbLabelText   $csharpLabel

1.3. Valeurs par défaut

Si un tableau est déclaré mais pas explicitement initialisé, ses éléments recevront des valeurs par défaut basées sur leurs types de données. Pour les types numériques, la valeur par défaut est 0, et pour les types de références, c'est null. Par exemple :

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]
$vbLabelText   $csharpLabel

2. Initialisation des tableaux avec des valeurs

2.1. Syntaxe de l'initialisateur de tableau

C# offre une syntaxe concise appelée initialisateur de tableau pour initialiser des tableaux avec des valeurs spécifiques. Cette syntaxe vous permet de spécifier les valeurs directement entre accolades. Par exemple, vous pouvez initialiser des tableaux de chaînes de caractères ainsi :

string[] names = { "Alice", "Bob", "Charlie" };
string[] names = { "Alice", "Bob", "Charlie" };
Dim names() As String = { "Alice", "Bob", "Charlie" }
$vbLabelText   $csharpLabel

Cela crée un tableau nommé names avec trois éléments, chacun initialisé avec une valeur de chaîne de caractères.

2.2. Tableaux multidimensionnels

En plus d'un tableau unidimensionnel, C# supporte un tableau multidimensionnel. Par exemple, un tableau à deux dimensions peut être initialisé comme suit :

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 }
}
$vbLabelText   $csharpLabel

Ici, la matrice est un tableau 2x3 d'entiers, initialisé avec des valeurs spécifiques.

3. Initialisation dynamique des tableaux

3.1. Utiliser Enumerable.Range

Pour les scénarios où vous voulez initialiser un tableau avec une plage de valeurs séquentielles, Enumerable.Range peut être utile. Il génère une séquence de nombres dans une plage spécifiée. Considérez l'exemple suivant :

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]
$vbLabelText   $csharpLabel

C'est particulièrement pratique quand vous avez besoin d'une séquence de nombres plutôt que de spécifier chaque valeur individuellement.

Initialisation du tableau en C# (Comment cela fonctionne pour les développeurs) : Figure 1 - Sortie console pour l'exemple de code Enumerable.Range

3.2. Utiliser LINQ

LINQ (Language-Integrated Query) offre des capacités de requête puissantes en C#. Vous pouvez utiliser LINQ pour initialiser un tableau basé sur une expression de requête. L'extraction de données, comme l'extraction d'images, de tableaux et de texte des documents PDF, est fournie par la bibliothèque pdf2Data.

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]
$vbLabelText   $csharpLabel

Cette approche est plus expressive et permet des filtrages et transformations complexes lors de l'initialisation des tableaux.

Initialisation du tableau en C# (Comment cela fonctionne pour les développeurs) : Figure 2 - Sortie console pour l'exemple de code LINQ précédent

4. Présentation de IronPDF

IronPDF : bibliothèque PDF pour .NET est une bibliothèque C# puissante qui offre aux développeurs des capacités fluides pour créer, manipuler et traiter des documents PDF dans leurs applications .NET. Que vous ayez besoin de générer des PDF à partir de contenu HTML, de modifier des documents existants ou d'extraire des données de PDF, IronPDF propose un ensemble complet de fonctionnalités.

IronPDF se spécialise dans la conversion HTML en PDF, garantissant que les mises en page et styles sont préservés. C’est un excellent outil pour générer des PDF à partir de contenus web, tels que des rapports, des factures, et de la documentation. Les fichiers HTML, les URL et les chaînes HTML peuvent tous être convertis en fichiers PDF.

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}
using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}
Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()

		' 1. Convert HTML String to PDF
		Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
		Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
		pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")

		' 2. Convert HTML File to PDF
		Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
		Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
		pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

		' 3. Convert URL to PDF
		Dim url = "http://ironpdf.com" ' Specify the URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class
$vbLabelText   $csharpLabel

Avec son API conviviale, les développeurs peuvent facilement intégrer des fonctionnalités PDF dans leurs projets C#, permettant une gestion efficace et dynamique des tâches liées aux PDF. IronPDF se distingue par sa polyvalence et sa simplicité, en faisant un outil précieux pour les développeurs C# recherchant des solutions fiables et flexibles pour travailler avec des fichiers PDF.

4.1. Installation de IronPDF

Pour installer IronPDF dans votre projet C# en utilisant la Console du gestionnaire de packages NuGet, ouvrez Visual Studio, accédez à la Console du gestionnaire de packages dans le menu Affichage, et assurez-vous que le projet correct est sélectionné. Exécutez la commande :

Install-Package IronPdf

Laissez le processus d'installation se terminer, et vérifiez le succès via le message de confirmation dans la console et en vérifiant la section "Références" dans l'Explorateur de solutions. IronPDF est maintenant prêt pour une utilisation dans votre application C#, offrant de puissantes capacités de génération et de manipulation de PDF.

4.2. IronPDF : Création de PDF en utilisant l'initialisation dynamique de PDF

Voici un exemple d'utilisation de IronPDF pour créer dynamiquement plusieurs documents 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
$vbLabelText   $csharpLabel
  1. Nous spécifions le nombre de PDF à générer (numberOfPDFs) et créons un tableau d'objets PdfDocument (pdfArray) pour stocker les PDF générés.
  2. Nous utilisons une boucle pour initialiser chaque type d'élément du tableau. À l'intérieur de la boucle, nous créons du contenu dynamique pour chaque PDF en utilisant l'interpolation de chaînes pour inclure les noms et âges des tableaux respectifs.
  3. Nous initialisons un nouvel objet PdfDocument pour chaque itération et ajoutons le contenu HTML en utilisant la méthode RenderHtmlAsPdf de IronPDF.
  4. Enfin, nous enregistrons chaque PDF dans un fichier avec un nom unique (GeneratedPDF_1.pdf, GeneratedPDF_2.pdf, etc.).

4.2.1. Fichiers PDF générés

Initialisation du tableau en C# (Comment cela fonctionne pour les développeurs) : Figure 3 - Les fichiers PDF produits par l'exemple de code précédent

5. Conclusion

Maîtriser le processus divers de l'initialisation des tableaux en C#, y compris les méthodes de base, la syntaxe de l'initialisateur de tableau, et les approches dynamiques comme Enumerable.Range et LINQ, est primordial pour une manipulation efficace des données. Comprendre la distinction entre la longueur et le rang du tableau, surtout dans les tableaux multidimensionnels, assure une manipulation précise.

Ce tutoriel a également introduit IronPDF pour la génération de documents PDF. L'exemple fourni illustre l'efficacité d'IronPDF pour générer dynamiquement des PDF personnalisés, mettant en avant sa polyvalence. Dans l'ensemble, une solide compréhension de l'initialisation des tableaux, couplée à des outils comme IronPDF, permet aux développeurs de créer des applications dynamiques et efficaces, améliorant leur capacité à gérer et traiter des données efficacement.

IronPDF offre support et documentation ainsi qu'un tutoriel sur l'utilisation de la bibliothèque. Il offre également une licence d'essai gratuite. Pour un tutoriel détaillé sur la conversion HTML en PDF avec IronPDF, visitez le guide de conversion HTML en PDF de IronPDF.

Questions Fréquemment Posées

Quelles sont les techniques de base pour initialiser des tableaux en C# ?

Les techniques de base pour initialiser des tableaux en C# incluent la déclaration du tableau et l'affectation des valeurs au moment de la création en utilisant des crochets. Par exemple, vous pouvez initialiser un tableau d'entiers comme suit : int[] numbers = { 1, 2, 3, 4, 5 };.

Puis-je spécifier la taille d'un tableau lors de l'initialisation en C# ?

Oui, vous pouvez spécifier la taille d'un tableau lors de l'initialisation. Par exemple, vous pouvez déclarer un tableau avec une taille spécifique et affecter des valeurs plus tard : int[] dynamicArray = new int[5]; dynamicArray[2] = 42;.

Quels sont les valeurs par défaut pour les éléments de tableau non initialisés en C# ?

En C#, si un tableau est déclaré mais non initialisé, ses éléments ont des valeurs par défaut. Pour les types numériques, la valeur par défaut est 0, et pour les types de référence, c'est null.

Comment puis-je initialiser un tableau multidimensionnel en C# ?

Les tableaux multidimensionnels en C# peuvent être initialisés en utilisant des accolades imbriquées. Par exemple, un tableau bidimensionnel peut être initialisé ainsi : int[,] matrix = { { 1, 2, 3 }, { 4, 5, 6 } };.

Comment puis-je utiliser Enumerable.Range pour l'initialisation de tableau en C# ?

Enumerable.Range est utile pour générer une séquence de nombres pour initialiser un tableau. Par exemple, vous pouvez créer un tableau avec des valeurs séquentielles comme ceci : int[] rangeArray = Enumerable.Range(1, 5).ToArray();.

Comment LINQ est-il utilisé pour initialiser des tableaux en C# ?

LINQ peut être utilisé pour initialiser des tableaux en interrogeant des données et en convertissant le résultat en tableau. Par exemple, pour créer un tableau de nombres pairs, vous pouvez utiliser : int[] evenNumbers = (from number in Enumerable.Range(1, 10) where number % 2 == 0 select number).ToArray();.

Comment puis-je générer des documents PDF à partir de contenu dynamique en C# ?

Vous pouvez générer des documents PDF à partir de contenu dynamique en C# en utilisant une bibliothèque comme IronPDF. Elle vous permet de rendre du contenu HTML en PDF, idéal pour créer des documents PDF dynamiques et personnalisés.

Quel est le processus pour intégrer la fonctionnalité PDF dans un projet C# ?

Pour intégrer la fonctionnalité PDF dans un projet C#, vous pouvez installer une bibliothèque comme IronPDF en utilisant la console du gestionnaire de packages NuGet avec la commande : Install-Package IronPdf. Cette bibliothèque vous permet de créer et de manipuler des PDF au sein de votre application.

Quels sont les avantages d'utiliser une bibliothèque C# pour la génération de PDF ?

Utiliser une bibliothèque C# pour la génération de PDF, telle qu'IronPDF, offre des avantages comme la conversion d'HTML en PDF, la génération de PDF à partir de contenu dynamique, et l'extraction de données à partir de PDF, ce qui améliore la capacité d'un développeur à gérer des tâches de traitement de documents complexes.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Démarrer l'essai gratuit