C# Primärkonstruktor (Wie es für Entwickler funktioniert)

In der objektorientierten Landschaft der C#-Programmierung bringt die Einführung von Primärkonstruktoren eine neue Ebene der Eleganz und Einfachheit in die Sprache. Primäre Konstruktoren sind neben Features wie Interceptern und Collection Expressions in C# 12 zu einem leistungsstarken Feature geworden, das eine prägnantere Syntax für die Deklaration von Konstruktoren mit Parametern bietet. Sie können die primären Konstruktoren in der Microsoft C# Leitfaden.

In diesem Artikel lernen wir, wie man die primären Konstruktoren von C# 12 effizient einsetzt. Wir untersuchen ihre Funktionalität, Anwendungsfälle und wie sie die Art und Weise verändern, wie Entwickler an die Initialisierung von Klassen herangehen.

Die Grundlagen verstehen: Konstrukteure in C##

Konstruktoren spielen eine zentrale Rolle in der objektorientierten Programmierung, da sie als Entwurf für die Initialisierung von Objekten dienen. Traditionell haben C#-Entwickler den Standardkonstruktor oder parametrisierte Konstruktoren verwendet, um den Anfangszustand ihrer Klassen einzurichten. Mit der Einführung von Primärkonstruktoren wird dieser wesentliche Aspekt der C#-Entwicklung jedoch noch weiter vereinfacht.

Das Wesen der Primärkonstrukteure

Ein primärer Konstruktor in C# ist ein prägnanter Weg, um Eigenschaften direkt innerhalb der Klassendeklaration zu deklarieren und zu initialisieren. Sie vereinfacht den Prozess der Definition und Zuweisung von Werten zu Eigenschaften und bietet eine deklarative und lesbare Syntax.

Vorteile von Primärkonstrukteuren

1. Kompaktheit: Primäre Konstruktoren bieten eine prägnante Syntax, die den Kesselsteincode reduziert und die Lesbarkeit verbessert.

2. Scoping: Im Gegensatz zu traditionellen Konstruktoren sind Parameter in primären Konstruktoren für die gesamte Klasse oder Struktur gültig und bieten somit Flexibilität bei der Verwendung.

3. Standardwerte: Standardparameterwerte vereinfachen die Objekterstellung und machen sie für Entwickler bequemer.

Deklaration eines Primärkonstruktors

Die Syntax für einen Primärkonstruktor beinhaltet die Deklaration der Eigenschaften direkt im Klassenkopf. Betrachten wir ein einfaches Beispiel der Klasse Person:

public class Person(string name, int age)
{
    public string Name { get; } = name;
    public int Age { get; } = age
    public override string ToString() => $"Name: {Name}, Age: {Age}";
}

public class Person(string name, int age)
{
    public string Name { get; } = name;
    public int Age { get; } = age
    public override string ToString() => $"Name: {Name}, Age: {Age}";
}

Public Class Person(String name, Integer age)
	Public ReadOnly Property Name() As String = name
	public Integer Age {get;} = age public override String ToString()
	If True Then
		Return $"Name: {Name}, Age: {Age}"
	End If
End Class

Im obigen Codeschnipsel hat die Klasse Person einen primären Konstruktor, der die Eigenschaften des Instanzmitglieds Name und des Instanzmitglieds Alter initialisiert. Die Konstruktorparameter werden mit dem Klassen- oder Strukturnamen deklariert und bei der Definition der öffentlichen Eigenschaften werden ihnen die Parameterwerte zugewiesen.

Beispiel 1: Unveränderlicher Punkt im 2D-Raum

public readonly struct Point(double x, double y)
{
    public double X { get; } = x;
    public double Y { get; } = y;
    public double Magnitude => Math.Sqrt(X * X + Y * Y);
}

public readonly struct Point(double x, double y)
{
    public double X { get; } = x;
    public double Y { get; } = y;
    public double Magnitude => Math.Sqrt(X * X + Y * Y);
}

'INSTANT VB WARNING: VB has no equivalent to the C# readonly struct:
'ORIGINAL LINE: public readonly struct Point(double x, double y)
Public Structure Point(Double x, Double y)
	Public ReadOnly Property X() As Double = x
	Public ReadOnly Property Y() As Double = y
	Public ReadOnly Property Magnitude() As Double
		Get
			Return Math.Sqrt(X * X + Y * Y)
		End Get
	End Property
End Structure

In diesem Beispiel initialisiert der primäre Konstruktor für die Point-Struktur die Eigenschaften X und Y und zeigt, wie prägnant und ausdrucksstark die Syntax sein kann.

Beispiel 2: Konfigurierbarer Logger mit Standardeinstellungen

public class Logger(string filePath = "log.txt", LogLevel level = LogLevel.Info)
{
    private readonly string _filePath = filePath;
    private readonly LogLevel _level = level;
    public void Log(string message)
    {
        // Actual logging implementation using _filePath and _level
    }
}

public class Logger(string filePath = "log.txt", LogLevel level = LogLevel.Info)
{
    private readonly string _filePath = filePath;
    private readonly LogLevel _level = level;
    public void Log(string message)
    {
        // Actual logging implementation using _filePath and _level
    }
}

'INSTANT VB TODO TASK: The following line contains an assignment within expression that was not extracted by Instant VB:
'ORIGINAL LINE: public class Logger(string filePath = "log.txt", LogLevel level = LogLevel.Info)
Public Class Logger(String filePath = "log.txt", LogLevel level = LogLevel.Info)
	Private ReadOnly _filePath As String = filePath
	Private ReadOnly _level As LogLevel = level
	Public Sub Log(ByVal message As String)
		' Actual logging implementation using _filePath and _level
	End Sub
End Class

Hier bietet der primäre Konstruktor für die Klasse Logger Standardwerte für filePath und level, wodurch die Klasse flexibel und einfach zu verwenden ist und gleichzeitig konfigurierbar bleibt.

Beispiel 3: Dependency Injection

public interface IService
{
    Distance GetDistance();
}
public class ExampleController(IService service) : ControllerBase
{
    public ActionResult<Distance> Get() => service.GetDistance();
}

public interface IService
{
    Distance GetDistance();
}
public class ExampleController(IService service) : ControllerBase
{
    public ActionResult<Distance> Get() => service.GetDistance();
}

Public Interface IService
	Function GetDistance() As Distance
End Interface
Public Class ExampleController(IService service)
	Inherits ControllerBase

	Public Function [Get]() As ActionResult(Of Distance)
		Return service.GetDistance()
	End Function
End Class

Primäre Konstrukteure eignen sich für Dependency-Injection-Szenarien. In diesem Beispiel zeigt eine Controllerklasse ihre Abhängigkeiten an, was die Wartbarkeit verbessert und das Testen von Einheiten erleichtert.

Beispiel 4: Aufbau einer geometrischen Formenhierarchie

public abstract class Shape(double width, double height)
{
    public double Width { get; } = width;
    public double Height { get; } = height;
    public abstract double CalculateArea();
}
public class Rectangle(double width, double height) : Shape(width, height)
{
    public override double CalculateArea() => Width * Height;
}
public class Circle : Shape
{
    public Circle(double radius) : base(radius * 2, radius * 2) { }
    public override double CalculateArea() => Math.PI * Math.Pow(Width / 2, 2);
}

public abstract class Shape(double width, double height)
{
    public double Width { get; } = width;
    public double Height { get; } = height;
    public abstract double CalculateArea();
}
public class Rectangle(double width, double height) : Shape(width, height)
{
    public override double CalculateArea() => Width * Height;
}
public class Circle : Shape
{
    public Circle(double radius) : base(radius * 2, radius * 2) { }
    public override double CalculateArea() => Math.PI * Math.Pow(Width / 2, 2);
}

Public MustInherit Class Shape(Double width, Double height)
	Public ReadOnly Property Width() As Double = width
	Public ReadOnly Property Height() As Double = height
	Public MustOverride Function CalculateArea() As Double
End Class
Public Class Rectangle(Double width, Double height)
	Inherits Shape(width, height)

	Public Overrides Function CalculateArea() As Double
		Return Width * Height
	End Function
End Class
Public Class Circle
	Inherits Shape

	Public Sub New(ByVal radius As Double)
		MyBase.New(radius * 2, radius * 2)
	End Sub
	Public Overrides Function CalculateArea() As Double
		Return Math.PI * Math.Pow(Width / 2, 2)
	End Function
End Class

In diesem Beispiel bildet der primäre Konstruktor in der Klasse Shape die Grundlage für eine geometrische Formenhierarchie. Unterklassen wie Rectangle und Circle nutzen den primären Konstruktor für eine konsistente Initialisierung. Die Klasse Rechteck deklariert selbst den primären Konstruktor und übergibt die erfassten primären Konstruktorparameter an die primären Parameter der Klasse Form. Die Klasse Circle zeigt ihre Flexibilität, indem sie ihren Konstruktor innerhalb der gesamten Klasse definiert und dann seine Parameter als Standardwerte für den Shape-Konstruktor mit dem Schlüsselwort base übergibt.

Einführung in IronPDF

IronPDF ist eine vielseitige C#-Bibliothek, die es Entwicklern ermöglicht, PDF-Dateien mühelos zu erstellen, zu bearbeiten und zu konvertieren. Egal, ob Sie Rechnungen, Berichte oder andere Dokumente erstellen, IronPDF ermöglicht Ihnen die nahtlose Konvertierung von HTML-Inhalten in ausgefeilte und professionelle PDFs direkt in Ihrer C#-Anwendung.

Installation von IronPDF: Ein Schnellstart

Um IronPDF in Ihr C#-Projekt einzubinden, installieren Sie zunächst das IronPDF NuGet-Paket. Führen Sie den folgenden Befehl in Ihrer Paketmanager-Konsole aus:

Install-Package IronPdf

Alternativ können Sie "IronPDF" im NuGet Package Manager suchen und von dort aus mit der Installation fortfahren.

Erzeugen von PDFs mit IronPDF

Die Erstellung einer PDF-Datei mit IronPDF ist ein rationalisierter Prozess. Betrachten Sie das folgende Beispiel:

var htmlContent = "<html><body><h1>Hello, IronPDF!</h1></body></html>";
// Create a new PDF document
var pdfDocument = new IronPdf.ChromePdfRenderer();
pdfDocument.RenderHtmlAsPdf(htmlContent).SaveAs("C:/GeneratedDocument.pdf");

var htmlContent = "<html><body><h1>Hello, IronPDF!</h1></body></html>";
// Create a new PDF document
var pdfDocument = new IronPdf.ChromePdfRenderer();
pdfDocument.RenderHtmlAsPdf(htmlContent).SaveAs("C:/GeneratedDocument.pdf");

Dim htmlContent = "<html><body><h1>Hello, IronPDF!</h1></body></html>"
' Create a new PDF document
Dim pdfDocument = New IronPdf.ChromePdfRenderer()
pdfDocument.RenderHtmlAsPdf(htmlContent).SaveAs("C:/GeneratedDocument.pdf")

In diesem Beispiel wird IronPDF verwendet, um HTML-Inhalte in ein PDF-Dokument umzuwandeln, das anschließend an einem bestimmten Ort gespeichert wird. Weitere Einzelheiten zur Erstellung und Bearbeitung von PDFs in C# finden Sie in diesem vollständigen Tutorial-Link, und um mehr zu erfahren, besuchen Sie bitte diese Dokumentation seite.

C# Primäre Konstrukteure: Eine Revolution der Klasseninitialisierung

C#-Primärkonstruktoren bieten einen deklarativen und rationalisierten Ansatz zur Initialisierung von Klasseneigenschaften direkt in der Klassendeklaration. Lassen Sie uns untersuchen, ob diese elegante Funktion nahtlos in IronPDF integriert werden kann.

Integration von C# Primäre Konstrukteure mit IronPDF

Während C#-Primärkonstruktoren in erster Linie ein Sprachfeature sind, das sich auf die Klasseninitialisierung konzentriert, ist ihre direkte Integration in IronPDF möglicherweise kein gängiger Anwendungsfall. Die Kernfunktionalität von IronPDF liegt in der Erzeugung und Bearbeitung von PDF-Dokumenten, und die Besonderheiten der Klasseninitialisierung sind möglicherweise nicht direkt mit diesem Arbeitsablauf vereinbar.

Entwickler können jedoch C#-Primärkonstruktoren nutzen, wenn sie benutzerdefinierte Klassen oder Strukturen im Zusammenhang mit IronPDF-Konfigurationen oder Datenmodellen definieren. Wenn Ihre Anwendung zum Beispiel eine bestimmte Klassenstruktur benötigt, um PDF-bezogene Einstellungen oder Konfigurationen zu verwalten, können C#-Primärkonstruktoren ein wertvolles Werkzeug sein, um diese Klassen präzise zu initialisieren.

public class PdfGenerationSettings(string title, bool includeHeader, bool includeFooter)
{
    public string Title { get; } = title;
    public bool IncludeHeader { get; } = includeHeader;
    public bool IncludeFooter { get; } = includeFooter;
    // Additional properties...
}
// Usage with IronPDF
var pdfSettings = new PdfGenerationSettings("My PDF Title", true, false);
var renderOptions = new ChromePdfRenderOptions();
// Apply settings from PdfGenerationSettings
renderOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4;
renderOptions.MarginTop = 20;
renderOptions.MarginBottom = 20;
renderOptions.MarginLeft = 10;
renderOptions.MarginRight = 10;
renderOptions.Title = pdfSettings.Title ?? string.Empty;
if (pdfSettings.IncludeHeader)
{
    renderOptions.TextHeader = new TextHeaderFooter
    {
        CenterText = "Page {page} of {total-pages}",
        DrawDividerLine = true
    };
}
var pdfDocument = new IronPdf.ChromePdfRenderer();
pdfDocument.RenderingOptions = renderOptions;
pdfDocument.RenderHtmlAsPdf("<html><body><h1>Hello, IronPDF!</h1></body></html>").SaveAs("CustomizedDocument.pdf");

public class PdfGenerationSettings(string title, bool includeHeader, bool includeFooter)
{
    public string Title { get; } = title;
    public bool IncludeHeader { get; } = includeHeader;
    public bool IncludeFooter { get; } = includeFooter;
    // Additional properties...
}
// Usage with IronPDF
var pdfSettings = new PdfGenerationSettings("My PDF Title", true, false);
var renderOptions = new ChromePdfRenderOptions();
// Apply settings from PdfGenerationSettings
renderOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4;
renderOptions.MarginTop = 20;
renderOptions.MarginBottom = 20;
renderOptions.MarginLeft = 10;
renderOptions.MarginRight = 10;
renderOptions.Title = pdfSettings.Title ?? string.Empty;
if (pdfSettings.IncludeHeader)
{
    renderOptions.TextHeader = new TextHeaderFooter
    {
        CenterText = "Page {page} of {total-pages}",
        DrawDividerLine = true
    };
}
var pdfDocument = new IronPdf.ChromePdfRenderer();
pdfDocument.RenderingOptions = renderOptions;
pdfDocument.RenderHtmlAsPdf("<html><body><h1>Hello, IronPDF!</h1></body></html>").SaveAs("CustomizedDocument.pdf");

Public Class PdfGenerationSettings(String title, Boolean includeHeader, Boolean includeFooter)
	Public ReadOnly Property Title() As String = title
	Public ReadOnly Property IncludeHeader() As Boolean = includeHeader
	Public ReadOnly Property IncludeFooter() As Boolean = includeFooter
	' Additional properties...
End Class
' Usage with IronPDF
Private pdfSettings = New PdfGenerationSettings("My PDF Title", True, False)
Private renderOptions = New ChromePdfRenderOptions()
' Apply settings from PdfGenerationSettings
renderOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4
renderOptions.MarginTop = 20
renderOptions.MarginBottom = 20
renderOptions.MarginLeft = 10
renderOptions.MarginRight = 10
renderOptions.Title = If(pdfSettings.Title, String.Empty)
If pdfSettings.IncludeHeader Then
	renderOptions.TextHeader = New TextHeaderFooter With {
		.CenterText = "Page {page} of {total-pages}",
		.DrawDividerLine = True
	}
End If
Dim pdfDocument = New IronPdf.ChromePdfRenderer()
pdfDocument.RenderingOptions = renderOptions
pdfDocument.RenderHtmlAsPdf("<html><body><h1>Hello, IronPDF!</h1></body></html>").SaveAs("CustomizedDocument.pdf")

In diesem Beispiel verwendet die Klasse PdfGenerationSettings einen C#-Primärkonstruktor, um die Eigenschaften für die PDF-Erzeugungseinstellungen zu initialisieren. Damit lässt sich später herausfinden, welche Rendering-Optionen hinzugefügt und welche übersprungen werden sollen. Die Ausgabe enthält einen Kopftext und einen Titel, wie er mit dem primären Konstruktorparameter festgelegt wurde.

Schlussfolgerung

Zusammenfassend lässt sich sagen, dass primäre Konstruktoren in C# einen verfeinerten und ausdrucksstarken Ansatz für die Klasseninitialisierung darstellen. Ihre deklarative Syntax verbessert die Lesbarkeit des Codes, fördert die Unveränderlichkeit und vereinfacht die Erstellung von Objekten mit Standardwerten. Egal, ob Sie Eigenschaften definieren, Unveränderlichkeit erzwingen oder Standardwerte verwenden, mit Primary Constructors können Entwickler die Kunst der Klasseninitialisierung in der dynamischen Welt der C#-Programmierung meistern.

Auch wenn die direkte Integration von C# Primary Constructors mit IronPDF nicht im Vordergrund steht, können diese beiden Elemente harmonisch zusammenarbeiten. C#-Primärkonstruktoren verbessern die Klarheit und Einfachheit der Klasseninitialisierung, was sie für die Definition von Strukturen oder Konfigurationen im Zusammenhang mit IronPDF-Workflows wertvoll macht.

Nutzen Sie die Leistungsfähigkeit von IronPDF für eine robuste PDF-Erzeugung und setzen Sie C#-Primärkonstruktoren ein, wenn es auf eine elegante Klasseninitialisierung ankommt. Dieses dynamische Duo versetzt Sie in die Lage, die Komplexität der Dokumentenerstellung mit Kreativität und Effizienz in der dynamischen Welt der C#-Programmierung zu bewältigen.

IronPDF bietet eine kostenlos testen und seine Leichtigkeit Lizenz beginnt mit $749.