C# Virtual Keyword (How It Works For Developers)

Basic Usage of Virtual Keyword

At its core, a virtual method is a base class method that allows derived classes to provide a specific implementation for methods that are already defined in the base class.

The virtual keyword in C# marks a method, property, or event as virtual, signaling that it can be overridden in any class inheriting from it. Consider the following example where we define a base class Shape with a virtual method 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
    }
}

Overriding Virtual Methods

Derived classes can override these virtual methods to provide their own implementation, tailored to the specific requirements of the derived class. Using the override keyword, let's create a Circle class that derives from Shape and provides its own version of the Area method:

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

In the above code, the Circle class provides its specific implementation of the Area method, which calculates the area of a circle. This demonstrates the power of virtual methods in polymorphism.

Non-Virtual Methods

It's important to note that not all methods need to be or should be virtual. A non-virtual method is defined in such a way that it cannot be overridden in derived classes, which means the initial implementation remains unchanged and is utilized by all classes that inherit from it. This is useful when a base class provides a standard implementation that should not be altered.

Practical Application

Let's put these concepts to work in a practical scenario. Consider the following program that uses our Shape and Circle classes:

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()}");
    }
}

The above example program demonstrates polymorphism in action and the essence of virtual function. Despite myCircle being declared as a Shape, it calls the overridden Area method from the Circle class, showcasing the dynamic dispatch mechanism facilitated by the virtual and override keywords.

Abstract Methods and Classes

Abstract methods are a step further, used in abstract classes. An abstract method is a method declared in the base class without an implementation and must be overridden in derived classes. It forces derived classes to provide an implementation for the abstract method, ensuring a consistent interface while allowing for customized behavior in each derived class.

Method Overloading vs. Overriding

It's also crucial to understand the difference between method overloading and method overriding. Method overloading occurs within the same class and allows more than one method to have the same name but different parameters. Method overriding, facilitated by virtual and override keywords, allows a derived class to provide a different implementation for a method defined in the base class.

Virtual Properties and Events

Besides methods, properties, and events can also be virtual. This enables derived classes to provide custom getters, setters, and event handlers, further enhancing the flexibility of class hierarchies.

Example: Customizing PDF Rendering with Virtual Methods

Imagine you have a base class that uses IronPDF to render PDFs from HTML strings. By marking the rendering method as virtual, you allow derived classes to modify or enhance the rendering process. Here's a simple example:

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

We utilize IronPDF within a BasicPdfRenderer class to convert HTML to PDF, marking its RenderHtmlToPdf method as virtual to allow customization. The CustomPdfRenderer class, derived from BasicPdfRenderer, overrides this method to not only perform the conversion but also to inject a distinct, large, red watermark across the generated PDF.

Output PDF File

It is the PDF file generated by the IronPDF: