Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. csharp-orienté-objet
.NET AIDE

C# Object Oriented (Comment ça fonctionne pour les développeurs)

Curtis Chau
Curtis Chau
Mis à jour:

La programmation orientée objet (POO) est un concept fondamental dans le développement logiciel, permettant aux programmeurs de créer un code modulaire, réutilisable et adaptable. C#, un langage de programmation moderne orienté objet, offre un cadre solide pour construire des applications complexes. Ce guide introduit les concepts de la POO en utilisant C#, en se concentrant sur des implémentations pratiques et des exemples de codage pour aider les débutants à comprendre et à appliquer ces principes efficacement. Nous discuterons également de la manière dont on pourrait appliquer ces principes avec la bibliothèque IronPDF pour C#.

Comprendre les concepts de la programmation orientée objet

Au cœur de la POO, il y a plusieurs concepts clés : classes, objets, héritage, polymorphisme, abstraction et encapsulation. Ces concepts permettent aux développeurs de modéliser des entités du monde réel, de gérer la complexité et d'améliorer la maintenabilité de leur code.

Classes et objets : Les blocs de construction

Une classe crée des objets individuels. La classe est un plan qui définit les données et le comportement que les objets de la classe partagent tous. Un objet est une manifestation d'une classe. Il incarne des valeurs réelles plutôt que des espaces réservés abstraits définis dans le plan de la classe.

public class Car // A class declared as 'Car' defines its structure and behavior.
{
    public string Name;
    public string Color;

    public void DisplayInfo()
    {
        Console.WriteLine($"Name: {Name}, Color: {Color}");
    }
}

class Program // This is the program class, serving as the entry point of a C# program.
{
    static void Main(string[] args)
    {
        Car myCar = new Car();
        myCar.Name = "Toyota";
        myCar.Color = "Red";
        myCar.DisplayInfo();
    }
}
public class Car // A class declared as 'Car' defines its structure and behavior.
{
    public string Name;
    public string Color;

    public void DisplayInfo()
    {
        Console.WriteLine($"Name: {Name}, Color: {Color}");
    }
}

class Program // This is the program class, serving as the entry point of a C# program.
{
    static void Main(string[] args)
    {
        Car myCar = new Car();
        myCar.Name = "Toyota";
        myCar.Color = "Red";
        myCar.DisplayInfo();
    }
}
Public Class Car ' A class declared as 'Car' defines its structure and behavior.
	Public Name As String
	Public Color As String

	Public Sub DisplayInfo()
		Console.WriteLine($"Name: {Name}, Color: {Color}")
	End Sub
End Class

Friend Class Program ' This is the program class, serving as the entry point of a C# program.
	Shared Sub Main(ByVal args() As String)
		Dim myCar As New Car()
		myCar.Name = "Toyota"
		myCar.Color = "Red"
		myCar.DisplayInfo()
	End Sub
End Class
$vbLabelText   $csharpLabel

Dans cet exemple, la classe Car a deux membres de données (Name et Color) et une méthode (DisplayInfo). La méthode Main, qui sert de point d'entrée à l'application, crée une instance de la classe Car et attribue des valeurs à ses champs avant d'appeler sa méthode pour afficher ces valeurs.

POO en C# (Fonctionnalité pour les développeurs) : Figure 1 - La console affiche les valeurs des membres (nom, couleur) de l'objet Car via la méthode DisplayInfo

Héritage : Étendre les classes existantes

L'héritage permet à une classe d'hériter des propriétés et des méthodes d'une classe existante. La classe dont les propriétés sont héritées est appelée la classe de base, et la classe qui hérite de ces propriétés est appelée la classe dérivée.

public class Vehicle
{
    public string LicensePlate;

    public void Honk()
    {
        Console.WriteLine("Honking");
    }
}

public class Truck : Vehicle // Truck is a child class derived from the Vehicle base class.
{
    public int CargoCapacity;
}

class Program
{
    static void Main(string[] args)
    {
        Truck myTruck = new Truck();
        myTruck.LicensePlate = "ABC123";
        myTruck.CargoCapacity = 5000;
        myTruck.Honk();
    }
}
public class Vehicle
{
    public string LicensePlate;

    public void Honk()
    {
        Console.WriteLine("Honking");
    }
}

public class Truck : Vehicle // Truck is a child class derived from the Vehicle base class.
{
    public int CargoCapacity;
}

class Program
{
    static void Main(string[] args)
    {
        Truck myTruck = new Truck();
        myTruck.LicensePlate = "ABC123";
        myTruck.CargoCapacity = 5000;
        myTruck.Honk();
    }
}
Public Class Vehicle
	Public LicensePlate As String

	Public Sub Honk()
		Console.WriteLine("Honking")
	End Sub
End Class

Public Class Truck ' Truck is a child class derived from the Vehicle base class.
	Inherits Vehicle

	Public CargoCapacity As Integer
End Class

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim myTruck As New Truck()
		myTruck.LicensePlate = "ABC123"
		myTruck.CargoCapacity = 5000
		myTruck.Honk()
	End Sub
End Class
$vbLabelText   $csharpLabel

Dans cet exemple, Truck est une classe dérivée qui étend la classe de base Vehicle, héritant son champ LicensePlate et sa méthode Honk tout en ajoutant un nouveau champ, CargoCapacity.

Polymorphisme et abstraction : Interfaces et classes abstraites

Le polymorphisme permet de traiter les objets comme des instances de leur classe de base plutôt que de leur classe spécifique. L'abstraction vous permet de définir des classes abstraites et des interfaces qui ne peuvent pas être instanciées mais peuvent être utilisées comme classes de base.

Classes et méthodes abstraites

Les classes abstraites ne peuvent pas être instanciées et sont généralement utilisées pour fournir une définition commune d'une classe de base que plusieurs classes dérivées peuvent partager.

public abstract class Shape
{
    public abstract void Draw();
}

public class Circle : Shape
{
    public override void Draw()
    {
        Console.WriteLine("Drawing a circle");
    }
}
public abstract class Shape
{
    public abstract void Draw();
}

public class Circle : Shape
{
    public override void Draw()
    {
        Console.WriteLine("Drawing a circle");
    }
}
Public MustInherit Class Shape
	Public MustOverride Sub Draw()
End Class

Public Class Circle
	Inherits Shape

	Public Overrides Sub Draw()
		Console.WriteLine("Drawing a circle")
	End Sub
End Class
$vbLabelText   $csharpLabel

Implémentation de plusieurs interfaces

Une interface établit un accord, ou contrat, que les classes peuvent remplir en implémentant ses méthodes définies. Les classes peuvent implémenter plusieurs interfaces, permettant une forme de polymorphisme.

public interface IDrawable
{
    void Draw();
}

public interface IColorable
{
    void Color();
}

public class CustomShape : IDrawable, IColorable // Defining a new class CustomShape that implements IDrawable and IColorable.
{
    public void Draw()
    {
        Console.WriteLine("Custom shape drawn");
    }

    public void Color()
    {
        Console.WriteLine("Custom shape colored");
    }
}
public interface IDrawable
{
    void Draw();
}

public interface IColorable
{
    void Color();
}

public class CustomShape : IDrawable, IColorable // Defining a new class CustomShape that implements IDrawable and IColorable.
{
    public void Draw()
    {
        Console.WriteLine("Custom shape drawn");
    }

    public void Color()
    {
        Console.WriteLine("Custom shape colored");
    }
}
Public Interface IDrawable
	Sub Draw()
End Interface

Public Interface IColorable
	Sub Color()
End Interface

Public Class CustomShape ' Defining a new class CustomShape that implements IDrawable and IColorable.
	Implements IDrawable, IColorable

	Public Sub Draw() Implements IDrawable.Draw
		Console.WriteLine("Custom shape drawn")
	End Sub

	Public Sub Color() Implements IColorable.Color
		Console.WriteLine("Custom shape colored")
	End Sub
End Class
$vbLabelText   $csharpLabel

Encapsulation : Protéger les données

L'encapsulation est le mécanisme de restriction d'accès à certains composants d'un objet et de prévention des parties externes de voir la représentation interne. Cela est accompli grâce à l'utilisation de modificateurs d'accès.

public class Person
{
    private string name; // Private variable, inaccessible outside the class
    public string Name   // Public property to access the private variable
    {
        get { return name; }
        set { name = value; }
    }
}

// Example showing a simple customer class with encapsulated data
public class Customer
{
    public string Name { get; set; }
    public string Address { get; set; }
}
public class Person
{
    private string name; // Private variable, inaccessible outside the class
    public string Name   // Public property to access the private variable
    {
        get { return name; }
        set { name = value; }
    }
}

// Example showing a simple customer class with encapsulated data
public class Customer
{
    public string Name { get; set; }
    public string Address { get; set; }
}
Public Class Person
'INSTANT VB NOTE: The field name was renamed since Visual Basic does not allow fields to have the same name as other class members:
	Private name_Conflict As String ' Private variable, inaccessible outside the class
	Public Property Name() As String ' Public property to access the private variable
		Get
			Return name_Conflict
		End Get
		Set(ByVal value As String)
			name_Conflict = value
		End Set
	End Property
End Class

' Example showing a simple customer class with encapsulated data
Public Class Customer
	Public Property Name() As String
	Public Property Address() As String
End Class
$vbLabelText   $csharpLabel

Dans cet exemple, le champ name est privé, ce qui le rend inaccessible en dehors de la classe Person. L'accès à ce champ est fourni via la propriété publique Name, qui comprend les méthodes get et set.

Cas d'utilisation pratiques et exemples de codage

Maintenant, nous allons explorer un exemple impliquant plusieurs classes pour démontrer ces principes en action.

using System;

namespace OOPExample
{
    public class Program
    {
        static void Main(string[] args)
        {
            ElectricCar myElectricCar = new ElectricCar();
            myElectricCar.Make = "Tesla";
            myElectricCar.Model = "Model 3";
            myElectricCar.BatteryLevel = 100;
            myElectricCar.Drive();
            myElectricCar.Charge();
        }
    }

    public abstract class Vehicle
    {
        public string Make { get; set; }
        public string Model { get; set; }

        public abstract void Drive();
    }

    public class Car : Vehicle
    {
        public override void Drive()
        {
            Console.WriteLine($"The {Make} {Model} is driving.");
        }
    }

    public class ElectricCar : Car
    {
        public int BatteryLevel { get; set; }

        public void Charge()
        {
            Console.WriteLine("Charging the car.");
        }

        public override void Drive()
        {
            Console.WriteLine($"The {Make} {Model} is driving silently.");
        }
    }
}
using System;

namespace OOPExample
{
    public class Program
    {
        static void Main(string[] args)
        {
            ElectricCar myElectricCar = new ElectricCar();
            myElectricCar.Make = "Tesla";
            myElectricCar.Model = "Model 3";
            myElectricCar.BatteryLevel = 100;
            myElectricCar.Drive();
            myElectricCar.Charge();
        }
    }

    public abstract class Vehicle
    {
        public string Make { get; set; }
        public string Model { get; set; }

        public abstract void Drive();
    }

    public class Car : Vehicle
    {
        public override void Drive()
        {
            Console.WriteLine($"The {Make} {Model} is driving.");
        }
    }

    public class ElectricCar : Car
    {
        public int BatteryLevel { get; set; }

        public void Charge()
        {
            Console.WriteLine("Charging the car.");
        }

        public override void Drive()
        {
            Console.WriteLine($"The {Make} {Model} is driving silently.");
        }
    }
}
Imports System

Namespace OOPExample
	Public Class Program
		Shared Sub Main(ByVal args() As String)
			Dim myElectricCar As New ElectricCar()
			myElectricCar.Make = "Tesla"
			myElectricCar.Model = "Model 3"
			myElectricCar.BatteryLevel = 100
			myElectricCar.Drive()
			myElectricCar.Charge()
		End Sub
	End Class

	Public MustInherit Class Vehicle
		Public Property Make() As String
		Public Property Model() As String

		Public MustOverride Sub Drive()
	End Class

	Public Class Car
		Inherits Vehicle

		Public Overrides Sub Drive()
			Console.WriteLine($"The {Make} {Model} is driving.")
		End Sub
	End Class

	Public Class ElectricCar
		Inherits Car

		Public Property BatteryLevel() As Integer

		Public Sub Charge()
			Console.WriteLine("Charging the car.")
		End Sub

		Public Overrides Sub Drive()
			Console.WriteLine($"The {Make} {Model} is driving silently.")
		End Sub
	End Class
End Namespace
$vbLabelText   $csharpLabel

Dans cet exemple, Drive() est une méthode abstraite de la classe abstraite Vehicle. Car est une classe dérivée qui implémente Drive(), et ElectricCar est un autre niveau dans la hiérarchie, ajoutant de nouvelles fonctionnalités comme BatteryLevel et sa propre implémentation Drive(). Cette structure démontre l'abstraction, l'encapsulation, l'héritage et le polymorphisme travaillant ensemble dans une application C#.

POO en C# (Fonctionnalité pour les développeurs) : Figure 2 - Sortie de la console du code, affichant le résultat de la méthode abstraite drive et de la méthode charge

IronPDF : Bibliothèque PDF C

La bibliothèque IronPDF pour .NET est un outil polyvalent pour les développeurs C#, conçu pour simplifier le processus de création, d'édition et d'extraction de documents PDF dans les applications .NET. IronPDF a la capacité de facilement générer des PDFs à partir de chaînes HTML, d'URL ou de fichiers ASPX, offrant un haut niveau de contrôle sur le processus de création et de manipulation des PDF. De plus, IronPDF prend en charge des fonctionnalités avancées comme l'ajout d'en-têtes et de pieds de page, le filigrane et le cryptage, en faisant une solution complète pour la gestion des PDF dans les applications .NET.

Exemple d'utilisation d'IronPDF avec la POO

Voici un exemple simplifié démontrant l'utilisation de IronPDF dans une application C#, incorporant le mot-clé virtual pour illustrer comment on pourrait étendre la fonctionnalité IronPDF par l'héritage, un concept central de la POO. Supposons que nous ayons une classe de base qui génère un rapport PDF de base et une classe dérivée qui étend cette fonctionnalité pour inclure un en-tête personnalisé :

using IronPdf;

public class BasicReportGenerator
{
    public virtual PdfDocument GenerateReport(string htmlContent)
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        return pdf;
    }
}

public class CustomReportGenerator : BasicReportGenerator
{
    public override PdfDocument GenerateReport(string htmlContent)
    {
        var pdf = base.GenerateReport(htmlContent);
        AddCustomHeader(pdf, "Custom Report Header");
        return pdf;
    }

    private void AddCustomHeader(PdfDocument document, string headerContent)
    {
        // Create text header
        TextHeaderFooter textHeader = new TextHeaderFooter
        {
            CenterText = headerContent,
        };
        document.AddTextHeaders(textHeader);
    }
}

class Program
{
    static void Main(string[] args)
    {
        License.LicenseKey = "License-Key";
        // HTML content for the report
        string htmlContent = "<html><body><h1>Sample Report</h1><p>This is a sample report content.</p></body></html>";

        // Using BasicReportGenerator
        BasicReportGenerator basicReportGenerator = new BasicReportGenerator();
        var basicPdf = basicReportGenerator.GenerateReport(htmlContent);
        basicPdf.SaveAs("basic_report.pdf");

        // Using CustomReportGenerator
        CustomReportGenerator customReportGenerator = new CustomReportGenerator();
        var customPdf = customReportGenerator.GenerateReport(htmlContent);
        customPdf.SaveAs("custom_report.pdf");

        Console.WriteLine("PDF reports generated successfully.");
    }
}
using IronPdf;

public class BasicReportGenerator
{
    public virtual PdfDocument GenerateReport(string htmlContent)
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        return pdf;
    }
}

public class CustomReportGenerator : BasicReportGenerator
{
    public override PdfDocument GenerateReport(string htmlContent)
    {
        var pdf = base.GenerateReport(htmlContent);
        AddCustomHeader(pdf, "Custom Report Header");
        return pdf;
    }

    private void AddCustomHeader(PdfDocument document, string headerContent)
    {
        // Create text header
        TextHeaderFooter textHeader = new TextHeaderFooter
        {
            CenterText = headerContent,
        };
        document.AddTextHeaders(textHeader);
    }
}

class Program
{
    static void Main(string[] args)
    {
        License.LicenseKey = "License-Key";
        // HTML content for the report
        string htmlContent = "<html><body><h1>Sample Report</h1><p>This is a sample report content.</p></body></html>";

        // Using BasicReportGenerator
        BasicReportGenerator basicReportGenerator = new BasicReportGenerator();
        var basicPdf = basicReportGenerator.GenerateReport(htmlContent);
        basicPdf.SaveAs("basic_report.pdf");

        // Using CustomReportGenerator
        CustomReportGenerator customReportGenerator = new CustomReportGenerator();
        var customPdf = customReportGenerator.GenerateReport(htmlContent);
        customPdf.SaveAs("custom_report.pdf");

        Console.WriteLine("PDF reports generated successfully.");
    }
}
Imports IronPdf

Public Class BasicReportGenerator
	Public Overridable Function GenerateReport(ByVal htmlContent As String) As PdfDocument
		Dim renderer = New ChromePdfRenderer()
		Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
		Return pdf
	End Function
End Class

Public Class CustomReportGenerator
	Inherits BasicReportGenerator

	Public Overrides Function GenerateReport(ByVal htmlContent As String) As PdfDocument
		Dim pdf = MyBase.GenerateReport(htmlContent)
		AddCustomHeader(pdf, "Custom Report Header")
		Return pdf
	End Function

	Private Sub AddCustomHeader(ByVal document As PdfDocument, ByVal headerContent As String)
		' Create text header
		Dim textHeader As New TextHeaderFooter With {.CenterText = headerContent}
		document.AddTextHeaders(textHeader)
	End Sub
End Class

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		License.LicenseKey = "License-Key"
		' HTML content for the report
		Dim htmlContent As String = "<html><body><h1>Sample Report</h1><p>This is a sample report content.</p></body></html>"

		' Using BasicReportGenerator
		Dim basicReportGenerator As New BasicReportGenerator()
		Dim basicPdf = basicReportGenerator.GenerateReport(htmlContent)
		basicPdf.SaveAs("basic_report.pdf")

		' Using CustomReportGenerator
		Dim customReportGenerator As New CustomReportGenerator()
		Dim customPdf = customReportGenerator.GenerateReport(htmlContent)
		customPdf.SaveAs("custom_report.pdf")

		Console.WriteLine("PDF reports generated successfully.")
	End Sub
End Class
$vbLabelText   $csharpLabel

Dans cet exemple, BasicReportGenerator a une méthode GenerateReport qui prend du contenu HTML et génère un document PDF en utilisant IronPDF. La classe CustomReportGenerator, qui hérite de BasicReportGenerator, surcharge la méthode GenerateReport pour ajouter un en-tête personnalisé au PDF après qu'il ait été généré par la méthode de base. Voici le rapport personnalisé généré par le code :

POO en C# (Fonctionnalité pour les développeurs) : Figure 3 - Le PDF personnalisé généré à partir de l'exemple de code, illustrant les méthodes de la POO discutées dans l'article

Conclusion

POO en C# (Fonctionnalité pour les développeurs) : Figure 4 - Page de licence IronPDF

En comprenant et en appliquant les principes fondamentaux de la POO, les débutants peuvent faire des pas significatifs vers la maîtrise de C# et le développement de solutions logicielles robustes. L'héritage et le polymorphisme permettent la réutilisation et la flexibilité du code, permettant aux nouvelles classes de se construire sur des structures et des fonctionnalités existantes. L'abstraction et l'encapsulation garantissent que les classes n'exposent que ce qui est nécessaire au monde extérieur, gardant le fonctionnement interne privé et à l'abri d'une utilisation involontaire. Vous pouvez essayer le essai gratuit de IronPDF pour la génération de PDF en C#, disponible à partir de liteLicense.

Questions Fréquemment Posées

Comment puis-je appliquer les principes de la programmation orientée objet en C# ?

En C#, vous pouvez appliquer les principes de la programmation orientée objet en définissant des classes et des objets pour modéliser des entités du monde réel. Utilisez l'héritage pour étendre les classes, le polymorphisme pour permettre la surcharge de méthodes, et l'encapsulation pour protéger les données, créant ainsi un code modulaire et maintenable.

Quel est le rôle de l'abstraction dans la programmation C# ?

L'abstraction en C# permet aux développeurs de simplifier des systèmes complexes en établissant une séparation claire entre des concepts abstraits de haut niveau et des implémentations concrètes. Les classes abstraites et les interfaces sont utilisées pour définir un modèle pour d'autres classes, assurant une structure et un comportement cohérents à travers différentes parties d'une application.

Comment puis-je créer un rapport PDF en utilisant des principes orientés objet en C# ?

Vous pouvez créer un rapport PDF en C# en utilisant la bibliothèque IronPDF, qui vous permet de générer des documents PDF à partir de contenu HTML. En utilisant des principes orientés objet, vous pouvez créer une classe de base pour la génération de rapports et l'étendre avec des fonctionnalités spécifiques, comme l'ajout d'en-têtes ou pieds de page personnalisés, dans des classes dérivées.

Quels sont les avantages de l'utilisation de l'encapsulation en C# ?

L'encapsulation en C# offre l'avantage de protéger les données d'un objet en restreignant l'accès à ses composants internes. Cela est réalisé à l'aide de modificateurs d'accès, qui aident à maintenir l'intégrité des données et à prévenir les interférences non intentionnelles d'autres parties d'un programme.

Comment implémenter le polymorphisme dans une application C# ?

En C#, le polymorphisme peut être implémenté en utilisant la surcharge de méthodes dans des classes dérivées. Cela vous permet de définir des méthodes dans une classe de base et de les surcharger dans des classes dérivées, offrant ainsi une flexibilité et permettant aux objets d'être traités comme des instances de leur classe de base.

Comment puis-je étendre la fonctionnalité d'une bibliothèque PDF en C# ?

Vous pouvez étendre la fonctionnalité d'une bibliothèque PDF comme IronPDF en créant des classes personnalisées qui implémentent des fonctionnalités supplémentaires. Par exemple, vous pouvez créer une classe qui hérite d'une classe de génération de PDF de base et ajouter des méthodes pour personnaliser l'apparence ou le contenu des pages PDF.

Pouvez-vous fournir un exemple de code utilisant l'héritage en C# ?

Un exemple de code d'héritage en C# pourrait impliquer la définition d'une classe de base, `Véhicule`, avec des propriétés comme `Vitesse` et `Carburant`. Une classe dérivée, `Voiture`, pourrait étendre `Véhicule` et ajouter des fonctionnalités spécifiques comme `NombreDePortes`. Cela démontre comment les classes dérivées peuvent hériter et étendre la fonctionnalité des classes de base.

Comment IronPDF s'intègre-t-il avec la programmation orientée objet en C# ?

IronPDF s'intègre avec la programmation orientée objet en C# en permettant aux développeurs de créer des classes qui encapsulent la logique de génération de PDF. Vous pouvez définir des classes de base pour des opérations PDF courantes et les étendre avec des fonctionnalités spécifiques, telles que l'ajout de filigranes ou de formatages personnalisés, en utilisant l'héritage et le polymorphisme.

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