C# Call Base Constructor (How It Works For Developers)

When dealing with inheritance, the relationship between base and derived classes introduces complexities in how constructors are called. Understanding how to call a base class constructor from a derived class is helpful for properly managing object state and behavior.

This guide will explore the concept comprehensively, focusing on different scenarios and nuances related to constructor invocation in an inheritance hierarchy. It'll also explore the IronPDF library with its code example related to the topic.

Basic Concepts: Class Constructors and Inheritance

A constructor in C# is a special method in a class that initializes its objects. When a class inherits from another class, referred to as a base class, the derived class can also inherit or override the base class's constructors. The mechanism of calling base class constructor methods from a derived class ensures that the base class is properly initialized before the derived class adds its initialization.

The 'base' Keyword in Constructor Calls

The base keyword in C# is used within a derived class to refer to the base class. It is particularly useful in constructor declaration when you need to invoke the constructor of the base class instead of the derived constructor. Using the base keyword, the inherited constructor can specify which base class constructor should be executed to engage the appropriate constructor body. This capability is essential when the base class does not have a public parameterless constructor, or specific initialization in the base class needs to be performed.

Consider a scenario where you have a public class-derived class that inherits from a base class. The base class might have a private constructor or a public one that takes an integer parameter:

public class BaseClass {
    public int b;
    public BaseClass(int b) {
        this.b = b;
    }
}

public class BaseClass {
    public int b;
    public BaseClass(int b) {
        this.b = b;
    }
}

Public Class BaseClass
	Public b As Integer
	Public Sub New(ByVal b As Integer)
		Me.b = b
	End Sub
End Class

The derived class needs to call this constructor to properly initialize the base class part of its objects:

public class DerivedClass : BaseClass {
    public DerivedClass(int b) : base(b) {
        // Additional initialization for DerivedClass
    }
}

public class DerivedClass : BaseClass {
    public DerivedClass(int b) : base(b) {
        // Additional initialization for DerivedClass
    }
}

Public Class DerivedClass
	Inherits BaseClass

	Public Sub New(ByVal b As Integer)
		MyBase.New(b)
		' Additional initialization for DerivedClass
	End Sub
End Class

In this example: base(b) explicitly calls the base class constructor with the parameter b. This ensures that the field b in the base class is initialized before the derived class constructor proceeds with its body.

Detailed Use Cases and Variations

Handling Multiple Constructors

Often, both base and derived classes might have multiple constructors. The derived class can choose which base class constructor to call. This selection is critical when the base class constructors perform different kinds of initialization.

public class BaseClass {
    public BaseClass() {
        // Default constructor
    }
    public BaseClass(int b) {
        this.b = b;
    }
}
public class DerivedClass : BaseClass {
    public DerivedClass() : base() {
        // Calls the parameterless constructor of the base class
    }
    public DerivedClass(int b) : base(b) {
        // Calls the base class constructor that takes an int
    }
}

public class BaseClass {
    public BaseClass() {
        // Default constructor
    }
    public BaseClass(int b) {
        this.b = b;
    }
}
public class DerivedClass : BaseClass {
    public DerivedClass() : base() {
        // Calls the parameterless constructor of the base class
    }
    public DerivedClass(int b) : base(b) {
        // Calls the base class constructor that takes an int
    }
}

Public Class BaseClass
	Public Sub New()
		' Default constructor
	End Sub
	Public Sub New(ByVal b As Integer)
		Me.b = b
	End Sub
End Class
Public Class DerivedClass
	Inherits BaseClass

	Public Sub New()
		MyBase.New()
		' Calls the parameterless constructor of the base class
	End Sub
	Public Sub New(ByVal b As Integer)
		MyBase.New(b)
		' Calls the base class constructor that takes an int
	End Sub
End Class

In this setup, DerivedClass provides flexibility by corresponding to the base class's constructors, ensuring all forms of initialization provided by BaseClass are accessible, depending on the needs during object creation.

Introduction of IronPDF

IronPDF is a C# library designed for developers who need to create, read, and edit PDF documents within .NET applications. The primary benefit of using IronPDF is its ability to generate PDFs directly from HTML, CSS, images, and JavaScript. The library supports a variety of .NET frameworks and is compatible with numerous project types, including web forms, server applications, and console apps.

Code Example

To demonstrate using IronPDF in C# to create a PDF from HTML, you can use a base class that initializes IronPDF and a derived class that uses this initialization to create a PDF. Here’s an example of how you might structure this using a base constructor:

using IronPdf;
// Base class for PDF generation
public class PdfGenerator
{
    protected ChromePdfRenderer Renderer;
    // Base constructor initializes the HTML to PDF renderer
    public PdfGenerator()
    {
        Renderer = new ChromePdfRenderer();
        // Additional configuration
    }
}
// Derived class uses the base class to generate a specific PDF
public class SpecificPdfGenerator : PdfGenerator
{
    public void CreateSimplePdf(string htmlContent, string filePath)
    {
        // Uses the Renderer from the base class
        var pdfDocument = Renderer.RenderHtmlAsPdf(htmlContent);
        pdfDocument.SaveAs(filePath);
    }
}
// Usage
class Program
{
    static void Main(string[] args)
    {
        License.LicenseKey = "License-Key";
        var htmlContent = "<h1>Hello, IronPDF!</h1>";
        var filePath = "example.pdf";
        var pdfCreator = new SpecificPdfGenerator();
        pdfCreator.CreateSimplePdf(htmlContent, filePath);
    }
}

using IronPdf;
// Base class for PDF generation
public class PdfGenerator
{
    protected ChromePdfRenderer Renderer;
    // Base constructor initializes the HTML to PDF renderer
    public PdfGenerator()
    {
        Renderer = new ChromePdfRenderer();
        // Additional configuration
    }
}
// Derived class uses the base class to generate a specific PDF
public class SpecificPdfGenerator : PdfGenerator
{
    public void CreateSimplePdf(string htmlContent, string filePath)
    {
        // Uses the Renderer from the base class
        var pdfDocument = Renderer.RenderHtmlAsPdf(htmlContent);
        pdfDocument.SaveAs(filePath);
    }
}
// Usage
class Program
{
    static void Main(string[] args)
    {
        License.LicenseKey = "License-Key";
        var htmlContent = "<h1>Hello, IronPDF!</h1>";
        var filePath = "example.pdf";
        var pdfCreator = new SpecificPdfGenerator();
        pdfCreator.CreateSimplePdf(htmlContent, filePath);
    }
}

Imports IronPdf
' Base class for PDF generation
Public Class PdfGenerator
	Protected Renderer As ChromePdfRenderer
	' Base constructor initializes the HTML to PDF renderer
	Public Sub New()
		Renderer = New ChromePdfRenderer()
		' Additional configuration
	End Sub
End Class
' Derived class uses the base class to generate a specific PDF
Public Class SpecificPdfGenerator
	Inherits PdfGenerator

	Public Sub CreateSimplePdf(ByVal htmlContent As String, ByVal filePath As String)
		' Uses the Renderer from the base class
		Dim pdfDocument = Renderer.RenderHtmlAsPdf(htmlContent)
		pdfDocument.SaveAs(filePath)
	End Sub
End Class
' Usage
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		License.LicenseKey = "License-Key"
		Dim htmlContent = "<h1>Hello, IronPDF!</h1>"
		Dim filePath = "example.pdf"
		Dim pdfCreator = New SpecificPdfGenerator()
		pdfCreator.CreateSimplePdf(htmlContent, filePath)
	End Sub
End Class

This code structure promotes reusability and modularity, making it easier to manage different PDF generation needs within larger applications.

Output

Conclusion

Mastering how constructors are handled in an inheritance hierarchy in C# allows developers to write more reliable and maintainable code. By understanding the role of the base keyword and how to effectively manage multiple constructors and special scenarios like private constructors and a static method, you can ensure that your classes are correctly initialized in complex object hierarchies.

This comprehensive understanding is essential for both new and experienced developers working with object-oriented programming in C#. IronPDF for developers who want to test its features before committing to a purchase. After the trial period, if you decide that IronPDF meets your needs, the licensing starts at $749.