C# Nouveau (Comment ça marche pour les développeurs)

Le mot-clé nouveau de l'opérateur en C# est polyvalent et remplit plusieurs fonctions essentielles dans le langage. De l'instanciation des objets à la dissimulation des membres hérités, la compréhension de leurs applications est cruciale pour un développement C# efficace. Ce guideexplore les différentes utilisations du nouveau mot-cléla traduction doit également comprendre des exemples clairs pour illustrer la puissance et la flexibilité de ces outils. Nous explorerons également lesPrésentation de la bibliothèque IronPDF sur IronSoftware plus loin dans ce guide.

Introduction à l'instanciation d'objets

L'instanciation d'un objet est le processus par lequel le nouvel opérateur crée une instance d'une classe ou d'une structure. En C#, on utilise principalement le 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 de nouvelles

Pour créer une instance d'un objet, l'opérateur new est suivi du nom de la classe et d'une paire de parenthèses. Si la classe possède un constructeur qui prend des paramètres, les arguments doivent être fournis entre 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")

Constructeurs par défaut et sans paramètre

Un constructeur par défaut est fourni par C# si aucun constructeur n'est explicitement défini dans une classe. Toutefois, une fois qu'un constructeur avec 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

Techniques avancées de création d'objets

En C#, la création d'objets ne se limite pas à l'instanciation de classes ; il s'agit d'une passerelle permettant d'exploiter les puissantes fonctionnalités du langage pour obtenir un code plus efficace, plus lisible et plus concis. Nous explorons ici des techniques avancées telles que le travail avec des tableaux, l'utilisation de types et l'emploi d'initialisateurs d'objets pour rationaliser vos efforts de codage.

Tableaux et collections

La création de tableaux d'un type spécifique en C# est une compétence fondamentale, mais ce sont les nuances qui élèvent vos capacités de codage. Le mot-clé new permet d'instancier des tableaux en précisant 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 en dents de scie, s'adaptant ainsi à 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

Types anonymes

Les types anonymes s'avèrent très utiles dans les scénarios nécessitant des structures de données temporaires sans avoir à déclarer 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 lorsque 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 de 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
	}

Initialisateurs d'objets

Un initialisateur d'objet représente une commodité syntaxique, permettant de créer une instance d'une classe et de définir 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 la nécessité de construire plusieurs constructeurs pour différents scénarios. Les initialisateurs d'objets sont particulièrement pratiques lorsque vous travaillez avec des objets complexes, car ils vous permettent de définir uniquement les propriétés dont vous avez besoin.

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
	}
}

Fonctions locales et expressions Lambda

C# prend en charge les fonctions locales et les expressions lambda, ce qui améliore la flexibilité et la concision du code.

Fonction locale

Une fonction locale est une méthode définie à l'intérieur de la portée d'une autre méthode, ce qui constitue un outil puissant pour organiser le code et encapsuler la fonctionnalité.

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

Expressions lambda

L'expression lambda est un moyen concis d'écrire des expressions ou des 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

Utilisation de "new" dans l'héritage

Dans l'héritage de classes, le nouveau peut cacher les membres hérités, ce qui permet aux classes dérivées d'introduire un membre portant le même nom que ceux de leurs classes de base.

Cacher les membres hérités

L'utilisation de new pour cacher un membre dans une classe dérivée ne permet pas de surcharger 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

Comprendre le nouveau 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, des méthodes et des interfaces qui opèrent sur des types génériques. Associés au mot-clé new, les génériques permettent d'instancier des types de manière dynamique, ce qui améliore encore la réutilisation du code et réduit la redondance.

La contrainte new() dans les types génériques

Le nouveau() Cette contrainte est la pierre angulaire de l'utilisation de new avec les génériques. Elle spécifie qu'un argument de type dans une classe ou une méthode générique doit avoir un constructeur public sans paramètre. Cette contrainte vous permet de créer des instances de votre type générique au sein de la classe ou de la méthode, ce qui rend vos classes et méthodes génériques plus flexibles et plus puissantes.

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

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

public class Container(Of T) where T : New() {
	public T CreateItem() { Return New T(); }
}

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

Introduction à IronPDF

IronPDF - Une bibliothèque C# pour la génération et la manipulation de fichiers PDF est 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 par programme de nouvellesDocuments PDF à partir de chaînes HTMLles utilisateurs peuvent créer des fichiers PDF, des fichiers ou des URL, manipuler des PDF existants et en extraire le contenu, tout en utilisant la syntaxe familière de C# et le mot-clé new pour l'instanciation d'objets.

Exemple de code

using IronPdf;
using System;
namespace IronPdfExample
{
    class Program
    {
//static void main
        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
        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
'static void main
		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 programme de classe, new IronPDF.ChromePdfRenderer() démontre l'instanciation d'un objet de rendu IronPDF. Cet objet est ensuite utilisé pour créer un nouveau PDF à partir d'une chaîne HTML, ce qui illustre l'intégration transparente de 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 qui s'initient à l'instanciation d'objets et explorent les fonctionnalités avancées de C#.

Sortie

Lorsque vous exécutez le programme, vous verrez le message suivant sur la console :

Une fois que vous aurez ouvert le fichier PDF, vous verrez ceci :

Conclusion

Le mot-clé new de 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é. Au travers d'exemples pratiques, allant de la création de simples instances de classes à l'exploitation de fonctionnalités avancées telles que les types anonymes et les initialisateurs d'objets, ce guide démontre la polyvalence et la puissance de new.

L'intégration d'IronPDF montre comment C# peut étendre sa portée au-delà des applications traditionnelles, en permettant la génération et la manipulation de fichiers PDF par le biais du code. IronPDF offre un service deessai gratuit et options de licence la traduction doit rester professionnelle, en préservant l'exactitude technique tout en expliquant les caractéristiques et les avantages de ces outils de développement.