C# Record Vs Class (Comment ça marche pour les développeurs)

Dans le monde de C#, deux structures principales sont utilisées pour modéliser et encapsuler les données :classes etrecords. Les deux servent de types de référence mais diffèrent considérablement dans leur utilisation prévue, leur comportement et la manière dont ils gèrent l'égalité. Ce guide décortique ces différences, en fournissant des exemples clairs et des utilisations pratiques pour aider les développeurs à choisir la structure la plus adaptée à leurs besoins. Nous en apprendrons également plus sur laBibliothèque IronPDF.

Les classes en C#: Les bases

Les classes sont la pierre angulaire de la programmation orientée objet en C#. Elles sont conçues pour encapsuler les données et le comportement. Il s'agit de types de référence, ce qui signifie que deux instances de classe ayant les mêmes valeurs sont considérées comme deux objets distincts. Cette distinction est cruciale lorsqu'il s'agit de comparer deux classes ; la comparaison par défaut est basée sur la référence et non sur la valeur.

public class Person
{
    public int Id { get; set; }
    public string FullName { get; set; }
}

public class Person
{
    public int Id { get; set; }
    public string FullName { get; set; }
}

Public Class Person
	Public Property Id() As Integer
	Public Property FullName() As String
End Class

Dans l'exemple ci-dessus, Person est une classe avec les propriétés Id et FullName. Même si deux instances Person ont des valeurs Id et FullName identiques, elles ne sont pas considérées comme égales par défaut car il s'agit de deux références différentes en mémoire.

Enregistrements en C#: Structures de données immuables

Introduit dans le C#, le type record est un ajout récent visant à simplifier la création de structures de données immuables, offrant une alternative robuste aux structures de classes traditionnelles. Contrairement aux classes, les enregistrements offrent une sémantique d'égalité basée sur la valeur, ce qui les rend idéaux pour les objets de transfert de données ou les petites structures de données avec peu ou pas de comportement.

public record Person(int Id, string FullName);

public record Person(int Id, string FullName);

'INSTANT VB TODO TASK: C# 'records' are not converted by Instant VB:
'public record Person(int Id, string FullName)

Dans l'exemple ci-dessus, la définition de l'enregistrement est plus succincte, ce qui permet de réduire la quantité de code. Les enregistrements prennent automatiquement en charge la mutation non destructive et la comparaison basée sur la valeur. Deux instances d'enregistrement ayant les mêmes valeurs sont considérées comme égales, ce qui est conforme à la sémantique des valeurs.

Utilisations pratiques : Quand utiliser l'enregistrement ou la classe ?

Le choix entre une classe et un enregistrement, ou d'autres structures de données en C#, dépend de la complexité des données que vous modélisez et des comportements requis par votre application. Les classes sont spécialement conçues pour les structures de données complexes, et s'adaptent aux comportements(méthodes) et en autorisant les instances mutables si nécessaire. Les enregistrements, en revanche, sont des exemples parfaits de structure de données simple, conçue avec des caractéristiques immuables et une égalité basée sur la valeur, idéale pour les données qui restent constantes après leur création.

Les classes sont idéales lorsque votre structure de données nécessite l'encapsulation des données et des comportements ou lorsque vous devez manipuler les données après leur création. Cette flexibilité fait des classes une solution de choix pour la plupart des scénarios de programmation orientée objet traditionnels et pour la création de structures de données complexes.

Les enregistrements brillent dans les scénarios où l'immutabilité des données est cruciale ou lorsque vous avez affaire à des structures de données simples qui servent principalement de conteneurs de données. Leur égalité intégrée basée sur la valeur et leur syntaxe concise en font d'excellents objets de transfert de données ou objets de valeur.

Types de valeurs et types de références

Il est essentiel de comprendre la différence entre un type de valeur et un type de référence en C#. Les classes sont des types de référence, ce qui signifie que les variables contiennent une référence aux données réelles en mémoire. Cette caractéristique conduit à la comparaison d'égalité basée sur la référence par défaut.

Les enregistrements, bien qu'ils soient également des types de référence, émulent la sémantique des valeurs grâce à leur égalité intégrée basée sur les valeurs, ce qui les fait se comporter un peu comme des types de valeurs dans les comparaisons.

Exemples de code : Mise en œuvre des classes et des enregistrements

Mettons en œuvre une classe et un enregistrement pour mettre en évidence les différences de syntaxe et de comportement.

Mise en œuvre de la classe:

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }

    public Product(int id, string name)
    {
        Id = id;
        Name = name;
    }
}

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }

    public Product(int id, string name)
    {
        Id = id;
        Name = name;
    }
}

Public Class Product
	Public Property Id() As Integer
	Public Property Name() As String

	Public Sub New(ByVal id As Integer, ByVal name As String)
		Me.Id = id
		Me.Name = name
	End Sub
End Class

Record Implementation:

public record Product(int Id, string Name);

public record Product(int Id, string Name);

'INSTANT VB TODO TASK: C# 'records' are not converted by Instant VB:
'public record Product(int Id, string Name)

Remarquez la brièveté et la simplicité de la mise en œuvre de l'enregistrement. L'enregistrement génère automatiquement le constructeur, les propriétés et les méthodes pour l'égalité basée sur la valeur.

Comprendre l'égalité : Référence et valeur

La principale différence entre les types de classe et les types d'enregistrement en C# réside effectivement dans la manière dont ils gèrent l'égalité :

1. Par défaut, les classes utilisent l’égalité de référence, ce qui signifie que deux instances sont égales si elles pointent vers le même emplacement mémoire.

2. Les enregistrements utilisent l'égalité de valeur par défaut, considérant deux instances comme égales si leurs propriétés ont les mêmes valeurs.

   Exemple d'Égalité de Référence(Classe)**

public class Person
{
    public int Id { get; set; }
    public string Name { get; set; }
}

var classInstance1 = new Person { Id = 1, Name = "Iron Software" };
var classInstance2 = new Person { Id = 1, Name = "Iron Software" };
Console.WriteLine(classInstance1 == classInstance2); // Outputs: False

public class Person
{
    public int Id { get; set; }
    public string Name { get; set; }
}

var classInstance1 = new Person { Id = 1, Name = "Iron Software" };
var classInstance2 = new Person { Id = 1, Name = "Iron Software" };
Console.WriteLine(classInstance1 == classInstance2); // Outputs: False

Public Class Person
	Public Property Id() As Integer
	Public Property Name() As String
End Class

Private classInstance1 = New Person With {
	.Id = 1,
	.Name = "Iron Software"
}
Private classInstance2 = New Person With {
	.Id = 1,
	.Name = "Iron Software"
}
Console.WriteLine(classInstance1 = classInstance2) ' Outputs: False

Deux instances d'une classe avec les mêmes valeurs de propriétés ne sont pas considérées comme égales car ce sont des objets différents en mémoire.

Exemple d'égalité des valeurs

public record Person(int Id, string Name);

var recordInstance1 = new Person(1, "Iron Software");
var recordInstance2 = new Person(1, "Iron Software");
Console.WriteLine(recordInstance1 == recordInstance2); // Outputs: True

public record Person(int Id, string Name);

var recordInstance1 = new Person(1, "Iron Software");
var recordInstance2 = new Person(1, "Iron Software");
Console.WriteLine(recordInstance1 == recordInstance2); // Outputs: True

'INSTANT VB TODO TASK: C# 'records' are not converted by Instant VB:
'public record Person(int Id, string Name)

Private recordInstance1 = New Person(1, "Iron Software")
Private recordInstance2 = New Person(1, "Iron Software")
Console.WriteLine(recordInstance1 = recordInstance2) ' Outputs: True

Deux instances d'un enregistrement avec les mêmes valeurs de propriétés sont considérées comme égales par défaut.

Fonctionnalités avancées : Enregistrements

Les enregistrements sont dotés de plusieurs fonctions avancées qui répondent au besoin de structures de données immuables et d'égalité basée sur la valeur. L'expression avec permet de créer un nouvel enregistrement en copiant un enregistrement existant mais en modifiant certaines de ses propriétés, ce qui constitue une mutation non destructive.

Mutation non destructive avec enregistrements:

var originalRecord = new Person(1, "Doe");
var modifiedRecord = originalRecord with { Name = "Iron Developer" };

var originalRecord = new Person(1, "Doe");
var modifiedRecord = originalRecord with { Name = "Iron Developer" };

Dim originalRecord = New Person(1, "Doe")
'INSTANT VB TODO TASK: C# 'with expressions' are not converted by Instant VB:
'var modifiedRecord = originalRecord with { Name = "Iron Developer" }

Cette fonction est pratique lorsque l'on travaille avec des structures de données immuables, car elle permet de "modifier" une instance sans altérer les données d'origine.

Introduction de la bibliothèque IronPDF

IronPDF est une bibliothèque PDF pour les développeurs .NET, offrant une solution complète pour la création, l'édition et la gestion de documents PDF directement dans les applications .NET. Il simplifie le processus de génération de PDF en permettant aux développeurs deconvertir HTML en PDF, CSS, JavaScript et des images dans des PDF. IronPDF prend en charge une variété de frameworks .NET et de types de projets, notamment les applications web, de bureau et de console, sur plusieurs systèmes d'exploitation tels que Windows, Linux et macOS.

Au-delà de la création de PDF, IronPDF permet d'éditer les PDF, de définir les propriétés et la sécurité, de travailler avec des formulaires PDF et d'extraire du contenu. Il est conçu pour répondre aux besoins des développeurs à la recherche d'un outil fiable pour intégrer des fonctionnalités PDF dans leurs projets .NET.

Exemple de code

La création d'un PDF en C# à l'aide d'IronPDF peut être réalisée à la fois avec des classes et des enregistrements. Vous trouverez ci-dessous des exemples des deux approches pour générer un document PDF simple. La principale différence entre les classes et les enregistrements en C# réside dans leur utilisation prévue : les classes sont mutables par défaut et conçues pour la programmation orientée objet traditionnelle, tandis que les enregistrements sont immuables et conçus pour la programmation basée sur les valeurs, ce qui les rend idéaux pour la modélisation des données.

Utilisation d'une classe

Dans cet exemple, nous allons définir une classe PdfGenerator qui contient une méthode pour créer un PDF à partir d'une chaîne HTML donnée.

using IronPdf;

public class PdfGenerator
{
    public string HtmlContent { get; set; }

    public PdfGenerator(string htmlContent)
    {
        HtmlContent = htmlContent;
    }

    public void GeneratePdf(string filePath)
    {
        var renderer = new ChromePdfRenderer();
        var pdfDocument = renderer.RenderHtmlAsPdf(HtmlContent);
        pdfDocument.SaveAs(filePath);
    }
}

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

        var generator = new PdfGenerator("<h1>Hello, World from Class!</h1>");
        generator.GeneratePdf("ClassExample.pdf");
    }
}

using IronPdf;

public class PdfGenerator
{
    public string HtmlContent { get; set; }

    public PdfGenerator(string htmlContent)
    {
        HtmlContent = htmlContent;
    }

    public void GeneratePdf(string filePath)
    {
        var renderer = new ChromePdfRenderer();
        var pdfDocument = renderer.RenderHtmlAsPdf(HtmlContent);
        pdfDocument.SaveAs(filePath);
    }
}

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

        var generator = new PdfGenerator("<h1>Hello, World from Class!</h1>");
        generator.GeneratePdf("ClassExample.pdf");
    }
}

Imports IronPdf

Public Class PdfGenerator
	Public Property HtmlContent() As String

	Public Sub New(ByVal htmlContent As String)
		Me.HtmlContent = htmlContent
	End Sub

	Public Sub GeneratePdf(ByVal filePath As String)
		Dim renderer = New ChromePdfRenderer()
		Dim pdfDocument = renderer.RenderHtmlAsPdf(HtmlContent)
		pdfDocument.SaveAs(filePath)
	End Sub
End Class

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

		Dim generator = New PdfGenerator("<h1>Hello, World from Class!</h1>")
		generator.GeneratePdf("ClassExample.pdf")
	End Sub
End Class

Sortie :

Utilisation d'un enregistrement

En revanche, un enregistrement en C# est immuable après l'initialisation. Voici comment obtenir un résultat similaire avec un enregistrement, en utilisant des expressions with pour les modifications, qui renvoient essentiellement un nouvel exemplaire de l'enregistrement avec les changements souhaités.

using IronPdf;

public record PdfGeneratorRecord(string HtmlContent)
{
    public void GeneratePdf(string filePath)
    {
        var renderer = new ChromePdfRenderer();
        var pdfDocument = renderer.RenderHtmlAsPdf(this.HtmlContent);
        pdfDocument.SaveAs(filePath);
    }
}

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

        var recordGenerator = new PdfGeneratorRecord("<h1>Hello, World from Record!</h1>");
        recordGenerator.GeneratePdf("RecordExample.pdf");
    }
}

using IronPdf;

public record PdfGeneratorRecord(string HtmlContent)
{
    public void GeneratePdf(string filePath)
    {
        var renderer = new ChromePdfRenderer();
        var pdfDocument = renderer.RenderHtmlAsPdf(this.HtmlContent);
        pdfDocument.SaveAs(filePath);
    }
}

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

        var recordGenerator = new PdfGeneratorRecord("<h1>Hello, World from Record!</h1>");
        recordGenerator.GeneratePdf("RecordExample.pdf");
    }
}

Imports IronPdf

'INSTANT VB TODO TASK: C# 'records' are not converted by Instant VB:
'public record PdfGeneratorRecord(string HtmlContent)
'{
'	public void GeneratePdf(string filePath)
'	{
'		var renderer = New ChromePdfRenderer();
'		var pdfDocument = renderer.RenderHtmlAsPdf(Me.HtmlContent);
'		pdfDocument.SaveAs(filePath);
'	}
'}

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

		Dim recordGenerator = New PdfGeneratorRecord("<h1>Hello, World from Record!</h1>")
		recordGenerator.GeneratePdf("RecordExample.pdf")
	End Sub
End Class

Sortie :

Ces exemples illustrent comment générer un fichier PDF à l'aide d'IronPDF avec une classe et un enregistrement en C#. Le choix entre l'utilisation d'une classe ou d'un enregistrement dépend de vos besoins spécifiques : si vous avez besoin d'objets qui seront modifiés après leur création, une classe peut être plus appropriée. Si vous avez affaire à des données qui ne doivent pas changer une fois qu'elles ont été créées, ou si vous appréciez la simplicité syntaxique et la sécurité de l'immutabilité, un enregistrement peut être le meilleur choix.

Conclusion

En conclusion, les classes offrent des caractéristiques orientées objet traditionnelles avec un état mutable et une égalité basée sur les références, tandis que les enregistrements fournissent une approche moderne pour définir des structures de données immuables avec une égalité basée sur les valeurs.

Le choix entre l'utilisation d'une classe ou d'un enregistrement doit être guidé par les exigences spécifiques de votre application, en tenant compte de facteurs tels que le besoin d'immutabilité, la complexité de la structure de données et la méthode préférée de comparaison d'égalité. Découvrez la version d'essai gratuite d'IronPDFpour ceux qui souhaitent intégrer des fonctionnalités PDF dans leurs applications .NET, avec des licences à partir de $749.