C# orienté objet (Comment ça marche pour les développeurs)

Programmation orientée objet (OOP) est un concept fondamental dans le développement de logiciels, qui permet aux programmeurs de créer un code modulaire, réutilisable et adaptable. C#, un langage de programmation moderne orienté objet, offre un cadre robuste pour la création d'applications complexes. Ce guide présente les concepts de la POO à l'aide de C#, en se concentrant sur des mises en œuvre pratiques et des exemples de codage afin d'aider les débutants à comprendre et à appliquer ces principes de manière efficace. Nous discuterons également de la manière dont ces principes peuvent être appliqués dans les domaines suivants Bibliothèque IronPDF.

Comprendre les concepts de la programmation orientée objet

Au cœur de la POO se trouvent plusieurs concepts clés : les classes, les objets, l'héritage, le polymorphisme, l'abstraction et l'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 éléments constitutifs

Une classe crée des objets individuels. La classe est un modèle qui définit les données et le comportement que les objets de la classe partagent tous. Un objet est une manifestation de la classe. Elle incarne des valeurs réelles plutôt que des paramètres 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 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 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 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

Dans cet exemple, la classe Voiture possède deux membres de données (Nom et Couleur) 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.

Héritage : Extension des 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 classe de base, et la classe qui hérite de ces propriétés est appelée 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

Dans cet exemple, Truck est une classe dérivée qui étend la classe de base Vehicle, héritant de son champ LicensePlate et de 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 permet de définir des classes et des interfaces abstraites qui ne peuvent pas être instanciées mais qui 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

Mise en œuvre d'interfaces multiples

Une interface établit un accord, ou contrat, que les classes peuvent respecter en mettant en œuvre ses méthodes définies. Les classes peuvent implémenter plusieurs interfaces, ce qui permet 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

Encapsulation : Sauvegarde des données

L'encapsulation est le mécanisme qui permet de restreindre l'accès à certains composants d'un objet et d'empêcher les parties externes de voir la représentation interne. Cela se fait par 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

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

Cas d'utilisation pratiques et exemples de codage

Nous allons maintenant explorer un exemple impliquant plusieurs classes afin de 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

Dans cet exemple, Drive() est une méthode abstraite de la classe abstraite Véhicule. Car est une classe dérivée qui implémente Drive(), et ElectricCar est un autre niveau de la hiérarchie, ajoutant de nouvelles caractéristiques comme BatteryLevel et son propre Drive() mise en œuvre. Cette structure démontre que l'abstraction, l'encapsulation, l'héritage et le polymorphisme fonctionnent ensemble dans une application C#.

IronPDF : C&num ; Bibliothèque PDF

IronPDF est une bibliothèque polyvalente pour les développeurs C#, conçue 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 PDF à partir de chaînes HTMLles fichiers PDF peuvent être créés à l'aide d'un ordinateur, d'une adresse URL ou d'un fichier ASPX, ce qui permet de mieux contrôler le processus de création et de manipulation des PDF. En outre, IronPDF prend en charge des fonctions avancées telles que l'ajout d'en-têtes et de pieds de page, le filigrane et le cryptage, ce qui en fait une solution complète pour la gestion des PDF dans les applications .NET.

Exemple d'IronPDF avec OOP

Voici un exemple simplifié de l'utilisation d'IronPDF dans une application C#, avec le mot-clé virtual pour illustrer la manière dont on peut étendre la fonctionnalité d'IronPDF par le biais de l'héritage, un concept fondamental 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

Dans cet exemple, BasicReportGenerator possède une méthode GenerateReport qui prend un contenu HTML et génère un document PDF à l'aide d'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 a été généré par la méthode de base. Voici le rapport personnalisé généré par le code :

Conclusion

En comprenant et en appliquant les principes de base de la POO, les débutants peuvent faire des pas importants 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, en permettant aux nouvelles classes de s'appuyer sur les structures et les fonctionnalités existantes. L'abstraction et l'encapsulation garantissent que les classes n'exposent que ce qui est nécessaire au monde extérieur, en gardant le fonctionnement interne privé et à l'abri d'une utilisation involontaire. Vous pouvez essayer le logiciel IronPDF essai gratuitqui est disponible à partir de $749.