Le mot clé opérateur new en C# est polyvalent, servant à plusieurs fonctions essentielles dans le langage. Pour instancier des objets et masquer des membres hérités, comprendre leurs applications est crucial pour un développement efficace en C#. Ce guide explore les différentes utilisations du mot clé new, en fournissant des exemples clairs pour illustrer sa puissance et sa flexibilité. Nous explorerons également la vue d'ensemble de la bibliothèque IronPDF sur Iron Software plus tard dans ce guide.

Introduction à l'instanciation d'objets

L'instanciation d'un objet est le processus où l'opérateur new crée une instance d'une classe ou d'une structure. En C#, ceci est principalement réalisé à l'aide du mot clé new, qui appelle le constructeur du type spécifié et alloue de la mémoire pour le nouvel objet.

Création d'Instances avec new

Pour créer une instance d'un objet, l'opérateur new est suivi par le nom de la classe et une paire de parenthèses. Si la classe a un constructeur qui prend des paramètres, des arguments doivent être fournis dans ces parenthèses.

public class Book
{
    public string Title { get; set; }

    public Book(string title)
    {
        Title = title;
    }
}

Book book = new Book("The C# Programming Language");

public class Book
{
    public string Title { get; set; }

    public Book(string title)
    {
        Title = title;
    }
}

Book book = new Book("The C# Programming Language");

Public Class Book
	Public Property Title() As String

	Public Sub New(ByVal title As String)
		Me.Title = title
	End Sub
End Class

Private book As New Book("The C# Programming Language")

Public Class Book
	Public Property Title() As String

	Public Sub New(ByVal title As String)
		Me.Title = title
	End Sub
End Class

Private book As New Book("The C# Programming Language")

Constructeurs par Défaut et Sans Paramètres

Un constructeur par défaut est fourni par C# si aucun constructeur n'est explicitement défini dans une classe. Cependant, une fois qu'un constructeur avec des paramètres est défini, un constructeur sans paramètres doit être explicitement déclaré si nécessaire.

public class ExampleClass
{
    // Parameterless constructor
    public ExampleClass()
    {
        // Initialization code here
    }
}

public class ExampleClass
{
    // Parameterless constructor
    public ExampleClass()
    {
        // Initialization code here
    }
}

Public Class ExampleClass
	' Parameterless constructor
	Public Sub New()
		' Initialization code here
	End Sub
End Class

Public Class ExampleClass
	' Parameterless constructor
	Public Sub New()
		' Initialization code here
	End Sub
End Class

Techniques Avancées de Création d'Objets

En C#, la création d'objets ne se limite pas à l'instanciation de classes ; c'est une passerelle pour exploiter les puissantes fonctionnalités du langage pour un code plus efficace, lisible et concis. Ici, nous explorons des techniques avancées comme le travail avec des tableaux, l'utilisation de types et l'emploi d'initialiseurs d'objets pour rationaliser vos efforts de codage.

Tableaux et Collections

Créer des tableaux d'un type de tableau spécifique en C# est une compétence fondamentale, mais ce sont les subtilités qui élèvent vos capacités de codage. En utilisant le mot clé new, vous pouvez instancier des tableaux, en spécifiant leur type et le nombre d'éléments qu'ils doivent contenir. Ceci est crucial pour gérer des collections de variables de manière structurée. Au-delà des tableaux de base, new facilite la création de tableaux multidimensionnels et rectangulaires, accueillant des structures de données complexes.

// Single-dimensional array
int[] numbers = new int[5]; // Initializes an array for 5 integers

// Multidimensional array
int[,] matrix = new int[3, 2]; // A 3x2 matrix

// Jagged array (an array of arrays)
int[][] jaggedArray = new int[3][];
jaggedArray[0] = new int[4]; // First row has 4 columns
jaggedArray[1] = new int[5]; // Second row has 5 columns
jaggedArray[2] = new int[3]; // Third row has 3 columns

// Single-dimensional array
int[] numbers = new int[5]; // Initializes an array for 5 integers

// Multidimensional array
int[,] matrix = new int[3, 2]; // A 3x2 matrix

// Jagged array (an array of arrays)
int[][] jaggedArray = new int[3][];
jaggedArray[0] = new int[4]; // First row has 4 columns
jaggedArray[1] = new int[5]; // Second row has 5 columns
jaggedArray[2] = new int[3]; // Third row has 3 columns

' Single-dimensional array
Dim numbers(4) As Integer ' Initializes an array for 5 integers

' Multidimensional array
Dim matrix(2, 1) As Integer ' A 3x2 matrix

' Jagged array (an array of arrays)
Dim jaggedArray(2)() As Integer
jaggedArray(0) = New Integer(3){} ' First row has 4 columns
jaggedArray(1) = New Integer(4){} ' Second row has 5 columns
jaggedArray(2) = New Integer(2){} ' Third row has 3 columns

' Single-dimensional array
Dim numbers(4) As Integer ' Initializes an array for 5 integers

' Multidimensional array
Dim matrix(2, 1) As Integer ' A 3x2 matrix

' Jagged array (an array of arrays)
Dim jaggedArray(2)() As Integer
jaggedArray(0) = New Integer(3){} ' First row has 4 columns
jaggedArray(1) = New Integer(4){} ' Second row has 5 columns
jaggedArray(2) = New Integer(2){} ' Third row has 3 columns

Types Anonymes

Les types anonymes brillent dans les scénarios nécessitant des structures de données temporaires sans les frais généraux de déclaration d'une classe formelle. En utilisant new avec une syntaxe d'initialisation de propriété, vous pouvez créer des objets à la volée. Cette fonctionnalité est incroyablement utile pour les requêtes LINQ où vous devez sélectionner un sous-ensemble de propriétés d'un objet plus grand ou pour regrouper rapidement des données sans créer un type spécifique.

var person = new { Name = "Alice", Age = 30 };
Console.WriteLine($"Name: {person.Name}, Age: {person.Age}");

// In LINQ
var results = from p in people
              select new { p.Name, p.Age };

var person = new { Name = "Alice", Age = 30 };
Console.WriteLine($"Name: {person.Name}, Age: {person.Age}");

// In LINQ
var results = from p in people
              select new { p.Name, p.Age };

Dim person = New With {
	Key .Name = "Alice",
	Key .Age = 30
}
Console.WriteLine($"Name: {person.Name}, Age: {person.Age}")

' In LINQ
Dim results = From p In people
	Select New With {
		Key p.Name,
		Key p.Age
	}

Dim person = New With {
	Key .Name = "Alice",
	Key .Age = 30
}
Console.WriteLine($"Name: {person.Name}, Age: {person.Age}")

' In LINQ
Dim results = From p In people
	Select New With {
		Key p.Name,
		Key p.Age
	}

Initialiseurs d'Objets

Un initialiseur d'objet représente une commodité syntaxique, vous permettant de créer une instance d'une classe et de configurer immédiatement ses propriétés sans appeler un constructeur avec des paramètres. Cela rend non seulement le code plus lisible, mais réduit également la probabilité d'erreurs en éliminant le besoin de multiples constructeurs pour différents scénarios. Les initialiseurs d'objets sont particulièrement utiles lorsque vous travaillez avec des objets complexes, vous permettant de définir uniquement les propriétés nécessaires.

public class Rectangle
{
    public int Width { get; set; }
    public int Height { get; set; }
    public Point Location { get; set; }
}

Rectangle rect = new Rectangle
{
    Width = 100,
    Height = 50,
    Location = new Point { X = 0, Y = 0 }
};

public class Rectangle
{
    public int Width { get; set; }
    public int Height { get; set; }
    public Point Location { get; set; }
}

Rectangle rect = new Rectangle
{
    Width = 100,
    Height = 50,
    Location = new Point { X = 0, Y = 0 }
};

Public Class Rectangle
	Public Property Width() As Integer
	Public Property Height() As Integer
	Public Property Location() As Point
End Class

Private rect As New Rectangle With {
	.Width = 100,
	.Height = 50,
	.Location = New Point With {
		.X = 0,
		.Y = 0
	}
}

Public Class Rectangle
	Public Property Width() As Integer
	Public Property Height() As Integer
	Public Property Location() As Point
End Class

Private rect As New Rectangle With {
	.Width = 100,
	.Height = 50,
	.Location = New Point With {
		.X = 0,
		.Y = 0
	}
}

Fonctions Locales et Expression Lambda

C# supporte les fonctions locales et les expressions lambda, améliorant la flexibilité et la concision du code.

Fonction Locale

Une fonction locale est une méthode définie dans le cadre d'une autre méthode, servant de puissant outil pour organiser le code et encapsuler des fonctionnalités.

public void PerformOperation()
{
    int LocalFunction(int x)
    {
        return x * x;
    }
    Console.WriteLine(LocalFunction(5)); // Output: 25
}

public void PerformOperation()
{
    int LocalFunction(int x)
    {
        return x * x;
    }
    Console.WriteLine(LocalFunction(5)); // Output: 25
}

Public Sub PerformOperation()
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'	int LocalFunction(int x)
'	{
'		Return x * x;
'	}
	Console.WriteLine(LocalFunction(5)) ' Output: 25
End Sub

Public Sub PerformOperation()
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'	int LocalFunction(int x)
'	{
'		Return x * x;
'	}
	Console.WriteLine(LocalFunction(5)) ' Output: 25
End Sub

Expressions Lambda

L'expression lambda fournit un moyen concis d'écrire des expressions ou méthodes en ligne sans avoir besoin de types de délégués explicites.

Func<int, int> square = x => x * x;
Console.WriteLine(square(5)); // Output: 25

Func<int, int> square = x => x * x;
Console.WriteLine(square(5)); // Output: 25

Dim square As Func(Of Integer, Integer) = Function(x) x * x
Console.WriteLine(square(5)) ' Output: 25

Dim square As Func(Of Integer, Integer) = Function(x) x * x
Console.WriteLine(square(5)) ' Output: 25

Utiliser 'new' dans l'Héritage

Dans l'héritage de classe, new peut masquer des membres hérités, permettant aux classes dérivées d'introduire un membre ayant le même nom que ceux de leurs classes de base.

Masquage des Membres Hérités

Utiliser new pour masquer un membre dans une classe dérivée ne remplace pas le même membre ; au lieu de cela, il introduit un nouveau membre qui est distinct de la version de la classe de base.

public class BaseClass
{
    public void Display()
    {
        Console.WriteLine("Base display");
    }
}

public class DerivedClass : BaseClass
{
    public new void Display()
    {
        Console.WriteLine("Derived display");
    }
}

public class BaseClass
{
    public void Display()
    {
        Console.WriteLine("Base display");
    }
}

public class DerivedClass : BaseClass
{
    public new void Display()
    {
        Console.WriteLine("Derived display");
    }
}

Public Class BaseClass
	Public Sub Display()
		Console.WriteLine("Base display")
	End Sub
End Class

Public Class DerivedClass
	Inherits BaseClass

	Public Shadows Sub Display()
		Console.WriteLine("Derived display")
	End Sub
End Class

Public Class BaseClass
	Public Sub Display()
		Console.WriteLine("Base display")
	End Sub
End Class

Public Class DerivedClass
	Inherits BaseClass

	Public Shadows Sub Display()
		Console.WriteLine("Derived display")
	End Sub
End Class

Comprendre new avec les Génériques

Les génériques introduisent un niveau d'abstraction dans la programmation C#, permettant aux développeurs de concevoir des classes, méthodes et interfaces qui fonctionnent sur des types génériques. Lorsqu'ils sont associés au mot clé new, les génériques vous permettent d'instancier des types dynamiquement, améliorant davantage la réutilisabilité du code et réduisant la redondance.

La contrainte new() dans le Type Générique

La contrainte new() est une pierre angulaire de l'utilisation de new avec les génériques, spécifiant qu'un argument de type dans une classe ou méthode générique doit avoir un constructeur public sans paramètres. Cette contrainte permet de créer des instances de votre type générique dans la classe ou la méthode, rendant vos classes et méthodes génériques plus flexibles et puissantes.

public class Container<t> where T : new()
{
    public T CreateItem()
    {
        return new T();
    }
}

public class Container<t> where T : new()
{
    public T CreateItem()
    {
        return new T();
    }
}

Public Class Container(Of T As {New})
    Public Function CreateItem() As T
        Return New T()
    End Function
End Class

Public Class Container(Of T As {New})
    Public Function CreateItem() As T
        Return New T()
    End Function
End Class

Dans cet exemple, Container peut créer des instances de T, à condition que T ait un constructeur sans paramètres. Cette capacité est inestimable lors du développement de bibliothèques ou de frameworks qui nécessitent la création d'objets mais ne connaissent pas à l'avance les types spécifiques.

Introduction à IronPDF

IronPDF – Une Bibliothèque C# pour la Génération et la Manipulation de PDF se distingue comme un outil puissant qui utilise les capacités de C# pour travailler avec des fichiers PDF. En incorporant IronPDF, les développeurs peuvent créer des nouveaux documents PDF à partir de chaînes HTML, de fichiers ou d'URLs de manière programmatique, manipuler des PDF existants et extraire du contenu, le tout à travers la syntaxe familière de C# et en exploitant le mot clé new pour l'instanciation des objets.

IronPDF excelle dans la conversion HTML en PDF, garantissant une préservation précise des mises en page et styles originaux. Il est parfait pour créer des PDF à partir de contenus basés sur le Web tels que des rapports, des factures et de la documentation. Avec le support des fichiers HTML, des URLs et des chaînes HTML brutes, IronPDF produit facilement des documents PDF de haute qualité.

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

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

Exemple de Code

using IronPdf;
using System;

namespace IronPdfExample
{
    class Program
    {
        static void Main(string[] args)
        {
            IronPdf.License.LicenseKey = "License-Key";

            // Create a new PDF document from HTML content
            var renderer = new ChromePdfRenderer();
            var pdf = renderer.RenderHtmlAsPdf("<h1>Hello, World!</h1><p>This is a PDF generated from HTML using IronPDF.</p>");

            // Save the PDF to a file
            string filePath = "HelloWorld.pdf";
            pdf.SaveAs(filePath);

            // Confirmation message
            Console.WriteLine($"PDF file has been generated at: {Environment.CurrentDirectory}\\{filePath}");
        }
    }
}

using IronPdf;
using System;

namespace IronPdfExample
{
    class Program
    {
        static void Main(string[] args)
        {
            IronPdf.License.LicenseKey = "License-Key";

            // Create a new PDF document from HTML content
            var renderer = new ChromePdfRenderer();
            var pdf = renderer.RenderHtmlAsPdf("<h1>Hello, World!</h1><p>This is a PDF generated from HTML using IronPDF.</p>");

            // Save the PDF to a file
            string filePath = "HelloWorld.pdf";
            pdf.SaveAs(filePath);

            // Confirmation message
            Console.WriteLine($"PDF file has been generated at: {Environment.CurrentDirectory}\\{filePath}");
        }
    }
}

Imports IronPdf
Imports System

Namespace IronPdfExample
	Friend Class Program
		Shared Sub Main(ByVal args() As String)
			IronPdf.License.LicenseKey = "License-Key"

			' Create a new PDF document from HTML content
			Dim renderer = New ChromePdfRenderer()
			Dim pdf = renderer.RenderHtmlAsPdf("<h1>Hello, World!</h1><p>This is a PDF generated from HTML using IronPDF.</p>")

			' Save the PDF to a file
			Dim filePath As String = "HelloWorld.pdf"
			pdf.SaveAs(filePath)

			' Confirmation message
			Console.WriteLine($"PDF file has been generated at: {Environment.CurrentDirectory}\{filePath}")
		End Sub
	End Class
End Namespace

Imports IronPdf
Imports System

Namespace IronPdfExample
	Friend Class Program
		Shared Sub Main(ByVal args() As String)
			IronPdf.License.LicenseKey = "License-Key"

			' Create a new PDF document from HTML content
			Dim renderer = New ChromePdfRenderer()
			Dim pdf = renderer.RenderHtmlAsPdf("<h1>Hello, World!</h1><p>This is a PDF generated from HTML using IronPDF.</p>")

			' Save the PDF to a file
			Dim filePath As String = "HelloWorld.pdf"
			pdf.SaveAs(filePath)

			' Confirmation message
			Console.WriteLine($"PDF file has been generated at: {Environment.CurrentDirectory}\{filePath}")
		End Sub
	End Class
End Namespace

Dans cet extrait de code Program, new IronPdf.ChromePdfRenderer() démontre l'instanciation d'un objet rendu par IronPDF. Cet objet est ensuite utilisé pour créer un nouveau PDF à partir d'une chaîne HTML, illustrant l'intégration transparente des bibliothèques tierces avec les modèles de création d'objets de C#. IronPDF nécessite l'utilisation du mot clé new pour initier ses classes, ce qui en fait un exemple pertinent pour les développeurs apprenant l'instanciation d'objets et explorant les fonctionnalités avancées de C#.

Conclusion

Le mot clé new en C# est une pierre angulaire de la programmation orientée objet, permettant aux développeurs d'instancier des objets, de gérer l'héritage et d'utiliser les génériques avec précision et facilité. A travers des exemples pratiques, de la création d'instances de classes simples à l'exploitation des fonctionnalités avancées comme les types anonymes et les initialiseurs d'objets, ce guide démontre la polyvalence et la puissance de new.

L'intégration de IronPDF montre comment C# peut s'étendre au-delà des applications traditionnelles, permettant la génération et la manipulation de fichiers PDF par le biais de code. IronPDF propose un essai gratuit et des options de licence pour les développeurs afin d'explorer ses fonctionnalités, avec des licences à partir d'un prix compétitif.