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

Einführung

Eines der Hauptmerkmale von C#, Vererbungist bekannt für seine starke Unterstützung der objektorientierten Programmierung (OOP) grundsätze. Sie ist für das Schreiben von skalierbarem und effektivem Code unerlässlich. In diesem Beitrag wird das Thema C#-Vererbung mit dem Schwerpunkt auf realen Anwendungen für IronPDFeine leistungsfähige Bibliothek, die den Umgang mit PDFs in C#-Programmen erleichtert.

Wie man C&num verwendet; Vererbung

1. Erstellen Sie ein neues C#-Konsolenprojekt

2. Erstellen Sie eine Basisklasse mit einigen Methoden.

3. Schreiben Sie eine neue abgeleitete Klasse und erben Sie eine Klasse.

4. Aufruf der Funktion/Methode, die in einer Basisklasse verfügbar ist.

5. Verarbeiten Sie den Vorgang und entsorgen Sie das Objekt.

Vererbung in C##: Ein Überblick

Ein Schlüsselbegriff der objektorientierten Programmierung (OOP) ist die Vererbung, mit der eine Klasse (die abgeleitete oder Unterklasse) züge und Eigenschaften einer anderen Klasse zu übernehmen (die Basis- oder Oberklasse). In C# wird die Vererbung erreicht, indem man den Namen der Basisklasse hinter das: (dickdarm) symbol.

Einzelvererbung

Eine Klasse kann in C# nur von einer Basisklasse erben, da eine Einzelvererbung unterstützt wird. Wenn Sie möchten, dass eine abgeleitete Klasse die Fähigkeiten einer einzelnen Basisklasse erweitert, verwenden Sie die einfachste Art der Vererbung: die Verbundvererbung.

class Animal { /* Base/ Parent class */ }
class Dog : Animal { /* Derived class */ }

class Animal { /* Base/ Parent class */ }
class Dog : Animal { /* Derived class */ }

Friend Class Animal
End Class
Friend Class Dog
	Inherits Animal

End Class

Hierarchische Vererbung

Mehrere Klassen, die sich eine Basisklasse teilen, werden in einem hierarchischen Vererbungsschema an diese vererbt. Eine Klasse, die auf einer einzigen Grundlage basiert und von mehreren abgeleiteten Klassen geerbt wird. Jede abgeleitete Klasse kann je nach ihrem Zweck weitere einzigartige Merkmale aufweisen.

class Animal { /* Base class */ }
class Dog : Animal { /* Derived class */ }
class Wolf : Animal { /* Derived class */ }

class Animal { /* Base class */ }
class Dog : Animal { /* Derived class */ }
class Wolf : Animal { /* Derived class */ }

Friend Class Animal
End Class
Friend Class Dog
	Inherits Animal

End Class
Friend Class Wolf
	Inherits Animal

End Class

Mehrstufige Vererbung

Bei der mehrstufigen Vererbung fungiert eine Klasse sowohl als Basisklasse als auch als abgeleitete Klasse. So entsteht eine Vererbungskette, in der jede Klasse die Eigenschaften ihrer Vorgängerin erweitert.

class Animal { /* Base class */ }
class Mammal : Animal { /* Derived class */ }
class Dog : Mammal { /* Derived class  */ }

class Animal { /* Base class */ }
class Mammal : Animal { /* Derived class */ }
class Dog : Mammal { /* Derived class  */ }

Friend Class Animal
End Class
Friend Class Mammal
	Inherits Animal

End Class
Friend Class Dog
	Inherits Mammal

End Class

Vererbung von Schnittstellen

Eine Klasse in C# kann eine oder mehrere Schnittstellen implementieren und von einer einzigen Basisklasse erben. Dies ermöglicht es einer Klasse, die Implementierung von Methoden zu erben, die in Schnittstellen beschrieben sind, wodurch eine Art Mehrfachvererbung erreicht wird.

interface ILogger
{
    void Log(string message);
}
class ConsoleLogger : ILogger //child class
{
    public void Log(string message)
    {
        Console.WriteLine(message);
    }
}
class FileLogger : ILogger
{
    public void Log(string message)
    {
        // Log to file
    }
}

interface ILogger
{
    void Log(string message);
}
class ConsoleLogger : ILogger //child class
{
    public void Log(string message)
    {
        Console.WriteLine(message);
    }
}
class FileLogger : ILogger
{
    public void Log(string message)
    {
        // Log to file
    }
}

Friend Interface ILogger
	Sub Log(ByVal message As String)
End Interface
Friend Class ConsoleLogger 'child class
	Implements ILogger

	Public Sub Log(ByVal message As String) Implements ILogger.Log
		Console.WriteLine(message)
	End Sub
End Class
Friend Class FileLogger
	Implements ILogger

	Public Sub Log(ByVal message As String) Implements ILogger.Log
		' Log to file
	End Sub
End Class

Abstrakte Klassen und Methoden

In C# dient eine abstrakte Klasse als Basisklasse für andere Klassen und ist nicht in der Lage, selbst erstellt zu werden. Eine abstrakte Klasse hat die Aufgabe, ihren abgeleiteten Klassen eine gemeinsame Schnittstelle und einen Satz von Funktionen zu geben. Sie fungiert als Modell oder Vorlage, die die Attribute und Methoden umreißt, die ihre Nachfolgeklassen implementieren müssen. Schnittstellen sind eine von C# angebotene Funktionalität. Eine Art der Mehrfachvererbung wird im Wesentlichen durch Schnittstellen ermöglicht, über die eine Klasse zahlreiche Verträge implementieren kann.

Mit abstrakten Klassen können eine oder mehrere abstrakte Methoden für eine Basisklasse definiert werden. In der Folge müssen diese abstrakten Methoden von abgeleiteten Klassen konkret implementiert werden.

abstract class Shape
{
    public abstract double Area(); // Abstract method
}
class Square : Shape
{
    public double Radius { get; set; }
    public override double Area()
    {
        return Math.PI * Math.Pow(Radius, 2);
    }
}

abstract class Shape
{
    public abstract double Area(); // Abstract method
}
class Square : Shape
{
    public double Radius { get; set; }
    public override double Area()
    {
        return Math.PI * Math.Pow(Radius, 2);
    }
}

Friend MustInherit Class Shape
	Public MustOverride Function Area() As Double ' Abstract method
End Class
Friend Class Square
	Inherits Shape

	Public Property Radius() As Double
	Public Overrides Function Area() As Double
		Return Math.PI * Math.Pow(Radius, 2)
	End Function
End Class

Dies sind nur einige wenige Anwendungen der Vererbung in C#. Der angestrebte Grad an Flexibilität in der Codebasis, die Verbindungen zwischen den Klassen und die Entwurfsziele beeinflussen alle die gewählte Methode.

IronPDF

Die .NET-Bibliothek IronPDF ermöglicht es Programmierern, PDF-Dokumente mit der Sprache C# zu erstellen, zu bearbeiten und zu verändern. Die IronPDF-Bibliothek bietet eine Vielzahl von Werkzeugen und Funktionen für verschiedene Aufgaben im Zusammenhang mit PDF-Dateien, z. B. die Erzeugung von PDFs aus HTML, die Konvertierung von HTML in PDF, das Zusammenführen oder Teilen von PDF-Dokumenten und das Hinzufügen von Text, Bildern und Anmerkungen zu bereits vorhandenen PDFs. Um mehr über IronPDF zu erfahren, lesen Sie bitte die dokumentation seite.

IronPDF installieren

Erwerben Sie die IronPDF-Bibliothek; der kommende Patch erfordert dies. Geben Sie dazu den folgenden Code in den Paketmanager ein:

Install-Package IronPDF 
//or 
dotnet add package IronPdf

Eine weitere Möglichkeit ist die Suche nach dem Paket "IronPDF" über den NuGet Package Manager. Unter allen NuGet-Paketen, die mit IronPDF zusammenhängen, können wir das gewünschte Paket aus dieser Liste auswählen und herunterladen.

IronPDF in vererbten Klassen

Eine funktionsreiche Bibliothek namens IronPDF wurde entwickelt, um die Arbeit mit PDF-Dokumenten in C# zu erleichtern. Durch die Integration von IronPDF mit geerbten Klassen können Sie die Funktionalität Ihrer Anwendung verbessern und PDFs mit Leichtigkeit erstellen, manipulieren und erweitern.

Die Vorteile der Vererbung mit IronPDF

• Organisierte Code-Organisation: Durch den Aufbau einer Klassenhierarchie trägt die Vererbung zu einer geordneten Codeorganisation bei. Sie können mit der IronPDF-Integration Klassen speziell für die Verarbeitung von PDFs erstellen und haben trotzdem eine saubere, gut organisierte Codebasis.

• Wiederverwendung von Code: Klassen, die von ihren Basisklassen erben, ermöglichen die Wiederverwendung von Code. Dies ist besonders nützlich, wenn Sie eine Bibliothek wie IronPDF verwenden, da Sie damit allgemeine PDF-bezogene Funktionen in einer Basisklasse kapseln können, die Sie in anderen Bereichen Ihrer Anwendung wiederverwenden können.

  Um die Möglichkeiten von PdfDocument zu erweitern, insbesondere für die IronPDF-Integration, erstellen wir eine Klasse namens IronPdfDocument:

using IronPdf;
public class IronPdfDocument : PdfDocument
{
    // Additional properties or methods specific to IronPDF can be added here
    public void ConvertToPdf()
    {
        // Code to convert the HTML to PDF using IronPDF
           var Renderer = new IronPdf.HtmlToPdf();
           var PDF = Renderer.RenderHtmlAsPdf("<h1>Hello, World</h1>");
           PDF.SaveAs("Output.pdf");
    }
}

using IronPdf;
public class IronPdfDocument : PdfDocument
{
    // Additional properties or methods specific to IronPDF can be added here
    public void ConvertToPdf()
    {
        // Code to convert the HTML to PDF using IronPDF
           var Renderer = new IronPdf.HtmlToPdf();
           var PDF = Renderer.RenderHtmlAsPdf("<h1>Hello, World</h1>");
           PDF.SaveAs("Output.pdf");
    }
}

Imports IronPdf
Public Class IronPdfDocument
	Inherits PdfDocument

	' Additional properties or methods specific to IronPDF can be added here
	Public Sub ConvertToPdf()
		' Code to convert the HTML to PDF using IronPDF
		   Dim Renderer = New IronPdf.HtmlToPdf()
		   Dim PDF = Renderer.RenderHtmlAsPdf("<h1>Hello, World</h1>")
		   PDF.SaveAs("Output.pdf")
	End Sub
End Class

IronPdfDocument ist ein erweitertes Beispiel, das sich von PdfDocument ableitet. Diese Klasse ist so konzipiert, dass sie problemlos mit IronPDF zusammenarbeitet; können Sie bestimmte Attribute oder Methoden verwenden, um PDF-bezogene Funktionen einfach zu handhaben. Mehr über IronPDF erfahren Sie unter hier.

Erstellung eines PDF-Berichtsgenerators

Lassen Sie uns diese Ideen in die Praxis umsetzen, indem wir Vererbung und IronPDF nutzen, um einen einfachen PDF-Berichtsgenerator zu erstellen. Zunächst werden wir mit der Basisklasse Report arbeiten:

public class Report
{
    public virtual void GenerateReport()
    {
                var Renderer = new IronPdf.HtmlToPdf();
                var PDF = Renderer.RenderHtmlAsPdf("<h1>Hello, World</h1>");
                PDF.SaveAs("Output.pdf");
    }
}

public class Report
{
    public virtual void GenerateReport()
    {
                var Renderer = new IronPdf.HtmlToPdf();
                var PDF = Renderer.RenderHtmlAsPdf("<h1>Hello, World</h1>");
                PDF.SaveAs("Output.pdf");
    }
}

Public Class Report
	Public Overridable Sub GenerateReport()
				Dim Renderer = New IronPdf.HtmlToPdf()
				Dim PDF = Renderer.RenderHtmlAsPdf("<h1>Hello, World</h1>")
				PDF.SaveAs("Output.pdf")
	End Sub
End Class

Konstruieren wir nun PdfReport, eine abgeleitete Klasse, die IronPDF-Funktionen hinzufügt und von der Basisklasse erbt:

public class PdfReport : Report
{
    public override void GenerateReport()
    {
        var Renderer = new IronPdf.HtmlToPdf();
        var PDF = Renderer.RenderHtmlAsPdf("<h1>Hello, IronPDF</h1>");
        PDF.SaveAs("Output.pdf");
        Console.WriteLine("Generating PDF report...");
        // Additional code specific to PDF generation using IronPDF
    }
}

public class PdfReport : Report
{
    public override void GenerateReport()
    {
        var Renderer = new IronPdf.HtmlToPdf();
        var PDF = Renderer.RenderHtmlAsPdf("<h1>Hello, IronPDF</h1>");
        PDF.SaveAs("Output.pdf");
        Console.WriteLine("Generating PDF report...");
        // Additional code specific to PDF generation using IronPDF
    }
}

Public Class PdfReport
	Inherits Report

	Public Overrides Sub GenerateReport()
		Dim Renderer = New IronPdf.HtmlToPdf()
		Dim PDF = Renderer.RenderHtmlAsPdf("<h1>Hello, IronPDF</h1>")
		PDF.SaveAs("Output.pdf")
		Console.WriteLine("Generating PDF report...")
		' Additional code specific to PDF generation using IronPDF
	End Sub
End Class

Das obige Beispiel zeigt, dass die Title-Eigenschaft und die GenerateReport-Funktion von PdfReport von der vorhandenen Klasse geerbt werden, die in diesem Beispiel die Basisklasse Report ist. Sie fügt eine neue Eigenschaft namens Author hinzu und überschreibt die Funktion GenerateReport mit einer eigenen Logik für die IronPDF-basierte PDF-Berichterstellung. Nachfolgend sehen Sie die aus dem Code generierte PDF-Ausgabe.

Informationen zum Code für die Umwandlung von HTML-Strings in PDF finden Sie unter hier.

Schlussfolgerung

In Verbindung mit Bibliotheken wie IronPDFdie Vererbung ist eine leistungsstarke Funktion, die den Prozess der Anwendungsentwicklung verbessert. Die Grundlagen der Vererbung wurden in diesem Beitrag behandelt, zusammen mit einer nützlichen Anleitung zur Integration dieser Idee in IronPDF.

Die Entwicklung von hierarchischen Klassenstrukturen führt zu einer modularen und gut strukturierten Codebasis. Wenn Sie Klassen entwickeln, die die umfassenden Fähigkeiten ihrer Basisklassen erben, aber auf spezifische Aufgaben zugeschnitten sind, werden die Vorteile der Codeerweiterung und Wiederverwendbarkeit deutlich. Diese Vorteile werden durch die Integration von IronPDF noch verstärkt und bieten eine reibungslose Lösung für die Verwaltung von PDF-Dokumenten in Ihren C#-Anwendungen.

IronPDF's $749 Light Pack beinhaltet eine super haltbare Genehmigung, Redesign-Möglichkeiten und eine verlängerte Zeit der Programmierunterstützung. Während der mit einem Wasserzeichen versehenen Testzeit können die Kunden den Artikel in echten Anwendungseinstellungen testen. Um mehr über den Wert, die Genehmigung und die Vorform von IronPDF herauszufinden, besuchen Sie bitte die lizenzseite. Besuchen Sie die offizielle website um sich mit anderen Produkten von Iron Software vertraut zu machen.