C# Basis-Konstruktor aufrufen (Funktionsweise für Entwickler)

Das Schlüsselwort 'base' in Konstruktoraufrufen

Das Schlüsselwort base wird in C# innerhalb einer abgeleiteten Klasse verwendet, um auf die Basisklasse zu verweisen. Es ist besonders nützlich bei der Konstruktorerklärung, wenn Sie den Konstruktor der Basisklasse anstelle des abgeleiteten Konstruktors aufrufen müssen. Mit dem base-Schlüsselwort kann der geerbte Konstruktor angeben, welcher Basisklasse-Konstruktor ausgeführt werden soll, um den entsprechenden Konstruktorkörper zu aktivieren. Diese Fähigkeit ist essentiell, wenn die Basisklasse keinen öffentlichen parameterlosen Konstruktor hat, oder spezifische Initialisierungen in der Basisklasse durchgeführt werden müssen.

Betrachten Sie ein Szenario, in dem Sie eine öffentliche abgeleitete Klasse haben, die von einer Basisklasse erbt. Die Basisklasse könnte einen privaten Konstruktor oder einen öffentlichen haben, der einen ganzzahligen Parameter benötigt:

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

Die abgeleitete Klasse muss diesen Konstruktor aufrufen, um den Basisteil ihrer Objekte richtig zu initialisieren:

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 diesem Beispiel: base(b) ruft explizit den Konstruktor der Basisklasse mit dem Parameter b auf. Dies stellt sicher, dass das Feld b in der Basisklasse initialisiert wird, bevor der Konstruktor der abgeleiteten Klasse mit seinem Rumpf fortfährt.

Behandlung mehrerer Konstruktoren

Oft haben sowohl Basis- als auch abgeleitete Klassen mehrere Konstruktoren. Die abgeleitete Klasse kann wählen, welchen Basisklassen-Konstruktor sie aufrufen möchte. Diese Auswahl ist entscheidend, wenn die Basisklassen-Konstruktoren unterschiedliche Arten von Initialisierungen durchführen.

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 dieser Konfiguration bietet DerivedClass Flexibilität, indem es den Konstruktoren der Basisklasse entspricht und so sicherstellt, dass alle von BaseClass bereitgestellten Initialisierungsformen je nach Bedarf bei der Objekterstellung zugänglich sind.

Codebeispiel

Um zu demonstrieren, wie IronPDF in C# verwendet wird, um ein PDF aus HTML zu erstellen, können Sie eine Basisklasse verwenden, die IronPDF initialisiert, und eine abgeleitete Klasse, die diese Initialisierung zur Erstellung eines PDFs verwendet. Hier ist ein Beispiel, wie Sie dies mit einem Basiskonstruktor strukturieren können:

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

Diese Code-Struktur fördert Wiederverwendbarkeit und Modularität, was es einfacher macht, unterschiedliche Anforderungen an die PDF-Erzeugung innerhalb größerer Anwendungen zu verwalten.

Ausgabe