AIDE .NET

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

Name: IronPDF
Brand: Iron Software
Availability: InStock
Rating: 4.87 (307 reviews)

Jordi Bardia

avril 29, 2024

C# offre une fonctionnalité unique qui améliore l'organisation et la gestion du code dans les grands projets : le mot-clé partiel class. Cette fonctionnalité, accessible via le modificateur partial, permet aux développeurs de répartir la définition d'une classe, d'une interface ou d'une structure sur plusieurs fichiers. Cette capacité est particulièrement utile pour travailler avec du code source déjà généré, tel que des définitions de contrôle d'interface utilisateur ou du code d'enveloppe de service, parallèlement à une logique d'entreprise personnalisée. Dans cet article, nous allons nous intéresser aux classes partielles et à la fonctionIronPDF PDF Library for .NET (Bibliothèque PDF IronPDF pour .NET) en utilisant Visual Studio.

Comprendre la classe partielle

Une classe partielle, conservant le même niveau d'accessibilité, est définie avec le modificateur partial en C#, indiquant que la définition de la classe est répartie sur deux fichiers ou plus au sein du même assemblage. Cette approche permet de conserver le code apparenté ensemble tout en maintenant la séparation des préoccupations. Par exemple, une classe partielle Employé peut avoir sa logique commerciale dans un fichier et sa couche d'accès aux données dans un autre, mais les deux parties sont compilées dans une classe unique. Cette séparation rend non seulement le code plus facile à gérer, mais permet également à plusieurs développeurs de travailler sur la même classe sans conflit.

// File 1: Employee_BusinessLogic.cs
public partial class Employee
{
    public void CalculatePay() { /* Implementation */ }
}
// File 2: Employee_DataAccess.cs
public partial class Employee
{
    public void Load() { /* Implementation */ }
}

// File 1: Employee_BusinessLogic.cs
public partial class Employee
{
    public void CalculatePay() { /* Implementation */ }
}
// File 2: Employee_DataAccess.cs
public partial class Employee
{
    public void Load() { /* Implementation */ }
}

' File 1: Employee_BusinessLogic.cs
Partial Public Class Employee
	Public Sub CalculatePay()
	End Sub
End Class
' File 2: Employee_DataAccess.cs
Partial Public Class Employee
	Public Sub Load()
	End Sub
End Class

Exploiter les méthodes partielles

Les classes partielles peuvent également définir des méthodes partielles, qui sont facultatives ou même déclarées abstraites, ce qui permet des stratégies de mise en œuvre plus souples. Ces méthodes permettent un scénario intéressant dans lequel une partie de la classe peut déclarer une méthode sans l'implémenter, ce qui permet à une autre partie de la classe de l'implémenter. Si aucune implémentation n'est fournie, l'appel partiel à la méthode est supprimé au moment de la compilation, ce qui n'entraîne aucune pénalité en termes de performances.

// File 1: Employee_BusinessLogic.cs
public partial class Employee
{
    partial void OnPayCalculated(double amount);
    public void CalculatePay()
    {
        double amount = 1000; // Simplified calculation
        OnPayCalculated(amount);
    }
}
// File 2: Employee_Events.cs
public partial class Employee
{
    partial void OnPayCalculated(double amount)
    {
        Console.WriteLine($"Pay calculated: {amount}");
    }
}

// File 1: Employee_BusinessLogic.cs
public partial class Employee
{
    partial void OnPayCalculated(double amount);
    public void CalculatePay()
    {
        double amount = 1000; // Simplified calculation
        OnPayCalculated(amount);
    }
}
// File 2: Employee_Events.cs
public partial class Employee
{
    partial void OnPayCalculated(double amount)
    {
        Console.WriteLine($"Pay calculated: {amount}");
    }
}

' File 1: Employee_BusinessLogic.cs
Partial Public Class Employee
	Partial Private Sub OnPayCalculated(ByVal amount As Double)
	End Sub
	Public Sub CalculatePay()
		Dim amount As Double = 1000 ' Simplified calculation
		OnPayCalculated(amount)
	End Sub
End Class
' File 2: Employee_Events.cs
Partial Public Class Employee
	Private Sub OnPayCalculated(ByVal amount As Double)
		Console.WriteLine($"Pay calculated: {amount}")
	End Sub
End Class

Utilisation avancée des méthodes partielles

Les méthodes partielles, qui incarnent une approche de définition partielle, sont une caractéristique spéciale des classes partielles qui permettent une déclaration dans une partie de la classe partielle et une implémentation optionnelle dans une autre. Cette fonctionnalité est particulièrement utile pour fournir des crochets dans le code généré qui peuvent être optionnellement mis en œuvre par le développeur. Le mot clé partiel est crucial ici, car il signifie que la méthode peut ou non avoir une implémentation.

Prenons l'exemple d'un composant d'interface utilisateur qui doit effectuer une action avant le chargement d'un contrôle de l'interface utilisateur. La méthode partielle offre un moyen propre d'insérer une logique commerciale personnalisée sans encombrer le code généré automatiquement.

// File: UIControls_AutoGenerated.cs
public partial class UIControls
{
    partial void OnControlLoading();
    public void LoadControl()
    {
        OnControlLoading();
        // Auto-generated loading logic here
    }
}
// File: UIControls_CustomLogic.cs
public partial class UIControls
{
    partial void OnControlLoading()
    {
        // Custom business logic code here
        Console.WriteLine("Custom control loading logic executed.");
    }
}

// File: UIControls_AutoGenerated.cs
public partial class UIControls
{
    partial void OnControlLoading();
    public void LoadControl()
    {
        OnControlLoading();
        // Auto-generated loading logic here
    }
}
// File: UIControls_CustomLogic.cs
public partial class UIControls
{
    partial void OnControlLoading()
    {
        // Custom business logic code here
        Console.WriteLine("Custom control loading logic executed.");
    }
}

' File: UIControls_AutoGenerated.cs
Partial Public Class UIControls
	Partial Private Sub OnControlLoading()
	End Sub
	Public Sub LoadControl()
		OnControlLoading()
		' Auto-generated loading logic here
	End Sub
End Class
' File: UIControls_CustomLogic.cs
Partial Public Class UIControls
	Private Sub OnControlLoading()
		' Custom business logic code here
		Console.WriteLine("Custom control loading logic executed.")
	End Sub
End Class

Intégration de la logique d'entreprise dans les classes partielles

La logique d'entreprise nécessite souvent des modifications et des extensions au-delà de ce qui est généré automatiquement, en particulier dans les applications comportant des règles ou des comportements complexes. Les classes partielles permettent d'inclure la logique métier dans un fichier source distinct sans modifier l'interface utilisateur générée automatiquement ou le code d'accès aux données. Cette séparation garantit que la logique d'entreprise est facilement accessible et modifiable par les développeurs, ce qui améliore la collaboration, en particulier lorsque plusieurs développeurs travaillent sur le projet.

// File: Employee_AutoGenerated.cs
public partial class Employee
{
    // Auto-generated properties and methods
}
// File: Employee_BusinessLogic.cs
public partial class Employee
{
    public void Promote()
    {
        // Business logic code to promote an employee
        Console.WriteLine("Employee promoted.");
    }
}

// File: Employee_AutoGenerated.cs
public partial class Employee
{
    // Auto-generated properties and methods
}
// File: Employee_BusinessLogic.cs
public partial class Employee
{
    public void Promote()
    {
        // Business logic code to promote an employee
        Console.WriteLine("Employee promoted.");
    }
}

' File: Employee_AutoGenerated.cs
Partial Public Class Employee
	' Auto-generated properties and methods
End Class
' File: Employee_BusinessLogic.cs
Partial Public Class Employee
	Public Sub Promote()
		' Business logic code to promote an employee
		Console.WriteLine("Employee promoted.")
	End Sub
End Class

Emboîtement de types partiels

Les types partiels imbriqués étendent le concept de classes partielles aux classes imbriquées, ce qui permet de définir les parties d'une classe imbriquée dans des fichiers distincts. Cela peut être particulièrement utile pour organiser de grandes structures imbriquées, telles que la définition d'un contrôle d'interface utilisateur complexe qui comprend plusieurs types imbriqués pour gérer les différents aspects du comportement du contrôle.

// File: ComplexControl_Part1.cs
public partial class ComplexControl
{
    public partial class NestedControl
    {
        public void Initialize() { /* Initialization code here */ }
    }
}
// File: ComplexControl_Part2.cs
public partial class ComplexControl
{
    public partial class NestedControl
    {
        public void Cleanup() { /* Cleanup code here */ }
    }
}

// File: ComplexControl_Part1.cs
public partial class ComplexControl
{
    public partial class NestedControl
    {
        public void Initialize() { /* Initialization code here */ }
    }
}
// File: ComplexControl_Part2.cs
public partial class ComplexControl
{
    public partial class NestedControl
    {
        public void Cleanup() { /* Cleanup code here */ }
    }
}

' File: ComplexControl_Part1.cs
Partial Public Class ComplexControl
	Partial Public Class NestedControl
		Public Sub Initialize()
		End Sub
	End Class
End Class
' File: ComplexControl_Part2.cs
Partial Public Class ComplexControl
	Partial Public Class NestedControl
		Public Sub Cleanup()
		End Sub
	End Class
End Class

Applications pratiques

Les classes partielles sont particulièrement utiles dans les scénarios impliquant un code source généré automatiquement, comme les formulaires, où Visual Studio crée des formulaires Windows. Cette configuration permet aux développeurs de séparer le code de conception de l'interface utilisateur dans un fichier source distinct, ce qui leur permet d'étendre ou de modifier la classe sans affecter la conception originale de l'interface utilisateur.

Dans les applications web, les classes partielles facilitent la séparation du code de l'enveloppe du service web généré et de la logique commerciale personnalisée, garantissant que les mises à jour des services web n'écrasent pas les modifications personnalisées. De même, dans les applications utilisant LINQ to SQL, les fichiers dbml génèrent des définitions de classes partielles qui peuvent être étendues pour inclure des fonctionnalités supplémentaires ou une logique d'entreprise sans toucher au code généré automatiquement.

// Auto-generated UI class
public partial class MainForm : Form
{
    // Designer code
}
// Custom logic for MainForm
public partial class MainForm
{
    // Custom event handlers and methods
}

// Auto-generated UI class
public partial class MainForm : Form
{
    // Designer code
}
// Custom logic for MainForm
public partial class MainForm
{
    // Custom event handlers and methods
}

' Auto-generated UI class
Partial Public Class MainForm
	Inherits Form

	' Designer code
End Class
' Custom logic for MainForm
Partial Public Class MainForm
	Inherits Form

	' Custom event handlers and methods
End Class

IronPDF : Bibliothèque PDF C

C# partiel (Comment ça marche pour les développeurs) : Figure 1 - IronPDF

IronPDF est une bibliothèque complète pour .NET qui permet aux développeurs de créer, lire et modifier des documents PDF dans leurs applications. Il fournit une approche simple pourgénérer des PDF à partir de HTML à l'aide d'IronPDFil s'agit donc d'un outil polyvalent pour la création de rapports, de documents et l'archivage de contenu Web. IronPDF se distingue par sa facilité d'utilisation, ne nécessitant qu'une configuration minimale pour s'intégrer à n'importe quel projet .NET, y compris les applications développées en C#.

Intégration d'IronPDF avec des classes partielles

Pour illustrer l'intégration d'IronPDF avec les classes partielles, considérons un exemple où nous avons une application web qui génère des rapports au format PDF. Nous répartirons la fonctionnalité dans des fichiers de classe partiels afin de séparer notre logique commerciale de notre logique de génération de PDF.

Configuration d'IronPDF

Tout d'abord, assurez-vous qu'IronPDF est ajouté à votre projet. Cela peut être fait via le gestionnaire de paquets NuGet avec la commande :

Install-Package IronPdf

Création de la classe partielle pour la génération de rapports

Nous diviserons notre classe en deux parties : l'une pour la logique commerciale liée aux données du rapport et l'autre pour la génération de PDF à l'aide d'IronPDF.

Fichier 1 : ReportGenerator_BusinessLogic.cs

Ce fichier contient la logique de gestion permettant de préparer les données pour le rapport.

public partial class ReportGenerator
{
    public IEnumerable<string> GetDataForReport()
    {
        // Imagine this method fetches and prepares data for the report
        return new List<string> { "Data1", "Data2", "Data3" };
    }
}

public partial class ReportGenerator
{
    public IEnumerable<string> GetDataForReport()
    {
        // Imagine this method fetches and prepares data for the report
        return new List<string> { "Data1", "Data2", "Data3" };
    }
}

Partial Public Class ReportGenerator
	Public Function GetDataForReport() As IEnumerable(Of String)
		' Imagine this method fetches and prepares data for the report
		Return New List(Of String) From {"Data1", "Data2", "Data3"}
	End Function
End Class

Fichier 2 : ReportGenerator_PdfGeneration.cs

Ce fichier utilise IronPDF pour générer un rapport PDF à partir des données préparées.

public partial class ReportGenerator
{
    public void GeneratePdfReport()
    {
        var renderer = new IronPdf.ChromePdfRenderer();
        var data = GetDataForReport();
        var htmlContent = $"<html><body><h1>Report</h1><p>{string.Join("</p><p>", data)}</p></body></html>";
        // Generate PDF from HTML string
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        // Save the PDF to a file
        pdf.SaveAs("Report.pdf");
        Console.WriteLine("Report generated successfully.");
    }
}

public partial class ReportGenerator
{
    public void GeneratePdfReport()
    {
        var renderer = new IronPdf.ChromePdfRenderer();
        var data = GetDataForReport();
        var htmlContent = $"<html><body><h1>Report</h1><p>{string.Join("</p><p>", data)}</p></body></html>";
        // Generate PDF from HTML string
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        // Save the PDF to a file
        pdf.SaveAs("Report.pdf");
        Console.WriteLine("Report generated successfully.");
    }
}

Partial Public Class ReportGenerator
	Public Sub GeneratePdfReport()
		Dim renderer = New IronPdf.ChromePdfRenderer()
		Dim data = GetDataForReport()
		Dim htmlContent = $"<html><body><h1>Report</h1><p>{String.Join("</p><p>", data)}</p></body></html>"
		' Generate PDF from HTML string
		Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
		' Save the PDF to a file
		pdf.SaveAs("Report.pdf")
		Console.WriteLine("Report generated successfully.")
	End Sub
End Class

Utilisation

Avec la configuration de la classe partielle, la génération d'un rapport PDF devient une question d'invocation de la méthode GeneratePdfReport sur une instance de la classe ReportGenerator.

var reportGenerator = new ReportGenerator();
reportGenerator.GeneratePdfReport();

var reportGenerator = new ReportGenerator();
reportGenerator.GeneratePdfReport();

Dim reportGenerator As New ReportGenerator()
reportGenerator.GeneratePdfReport()

C# partiel (Comment ça marche pour les développeurs) : Figure 2 - Sortie du rapport PDF

Conclusion

C# partiel (Comment ça marche pour les développeurs) : Figure 3 - Licences

L'utilisation de classes partielles, de méthodes partielles et de types partiels imbriqués en C# offre aux développeurs un outil flexible et puissant pour l'organisation et la gestion du code. En séparant le code généré automatiquement de la logique commerciale, des définitions de contrôle de l'interface utilisateur et d'autres parties de l'application, les développeurs peuvent créer des applications plus faciles à maintenir, plus lisibles et plus évolutives.

En séparant les préoccupations liées à la logique commerciale et au traitement des PDF, les développeurs peuvent améliorer l'organisation du code, la maintenabilité et l'évolutivité. Les fonctionnalités robustes d'IronPDF combinées aux avantages organisationnels des classes partielles créent un ensemble d'outils puissants pour les développeurs .NET qui travaillent avec des PDF dans leurs projets. Vous pouvez essayer IronPDF gratuitement en utilisant sonessai gratuit sur IronPDF. Si vous êtes intéressé par l'achat, la licence d'IronPDF commence à partir de $749.

Jordi Bardia

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

Ingénieur logiciel

Jordi maîtrise parfaitement Python, C# et C++. Lorsqu'il ne met pas à profit ses compétences chez Iron Software, il se consacre à la programmation de jeux. Partageant des responsabilités en matière de tests de produits, de développement de produits et de recherche, Jordi apporte une valeur ajoutée considérable à l'amélioration continue des produits. Cette expérience variée le stimule et l'engage, et il dit que c'est l'un des aspects qu'il préfère dans son travail chez Iron Software. Jordi a grandi à Miami, en Floride, et a étudié l'informatique et les statistiques à l'université de Floride.

< PRÉCÉDENT
Npgsql C# (Comment ça marche pour les développeurs)

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