Comment puis-je appeler un constructeur de la classe de base depuis une classe dérivée en C# ?

Vous pouvez appeler un constructeur de la classe de base depuis une classe dérivée en C# en utilisant le mot-clé base suivi des paramètres appropriés. Cela garantit que la classe de base est correctement initialisée avant la classe dérivée.

Pourquoi le mot-clé base est-il important dans l'héritage C# ?

Le mot-clé base est important dans l'héritage C# car il permet aux classes dérivées d'accéder et d'initialiser les membres et les constructeurs de la classe de base, assurant une hiérarchie d'objets et une gestion d'état appropriées.

Comment les bibliothèques spécialisées peuvent-elles améliorer les applications C# ?

Les bibliothèques spécialisées, comme IronPDF, améliorent les applications C# en fournissant des outils pour effectuer des tâches spécifiques telles que convertir HTML en PDF, lire ou éditer des fichiers PDF. Cela ajoute des fonctionnalités sans avoir besoin d'écrire un code complexe à partir de zéro.

Qu'est-ce qu'IronPDF et comment peut-il être utilisé dans un projet C# ?

IronPDF est une bibliothèque qui peut être utilisée dans des projets C# pour créer, lire et éditer des documents PDF. Il supporte la conversion de contenu HTML en PDF, ce qui est utile pour générer des rapports et de la documentation dans les applications .NET.

Que se passe-t-il si une classe de base ne dispose pas d'un constructeur public sans paramètres ?

Si une classe de base ne dispose pas d'un constructeur public sans paramètres, la classe dérivée doit explicitement appeler l'un des constructeurs de la classe de base qui correspond aux paramètres disponibles en utilisant le mot-clé base pour assurer une initialisation correcte.

Quels sont les avantages d'utiliser IronPDF pour générer des rapports ?

IronPDF offre des avantages pour générer des rapports en permettant une conversion facile de HTML en PDF, en conservant la mise en page et le style d'origine, et en permettant la personnalisation de la sortie PDF, ce qui est crucial pour la documentation professionnelle.

Pourquoi est-il essentiel de comprendre l'invocation de constructeur dans les applications C# complexes ?

Comprendre l'invocation de constructeur est essentiel car cela garantit que les objets sont correctement initialisés au sein d'une hiérarchie d'héritage, ce qui est vital pour maintenir un code fiable et maintenable dans des applications C# complexes.

Pouvez-vous fournir un exemple d'utilisation du mot-clé base avec plusieurs constructeurs ?

Oui, si une classe de base possède plusieurs constructeurs, une classe dérivée peut utiliser le mot-clé base pour spécifier quel constructeur appeler. Cette flexibilité permet une initialisation personnalisée en fonction du contexte.

La Bibliothèque PDF C#

Explore IronPDF Essai gratuit

HTML en PDF

Online Demo Voir tous les exemples de code %s

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

PM >Install-Package IronPdf

Install-Package IronPdf

MISES À JOUR POUR LES DÉVELOPPEURS

C# Call Base Constructor (Comment ça fonctionne pour les développeurs)

Jacob Mellor

Updated: 20 juin 2025

Lorsqu'on traite de l'héritage, la relation entre les classes de base et dérivées introduit des complexités sur la façon dont les constructeurs sont appelés. Comprendre comment appeler un constructeur de classe de base depuis une classe dérivée est utile pour gérer correctement l'état et le comportement de l'objet.

Ce guide explorera le concept de manière exhaustive, en se concentrant sur différents scénarios et nuances liés à l'invocation des constructeurs dans une hiérarchie d'héritage. Il explorera également la bibliothèque IronPDF avec son exemple de code lié au sujet.

Concepts de base : Constructeurs de classe et héritage

Un constructeur en C# est une méthode spéciale dans une classe qui initialise ses objets. Lorsqu'une classe hérite d'une autre classe, appelée classe de base, la classe dérivée peut également hériter ou remplacer les constructeurs de la classe de base. Le mécanisme d'appel des méthodes de constructeur de la classe de base à partir d'une classe dérivée garantit que la classe de base est correctement initialisée avant que la classe dérivée n'ajoute son initialisation.

Le mot-clé 'base' dans les appels de constructeur

Le mot-clé base en C# est utilisé dans une classe dérivée pour se référer à la classe de base. Il est particulièrement utile dans la déclaration de constructeur lorsque vous devez invoquer le constructeur de la classe de base au lieu du constructeur dérivé. En utilisant le mot-clé base, le constructeur hérité peut spécifier quel constructeur de classe de base doit être exécuté pour engager le corps de constructeur approprié. Cette capacité est essentielle lorsque la classe de base n'a pas de constructeur public sans paramètres, ou lorsqu'une initialisation spécifique dans la classe de base doit être effectuée.

Considérez un scénario où vous avez une classe dérivée de classe publique qui hérite d'une classe de base. La classe de base peut avoir un constructeur privé ou un public qui prend un paramètre entier :

public class BaseClass {
    public int b;
    public BaseClass(int b) {
        this.b = b;
    }
}

public class BaseClass {
    public int b;
    public BaseClass(int b) {
        this.b = b;
    }
}

Public Class BaseClass
	Public b As Integer
	Public Sub New(ByVal b As Integer)
		Me.b = b
	End Sub
End Class

Public Class BaseClass
	Public b As Integer
	Public Sub New(ByVal b As Integer)
		Me.b = b
	End Sub
End Class

La classe dérivée a besoin d'appeler ce constructeur pour initialiser correctement la partie de ses objets de la classe de base :

public class DerivedClass : BaseClass {
    public DerivedClass(int b) : base(b) {
        // Additional initialization for DerivedClass
    }
}

public class DerivedClass : BaseClass {
    public DerivedClass(int b) : base(b) {
        // Additional initialization for DerivedClass
    }
}

Public Class DerivedClass
	Inherits BaseClass

	Public Sub New(ByVal b As Integer)
		MyBase.New(b)
		' Additional initialization for DerivedClass
	End Sub
End Class

Public Class DerivedClass
	Inherits BaseClass

	Public Sub New(ByVal b As Integer)
		MyBase.New(b)
		' Additional initialization for DerivedClass
	End Sub
End Class

Dans cet exemple : base(b) appelle explicitement le constructeur de la classe de base avec le paramètre b. Cela garantit que le champ b dans la classe de base est initialisé avant que le constructeur de la classe dérivée ne procède à son corps.

Cas d'utilisation détaillés et variations

Gérer plusieurs constructeurs

Souvent, les classes de base et dérivées peuvent avoir plusieurs constructeurs. La classe dérivée peut choisir quel constructeur de classe de base appeler. Cette sélection est critique lorsque les constructeurs de la classe de base exécutent différents types d'initialisation.

public class BaseClass {
    public BaseClass() {
        // Default constructor
    }
    public BaseClass(int b) {
        this.b = b;
    }
}
public class DerivedClass : BaseClass {
    public DerivedClass() : base() {
        // Calls the parameterless constructor of the base class
    }
    public DerivedClass(int b) : base(b) {
        // Calls the base class constructor that takes an int
    }
}

public class BaseClass {
    public BaseClass() {
        // Default constructor
    }
    public BaseClass(int b) {
        this.b = b;
    }
}
public class DerivedClass : BaseClass {
    public DerivedClass() : base() {
        // Calls the parameterless constructor of the base class
    }
    public DerivedClass(int b) : base(b) {
        // Calls the base class constructor that takes an int
    }
}

Public Class BaseClass
	Public Sub New()
		' Default constructor
	End Sub
	Public Sub New(ByVal b As Integer)
		Me.b = b
	End Sub
End Class
Public Class DerivedClass
	Inherits BaseClass

	Public Sub New()
		MyBase.New()
		' Calls the parameterless constructor of the base class
	End Sub
	Public Sub New(ByVal b As Integer)
		MyBase.New(b)
		' Calls the base class constructor that takes an int
	End Sub
End Class

Public Class BaseClass
	Public Sub New()
		' Default constructor
	End Sub
	Public Sub New(ByVal b As Integer)
		Me.b = b
	End Sub
End Class
Public Class DerivedClass
	Inherits BaseClass

	Public Sub New()
		MyBase.New()
		' Calls the parameterless constructor of the base class
	End Sub
	Public Sub New(ByVal b As Integer)
		MyBase.New(b)
		' Calls the base class constructor that takes an int
	End Sub
End Class

Dans cette configuration, DerivedClass offre de la flexibilité en correspondant aux constructeurs de la classe de base, garantissant que toutes les formes d'initialisation fournies par BaseClass sont accessibles, selon les besoins lors de la création de l'objet.

Introduction de IronPDF

Introduction à IronPDF est une bibliothèque C# conçue pour les développeurs qui ont besoin de créer, lire et modifier des documents PDF au sein des applications .NET. Le principal avantage de l'utilisation d'IronPDF est sa capacité à générer des PDF directement à partir de HTML, CSS, images et JavaScript. La bibliothèque prend en charge une variété de frameworks .NET et est compatible avec de nombreux types de projets, y compris les formulaires web, les applications serveur et les applications console.

IronPDF se spécialise dans la conversion HTML en PDF, préservant avec précision les mises en page et styles originaux. Il est idéal pour générer des PDF à partir de contenu basé sur le web, comme des rapports, des factures et de la documentation. IronPDF permet la conversion de fichiers HTML, d'URLs et de chaînes HTML brutes en 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

Pour démontrer l'utilisation d'IronPDF en C# pour créer un PDF à partir de HTML, vous pouvez utiliser une classe de base qui initialise IronPDF et une classe dérivée qui utilise cette initialisation pour créer un PDF. Voici un exemple de la façon dont vous pouvez structurer ceci en utilisant un constructeur de base :

using IronPdf;

// Base class for PDF generation
public class PdfGenerator
{
    protected ChromePdfRenderer Renderer;

    // Base constructor initializes the HTML to PDF renderer
    public PdfGenerator()
    {
        Renderer = new ChromePdfRenderer();
        // Additional configuration
    }
}

// Derived class uses the base class to generate a specific PDF
public class SpecificPdfGenerator : PdfGenerator
{
    public void CreateSimplePdf(string htmlContent, string filePath)
    {
        // Uses the Renderer from the base class
        var pdfDocument = Renderer.RenderHtmlAsPdf(htmlContent);
        pdfDocument.SaveAs(filePath);
    }
}

// Usage
class Program
{
    static void Main(string[] args)
    {
        License.LicenseKey = "License-Key";
        var htmlContent = "<h1>Hello, IronPDF!</h1>";
        var filePath = "example.pdf";
        var pdfCreator = new SpecificPdfGenerator();
        pdfCreator.CreateSimplePdf(htmlContent, filePath);
    }
}

using IronPdf;

// Base class for PDF generation
public class PdfGenerator
{
    protected ChromePdfRenderer Renderer;

    // Base constructor initializes the HTML to PDF renderer
    public PdfGenerator()
    {
        Renderer = new ChromePdfRenderer();
        // Additional configuration
    }
}

// Derived class uses the base class to generate a specific PDF
public class SpecificPdfGenerator : PdfGenerator
{
    public void CreateSimplePdf(string htmlContent, string filePath)
    {
        // Uses the Renderer from the base class
        var pdfDocument = Renderer.RenderHtmlAsPdf(htmlContent);
        pdfDocument.SaveAs(filePath);
    }
}

// Usage
class Program
{
    static void Main(string[] args)
    {
        License.LicenseKey = "License-Key";
        var htmlContent = "<h1>Hello, IronPDF!</h1>";
        var filePath = "example.pdf";
        var pdfCreator = new SpecificPdfGenerator();
        pdfCreator.CreateSimplePdf(htmlContent, filePath);
    }
}

Imports IronPdf

' Base class for PDF generation
Public Class PdfGenerator
    Protected Renderer As ChromePdfRenderer

    ' Base constructor initializes the HTML to PDF renderer
    Public Sub New()
        Renderer = New ChromePdfRenderer()
        ' Additional configuration
    End Sub
End Class

' Derived class uses the base class to generate a specific PDF
Public Class SpecificPdfGenerator
    Inherits PdfGenerator

    Public Sub CreateSimplePdf(htmlContent As String, filePath As String)
        ' Uses the Renderer from the base class
        Dim pdfDocument = Renderer.RenderHtmlAsPdf(htmlContent)
        pdfDocument.SaveAs(filePath)
    End Sub
End Class

' Usage
Class Program
    Shared Sub Main(args As String())
        License.LicenseKey = "License-Key"
        Dim htmlContent = "<h1>Hello, IronPDF!</h1>"
        Dim filePath = "example.pdf"
        Dim pdfCreator = New SpecificPdfGenerator()
        pdfCreator.CreateSimplePdf(htmlContent, filePath)
    End Sub
End Class

Imports IronPdf

' Base class for PDF generation
Public Class PdfGenerator
    Protected Renderer As ChromePdfRenderer

    ' Base constructor initializes the HTML to PDF renderer
    Public Sub New()
        Renderer = New ChromePdfRenderer()
        ' Additional configuration
    End Sub
End Class

' Derived class uses the base class to generate a specific PDF
Public Class SpecificPdfGenerator
    Inherits PdfGenerator

    Public Sub CreateSimplePdf(htmlContent As String, filePath As String)
        ' Uses the Renderer from the base class
        Dim pdfDocument = Renderer.RenderHtmlAsPdf(htmlContent)
        pdfDocument.SaveAs(filePath)
    End Sub
End Class

' Usage
Class Program
    Shared Sub Main(args As String())
        License.LicenseKey = "License-Key"
        Dim htmlContent = "<h1>Hello, IronPDF!</h1>"
        Dim filePath = "example.pdf"
        Dim pdfCreator = New SpecificPdfGenerator()
        pdfCreator.CreateSimplePdf(htmlContent, filePath)
    End Sub
End Class

Cette structure de code favorise la réutilisabilité et la modularité, facilitant la gestion des différents besoins de génération de PDF au sein d'applications plus larges.

Sortie

Appel du constructeur de base en C# (Comment cela fonctionne pour les développeurs) : Figure 1 - PDF généré à partir de l'exemple de code précédent

Conclusion

Maîtriser la façon dont les constructeurs sont gérés dans une hiérarchie d'héritage en C# permet aux développeurs d'écrire des codes plus fiables et maintenables. En comprenant le rôle du mot-clé base et comment gérer efficacement plusieurs constructeurs et des scénarios spéciaux comme les constructeurs privés et une méthode statique, vous pouvez vous assurer que vos classes sont correctement initialisées dans des hiérarchies d'objets complexes.

Cette compréhension globale est essentielle pour les développeurs, qu'ils soient débutants ou expérimentés, travaillant avec la programmation orientée objet en C#. Licence d'essai pour IronPDF pour les développeurs qui souhaitent tester ses fonctionnalités avant de s'engager dans un achat. Après la période d'essai, si vous décidez que IronPDF correspond à vos besoins, les options de licence commencent à $999.

Jacob Mellor

Discutez maintenant avec l'équipe d'ingénierie

Directeur technique

Jacob Mellor est directeur de la technologie chez Iron Software et un ingénieur visionnaire pionnier de la technologie C# PDF. En tant que développeur à l'origine de la base de code centrale d'Iron Software, il a façonné l'architecture des produits de l'entreprise depuis sa création, la transformant aux côtés du PDG Cameron Rimington en une entreprise de plus de 50 personnes au service de la NASA, de Tesla et d'agences gouvernementales mondiales.

...