C#: wirtualne a abstrakcyjne (jak to działa dla programistów)

Klasa abstrakcyjna i metody

Klasa abstrakcyjna to specjalny typ klasy, której nie można bezpośrednio instancjonować. Zamiast tego służy jako wzór dla innych klas. Klasa abstrakcyjna może zawierać metody abstrakcyjne, które są metodami zadeklarowanymi w klasie abstrakcyjnej, ale muszą być zaimplementowane w konkretnych klasach pochodnych.

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

W tym przykładzie klasa Vehicle jest abstrakcyjna, a DisplayInfo jest metodą abstrakcyjną. Metoda DisplayInfo nie ma żadnej implementacji w klasie Vehicle. Wymusza to na klasie pochodnej dostarczenie własnej definicji tej metody.

Metody wirtualne

Metody wirtualne to metody w klasie bazowej, które mają domyślną implementację, ale mogą być nadpisane w klasach pochodnych. Słowo kluczowe virtual służy do deklarowania metody jako wirtualnej. Klasy pochodne używają słowa kluczowego override, aby zapewnić konkretną implementację metody, co pomaga zrozumieć, w jaki sposób klasa potomna może nadpisać metodę wirtualną swojej klasy nadrzędnej.

// Non-abstract class
public class Animal
{
    // Virtual method with a default implementation
    public virtual void Speak()
    {
        Console.WriteLine("Some generic animal sound");
    }
}

// Non-abstract class
public class Animal
{
    // Virtual method with a default implementation
    public virtual void Speak()
    {
        Console.WriteLine("Some generic animal sound");
    }
}

' Non-abstract class
Public Class Animal
	' Virtual method with a default implementation
	Public Overridable Sub Speak()
		Console.WriteLine("Some generic animal sound")
	End Sub
End Class

W tym przypadku klasa Animal posiada metodę wirtualną Speak z domyślną implementacją. Klasy pochodne mogą nadpisywać metodę, aby zapewnić konkretny odgłos zwierzęcia, używając słowa kluczowego override.

Łączenie metod wirtualnych i abstrakcyjnych

Klasa może posiadać zarówno metody abstrakcyjne, jak i wirtualne. Metody abstrakcyjne nie mają implementacji i muszą być nadpisywane w klasach pochodnych, podczas gdy metody wirtualne mają domyślną implementację, którą klasy pochodne mogą opcjonalnie nadpisać.

Rozważmy scenariusz, w którym tworzysz system modelujący różne typy pojazdów, z których każdy ma swój sposób wyświetlania informacji. Oto jak można używać metod abstrakcyjnych i wirtualnych:

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

W tej klasie Vehicle metoda DisplayInfo jest metodą abstrakcyjną, co wymusza na wszystkich klasach pochodnych zaimplementowanie własnego sposobu wyświetlania informacji. StartEngine zapewnia jednak domyślny sposób uruchamiania silnika, który w razie potrzeby może zostać nadpisany przez klasę dziedziczącą.

public class Car : Vehicle
{
    // Override the abstract method
    public override void DisplayInfo()
    {
        Console.WriteLine("This is a car.");
    }

    // Override the virtual method
    public override void StartEngine()
    {
        Console.WriteLine("Car engine started with custom settings.");
    }
}

public class Car : Vehicle
{
    // Override the abstract method
    public override void DisplayInfo()
    {
        Console.WriteLine("This is a car.");
    }

    // Override the virtual method
    public override void StartEngine()
    {
        Console.WriteLine("Car engine started with custom settings.");
    }
}

Public Class Car
	Inherits Vehicle

	' Override the abstract method
	Public Overrides Sub DisplayInfo()
		Console.WriteLine("This is a car.")
	End Sub

	' Override the virtual method
	Public Overrides Sub StartEngine()
		Console.WriteLine("Car engine started with custom settings.")
	End Sub
End Class

Nadpisywanie metod wirtualnych

Nadpisywanie metod wirtualnych w klasach pochodnych pozwala na dostosowanie zachowania, zachowując jednocześnie możliwość wywołania implementacji klasy bazowej. Osiąga się to poprzez użycie słowa kluczowego "base".

public class ElectricCar : Car
{
    // Override the StartEngine method
    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
{
    // Override the StartEngine method
    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

	' Override the StartEngine method
	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

IronPDF: biblioteka PDF dla języka C

IronPDF to kompleksowa biblioteka PDF przeznaczona do generowania, edycji i odczytu dokumentów PDF bezpośrednio w aplikacjach .NET. Narzędzie to wyróżnia się możliwością tworzenia plików PDF bezpośrednio z ciągów znaków HTML, plików i adresów URL. Programiści mogą programowo tworzyć, modyfikować i wyodrębniać zawartość plików PDF w projektach C#. Przyjrzyjmy się przykładowi IronPDF w kontekście naszego artykułu.

Główną funkcją IronPDF jest konwersja HTML do PDF z zachowaniem układu i stylów. To narzędzie świetnie nadaje się do tworzenia plików PDF z treści internetowych na potrzeby raportów, faktur i dokumentacji. Obsługuje konwersję plików HTML, adresów URL i ciągów znaków HTML do plików PDF.

using IronPdf;

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

        // 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");

        // 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");

        // 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();

        // 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");

        // 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");

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

		' 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")

		' 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")

		' 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

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

Wnioski

Zrozumienie i skuteczne wykorzystanie metod wirtualnych i abstrakcyjnych może znacznie usprawnić programowanie w języku C#. Należy pamiętać, że metody abstrakcyjne wymagają klasy pochodnej w celu zapewnienia implementacji, podczas gdy metody wirtualne pozwalają na opcjonalne nadpisanie domyślnej implementacji. Biblioteka IronPDF oferuje bezpłatną wersję próbną oraz opcje licencyjne, których ceny zaczynają się od $799, zapewniając kompleksowe rozwiązanie dla Twoich potrzeb związanych z plikami PDF.