A palavra-chave virtual em C# (como funciona para desenvolvedores)

Uso básico de palavras-chave virtuais

Em sua essência, um método virtual é um método de classe base que permite que classes derivadas forneçam uma implementação específica para métodos que já estão definidos na classe base.

A palavra-chave virtual em C# marca um método, propriedade ou evento como virtual, sinalizando que ele pode ser sobrescrito em qualquer classe que herde dele. Considere o seguinte exemplo, onde definimos uma classe base Shape com um método virtual 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

Sobrescrita de métodos virtuais

As classes derivadas podem sobrescrever esses métodos virtuais para fornecer sua própria implementação, adaptada aos requisitos específicos da classe derivada. Usando a palavra-chave override, vamos criar uma classe Circle que herda de Shape e fornece sua própria versão do método 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

No código acima, a classe Circle fornece sua implementação específica do método Area , que calcula a área de um círculo. Isso demonstra o poder dos métodos virtuais no polimorfismo.

Métodos não virtuais

É importante observar que nem todos os métodos precisam ou devem ser virtuais. Um método não virtual é definido de forma que não possa ser sobrescrito em classes derivadas, o que significa que a implementação inicial permanece inalterada e é utilizada por todas as classes que herdam dela. Isso é útil quando uma classe base fornece uma implementação padrão que não deve ser alterada.

Aplicação prática

Vamos colocar esses conceitos em prática em um cenário real. Considere o seguinte programa que utiliza nossas classes de Formas e Círculos :

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

O programa de exemplo acima demonstra o polimorfismo em ação e a essência da função virtual. Apesar de myCircle ter sido declarado como um Shape , ele chama o método **Area sobrescrito da classe Circle** , demonstrando o mecanismo de despacho dinâmico facilitado pelas palavras-chave virtual e override.

Métodos abstratos e classes

Os métodos abstratos representam um passo além, sendo utilizados em classes abstratas. Um método abstrato é um método declarado na classe base sem implementação e que deve ser sobrescrito nas classes derivadas. Isso força as classes derivadas a fornecerem uma implementação para o método abstrato, garantindo uma interface consistente e permitindo, ao mesmo tempo, um comportamento personalizado em cada classe derivada.

Sobrecarga de métodos vs. Substituição

É crucial também entender a diferença entre sobrecarga de métodos e sobrescrita de métodos. A sobrecarga de métodos ocorre dentro da mesma classe e permite que mais de um método tenha o mesmo nome, mas parâmetros diferentes. A sobrescrita de métodos, facilitada pelas palavras-chave virtual e override, permite que uma classe derivada forneça uma implementação diferente para um método definido na classe base.

Propriedades e eventos virtuais

Além dos métodos, as propriedades e os eventos também podem ser virtuais. Isso permite que as classes derivadas forneçam getters, setters e manipuladores de eventos personalizados, aumentando ainda mais a flexibilidade das hierarquias de classes.

Exemplo: Personalizando a renderização de PDF com métodos virtuais

Imagine que você tem uma classe base que usa o IronPDF para renderizar PDFs a partir de strings HTML. Ao marcar o método de renderização como virtual, você permite que as classes derivadas modifiquem ou aprimorem o processo de renderização. Eis um exemplo simples:

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

Utilizamos o IronPDF dentro de uma classe BasicPdfRenderer para converter HTML em PDF, marcando seu método RenderHtmlToPdf como virtual para permitir personalização. A classe CustomPdfRenderer , derivada de BasicPdfRenderer , sobrescreve esse método não apenas para realizar a conversão, mas também para inserir uma marca d'água vermelha grande e distinta no PDF gerado .

Arquivo PDF de saída

É o arquivo PDF gerado pelo IronPDF: