Słowo kluczowe C# Virtual (jak działa dla programistów)

Podstawowe zastosowanie wirtualnego słowa kluczowego

W swej istocie metoda wirtualna jest metodą klasy bazowej, która pozwala klasom pochodnym na zapewnienie konkretnej implementacji metod już zdefiniowanych w klasie bazowej.

Słowo kluczowe virtual w języku C# oznacza metodę, właściwość lub zdarzenie jako wirtualne, sygnalizując, że może ono zostać nadpisane w dowolnej klasie dziedziczącej po nim. Rozważmy następujący przykład, w którym definiujemy klasę bazową Shape z metodą wirtualną Area:

public class Shape
{
    public virtual double Area()
    {
        return 0; // Default implementation, returns 0
    }
}

public class Shape
{
    public virtual double Area()
    {
        return 0; // Default implementation, returns 0
    }
}

Public Class Shape
	Public Overridable Function Area() As Double
		Return 0 ' Default implementation, returns 0
	End Function
End Class

Nadpisywanie metod wirtualnych

Klasy pochodne mogą nadpisywać te metody wirtualne, aby zapewnić własną implementację, dostosowaną do konkretnych wymagań klasy pochodnej. Używając słowa kluczowego override, stwórzmy klasę Circle, która dziedziczy po Shape i udostępnia własną wersję metody Area:

public class Circle : Shape
{
    public double Radius { get; set; }

    public Circle(double radius)
    {
        Radius = radius;
    }

    public override double Area()
    {
        // Own implementation for circle area
        return Math.PI * Radius * Radius; 
    }
}

public class Circle : Shape
{
    public double Radius { get; set; }

    public Circle(double radius)
    {
        Radius = radius;
    }

    public override double Area()
    {
        // Own implementation for circle area
        return Math.PI * Radius * Radius; 
    }
}

Public Class Circle
	Inherits Shape

	Public Property Radius() As Double

	Public Sub New(ByVal radius As Double)
		Me.Radius = radius
	End Sub

	Public Overrides Function Area() As Double
		' Own implementation for circle area
		Return Math.PI * Radius * Radius
	End Function
End Class

W powyższym kodzie klasa Circle udostępnia swoją specyficzną implementację metody Area, która oblicza pole powierzchni koła. To pokazuje potęgę metod wirtualnych w polimorfizmie.

Metody niewirtualne

Należy pamiętać, że nie wszystkie metody muszą być lub powinny być wirtualne. Metoda niewirtualna jest zdefiniowana w taki sposób, że nie można jej nadpisać w klasach pochodnych, co oznacza, że początkowa implementacja pozostaje niezmieniona i jest wykorzystywana przez wszystkie klasy, które z niej dziedziczą. Jest to przydatne, gdy klasa bazowa zapewnia standardową implementację, której nie należy zmieniać.

Zastosowanie praktyczne

Zastosujmy te koncepcje w praktycznym scenariuszu. Rozważmy następujący program, który wykorzystuje nasze klasy Shape i Circle:

public class Program
{
    public static void Main(string[] args)
    {
        Shape myShape = new Shape();
        Shape myCircle = new Circle(5);

        // Display the area calculation of the default and overridden methods.
        Console.WriteLine($"Shape area: {myShape.Area()}");
        Console.WriteLine($"Circle area: {myCircle.Area()}");
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        Shape myShape = new Shape();
        Shape myCircle = new Circle(5);

        // Display the area calculation of the default and overridden methods.
        Console.WriteLine($"Shape area: {myShape.Area()}");
        Console.WriteLine($"Circle area: {myCircle.Area()}");
    }
}

Public Class Program
	Public Shared Sub Main(ByVal args() As String)
		Dim myShape As New Shape()
		Dim myCircle As Shape = New Circle(5)

		' Display the area calculation of the default and overridden methods.
		Console.WriteLine($"Shape area: {myShape.Area()}")
		Console.WriteLine($"Circle area: {myCircle.Area()}")
	End Sub
End Class

Powyższy przykładowy program ilustruje działanie polimorfizmu oraz istotę funkcji wirtualnej. Pomimo tego, że myCircle jest zadeklarowane jako Shape, wywołuje ono nadpisane metodę Area z klasy Circle, demonstrując mechanizm dynamicznego wysyłania ułatwiony przez słowa kluczowe virtual i override.

Metody i klasy abstrakcyjne

Metody abstrakcyjne stanowią kolejny krok naprzód i są używane w klasach abstrakcyjnych. Metoda abstrakcyjna to metoda zadeklarowana w klasie bazowej bez implementacji, która musi zostać nadpisana w klasach pochodnych. Wymusza to na klasach pochodnych dostarczenie implementacji dla metody abstrakcyjnej, zapewniając spójny interfejs, a jednocześnie umożliwiając dostosowanie zachowania w każdej klasie pochodnej.

Przeładowanie metod a nadpisywanie

Bardzo ważne jest również zrozumienie różnicy między przeciążaniem metod a nadpisywaniem metod. Przeciążanie metod ma miejsce w obrębie tej samej klasy i pozwala na to, by więcej niż jedna metoda miała tę samą nazwę, ale różne parametry. Nadpisywanie metod, ułatwione przez słowa kluczowe virtual i override, pozwala klasie pochodnej na zapewnienie innej implementacji metody zdefiniowanej w klasie bazowej.

Wirtualne właściwości i zdarzenia

Oprócz metod, właściwości i zdarzenia również mogą być wirtualne. Umożliwia to klasom pochodnym dostarczanie niestandardowych metod pobierających, ustawiających i procedur obsługi zdarzeń, co dodatkowo zwiększa elastyczność hierarchii klas.

Przykład: Dostosowywanie renderowania plików PDF za pomocą metod wirtualnych

Wyobraź sobie, że masz klasę bazową, która wykorzystuje IronPDF do renderowania plików PDF na podstawie ciągów znaków HTML. Oznaczając metodę renderowania jako wirtualną, umożliwiasz klasom pochodnym modyfikowanie lub ulepszanie procesu renderowania. Oto prosty przykład:

public class BasicPdfRenderer
{
    // Virtual method allowing customization in derived classes
    public virtual byte[] RenderHtmlToPdf(string htmlContent)
    {
        // Use IronPDF to render PDF from HTML
        var renderer = new IronPdf.ChromePdfRenderer();
        var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);
        return pdfDocument.BinaryData;
    }
}

public class CustomPdfRenderer : BasicPdfRenderer
{
    // Overriding the base class method to implement custom rendering settings
    public override byte[] RenderHtmlToPdf(string htmlContent)
    {
        var renderer = new IronPdf.ChromePdfRenderer();
        var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);

        // Apply a prominent watermark to the PDF document
        pdfDocument.ApplyWatermark("<h2 style='color:red; font-size: 60px; opacity: 0.5; text-shadow: 2px 2px 5px grey;'>SAMPLE</h2>",
                                   30,
                                   IronPdf.Editing.VerticalAlignment.Middle,
                                   IronPdf.Editing.HorizontalAlignment.Center);

        // Return the binary data of the PDF document
        return pdfDocument.BinaryData;
    }
}

class Program
{
    static void Main(string[] args)
    {
        License.LicenseKey = "License-Key";

        // HTML content to be converted to PDF
        string htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a simple PDF document generated from HTML.</p>";

        // Create an instance of CustomPdfRenderer
        CustomPdfRenderer renderer = new CustomPdfRenderer();

        // Call RenderHtmlToPdf method to generate PDF binary data
        byte[] pdfData = renderer.RenderHtmlToPdf(htmlContent);

        // Specify the file path to save the PDF
        string filePath = "f:\\CustomRenderedPdf.pdf";

        // Save the binary data to a file
        File.WriteAllBytes(filePath, pdfData);

        // Output success message
        Console.WriteLine($"PDF generated and saved to {filePath}");
    }
}

public class BasicPdfRenderer
{
    // Virtual method allowing customization in derived classes
    public virtual byte[] RenderHtmlToPdf(string htmlContent)
    {
        // Use IronPDF to render PDF from HTML
        var renderer = new IronPdf.ChromePdfRenderer();
        var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);
        return pdfDocument.BinaryData;
    }
}

public class CustomPdfRenderer : BasicPdfRenderer
{
    // Overriding the base class method to implement custom rendering settings
    public override byte[] RenderHtmlToPdf(string htmlContent)
    {
        var renderer = new IronPdf.ChromePdfRenderer();
        var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);

        // Apply a prominent watermark to the PDF document
        pdfDocument.ApplyWatermark("<h2 style='color:red; font-size: 60px; opacity: 0.5; text-shadow: 2px 2px 5px grey;'>SAMPLE</h2>",
                                   30,
                                   IronPdf.Editing.VerticalAlignment.Middle,
                                   IronPdf.Editing.HorizontalAlignment.Center);

        // Return the binary data of the PDF document
        return pdfDocument.BinaryData;
    }
}

class Program
{
    static void Main(string[] args)
    {
        License.LicenseKey = "License-Key";

        // HTML content to be converted to PDF
        string htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a simple PDF document generated from HTML.</p>";

        // Create an instance of CustomPdfRenderer
        CustomPdfRenderer renderer = new CustomPdfRenderer();

        // Call RenderHtmlToPdf method to generate PDF binary data
        byte[] pdfData = renderer.RenderHtmlToPdf(htmlContent);

        // Specify the file path to save the PDF
        string filePath = "f:\\CustomRenderedPdf.pdf";

        // Save the binary data to a file
        File.WriteAllBytes(filePath, pdfData);

        // Output success message
        Console.WriteLine($"PDF generated and saved to {filePath}");
    }
}

Public Class BasicPdfRenderer
	' Virtual method allowing customization in derived classes
	Public Overridable Function RenderHtmlToPdf(ByVal htmlContent As String) As Byte()
		' Use IronPDF to render PDF from HTML
		Dim renderer = New IronPdf.ChromePdfRenderer()
		Dim pdfDocument = renderer.RenderHtmlAsPdf(htmlContent)
		Return pdfDocument.BinaryData
	End Function
End Class

Public Class CustomPdfRenderer
	Inherits BasicPdfRenderer

	' Overriding the base class method to implement custom rendering settings
	Public Overrides Function RenderHtmlToPdf(ByVal htmlContent As String) As Byte()
		Dim renderer = New IronPdf.ChromePdfRenderer()
		Dim pdfDocument = renderer.RenderHtmlAsPdf(htmlContent)

		' Apply a prominent watermark to the PDF document
		pdfDocument.ApplyWatermark("<h2 style='color:red; font-size: 60px; opacity: 0.5; text-shadow: 2px 2px 5px grey;'>SAMPLE</h2>", 30, IronPdf.Editing.VerticalAlignment.Middle, IronPdf.Editing.HorizontalAlignment.Center)

		' Return the binary data of the PDF document
		Return pdfDocument.BinaryData
	End Function
End Class

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		License.LicenseKey = "License-Key"

		' HTML content to be converted to PDF
		Dim htmlContent As String = "<h1>Hello, IronPDF!</h1><p>This is a simple PDF document generated from HTML.</p>"

		' Create an instance of CustomPdfRenderer
		Dim renderer As New CustomPdfRenderer()

		' Call RenderHtmlToPdf method to generate PDF binary data
		Dim pdfData() As Byte = renderer.RenderHtmlToPdf(htmlContent)

		' Specify the file path to save the PDF
		Dim filePath As String = "f:\CustomRenderedPdf.pdf"

		' Save the binary data to a file
		File.WriteAllBytes(filePath, pdfData)

		' Output success message
		Console.WriteLine($"PDF generated and saved to {filePath}")
	End Sub
End Class

Wykorzystujemy IronPDF w klasie BasicPdfRenderer do konwersji HTML na PDF, oznaczając metodę RenderHtmlToPdf jako wirtualną, aby umożliwić dostosowanie. Klasa CustomPdfRenderer, wywodząca się z BasicPdfRenderer, nadpisuje tę metodę, aby nie tylko przeprowadzić konwersję, ale także umieścić wyraźny, duży, czerwony znak wodny na wygenerowanym pliku PDF.

Plik PDF wyjściowy

Jest to plik PDF wygenerowany przez IronPDF: