C# Vitrual Vs Abstract (Comment ça marche pour les développeurs)

En C#, méthodes virtuelles peuvent être surchargées dans les classes dérivées, tandis que les méthodes abstraites doivent être surchargées dans les classes dérivées. Cela permet un comportement flexible et permet le polymorphisme dans la programmation orientée objet. Ces deux concepts permettent la flexibilité et la réutilisation dans la programmation orientée objet. Cet article explique les spécificités des méthodes abstraites et virtuelles, en fournissant des exemples clairs et en se concentrant sur leurs utilisations pratiques dans le codage. Nous explorerons également IronPDF plus loin dans l'article.

Classe et méthodes abstraites

Une classe abstraite est un type particulier de classe qui ne peut pas être instanciée directement. Il sert plutôt de modèle pour d'autres classes. Une classe abstraite peut contenir des méthodes abstraites, c'est-à-dire des méthodes déclarées dans la classe abstraite mais qui doivent être implémentées dans les classes dérivées concrètes.

public abstract class Vehicle
{
// abstract method to be implemented in non abstract child class
    public abstract void DisplayInfo();
}

public abstract class Vehicle
{
// abstract method to be implemented in non abstract child class
    public abstract void DisplayInfo();
}

Public MustInherit Class Vehicle
' abstract method to be implemented in non abstract child class
	Public MustOverride Sub DisplayInfo()
End Class

Dans cet exemple, la classe Véhicule est abstraite et DisplayInfo est une méthode abstraite. La méthode DisplayInfo n'est pas implémentée dans la classe Véhicule. Elle oblige la classe dérivée à fournir sa propre définition de cette méthode.

Méthodes virtuelles

Les méthodes virtuelles sont des méthodes d'une classe de base qui ont une implémentation par défaut mais qui peuvent être surchargées dans les classes dérivées. Le mot-clé virtual permet de déclarer une méthode comme étant virtuelle. Les classes dérivées utilisent le mot-clé override pour fournir une implémentation spécifique de la méthode, ce qui permet de comprendre comment une classe enfant peut surcharger une méthode virtuelle de sa classe mère.

// non abstract class
public class Animal
{
    public virtual void Speak()
    {
        Console.WriteLine("Some generic animal sound");
    }
}

// non abstract class
public class Animal
{
    public virtual void Speak()
    {
        Console.WriteLine("Some generic animal sound");
    }
}

' non abstract class
Public Class Animal
	Public Overridable Sub Speak()
		Console.WriteLine("Some generic animal sound")
	End Sub
End Class

Ici, la classe Animal possède une méthode virtuelle Speak avec une implémentation par défaut. Les classes dérivées peuvent surcharger la méthode pour fournir un son d'animal spécifique en utilisant le mot-clé override.

Combinaison de méthodes virtuelles et abstraites

Une classe peut avoir des méthodes abstraites et virtuelles. Les méthodes abstraites n'ont pas d'implémentation et doivent être surchargées dans les classes dérivées, tandis que les méthodes virtuelles ont une implémentation par défaut que les classes dérivées peuvent surcharger facultativement.

Imaginez un scénario dans lequel vous construisez un système qui modélise différents types de véhicules, chacun ayant sa propre façon d'afficher les informations. Voici comment utiliser les méthodes abstraites et virtuelles :

public abstract class Vehicle
{
    // Abstract method
    public abstract void DisplayInfo();
    // Virtual method
    public virtual void StartEngine()
    {
        Console.WriteLine("Engine started with default configuration.");
    }
}

public abstract class Vehicle
{
    // Abstract method
    public abstract void DisplayInfo();
    // Virtual method
    public virtual void StartEngine()
    {
        Console.WriteLine("Engine started with default configuration.");
    }
}

Public MustInherit Class Vehicle
	' Abstract method
	Public MustOverride Sub DisplayInfo()
	' Virtual method
	Public Overridable Sub StartEngine()
		Console.WriteLine("Engine started with default configuration.")
	End Sub
End Class

Dans cette classe Véhicule, DisplayInfo est une méthode abstraite, obligeant toutes les classes dérivées à implémenter leur façon d'afficher les informations. StartEngine, cependant, fournit une méthode par défaut pour démarrer le moteur, qui peut être surchargée par une classe héritée si nécessaire.

Exemple avec les classes dérivées

Définissons maintenant une classe Car, une classe enfant non abstraite, qui hérite de Vehicle et implémente la méthode abstraite tout en surchargeant éventuellement la méthode virtuelle :

public class Car : Vehicle
{
// public override void abstractmethod
    public override void DisplayInfo()
    {
        Console.WriteLine("This is a car.");
    }
    public override void StartEngine()
    {
        Console.WriteLine("Car engine started with custom settings.");
    }
}

public class Car : Vehicle
{
// public override void abstractmethod
    public override void DisplayInfo()
    {
        Console.WriteLine("This is a car.");
    }
    public override void StartEngine()
    {
        Console.WriteLine("Car engine started with custom settings.");
    }
}

Public Class Car
	Inherits Vehicle

' public override void abstractmethod
	Public Overrides Sub DisplayInfo()
		Console.WriteLine("This is a car.")
	End Sub
	Public Overrides Sub StartEngine()
		Console.WriteLine("Car engine started with custom settings.")
	End Sub
End Class

Ici, la classe Car fournit des implémentations spécifiques pour la méthode abstraite DisplayInfo et la méthode virtuelle StartEngine.

Différence et moment d'utilisation

• Utilisez des méthodes abstraites lorsque toutes les classes dérivées doivent fournir leur propre implémentation d'une méthode.

• Utilisez des méthodes virtuelles lorsque les classes dérivées doivent avoir la possibilité de remplacer une valeur par défaut ou de fournir des comportements supplémentaires.

  Les méthodes abstraites et virtuelles sont des fonctionnalités puissantes de C# qui vous permettent d'écrire un code plus facile à maintenir et à réutiliser. En définissant toutes les méthodes d'une classe de base comme abstraites ou virtuelles, vous pouvez déterminer quelles méthodes doivent être remplacées dans les classes dérivées et quelles méthodes peuvent être remplacées facultativement pour modifier ou étendre le comportement par défaut.

Surcharge des méthodes virtuelles

La surcharge des méthodes virtuelles dans les classes dérivées permet d'obtenir un comportement personnalisé tout en conservant la possibilité d'appeler l'implémentation de la classe de base. Pour ce faire, on utilise le mot-clé base.

Exemple de surcharge et d'appel de l'implémentation de base

public class ElectricCar : Car
{
    public override void StartEngine()
    {
        base.StartEngine(); // Call the base class implementation
        Console.WriteLine("Electric car engine started with energy-saving mode.");
    }
}

public class ElectricCar : Car
{
    public override void StartEngine()
    {
        base.StartEngine(); // Call the base class implementation
        Console.WriteLine("Electric car engine started with energy-saving mode.");
    }
}

Public Class ElectricCar
	Inherits Car

	Public Overrides Sub StartEngine()
		MyBase.StartEngine() ' Call the base class implementation
		Console.WriteLine("Electric car engine started with energy-saving mode.")
	End Sub
End Class

Dans cet exemple, ElectricCar, qui est une classe enfant de Car, surcharge la méthode StartEngine héritée de sa classe mère. Il appelle l'implémentation de la classe de base et ajoute un comportement supplémentaire spécifique aux voitures électriques.

Mise en œuvre de classes abstraites et non abstraites

Il est essentiel de comprendre les différences et les applications pratiques des classes abstraites et non abstraites dans le développement de logiciels. Les classes abstraites servent de modèle à d'autres classes, tandis que les classes non abstraites sont utilisées pour instancier des objets. Le choix entre une classe abstraite et une classe non abstraite dépend de la nécessité de créer une classe de base qui ne doit pas être instanciée seule.

IronPDF : C&num ; Bibliothèque PDF

IronPDF est une bibliothèque PDF complète conçue pour générer, éditer et lire des documents PDF directement dans les applications .NET. Cet outil se distingue par sa capacité à créer PDF directement à partir de chaînes HTMLles fichiers HTML et les URL. Les développeurs peuvent créer, modifier et extraire du contenu PDF de manière programmatique dans des projets C#. Examinons un exemple d'IronPDF dans le contexte de notre article.

La principale capacité d'IronPDF est la conversion HTML vers PDFen veillant à ce que les mises en page et les styles soient conservés. Cet outil est excellent pour créer des PDF à partir de contenu web pour des rapports, des factures et de la documentation. Il prend en charge la conversion de fichiers HTML, d'URLs et de chaînes HTML en fichiers 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");
    }
}

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

Exemple de code

Voici un exemple de code réel simple pour illustrer l'utilisation des mots-clés virtual et abstract dans le contexte de l'extension des fonctionnalités d'IronPDF :

public abstract class PdfReportGenerator
{
    // Use abstract method to force derived classes to implement their custom PDF generation logic.
    public abstract void GenerateReport(string filePath);
    // A virtual function allows derived classes to override the default implementation of PDF setup.
    public virtual void SetupPdfGenerator()
    {
        // Default PDF setup logic that can be overridden by derived classes.
        IronPdf.Installation.TempFolderPath = @"F:\TempPdfFiles";
    }
}
public class MonthlyReportGenerator : PdfReportGenerator
{
    // Override abstract method to provide specific implementation using override modifier.
    public override void GenerateReport(string filePath)
    {
        var pdf = new ChromePdfRenderer();
        pdf.RenderHtmlAsPdf("<h1>Monthly Report</h1> <p>Add Your report content here....</p>").SaveAs(filePath);
    }
    // Optionally override the virtual method to customize the setup.
    public override void SetupPdfGenerator()
    {
        base.SetupPdfGenerator();
        // Additional setup logic specific to monthly reports.
        IronPdf.Installation.TempFolderPath = @"F:\MonthlyReports";
    }
}
class Program
{
    static void Main(string [] args)
    {
        License.LicenseKey = "License-Key";
        PdfReportGenerator reportGenerator = new MonthlyReportGenerator();
        reportGenerator.SetupPdfGenerator();
        reportGenerator.GenerateReport(@"F:\MonthlyReports\MonthlyReport.pdf");
        Console.WriteLine("Report generated successfully.");
    }
}

public abstract class PdfReportGenerator
{
    // Use abstract method to force derived classes to implement their custom PDF generation logic.
    public abstract void GenerateReport(string filePath);
    // A virtual function allows derived classes to override the default implementation of PDF setup.
    public virtual void SetupPdfGenerator()
    {
        // Default PDF setup logic that can be overridden by derived classes.
        IronPdf.Installation.TempFolderPath = @"F:\TempPdfFiles";
    }
}
public class MonthlyReportGenerator : PdfReportGenerator
{
    // Override abstract method to provide specific implementation using override modifier.
    public override void GenerateReport(string filePath)
    {
        var pdf = new ChromePdfRenderer();
        pdf.RenderHtmlAsPdf("<h1>Monthly Report</h1> <p>Add Your report content here....</p>").SaveAs(filePath);
    }
    // Optionally override the virtual method to customize the setup.
    public override void SetupPdfGenerator()
    {
        base.SetupPdfGenerator();
        // Additional setup logic specific to monthly reports.
        IronPdf.Installation.TempFolderPath = @"F:\MonthlyReports";
    }
}
class Program
{
    static void Main(string [] args)
    {
        License.LicenseKey = "License-Key";
        PdfReportGenerator reportGenerator = new MonthlyReportGenerator();
        reportGenerator.SetupPdfGenerator();
        reportGenerator.GenerateReport(@"F:\MonthlyReports\MonthlyReport.pdf");
        Console.WriteLine("Report generated successfully.");
    }
}

Public MustInherit Class PdfReportGenerator
	' Use abstract method to force derived classes to implement their custom PDF generation logic.
	Public MustOverride Sub GenerateReport(ByVal filePath As String)
	' A virtual function allows derived classes to override the default implementation of PDF setup.
	Public Overridable Sub SetupPdfGenerator()
		' Default PDF setup logic that can be overridden by derived classes.
		IronPdf.Installation.TempFolderPath = "F:\TempPdfFiles"
	End Sub
End Class
Public Class MonthlyReportGenerator
	Inherits PdfReportGenerator

	' Override abstract method to provide specific implementation using override modifier.
	Public Overrides Sub GenerateReport(ByVal filePath As String)
		Dim pdf = New ChromePdfRenderer()
		pdf.RenderHtmlAsPdf("<h1>Monthly Report</h1> <p>Add Your report content here....</p>").SaveAs(filePath)
	End Sub
	' Optionally override the virtual method to customize the setup.
	Public Overrides Sub SetupPdfGenerator()
		MyBase.SetupPdfGenerator()
		' Additional setup logic specific to monthly reports.
		IronPdf.Installation.TempFolderPath = "F:\MonthlyReports"
	End Sub
End Class
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		License.LicenseKey = "License-Key"
		Dim reportGenerator As PdfReportGenerator = New MonthlyReportGenerator()
		reportGenerator.SetupPdfGenerator()
		reportGenerator.GenerateReport("F:\MonthlyReports\MonthlyReport.pdf")
		Console.WriteLine("Report generated successfully.")
	End Sub
End Class

Dans cet exemple de mise en œuvre personnalisée, PdfReportGenerator est une classe abstraite définissant un contrat pour la génération de rapports PDF avec une méthode pour générer le rapport et une méthode virtuelle pour la configuration qui peut être optionnellement surchargée. MonthlyReportGenerator est une implémentation concrète qui fournit les spécificités de la génération d'un rapport mensuel et personnalise la configuration en surchargeant la méthode virtuelle.

Conclusion

Comprendre et utiliser efficacement les méthodes virtuelles et abstraites peut améliorer considérablement votre programmation C#. N'oubliez pas que les méthodes abstraites exigent qu'une classe dérivée fournisse une implémentation, tandis que les méthodes virtuelles permettent une surcharge optionnelle d'une implémentation par défaut. La bibliothèque IronPDF offre un service de essai gratuitles licences sont proposées à partir de 749 $, ce qui constitue une solution complète pour vos besoins en matière de PDF.