Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. csharp-record-vs-class
.NET AIDE

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

Curtis Chau
Curtis Chau
Mis à jour:

In the world of C#, two primary structures are utilized to model and encapsulate data: classes and records. Les deux servent de types de référence mais diffèrent considérablement dans leur utilisation prévue, leur comportement et la façon dont ils gèrent l'égalité. Ce guide dissèquera ces différences, fournissant des exemples clairs et des utilisations pratiques pour aider les développeurs à choisir la bonne structure pour leurs besoins. Nous allons également apprendre à connaître la bibliothèque IronPDF.

Les classes en C#: Les notions de base

Les classes ont été un pilier de la programmation orientée objet en C#, conçues pour encapsuler les données et les comportements. Ce sont des types de référence, ce qui signifie que deux instances de classe avec les mêmes valeurs sont considérées comme deux objets distincts. Cette distinction est cruciale lors de la comparaison de deux instances de classe ; la comparaison par défaut est basée sur la référence, 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
$vbLabelText   $csharpLabel

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

Les enregistrements en C#: Structures de données immuables

Introduit en C#, le type enregistrement est un ajout plus récent visant à simplifier la création de structures de données immuables, fournissant une alternative robuste aux structures de classe traditionnelles. Contrairement aux classes, les enregistrements offrent des sémantiques d'égalité basées sur la valeur, les rendant 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)
$vbLabelText   $csharpLabel

Dans l’exemple ci-dessus, la définition de l’enregistrement est plus concise, réduisant le code standard. Les enregistrements prennent en charge automatiquement la mutation non destructive et la comparaison basée sur la valeur. Deux instances d'enregistrement avec les mêmes valeurs sont considérées comme égales, en adéquation avec les sémantiques de valeur.

Utilisations pratiques : Quand utiliser un enregistrement ou une classe

Choisir 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écifiquement conçues pour des structures de données complexes, accommodant des comportements (méthodes) et permettant des instances modifiables selon les besoins. Les enregistrements, d'autre part, sont des exemples parfaits de structures de données simples, conçues avec des caractéristiques immuables et une égalité basée sur la valeur, idéales pour des données qui restent constantes après leur création.

Les classes sont idéales lorsque votre structure de données nécessite encapsuler des données et des comportements ou lorsque vous devez manipuler les données après leur création. Cette flexibilité fait des classes un choix privilégié pour la plupart des scénarios de programmation orientée objet traditionnelle et lorsqu'on crée des structures de données complexes.

Les enregistrements brillent dans les scénarios où l'immuabilité des données est cruciale ou lorsque vous traitez 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 les rendent excellents pour les objets de transfert de données ou les objets de valeur.

Types de valeur et types de référence

Comprendre la différence entre type de valeur et type de référence en C# est essentiel. 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 par défaut basée sur la référence.

Les enregistrements, bien qu'étant également des types de référence, émulent des sémantiques de valeur via leur égalité intégrée basée sur la valeur, les faisant se comporter un peu comme des types de valeur lors des comparaisons.

Exemples de code : Implémentation de classes et d'enregistrements

Implémentons une classe et un enregistrement pour mettre en évidence les différences de syntaxe et de comportement.

Implémentation 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
$vbLabelText   $csharpLabel

Implémentation de l'enregistrement :

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

Remarquez la concision et la simplicité de l'implémentation 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 vs Valeur

La différence fondamentale entre les types classe et enregistrement en C# réside en effet dans la façon dont ils gèrent l'égalité :

  1. Les classes utilisent l'égalité de référence par défaut, 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èrent deux instances é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
$vbLabelText   $csharpLabel

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

Exemple d'égalité de valeur

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

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

Fonctionnalités avancées : Enregistrements

Les enregistrements viennent avec plusieurs fonctionnalités avancées qui répondent au besoin de structures de données immuables et d'égalité basée sur la valeur. L'expression with permet de créer une nouvelle instance d'enregistrement en copiant un enregistrement existant mais avec certaines propriétés modifiées, montrant 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" }
$vbLabelText   $csharpLabel

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

Présentation de la Bibliothèque IronPDF

Page de la bibliothèque IronPDF

IronPDF est une bibliothèque PDF pour les développeurs .NET, offrant une solution complète pour créer, éditer et gérer des documents PDF directement dans les applications .NET. Elle simplifie le processus de génération de PDF en permettant aux développeurs de convertir HTML en PDF, les CSS, JavaScript et images en PDF. IronPDF prend en charge une variété de frameworks .NET et de types de projets, y compris 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 PDF, IronPDF offre des capacités pour éditer des PDFs, définir des propriétés et la sécurité, travailler avec des formulaires PDF, et extraire du contenu. Elle est conçue pour répondre aux besoins des développeurs cherchant un outil fiable pour intégrer la fonctionnalité PDF dans leurs projets .NET.

Exemple de code

Créer un PDF en C# en utilisant IronPDF peut être réalisé avec des classes et des enregistrements. Ci-dessous se trouvent 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 usage prévu : les classes sont mutables par défaut et conçues pour la programmation orientée objet traditionnelle, alors que les enregistrements sont immuables et conçus pour la programmation basée sur la valeur, ce qui les rend idéals pour la modélisation de 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;
using System;

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"; // Set your license key here

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

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"; // Set your license key here

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

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" ' Set your license key here

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

Sortie :

PDF généré à partir de l'exemple de classe

Utilisation d'un Enregistrement

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

using IronPdf;
using System;

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"; // Set your license key here

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

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"; // Set your license key here

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

'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" ' Set your license key here

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

Sortie :

PDF généré à partir de l'exemple d'enregistrement

Ces exemples illustrent comment générer un fichier PDF en utilisant IronPDF avec à la fois une classe et un enregistrement en C#. Le choix entre utiliser une classe ou 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 pourrait être plus appropriée. Si vous traitez avec des données qui ne devraient pas changer une fois qu'elles ont été créées, ou que vous appréciez la simplicité syntaxique et la sécurité de l'immuabilité, un enregistrement pourrait être le meilleur choix.

Conclusion

Page de licence IronPDF

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

Le choix entre utiliser une classe ou un enregistrement devrait être guidé par les exigences spécifiques de votre application, en considérant des facteurs comme le besoin d'immuabilité, la complexité de la structure de données, et la méthode de comparaison d'égalité préférée. Découvrez l'essai gratuit d'IronPDF pour ceux qui cherchent à intégrer la fonctionnalité PDF dans leurs applications .NET, avec des licences à partir de $799.

Questions Fréquemment Posées

Quelles sont les principales différences entre les classes C# et les enregistrements ?

Les classes et les enregistrements en C# sont tous deux des types de référence utilisés pour modéliser et encapsuler des données, mais diffèrent dans la gestion de l'égalité et de l'immuabilité. Les classes utilisent l'égalité de référence, ce qui signifie que deux instances sont considérées comme égales si elles pointent vers le même emplacement mémoire. Par contre, les enregistrements utilisent l'égalité de valeur, considérant que deux instances sont égales si leurs propriétés ont les mêmes valeurs, et sont conçus pour être immuables par défaut.

Comment puis-je décider d'utiliser une classe ou un enregistrement en C# ?

Le choix entre utiliser une classe ou un enregistrement en C# dépend de vos besoins spécifiques. Utilisez une classe si vous avez besoin d'instances mutables ou si vous souhaitez encapsuler des données et des comportements typiques de la programmation orientée objet. Optez pour un enregistrement si votre structure est simple, immuable et nécessite une égalité basée sur les valeurs, comme dans les objets de transfert de données.

Comment la bibliothèque IronPDF prend-elle en charge la génération de PDF en .NET ?

IronPDF est une bibliothèque PDF robuste pour .NET qui simplifie la création, la modification et la gestion des documents PDF. Elle permet aux développeurs de convertir du HTML, CSS, JavaScript et des images en PDF, supportant divers cadres et systèmes d'exploitation .NET, ce qui en fait un outil essentiel pour les développeurs .NET.

Puis-je utiliser à la fois des classes C# et des enregistrements dans des projets de génération de PDF ?

Oui, à la fois les classes C# et les enregistrements peuvent être utilisés dans des projets de génération de PDF. Le choix dépend de la nécessité d'avoir des structures de données mutables ou immuables pour votre logique. Par exemple, IronPDF peut fonctionner parfaitement avec l'une ou l'autre structure pour générer et manipuler des PDFs.

Quel rôle joue l'immuabilité dans les enregistrements C# ?

L'immuabilité est une caractéristique fondamentale des enregistrements C#. Une fois créé, les propriétés d'un enregistrement ne peuvent être modifiées, ce qui correspond aux sémantiques d'égalité basées sur les valeurs. Cette conception rend les enregistrements idéaux pour les scénarios où la cohérence et l'intégrité des données sont cruciales, comme dans les objets de transfert de données.

Comment IronPDF améliore-t-il les fonctionnalités PDF pour les applications .NET ?

IronPDF améliore les fonctionnalités PDF pour les applications .NET en fournissant des fonctionnalités telles que la conversion de HTML en PDF, la modification de PDF et la gestion de la sécurité des documents. Il prend en charge le travail avec des formulaires, l'extraction de contenu et l'intégration transparente avec différents environnements .NET, simplifiant ainsi le traitement des documents PDF.

Quelle est l'expression 'with' dans le contexte des enregistrements C# ?

L'expression 'with' dans les enregistrements C# est utilisée pour la mutation non-destructive. Elle permet aux développeurs de créer une nouvelle instance d'enregistrement en recopiant une existante mais avec certaines propriétés modifiées, garantissant que les données d'origine restent inchangées.

Pourquoi les enregistrements sont-ils considérés comme adaptés aux objets de transfert de données ?

Les enregistrements sont considérés comme adaptés pour les objets de transfert de données car ils offrent une syntaxe concise pour définir des structures immuables avec égalité basée sur les valeurs. Cela garantit le maintien de l'intégrité des données et que les instances ayant des valeurs identiques soient traitées comme égales, ce qui est souvent souhaité dans les scénarios de transfert de données.

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