C# Teilweise (Wie es für Entwickler funktioniert)

C# bietet eine einzigartige Funktion, die die Organisation und Verwaltung von Code in größeren Projekten verbessert: das partielle Schlüsselwort class. Diese Funktion, die über den Modifikator partial zugänglich ist, ermöglicht es Entwicklern, die Definition einer Klasse, Schnittstelle oder Struktur auf mehrere Dateien zu verteilen. Diese Fähigkeit ist besonders vorteilhaft für die Arbeit mit bereits generiertem Quellcode, wie z. B. Definitionen von Benutzeroberflächen-Steuerelementen oder Service-Wrapper-Code, neben benutzerdefinierter Geschäftslogik. In diesem Artikel lernen wir etwas über partielle Klassen und die IronPDF-Bibliothek mit Visual Studio.

Verständnis der partiellen Klasse

Eine partielle Klasse, die dieselbe Zugriffsebene beibehält, wird in C# mit dem partiellen Modifikator definiert, der angibt, dass die Klassendefinition über zwei oder mehr Dateien innerhalb derselben Assembly verteilt ist. Bei diesem Ansatz wird zusammengehöriger Code zusammengehalten, während die Trennung von Belangen beibehalten wird. Bei einer Teilklasse Employee kann sich beispielsweise die Geschäftslogik in einer Datei und die Datenzugriffsschicht in einer anderen befinden, dennoch werden beide Teile zu einer einzigen Klasse kompiliert. Diese Trennung macht den Code nicht nur überschaubarer, sondern ermöglicht es auch mehreren Entwicklern, konfliktfrei an der gleichen Klasse zu arbeiten.

// 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

Nutzung von Partialmethoden

Partielle Klassen können auch partielle Methoden definieren, die optional sind oder sogar als abstrakt deklariert werden können, was flexiblere Implementierungsstrategien ermöglicht. Diese Methoden ermöglichen ein interessantes Szenario, bei dem ein Teil der Klasse eine Methode deklarieren kann, ohne sie zu implementieren, und einem anderen Teil der Klasse erlaubt, sie zu implementieren. Wird keine Implementierung bereitgestellt, wird der partielle Methodenaufruf zur Kompilierzeit entfernt, was keine Leistungseinbußen zur Folge hat.

// 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

Fortgeschrittene Verwendung von Partialmethoden

Partielle Methoden, die einen partiellen Definitionsansatz verkörpern, sind ein besonderes Merkmal innerhalb partieller Klassen, die eine Deklaration in einem Teil einer partiellen Klasse und eine optionale Implementierung in einem anderen Teil ermöglichen. Diese Funktion ist besonders nützlich, um Haken im generierten Code zu setzen, die vom Entwickler optional implementiert werden können. Das Schlüsselwort partial ist hier entscheidend, da es bedeutet, dass die Methode eine Implementierung haben kann oder nicht.

Nehmen wir ein Beispiel, bei dem eine UI-Komponente eine Aktion ausführen muss, bevor ein Steuerelement der Benutzeroberfläche geladen wird. Die partielle Methode bietet eine saubere Möglichkeit, benutzerdefinierte Geschäftslogik einzufügen, ohne den automatisch generierten Code zu überladen.

// 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

Integration von Geschäftslogik mit partiellen Klassen

Die Geschäftslogik muss oft über die automatisch generierte Logik hinaus geändert und erweitert werden, insbesondere bei Anwendungen mit komplexen Regeln oder Verhaltensweisen. Partielle Klassen bieten eine nahtlose Möglichkeit, Geschäftslogik in eine separate Quelldatei einzubinden, ohne den automatisch generierten UI- oder Datenzugriffscode zu verändern. Durch diese Trennung wird sichergestellt, dass die Geschäftslogik für die Entwickler leicht zugänglich und änderbar ist, was die Zusammenarbeit fördert, insbesondere wenn mehr als ein Entwickler an dem Projekt beteiligt ist.

// 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

Verschachtelung partieller Typen

Geschachtelte partielle Typen erweitern das Konzept der partiellen Klassen auf geschachtelte Klassen, so dass Teile einer geschachtelten Klasse in separaten Dateien definiert werden können. Dies kann besonders nützlich sein, um große verschachtelte Strukturen zu organisieren, z. B. eine komplexe Benutzeroberflächen-Steuerungsdefinition, die mehrere verschachtelte Typen für die Handhabung verschiedener Aspekte des Steuerungsverhaltens enthält.

// 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

Praktische Anwendungen

Partielle Klassen sind besonders vorteilhaft in Szenarien mit automatisch generiertem Quellcode, wie z. B. Forms, wo Visual Studio Windows Forms erstellt. Auf diese Weise können Entwickler den Code für das UI-Design in einer separaten Quelldatei abtrennen und so die Klasse erweitern oder ändern, ohne das ursprüngliche UI-Design zu beeinflussen.

In Webanwendungen erleichtern partielle Klassen die Trennung des generierten Webdienst-Wrapper-Codes von der benutzerdefinierten Geschäftslogik und stellen sicher, dass Aktualisierungen der Webdienste keine benutzerdefinierten Änderungen überschreiben. In ähnlicher Weise erzeugen dbml-Dateien in Anwendungen, die LINQ to SQL verwenden, partielle Klassendefinitionen, die um zusätzliche Funktionen oder Geschäftslogik erweitert werden können, ohne den automatisch generierten Code zu verändern.

// 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: C# PDF-Bibliothek

IronPDF ist eine umfassende Bibliothek für .NET, mit der Entwickler PDF-Dokumente in ihren Anwendungen erstellen, lesen und bearbeiten können. Sie bietet einen unkomplizierten Ansatz für pDFs aus HTML generierenuRLs, Bilder, ASPX und Text, was es zu einem vielseitigen Werkzeug für die Berichterstellung, Dokumentenerstellung und Archivierung von Webinhalten macht. IronPDF zeichnet sich durch seine Benutzerfreundlichkeit aus und erfordert nur eine minimale Einrichtung zur Integration in jedes .NET-Projekt, einschließlich der mit C# entwickelten Anwendungen.

Integration von IronPDF mit partiellen Klassen

Um die Integration von IronPDF mit partiellen Klassen zu veranschaulichen, betrachten wir ein Beispiel, in dem wir eine Webanwendung haben, die Berichte im PDF-Format erzeugt. Wir werden die Funktionalität auf Teilklassendateien aufteilen, um unsere Geschäftslogik von der Logik der PDF-Erzeugung zu trennen.

IronPDF einrichten

Stellen Sie zunächst sicher, dass IronPDF zu Ihrem Projekt hinzugefügt wird. Dies kann in der Regel über den NuGet Package Manager mit dem folgenden Befehl erfolgen:

Install-Package IronPdf

Erstellen der partiellen Klasse für die Berichtsgenerierung

Wir werden unsere Klasse in zwei Teile aufteilen: einen für die Geschäftslogik im Zusammenhang mit den Berichtsdaten und einen weiteren für die PDF-Erzeugung mit IronPDF.

Datei 1: ReportGenerator_BusinessLogic.cs

Diese Datei enthält die Geschäftslogik zur Aufbereitung der Daten für den Bericht.

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

Datei 2: ReportGenerator_PdfGeneration.cs

Diese Datei verwendet IronPDF, um einen PDF-Bericht aus den aufbereiteten Daten zu erstellen.

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

Verwendung

Mit der Einrichtung der Teilklasse wird die Erstellung eines PDF-Berichts zu einer Angelegenheit des Aufrufs der Methode GeneratePdfReport auf einer Instanz der Klasse ReportGenerator.

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

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

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

Schlussfolgerung

Die Verwendung von partiellen Klassen, partiellen Methoden und verschachtelten partiellen Typen in C# bietet Entwicklern ein flexibles und leistungsstarkes Werkzeug für die Codeorganisation und -verwaltung. Durch die Trennung des automatisch generierten Codes von der Geschäftslogik, den Definitionen der Benutzeroberflächensteuerung und anderen Teilen der Anwendung können Entwickler besser wartbare, lesbare und skalierbare Anwendungen erstellen.

Durch die Trennung von Geschäftslogik und PDF-Verarbeitung können Entwickler eine bessere Codeorganisation, Wartbarkeit und Skalierbarkeit erreichen. Die robusten Funktionen von IronPDF in Kombination mit den organisatorischen Vorteilen partieller Klassen bilden ein leistungsstarkes Toolset für .NET-Entwickler, die in ihren Projekten mit PDFs arbeiten. Sie können IronPDF kostenlos testen, indem Sie die kostenloser Test. Wenn Sie an einem Kauf interessiert sind, kostet die Lizenz von IronPDF ab $749.