L'héritage en C# (Comment ça marche pour les développeurs)

Introduction

L'une des principales caractéristiques de C#,Héritageest bien connue pour son soutien important à la programmation orientée objet(OOP) principes. Il est essentiel pour écrire un code évolutif et efficace. Ce billet explore le thème de l'héritage en C# en mettant l'accent sur les utilisations réelles de l'héritage en C#Bibliothèque IronPDFune bibliothèque puissante qui facilite la manipulation des PDF dans les programmes C#.

Comment utiliser C# ; Héritage

1. Créer un nouveau projet de console C#

2. Créer une classe de base avec quelques méthodes.

3. Écrire une nouvelle classe dérivée et hériter d'une classe.

4. Appeler la fonction/méthode disponible dans une classe de base.

5. Traiter l'opération et éliminer l'objet.

Héritage dans les C#; : Une vue d'ensemble

Une idée clé de la programmation orientée objet(OOP) est l'héritage, qui permet à une classe(la classe dérivée ou la sous-classe) prendre des traits et des caractéristiques d'une autre classe(la classe de base ou superclasse). En C#, l'héritage est réalisé en plaçant le nom de la classe de base après le :(côlon) symbole.

Héritage unique

Une classe peut hériter d'une seule classe de base en C# puisqu'un seul héritage est pris en charge. Lorsque vous souhaitez qu'une classe dérivée augmente les capacités d'une classe de base unique, vous utilisez le type d'héritage le plus élémentaire : l'héritage composé.

class Animal { /* Base/ Parent class */ }
class Dog : Animal { /* Derived class */ }

class Animal { /* Base/ Parent class */ }
class Dog : Animal { /* Derived class */ }

Friend Class Animal
End Class
Friend Class Dog
	Inherits Animal

End Class

Héritage hiérarchique

Plusieurs classes qui partagent une classe de base sont héritées par celles-ci dans un schéma d'héritage hiérarchique. Il s'agit d'une classe à base unique héritée par plusieurs classes dérivées. Il peut y avoir d'autres caractéristiques propres à chaque classe dérivée en fonction de son objectif.

class Animal { /* Base class */ }
class Dog : Animal { /* Derived class */ }
class Wolf : Animal { /* Derived class */ }

class Animal { /* Base class */ }
class Dog : Animal { /* Derived class */ }
class Wolf : Animal { /* Derived class */ }

Friend Class Animal
End Class
Friend Class Dog
	Inherits Animal

End Class
Friend Class Wolf
	Inherits Animal

End Class

Héritage à plusieurs niveaux

Une classe fonctionne à la fois comme classe de base et comme classe dérivée dans le cadre de l'héritage à plusieurs niveaux. Il en résulte une chaîne d'héritage, chaque classe développant les caractéristiques de la précédente.

class Animal { /* Base class */ }
class Mammal : Animal { /* Derived class */ }
class Dog : Mammal { /* Derived class  */ }

class Animal { /* Base class */ }
class Mammal : Animal { /* Derived class */ }
class Dog : Mammal { /* Derived class  */ }

Friend Class Animal
End Class
Friend Class Mammal
	Inherits Animal

End Class
Friend Class Dog
	Inherits Mammal

End Class

Héritage d'interface

En C#, une classe peut mettre en œuvre une ou plusieurs interfaces et hériter d'une seule classe de base. Cela permet à une classe d'hériter de l'implémentation des méthodes décrites dans les interfaces, réalisant ainsi un type d'héritage multiple.

interface ILogger
{
    void Log(string message);
}
class ConsoleLogger : ILogger //child class
{
    public void Log(string message)
    {
        Console.WriteLine(message);
    }
}
class FileLogger : ILogger
{
    public void Log(string message)
    {
        // Log to file
    }
}

interface ILogger
{
    void Log(string message);
}
class ConsoleLogger : ILogger //child class
{
    public void Log(string message)
    {
        Console.WriteLine(message);
    }
}
class FileLogger : ILogger
{
    public void Log(string message)
    {
        // Log to file
    }
}

Friend Interface ILogger
	Sub Log(ByVal message As String)
End Interface
Friend Class ConsoleLogger 'child class
	Implements ILogger

	Public Sub Log(ByVal message As String) Implements ILogger.Log
		Console.WriteLine(message)
	End Sub
End Class
Friend Class FileLogger
	Implements ILogger

	Public Sub Log(ByVal message As String) Implements ILogger.Log
		' Log to file
	End Sub
End Class

Classes et méthodes abstraites

En C#, une classe abstraite sert de classe de base pour d'autres classes et ne peut être créée seule. Le rôle d'une classe abstraite est de donner à ses classes dérivées une interface commune et un ensemble de fonctions. Elle agit comme un modèle qui décrit les attributs et les méthodes que les classes descendantes doivent mettre en œuvre. Les interfaces sont une fonctionnalité offerte par C#. Un type d'héritage multiple est essentiellement rendu possible par les interfaces, qui permettent à une classe de mettre en œuvre de nombreux contrats.

Une ou plusieurs méthodes abstraites peuvent être définies pour une classe de base à l'aide de classes abstraites. Par la suite, ces méthodes abstraites doivent être mises en œuvre concrètement par des classes dérivées.

abstract class Shape
{
    public abstract double Area(); // Abstract method
}
class Square : Shape
{
    public double Radius { get; set; }
    public override double Area()
    {
        return Math.PI * Math.Pow(Radius, 2);
    }
}

abstract class Shape
{
    public abstract double Area(); // Abstract method
}
class Square : Shape
{
    public double Radius { get; set; }
    public override double Area()
    {
        return Math.PI * Math.Pow(Radius, 2);
    }
}

Friend MustInherit Class Shape
	Public MustOverride Function Area() As Double ' Abstract method
End Class
Friend Class Square
	Inherits Shape

	Public Property Radius() As Double
	Public Overrides Function Area() As Double
		Return Math.PI * Math.Pow(Radius, 2)
	End Function
End Class

Il ne s'agit là que de quelques applications de l'héritage en C#. Le degré de flexibilité souhaité dans la base de code, les connexions entre les classes et les objectifs de conception influencent tous la méthode choisie.

IronPDF

La bibliothèque .NETIronPDF permet aux programmeurs de créer, d'éditer et de modifier des documents PDF à l'aide du langage C#. Une variété d'outils et de capacités sont fournis par la bibliothèque IronPDF pour permettre diverses tâches avec des fichiers PDF, telles que la génération de PDF à partir de HTML, la conversion de HTML en PDF, la fusion ou la division de documents PDF, et l'ajout de texte, d'images et d'annotations à des PDF existants. Pour en savoir plus sur IronPDF, veuillez vous référer à la page d'accueil du siteDocumentation IronPDF.

Installer IronPDF

Acquérir la bibliothèque IronPDF ; le prochain correctif l'exige. Pour ce faire, entrez le code suivant dans le gestionnaire de paquets :

Install-Package IronPDF 
//or 
dotnet add package IronPdf

Une autre option consiste à rechercher le paquetage "IronPDF" à l'aide du gestionnaire de paquets NuGet. Parmi tous les paquets NuGet liés à IronPDF, nous pouvons sélectionner et télécharger le paquet requis à partir de cette liste.

IronPDF dans les classes héritées

Une bibliothèque riche en fonctionnalités appelée IronPDF a été créée pour faciliter le travail avec des documents PDF en C#. En intégrant IronPDF aux classes héritées, vous pouvez améliorer la fonctionnalité de votre application et créer, manipuler et multiplier les PDF en toute simplicité.

Les avantages de l'héritage avec IronPDF

• Organisation du code : En établissant une hiérarchie entre les classes, l'héritage favorise l'organisation du code. Vous pouvez créer des classes spécialement destinées à la gestion des PDF grâce à l'intégration d'IronPDF, tout en conservant une base de code propre et bien organisée.

• Réutilisation du code : Les classes qui héritent de leurs classes de base permettent de réutiliser le code. Ceci est particulièrement utile si vous utilisez une bibliothèque telle qu'IronPDF, car elle vous permet d'encapsuler les fonctions communes liées au PDF dans une classe de base que vous pouvez réutiliser dans d'autres domaines de votre application.

  Pour étendre les capacités de PdfDocument, en particulier pour l'intégration d'IronPDF, créons une classe nommée IronPdfDocument :

using IronPdf;
public class IronPdfDocument : PdfDocument
{
    // Additional properties or methods specific to IronPDF can be added here
    public void ConvertToPdf()
    {
        // Code to convert the HTML to PDF using IronPDF
           var Renderer = new IronPdf.HtmlToPdf();
           var PDF = Renderer.RenderHtmlAsPdf("<h1>Hello, World</h1>");
           PDF.SaveAs("Output.pdf");
    }
}

using IronPdf;
public class IronPdfDocument : PdfDocument
{
    // Additional properties or methods specific to IronPDF can be added here
    public void ConvertToPdf()
    {
        // Code to convert the HTML to PDF using IronPDF
           var Renderer = new IronPdf.HtmlToPdf();
           var PDF = Renderer.RenderHtmlAsPdf("<h1>Hello, World</h1>");
           PDF.SaveAs("Output.pdf");
    }
}

Imports IronPdf
Public Class IronPdfDocument
	Inherits PdfDocument

	' Additional properties or methods specific to IronPDF can be added here
	Public Sub ConvertToPdf()
		' Code to convert the HTML to PDF using IronPDF
		   Dim Renderer = New IronPdf.HtmlToPdf()
		   Dim PDF = Renderer.RenderHtmlAsPdf("<h1>Hello, World</h1>")
		   PDF.SaveAs("Output.pdf")
	End Sub
End Class

IronPdfDocument est un exemple amélioré qui dérive de PdfDocument. Cette classe est conçue pour fonctionner facilement avec IronPDF ; vous pouvez utiliser certains attributs ou méthodes pour gérer facilement les fonctionnalités liées aux PDF. Pour en savoir plus sur les fonctionnalités d'IronPDF, reportez-vous à la rubriquePage des fonctionnalités d'IronPDF.

Création d'un générateur de rapports PDF

Mettons ces idées en pratique en utilisant l'héritage et IronPDF pour créer un générateur de rapports PDF de base. Tout d'abord, nous allons travailler avec la classe de base Report :

public class Report
{
    public virtual void GenerateReport()
    {
                var Renderer = new IronPdf.HtmlToPdf();
                var PDF = Renderer.RenderHtmlAsPdf("<h1>Hello, World</h1>");
                PDF.SaveAs("Output.pdf");
    }
}

public class Report
{
    public virtual void GenerateReport()
    {
                var Renderer = new IronPdf.HtmlToPdf();
                var PDF = Renderer.RenderHtmlAsPdf("<h1>Hello, World</h1>");
                PDF.SaveAs("Output.pdf");
    }
}

Public Class Report
	Public Overridable Sub GenerateReport()
				Dim Renderer = New IronPdf.HtmlToPdf()
				Dim PDF = Renderer.RenderHtmlAsPdf("<h1>Hello, World</h1>")
				PDF.SaveAs("Output.pdf")
	End Sub
End Class

Construisons maintenant PdfReport, une classe dérivée qui ajoute des fonctionnalités IronPDF et hérite de la classe de base :

public class PdfReport : Report
{
    public override void GenerateReport()
    {
        var Renderer = new IronPdf.HtmlToPdf();
        var PDF = Renderer.RenderHtmlAsPdf("<h1>Hello, IronPDF</h1>");
        PDF.SaveAs("Output.pdf");
        Console.WriteLine("Generating PDF report...");
        // Additional code specific to PDF generation using IronPDF
    }
}

public class PdfReport : Report
{
    public override void GenerateReport()
    {
        var Renderer = new IronPdf.HtmlToPdf();
        var PDF = Renderer.RenderHtmlAsPdf("<h1>Hello, IronPDF</h1>");
        PDF.SaveAs("Output.pdf");
        Console.WriteLine("Generating PDF report...");
        // Additional code specific to PDF generation using IronPDF
    }
}

Public Class PdfReport
	Inherits Report

	Public Overrides Sub GenerateReport()
		Dim Renderer = New IronPdf.HtmlToPdf()
		Dim PDF = Renderer.RenderHtmlAsPdf("<h1>Hello, IronPDF</h1>")
		PDF.SaveAs("Output.pdf")
		Console.WriteLine("Generating PDF report...")
		' Additional code specific to PDF generation using IronPDF
	End Sub
End Class

L'exemple ci-dessus montre que la propriété Title et la fonction GenerateReport sont héritées par PdfReport de la classe existante qui est la classe de base Report dans cet exemple. Il ajoute une nouvelle propriété appelée Author et remplace la fonction GenerateReport par une logique personnalisée pour la génération de rapports PDF basée sur IronPDF. Vous trouverez ci-dessous le PDF généré par le code.

Pour en savoir plus sur le code permettant de convertir une chaîne HTML en PDF, reportez-vous à la sectionExemple de traduction de HTML en PDF.

Conclusion

Lorsqu'elle est associée à des bibliothèques telles queIronPDFl'héritage est une fonctionnalité puissante qui améliore le processus de développement des applications. Les fondements de l'héritage ont été abordés dans ce billet, ainsi qu'un mode d'emploi utile pour intégrer l'idée à IronPDF.

Le développement de structures de classes hiérarchiques permet d'obtenir une base de code modulaire et bien structurée. Lorsque vous développez des classes qui héritent des capacités générales de leurs classes de base mais qui s'adaptent à des tâches spécifiques, les avantages de l'extension et de la réutilisation du code deviennent évidents. Ces avantages sont accrus lorsqu'IronPDF est intégré, offrant une solution transparente pour la gestion des documents PDF dans vos applications C#.

Le pack léger $749 d'IronPDF incorpore un permis super durable, des choix de refonte, et une période prolongée d'assistance à la programmation. Pendant la période d'essai en filigrane, les clients peuvent évaluer le produit dans des conditions d'application réelles. Pour en savoir plus sur les tarifs, les licences et la version d'essai d'IronPDF, veuillez consulter le site Web de l'entreprisePage de licences IronPDF. Visitez le site officielSite web d'Iron Software pour vous familiariser avec d'autres produits d'Iron Software.