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

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

Curtis Chau
Curtis Chau
Mis à jour:

C# offre une fonctionnalité unique qui améliore l'organisation et la gestion du code dans les projets plus importants : la classe de mot-clé partiel. Cette fonctionnalité, accessible via le modificateur partial, permet aux développeurs de diviser la définition d'une classe, d'une interface ou d'une structure sur plusieurs fichiers. Cette capacité est particulièrement bénéfique pour travailler avec du code source déjà généré, tel que les définitions de contrôles d'interface utilisateur ou le code d'encapsulation de service, en parallèle avec la logique métier personnalisée. Dans cet article, nous allons apprendre les classes partielles et la 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 assembly. Cette approche permet de garder le code connexe ensemble tout en maintenant la séparation des préoccupations. Par exemple, une classe partielle Employé pourrait avoir sa logique métier dans un fichier et sa couche d'accès aux données dans un autre, mais les deux parties sont compilées en une seule classe. Cette séparation rend non seulement le code plus gérable, mais permet également à plusieurs développeurs de travailler sur la même classe sans conflit.

// File 1: Employee_BusinessLogic.cs
public partial class Employee
{
    // Method for calculating pay
    public void CalculatePay() 
    { 
        // Implementation of pay calculation
    }
}

// File 2: Employee_DataAccess.cs
public partial class Employee
{
    // Method for loading employee data
    public void Load() 
    { 
        // Implementation of data loading
    }
}
// File 1: Employee_BusinessLogic.cs
public partial class Employee
{
    // Method for calculating pay
    public void CalculatePay() 
    { 
        // Implementation of pay calculation
    }
}

// File 2: Employee_DataAccess.cs
public partial class Employee
{
    // Method for loading employee data
    public void Load() 
    { 
        // Implementation of data loading
    }
}
' File 1: Employee_BusinessLogic.cs
Partial Public Class Employee
	' Method for calculating pay
	Public Sub CalculatePay()
		' Implementation of pay calculation
	End Sub
End Class

' File 2: Employee_DataAccess.cs
Partial Public Class Employee
	' Method for loading employee data
	Public Sub Load()
		' Implementation of data loading
	End Sub
End Class
$vbLabelText   $csharpLabel

Exploiter les Méthodes Partielles

Les classes partielles peuvent également définir des méthodes partielles, qui sont déclarées mais pas nécessairement implémentées. Ces méthodes permettent des scénarios où une partie de la classe peut déclarer une méthode sans l'implémenter, permettant éventuellement à une autre partie de la classe de l'implémenter. Si aucune implémentation n'est fournie, l'appel de la méthode partielle est supprimé lors de la compilation, entraînant aucune pénalité de performance.

// File 1: Employee_BusinessLogic.cs
public partial class Employee
{
    // Declaration of a partial method to be called when pay is calculated
    partial void OnPayCalculated(double amount);

    public void CalculatePay()
    {
        double amount = 1000; // Simplified calculation
        OnPayCalculated(amount); // Call the partial method
    }
}

// File 2: Employee_Events.cs
public partial class Employee
{
    // Implementation of the partial method
    partial void OnPayCalculated(double amount)
    {
        Console.WriteLine($"Pay calculated: {amount}");
    }
}
// File 1: Employee_BusinessLogic.cs
public partial class Employee
{
    // Declaration of a partial method to be called when pay is calculated
    partial void OnPayCalculated(double amount);

    public void CalculatePay()
    {
        double amount = 1000; // Simplified calculation
        OnPayCalculated(amount); // Call the partial method
    }
}

// File 2: Employee_Events.cs
public partial class Employee
{
    // Implementation of the partial method
    partial void OnPayCalculated(double amount)
    {
        Console.WriteLine($"Pay calculated: {amount}");
    }
}
' File 1: Employee_BusinessLogic.cs
Partial Public Class Employee
	' Declaration of a partial method to be called when pay is calculated
	Partial Private Sub OnPayCalculated(ByVal amount As Double)
	End Sub

	Public Sub CalculatePay()
		Dim amount As Double = 1000 ' Simplified calculation
		OnPayCalculated(amount) ' Call the partial method
	End Sub
End Class

' File 2: Employee_Events.cs
Partial Public Class Employee
	' Implementation of the partial method
	Private Sub OnPayCalculated(ByVal amount As Double)
		Console.WriteLine($"Pay calculated: {amount}")
	End Sub
End Class
$vbLabelText   $csharpLabel

Utilisation Avancée des Méthodes Partielles

Les méthodes partielles, incarnant une approche de définition partielle, permettent une déclaration dans une partie d'une classe partielle et une implémentation optionnelle dans une autre. Cette fonctionnalité est particulièrement utile pour fournir des points d'ancrage dans le code généré qui peuvent être éventuellement implémentés par les développeurs. Le mot-clé partial indique que la méthode peut ou non avoir une implémentation.

Considérez un exemple où un composant d'interface utilisateur doit effectuer une action avant le chargement d'un contrôle d'interface utilisateur. La méthode partielle offre un moyen élégant d'insérer de la logique métier personnalisée sans encombrer le code généré automatiquement.

// File: UIControls_AutoGenerated.cs
public partial class UIControls
{
    // Declaration of a partial method for control loading
    partial void OnControlLoading();

    public void LoadControl()
    {
        OnControlLoading(); // Call the partial method
        // Auto-generated loading logic here
    }
}

// File: UIControls_CustomLogic.cs
public partial class UIControls
{
    // Implementation of the partial method for adding custom logic
    partial void OnControlLoading()
    {
        // Custom business logic code here
        Console.WriteLine("Custom control loading logic executed.");
    }
}
// File: UIControls_AutoGenerated.cs
public partial class UIControls
{
    // Declaration of a partial method for control loading
    partial void OnControlLoading();

    public void LoadControl()
    {
        OnControlLoading(); // Call the partial method
        // Auto-generated loading logic here
    }
}

// File: UIControls_CustomLogic.cs
public partial class UIControls
{
    // Implementation of the partial method for adding custom logic
    partial void OnControlLoading()
    {
        // Custom business logic code here
        Console.WriteLine("Custom control loading logic executed.");
    }
}
' File: UIControls_AutoGenerated.cs
Partial Public Class UIControls
	' Declaration of a partial method for control loading
	Partial Private Sub OnControlLoading()
	End Sub

	Public Sub LoadControl()
		OnControlLoading() ' Call the partial method
		' Auto-generated loading logic here
	End Sub
End Class

' File: UIControls_CustomLogic.cs
Partial Public Class UIControls
	' Implementation of the partial method for adding custom logic
	Private Sub OnControlLoading()
		' Custom business logic code here
		Console.WriteLine("Custom control loading logic executed.")
	End Sub
End Class
$vbLabelText   $csharpLabel

Intégrer la Logique Métier avec des Classes Partielles

La logique métier exige souvent des modifications et une extension au-delà de ce qui est généré automatiquement, surtout dans les applications avec des règles ou des comportements complexes. Les classes partielles offrent un moyen transparent d'inclure de la logique métier dans un fichier source distinct sans altérer le code interface utilisateur ou accès aux données généré automatiquement. Cette séparation garantit que la logique métier est facilement accessible et modifiable par les développeurs, améliorant 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
{
    // Business logic method for promoting an 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
{
    // Business logic method for promoting an 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
	' Business logic method for promoting an employee
	Public Sub Promote()
		' Business logic code to promote an employee
		Console.WriteLine("Employee promoted.")
	End Sub
End Class
$vbLabelText   $csharpLabel

Imbrication de Types Partiels

Les types partiels imbriqués étendent le concept des classes partielles aux classes imbriquées, permettant aux parties d'une classe imbriquée d'être définies dans des fichiers séparés. Cela peut être particulièrement utile pour organiser de grandes structures imbriquées, telles qu'une définition de contrôle d'interface utilisateur complexe incluant plusieurs types imbriqués pour gérer divers aspects du comportement du contrôle.

// File: ComplexControl_Part1.cs
public partial class ComplexControl
{
    public partial class NestedControl
    {
        // Method for initializing the nested control
        public void Initialize() 
        { 
            // Initialization code here 
        }
    }
}

// File: ComplexControl_Part2.cs
public partial class ComplexControl
{
    public partial class NestedControl
    {
        // Method for cleaning up the nested control
        public void Cleanup() 
        { 
            // Cleanup code here 
        }
    }
}
// File: ComplexControl_Part1.cs
public partial class ComplexControl
{
    public partial class NestedControl
    {
        // Method for initializing the nested control
        public void Initialize() 
        { 
            // Initialization code here 
        }
    }
}

// File: ComplexControl_Part2.cs
public partial class ComplexControl
{
    public partial class NestedControl
    {
        // Method for cleaning up the nested control
        public void Cleanup() 
        { 
            // Cleanup code here 
        }
    }
}
' File: ComplexControl_Part1.cs
Partial Public Class ComplexControl
	Partial Public Class NestedControl
		' Method for initializing the nested control
		Public Sub Initialize()
			' Initialization code here 
		End Sub
	End Class
End Class

' File: ComplexControl_Part2.cs
Partial Public Class ComplexControl
	Partial Public Class NestedControl
		' Method for cleaning up the nested control
		Public Sub Cleanup()
			' Cleanup code here 
		End Sub
	End Class
End Class
$vbLabelText   $csharpLabel

Applications pratiques

Les classes partielles sont particulièrement bénéfiques dans des scénarios impliquant du 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, leur permettant 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 d'encapsulation de services web généré de la logique métier 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 classe partielle qui peuvent être étendues pour inclure des fonctionnalités supplémentaires ou de la logique métier sans toucher le 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
$vbLabelText   $csharpLabel

IronPDF : Bibliothèque PDF C

!

IronPDF est une bibliothèque complète pour .NET qui permet aux développeurs de créer, lire et éditer des documents PDF dans leurs applications. Elle offre une approche simple pour générer des PDFs à partir de HTML en utilisant IronPDF, des URL, des images, ASPX, et du texte, ce qui en fait un outil polyvalent pour les rapports, la génération de documents et l'archivage de contenu web. IronPDF excelle par sa facilité d'utilisation, nécessitant une configuration minimale pour s'intégrer dans n'importe quel projet .NET, y compris des applications développées avec C#.

Intégrer IronPDF avec des Classes Partielles

Pour illustrer l'intégration de IronPDF avec des classes partielles, considérons un exemple où nous avons une application web qui génère des rapports au format PDF. Nous allons diviser la fonctionnalité entre des fichiers de classe partiels pour garder notre logique métier séparée de notre logique de génération de PDF.

Installation de IronPDF

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

Install-Package IronPdf

Créer la Classe Partielle pour la Génération de Rapports

Nous allons diviser notre classe en deux parties : une pour la logique métier liée aux données de rapport et une autre pour la génération de PDF en utilisant IronPDF.

Fichier 1 : ReportGenerator_BusinessLogic.cs

Ce fichier contient la logique métier pour préparer les données pour le rapport.

public partial class ReportGenerator
{
    // Method to get data for the report
    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
{
    // Method to get data for the report
    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
	' Method to get data for the report
	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
$vbLabelText   $csharpLabel

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
{
    // Method to generate PDF report using IronPDF
    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
{
    // Method to generate PDF report using IronPDF
    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
	' Method to generate PDF report using IronPDF
	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
$vbLabelText   $csharpLabel

Utilisation

Avec la configuration de classe partielle, générer un rapport PDF devient une question d'invoquer 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()
$vbLabelText   $csharpLabel

!

Conclusion

!

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 métier, des définitions de contrôle d'interface utilisateur et d'autres parties de l'application, les développeurs peuvent créer des applications plus maintenables, lisibles et évolutives.

En séparant les préoccupations de la logique métier et du traitement PDF, les développeurs peuvent atteindre une meilleure organisation, maintenabilité et évolutivité du code. Les fonctionnalités robustes d'IronPDF combinées aux avantages organisationnels des classes partielles forment un ensemble d'outils puissant pour les développeurs .NET travaillant avec des PDFs dans leurs projets. Vous pouvez essayer IronPDF gratuitement en utilisant sa version d'essai gratuite sur IronPDF. Si vous êtes intéressé par l'achat, la licence de IronPDF commence à partir de $799.

Questions Fréquemment Posées

Quel est le but d'utiliser des classes partielles en C# ?

Les classes partielles en C# sont utilisées pour diviser la définition d'une classe, interface ou structure sur plusieurs fichiers. Cela est particulièrement utile pour séparer le code généré automatiquement, tel que les contrôles d'interface utilisateur, de la logique métier personnalisée, améliorant ainsi la gestion et l'organisation du code.

En quoi les classes partielles peuvent-elles être bénéfiques dans une application web ?

Dans une application web, les classes partielles permettent aux développeurs de séparer le code de conception de l'interface utilisateur de la logique métier personnalisée. Cette séparation aide à maintenir une architecture de code propre, ce qui facilite la gestion et l'évolution de l'application à mesure qu'elle se développe.

Quelle est l'importance du mot-clé partial en C# ?

Le mot-clé partial en C# indique que la définition d'une classe, d'une interface ou d'une structure est répartie en plusieurs parties à travers différents fichiers. Cette fonctionnalité est cruciale pour gérer de grandes bases de code, en particulier lors de la gestion du code généré automatiquement.

Pouvez-vous intégrer la génération de PDF avec des classes partielles en C# ?

Oui, vous pouvez intégrer la génération de PDF avec des classes partielles en C#. En utilisant une bibliothèque comme IronPDF, vous pouvez séparer la logique de génération de PDF dans une classe partielle, la gardant distincte des autres logiques métier et améliorant la clarté du code.

Comment fonctionnent les méthodes partielles au sein des classes partielles ?

Les méthodes partielles dans les classes partielles sont déclarées sans implémentation dans une partie de la classe et peuvent être optionnellement implémentées dans une autre. Si une méthode partielle est déclarée mais n'est pas implémentée, elle est supprimée pendant la compilation, évitant toute surcharge de performance.

Quelles sont les types partiels imbriqués et leurs cas d'utilisation ?

Les types partiels imbriqués permettent aux parties d'une classe imbriquée d'être définies dans des fichiers distincts. Cet outil organisationnel est utile pour gérer des structures complexes, telles que des contrôles d'interface utilisateur avec plusieurs types imbriqués, permettant une meilleure gestion du code.

Comment une bibliothèque .NET pour la fonctionnalité PDF peut-elle être installée ?

Une bibliothèque .NET pour la fonctionnalité PDF, comme IronPDF, peut être installée en utilisant le gestionnaire de packages NuGet. Vous utiliseriez une commande spécifique au package, par exemple : Install-Package IronPdf.

Quels sont les avantages d'utiliser des classes partielles pour le développement collaboratif ?

Les classes partielles facilitent le développement collaboratif en permettant à plusieurs développeurs de travailler sur différentes parties de la même classe sans conflits de code. Cela est réalisé en divisant la classe en différents fichiers, ce qui facilite la gestion des modifications concurrentes.

Comment la logique de génération de PDF peut-elle être organisée dans un projet C# ?

La logique de génération de PDF peut être organisée dans un projet C# en utilisant des classes partielles pour séparer cette fonctionnalité des autres logiques métier. Cette approche améliore la gestion et la clarté du code, en particulier lors de l'utilisation de bibliothèques comme IronPDF pour la création et la manipulation de PDF.

Pourquoi les classes partielles sont utiles pour le code généré automatiquement ?

Les classes partielles sont particulièrement utiles pour le code généré automatiquement car elles permettent aux développeurs d'ajouter une logique personnalisée sans altérer les parties générées automatiquement. Cette ségrégation garantit que les mises à jour du code généré n'interrompent pas les implémentations personnalisées.

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