C# Vitrual Vs Abstract (Wie es funktioniert für Entwickler)

In C#, virtuelle Methoden können in abgeleiteten Klassen überschrieben werden, während abstrakte Methoden in abgeleiteten Klassen überschrieben werden müssen. Dies erlaubt ein flexibles Verhalten und ermöglicht Polymorphismus in der objektorientierten Programmierung. Diese beiden Konzepte sorgen für Flexibilität und Wiederverwendbarkeit in der objektorientierten Programmierung. In diesem Artikel werden die Besonderheiten abstrakter und virtueller Methoden erläutert, wobei klare Beispiele gegeben werden und der Schwerpunkt auf deren praktischen Einsatz in der Programmierung liegt. Wir werden auch Folgendes erforschen IronPDF weiter unten in dem Artikel.

Abstrakte Klasse und Methoden

Eine abstrakte Klasse ist eine besondere Art von Klasse, die nicht direkt instanziiert werden kann. Stattdessen dient sie als Blaupause für andere Klassen. Eine abstrakte Klasse kann abstrakte Methoden enthalten, d. h. Methoden, die in der abstrakten Klasse deklariert sind, aber in konkreten abgeleiteten Klassen implementiert werden müssen.

public abstract class Vehicle
{
// abstract method to be implemented in non abstract child class
    public abstract void DisplayInfo();
}

public abstract class Vehicle
{
// abstract method to be implemented in non abstract child class
    public abstract void DisplayInfo();
}

Public MustInherit Class Vehicle
' abstract method to be implemented in non abstract child class
	Public MustOverride Sub DisplayInfo()
End Class

In diesem Beispiel ist die Klasse Fahrzeug abstrakt, und DisplayInfo ist eine abstrakte Methode. Die Methode DisplayInfo hat keine Implementierung in der Klasse Vehicle. Sie zwingt die abgeleitete Klasse, ihre Definition dieser Methode zur Verfügung zu stellen.

Virtuelle Methoden

Virtuelle Methoden sind Methoden in einer Basisklasse, die eine Standardimplementierung haben, aber in abgeleiteten Klassen außer Kraft gesetzt werden können. Das Schlüsselwort virtual wird verwendet, um eine Methode als virtuell zu deklarieren. Abgeleitete Klassen verwenden das Override-Schlüsselwort, um eine spezifische Implementierung der Methode bereitzustellen. Dies hilft zu verstehen, wie eine Kindklasse eine virtuelle Methode ihrer Elternklasse überschreiben kann.

// non abstract class
public class Animal
{
    public virtual void Speak()
    {
        Console.WriteLine("Some generic animal sound");
    }
}

// non abstract class
public class Animal
{
    public virtual void Speak()
    {
        Console.WriteLine("Some generic animal sound");
    }
}

' non abstract class
Public Class Animal
	Public Overridable Sub Speak()
		Console.WriteLine("Some generic animal sound")
	End Sub
End Class

Hier hat die Klasse Tier eine virtuelle Methode Speak mit einer Standardimplementierung. Abgeleitete Klassen können die Methode mit dem Schlüsselwort override überschreiben, um einen bestimmten Tierlaut zu erzeugen.

Kombination von virtuellen und abstrakten Methoden

Eine Klasse kann sowohl abstrakte als auch virtuelle Methoden haben. Abstrakte Methoden haben keine Implementierung und müssen in abgeleiteten Klassen überschrieben werden, während virtuelle Methoden eine Standardimplementierung haben, die von abgeleiteten Klassen optional überschrieben werden kann.

Stellen Sie sich ein Szenario vor, in dem Sie ein System aufbauen, das verschiedene Fahrzeugtypen modelliert, von denen jeder seine eigene Art der Informationsdarstellung hat. Hier erfahren Sie, wie Sie abstrakte und virtuelle Methoden verwenden können:

public abstract class Vehicle
{
    // Abstract method
    public abstract void DisplayInfo();
    // Virtual method
    public virtual void StartEngine()
    {
        Console.WriteLine("Engine started with default configuration.");
    }
}

public abstract class Vehicle
{
    // Abstract method
    public abstract void DisplayInfo();
    // Virtual method
    public virtual void StartEngine()
    {
        Console.WriteLine("Engine started with default configuration.");
    }
}

Public MustInherit Class Vehicle
	' Abstract method
	Public MustOverride Sub DisplayInfo()
	' Virtual method
	Public Overridable Sub StartEngine()
		Console.WriteLine("Engine started with default configuration.")
	End Sub
End Class

In dieser Klasse Fahrzeug ist DisplayInfo eine abstrakte Methode, die alle abgeleiteten Klassen zwingt, ihre Art der Anzeige von Informationen zu implementieren. StartEngine bietet jedoch eine Standardmethode zum Starten des Motors, die bei Bedarf von einer geerbten Klasse überschrieben werden kann.

Beispiel mit abgeleiteten Klassen

Definieren wir nun eine Klasse Car, eine nicht-abstrakte Unterklasse, die von Vehicle erbt und die abstrakte Methode implementiert, während sie optional die virtuelle Methode überschreibt:

public class Car : Vehicle
{
// public override void abstractmethod
    public override void DisplayInfo()
    {
        Console.WriteLine("This is a car.");
    }
    public override void StartEngine()
    {
        Console.WriteLine("Car engine started with custom settings.");
    }
}

public class Car : Vehicle
{
// public override void abstractmethod
    public override void DisplayInfo()
    {
        Console.WriteLine("This is a car.");
    }
    public override void StartEngine()
    {
        Console.WriteLine("Car engine started with custom settings.");
    }
}

Public Class Car
	Inherits Vehicle

' public override void abstractmethod
	Public Overrides Sub DisplayInfo()
		Console.WriteLine("This is a car.")
	End Sub
	Public Overrides Sub StartEngine()
		Console.WriteLine("Car engine started with custom settings.")
	End Sub
End Class

Hier bietet die Klasse Car spezifische Implementierungen sowohl für die abstrakte Methode DisplayInfo als auch für die virtuelle Methode StartEngine.

Unterschied und Anwendungszeitpunkt

• Verwenden Sie abstrakte Methoden, wenn alle abgeleiteten Klassen ihre eigene Implementierung einer Methode bereitstellen müssen.

• Verwenden Sie virtuelle Methoden, wenn abgeleitete Klassen die Möglichkeit haben sollen, eine Vorgabe zu überschreiben oder zusätzliche Verhaltensweisen anzubieten.

  Abstrakte und virtuelle Methoden sind leistungsstarke Funktionen in C#, die es Ihnen ermöglichen, besser wartbaren und wiederverwendbaren Code zu schreiben. Indem Sie alle Methoden in einer Basisklasse als abstrakt oder virtuell definieren, können Sie festlegen, welche Methoden in abgeleiteten Klassen überschrieben werden müssen und welche Methoden optional überschrieben werden können, um das Standardverhalten zu ändern oder zu erweitern.

Überschreiben von virtuellen Methoden

Das Überschreiben virtueller Methoden in abgeleiteten Klassen ermöglicht ein benutzerdefiniertes Verhalten, während die Option, die Implementierung der Basisklasse aufzurufen, erhalten bleibt. Dies wird mit dem Schlüsselwort base erreicht.

Beispiel für Überschreiben und Aufrufen der Basisimplementierung

public class ElectricCar : Car
{
    public override void StartEngine()
    {
        base.StartEngine(); // Call the base class implementation
        Console.WriteLine("Electric car engine started with energy-saving mode.");
    }
}

public class ElectricCar : Car
{
    public override void StartEngine()
    {
        base.StartEngine(); // Call the base class implementation
        Console.WriteLine("Electric car engine started with energy-saving mode.");
    }
}

Public Class ElectricCar
	Inherits Car

	Public Overrides Sub StartEngine()
		MyBase.StartEngine() ' Call the base class implementation
		Console.WriteLine("Electric car engine started with energy-saving mode.")
	End Sub
End Class

In diesem Beispiel überschreibt ElectricCar, eine Unterklasse von Car, die von der übergeordneten Klasse geerbte Methode StartEngine. Sie ruft die Implementierung der Basisklasse auf und fügt zusätzliches Verhalten speziell für Elektroautos hinzu.

Implementierung von abstrakten und nicht-abstrakten Klassen

Es ist wichtig, die praktischen Unterschiede und Anwendungen von abstrakten und nicht-abstrakten Klassen in der Softwareentwicklung zu verstehen. Abstrakte Klassen dienen als Vorlage für andere Klassen, während nicht-abstrakte Klassen zur Instanziierung von Objekten verwendet werden. Die Entscheidung zwischen einer abstrakten Klasse und einer nicht-abstrakten Klasse hängt davon ab, ob Sie eine Basisklasse erstellen müssen, die nicht eigenständig instanziiert werden soll.

IronPDF: C# PDF-Bibliothek

IronPDF ist eine umfassende PDF-Bibliothek, die für die Erstellung, Bearbeitung und das Lesen von PDF-Dokumenten direkt in .NET-Anwendungen entwickelt wurde. Dieses Tool zeichnet sich durch seine Fähigkeit aus, Folgendes zu erstellen PDFs direkt aus HTML-Strings, HTML-Dateien und URLs. Entwickler können PDF-Inhalte in C#-Projekten programmatisch erstellen, ändern und extrahieren. Schauen wir uns ein Beispiel für IronPDF im Zusammenhang mit unserem Artikel an.

Die Hauptfunktion von IronPDF ist das Konvertieren von HTML zu PDF, wobei das Layout und die Stile erhalten bleiben. Dieses Werkzeug ist ideal zur Erstellung von PDFs aus Webinhalten für Berichte, Rechnungen und Dokumentationen. Es unterstützt die Umwandlung von HTML-Dateien, URLs und HTML-Strings in PDF-Dateien.

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()

		' 1. Convert HTML String to PDF
		Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
		Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
		pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")

		' 2. Convert HTML File to PDF
		Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
		Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
		pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

		' 3. Convert URL to PDF
		Dim url = "http://ironpdf.com" ' Specify the URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class

Code-Beispiel

Hier ist ein einfaches Beispiel, um die Verwendung der Schlüsselwörter virtuell und abstrakt im Zusammenhang mit der Erweiterung der IronPDF-Funktionalitäten zu veranschaulichen:

public abstract class PdfReportGenerator
{
    // Use abstract method to force derived classes to implement their custom PDF generation logic.
    public abstract void GenerateReport(string filePath);
    // A virtual function allows derived classes to override the default implementation of PDF setup.
    public virtual void SetupPdfGenerator()
    {
        // Default PDF setup logic that can be overridden by derived classes.
        IronPdf.Installation.TempFolderPath = @"F:\TempPdfFiles";
    }
}
public class MonthlyReportGenerator : PdfReportGenerator
{
    // Override abstract method to provide specific implementation using override modifier.
    public override void GenerateReport(string filePath)
    {
        var pdf = new ChromePdfRenderer();
        pdf.RenderHtmlAsPdf("<h1>Monthly Report</h1> <p>Add Your report content here....</p>").SaveAs(filePath);
    }
    // Optionally override the virtual method to customize the setup.
    public override void SetupPdfGenerator()
    {
        base.SetupPdfGenerator();
        // Additional setup logic specific to monthly reports.
        IronPdf.Installation.TempFolderPath = @"F:\MonthlyReports";
    }
}
class Program
{
    static void Main(string [] args)
    {
        License.LicenseKey = "License-Key";
        PdfReportGenerator reportGenerator = new MonthlyReportGenerator();
        reportGenerator.SetupPdfGenerator();
        reportGenerator.GenerateReport(@"F:\MonthlyReports\MonthlyReport.pdf");
        Console.WriteLine("Report generated successfully.");
    }
}

public abstract class PdfReportGenerator
{
    // Use abstract method to force derived classes to implement their custom PDF generation logic.
    public abstract void GenerateReport(string filePath);
    // A virtual function allows derived classes to override the default implementation of PDF setup.
    public virtual void SetupPdfGenerator()
    {
        // Default PDF setup logic that can be overridden by derived classes.
        IronPdf.Installation.TempFolderPath = @"F:\TempPdfFiles";
    }
}
public class MonthlyReportGenerator : PdfReportGenerator
{
    // Override abstract method to provide specific implementation using override modifier.
    public override void GenerateReport(string filePath)
    {
        var pdf = new ChromePdfRenderer();
        pdf.RenderHtmlAsPdf("<h1>Monthly Report</h1> <p>Add Your report content here....</p>").SaveAs(filePath);
    }
    // Optionally override the virtual method to customize the setup.
    public override void SetupPdfGenerator()
    {
        base.SetupPdfGenerator();
        // Additional setup logic specific to monthly reports.
        IronPdf.Installation.TempFolderPath = @"F:\MonthlyReports";
    }
}
class Program
{
    static void Main(string [] args)
    {
        License.LicenseKey = "License-Key";
        PdfReportGenerator reportGenerator = new MonthlyReportGenerator();
        reportGenerator.SetupPdfGenerator();
        reportGenerator.GenerateReport(@"F:\MonthlyReports\MonthlyReport.pdf");
        Console.WriteLine("Report generated successfully.");
    }
}

Public MustInherit Class PdfReportGenerator
	' Use abstract method to force derived classes to implement their custom PDF generation logic.
	Public MustOverride Sub GenerateReport(ByVal filePath As String)
	' A virtual function allows derived classes to override the default implementation of PDF setup.
	Public Overridable Sub SetupPdfGenerator()
		' Default PDF setup logic that can be overridden by derived classes.
		IronPdf.Installation.TempFolderPath = "F:\TempPdfFiles"
	End Sub
End Class
Public Class MonthlyReportGenerator
	Inherits PdfReportGenerator

	' Override abstract method to provide specific implementation using override modifier.
	Public Overrides Sub GenerateReport(ByVal filePath As String)
		Dim pdf = New ChromePdfRenderer()
		pdf.RenderHtmlAsPdf("<h1>Monthly Report</h1> <p>Add Your report content here....</p>").SaveAs(filePath)
	End Sub
	' Optionally override the virtual method to customize the setup.
	Public Overrides Sub SetupPdfGenerator()
		MyBase.SetupPdfGenerator()
		' Additional setup logic specific to monthly reports.
		IronPdf.Installation.TempFolderPath = "F:\MonthlyReports"
	End Sub
End Class
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		License.LicenseKey = "License-Key"
		Dim reportGenerator As PdfReportGenerator = New MonthlyReportGenerator()
		reportGenerator.SetupPdfGenerator()
		reportGenerator.GenerateReport("F:\MonthlyReports\MonthlyReport.pdf")
		Console.WriteLine("Report generated successfully.")
	End Sub
End Class

In diesem Beispiel für eine benutzerdefinierte Implementierung ist PdfReportGenerator eine abstrakte Klasse, die einen Vertrag für die Erstellung von PDF-Berichten mit einer Methode zur Generierung des Berichts und einer virtuellen Methode zur Einrichtung definiert, die optional überschrieben werden kann. MonthlyReportGenerator ist eine konkrete Implementierung, die die Besonderheiten für die Erstellung eines Monatsberichts bereitstellt und die Einrichtung durch Überschreiben der virtuellen Methode anpasst.

Schlussfolgerung

Das Verständnis und die effektive Nutzung von virtuellen und abstrakten Methoden können Ihre C#-Programmierung erheblich verbessern. Denken Sie daran, dass abstrakte Methoden eine abgeleitete Klasse erfordern, die eine Implementierung bereitstellt, während virtuelle Methoden eine optionale Überschreibung einer Standardimplementierung ermöglichen. IronPDF-Bibliothek bietet eine kostenloser Testund Lizenzen sind ab 749 $ erhältlich und bieten eine umfassende Lösung für Ihre PDF-Anforderungen.