C# Vitrual Vs Abstract (How It Works For Developers)

Abstract Class and Methods

An abstract class is a special type of class that cannot be instantiated directly. Instead, it serves as a blueprint for other classes. An abstract class may contain abstract methods, which are methods declared in the abstract class but must be implemented in concrete-derived classes.

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

In this example, the Vehicle class is abstract, and DisplayInfo is an abstract method. The DisplayInfo method doesn't have any implementation in the Vehicle class. It forces the derived class to provide its own definition of this method.

Virtual Methods

Virtual methods are methods in a base class that have a default implementation but can be overridden in derived classes. The virtual keyword is used to declare a method as virtual. Derived classes use the override keyword to provide a specific implementation of the method, which helps to understand how a child class can override the virtual method of its parent.

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

Here, the Animal class has a virtual method Speak with a default implementation. Derived classes can override the method to provide a specific animal sound using the override keyword.

Combining Virtual and Abstract Methods

A class can have both abstract and virtual methods. Abstract methods do not have an implementation and must be overridden in derived classes, whereas virtual methods have a default implementation that derived classes can override optionally.

Consider a scenario where you're building a system that models different types of vehicles, each with its way of displaying information. Here's how you can use abstract and virtual methods:

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

In this Vehicle class, DisplayInfo is an abstract method, forcing all derived classes to implement their way of displaying information. StartEngine, however, provides a default way to start the engine, which can be overridden by an inherited class if needed.

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

Overriding Virtual Methods

Overriding virtual methods in derived classes allows for custom behavior while retaining the option to call the base class implementation. This is achieved using the base keyword.

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

IronPDF: C# PDF Library

IronPDF is a comprehensive PDF library designed for generating, editing, and reading PDF documents directly within .NET applications. This tool stands out for its ability to create PDFs directly from HTML strings, files, and URLs. Developers can create, modify, and extract PDF content programmatically in C# projects. Let's explore an example of IronPDF in the context of our article.

The main capability of IronPDF is converting HTML to PDF, ensuring that layouts and styles are retained. This tool is great for creating PDFs from web content for reports, invoices, and documentation. It supports the conversion of HTML files, URLs, and HTML strings to PDF files.

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

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

Conclusion

Understanding and using virtual and abstract methods effectively can significantly enhance your C# programming. Remember, abstract methods require a derived class to provide an implementation, while virtual methods allow for an optional override of a default implementation. IronPDF library offers a free trial and licensing options, with licenses starting from $799, providing a comprehensive solution for your PDF needs.