.NET-HILFE

C# Init Keyword (Wie es für Entwickler funktioniert)

Veröffentlicht 24. Oktober 2024

Teilen Sie:

Dieinit-Schlüsselwort in C# 9.0 wurde eine neue Art der Definition von Klasseneigenschaften zur Erstellung unveränderlicher Objekte eingeführt. In früheren Versionen von C# wurden Eigenschaften typischerweise für Get- und Set-Accessors verwendet, um aus Objektfeldern zu lesen und in sie zu schreiben. Mit init können Sie jedoch nur während der Objektinitialisierung schreibbare Eigenschaften festlegen, die danach schreibgeschützt bleiben.

In diesem Tutorium wird die Verwendung des C#-Schlüsselworts init anhand praktischer Beispiele und Szenarien mit demIronPDF-Bibliothek. Sie lernen auch die entscheidenden Unterschiede zwischen den traditionellen Property Settern kennen(satz) und die neuen Init-Only-Setter.

Grundlegendes Beispiel für das Init-Schlüsselwort

Beginnen wir mit einem einfachen Beispiel:

public class Person
{
    public string FirstName { get; init; }
    public string LastName { get; init; }
}
var person = new Person
{
    FirstName = "Iron",d
    LastName = "Dev"
};
// person.FirstName = "Jane";  // This will give a compile-time error.

public class Person
{
    public string FirstName { get; init; }
    public string LastName { get; init; }
}
var person = new Person
{
    FirstName = "Iron",d
    LastName = "Dev"
};
// person.FirstName = "Jane";  // This will give a compile-time error.

Public Class Person
	Public Property FirstName() As String
	Public Property LastName() As String
End Class
Private person = New Person With {
	.FirstName = "Iron",
	d LastName = "Dev"
}
' person.FirstName = "Jane";  // This will give a compile-time error.

C# Init Schlüsselwort(Wie es für Entwickler funktioniert): Abbildung 1 - IDE gibt einen Fehler aus, weil die Eigenheiten als init-only markiert sind

In diesem Beispiel sind FirstName und LastName als reine Init-Eigenschaften gekennzeichnet. Das bedeutet, dass sie nur während eines Objektinitialisierers zugewiesen werden können. Nachdem das Objekt erstellt wurde, führt der Versuch, die Werte zu ändern, zu einem Kompilierfehler.

Warum das Schlüsselwort Init verwenden?

Der Hauptgrund für die Verwendung des Schlüsselworts init besteht darin, Objekteigenschaften nach der Initialisierung unveränderlich zu machen. Traditionell konnten Sie Eigenschaften als schreibgeschützt markieren, um Unveränderlichkeit zu erreichen. Häufig wird jedoch ein Konstruktor benötigt, der alle erforderlichen Werte zum Setzen der Felder akzeptiert, was zu Konstruktor-Boilerplate-Code führen kann. Mit init können Sie das gleiche Ziel mit Objektinitialisierungen erreichen, ohne lange Konstruktoren zu schreiben.

public class Person
{
    public string FirstName { get; init; }
    public string LastName { get; init; }
    // Without using constructor boilerplate for property initialization
}
var person = new Person
{
    FirstName = "John",
    LastName = "Doe"
};

public class Person
{
    public string FirstName { get; init; }
    public string LastName { get; init; }
    // Without using constructor boilerplate for property initialization
}
var person = new Person
{
    FirstName = "John",
    LastName = "Doe"
};

Public Class Person
	Public Property FirstName() As String
	Public Property LastName() As String
	' Without using constructor boilerplate for property initialization
End Class
Private person = New Person With {
	.FirstName = "John",
	.LastName = "Doe"
}

Objektinitialisierung mit Init-Only-Eigenschaften

Die Verwendung von init funktioniert nahtlos mit Objektinitialisierungen. Anstatt sich auf Konstruktoren zu verlassen, um Werte festzulegen, können Sie die benötigten Eigenschaften direkt beim Erstellen eines Objekts definieren.

public class Point
{
    public int X { get; init; }
    public int Y { get; init; }
}
var point = new Point { X = 10, Y = 20 };
// point.X = 30;  // This will throw a compile-time error

public class Point
{
    public int X { get; init; }
    public int Y { get; init; }
}
var point = new Point { X = 10, Y = 20 };
// point.X = 30;  // This will throw a compile-time error

Public Class Point
	Public Property X() As Integer
	Public Property Y() As Integer
End Class
Private point = New Point With {
	.X = 10,
	.Y = 20
}
' point.X = 30;  // This will throw a compile-time error

Dadurch wird ein einfaches, unveränderliches Objekt vom Typ Point erstellt. Beachten Sie, dass die Werte für X und Y bei der Initialisierung festgelegt werden und später nicht mehr geändert werden können.

Mischen von init mit Konstruktoren

Obwohl der primäre Anwendungsfall für init die Objektinitialisierung über Objektinitialisierer ist, können Sie bei Bedarf auch einen Konstruktor verwenden. Dies ist besonders nützlich, wenn bei der Objekterstellung bestimmte Eigenschaftswerte erzwungen werden sollen.

public class Person
{
    public string FirstName { get; init; }
    public string LastName { get; init; }
    public Person(string firstName, string lastName)
    {
        FirstName = firstName;
        LastName = lastName;
    }
}

public class Person
{
    public string FirstName { get; init; }
    public string LastName { get; init; }
    public Person(string firstName, string lastName)
    {
        FirstName = firstName;
        LastName = lastName;
    }
}

Public Class Person
	Public Property FirstName() As String
	Public Property LastName() As String
	Public Sub New(ByVal firstName As String, ByVal lastName As String)
		Me.FirstName = firstName
		Me.LastName = lastName
	End Sub
End Class

Sie können sowohl Konstruktoren als auch init-Eigenschaften zusammen verwenden. Dieser Ansatz bietet mehr Flexibilität und erzwingt gleichzeitig die Unveränderlichkeit nach der Objektkonstruktion.

Vorteile von Init Over Private Set

Bisher haben Entwickler einen privaten Set-Accessor verwendet, um die Änderung von Eigenschaften außerhalb der Klasse zu begrenzen.

public class Person
{
    public string FirstName { get; private set; }
    public string LastName { get; private set; }
    public Person(string firstName, string lastName)
    {
        FirstName = firstName;
        LastName = lastName;
    }
}

public class Person
{
    public string FirstName { get; private set; }
    public string LastName { get; private set; }
    public Person(string firstName, string lastName)
    {
        FirstName = firstName;
        LastName = lastName;
    }
}

Public Class Person
	Private privateFirstName As String
	Public Property FirstName() As String
		Get
			Return privateFirstName
		End Get
		Private Set(ByVal value As String)
			privateFirstName = value
		End Set
	End Property
	Private privateLastName As String
	Public Property LastName() As String
		Get
			Return privateLastName
		End Get
		Private Set(ByVal value As String)
			privateLastName = value
		End Set
	End Property
	Public Sub New(ByVal firstName As String, ByVal lastName As String)
		Me.FirstName = firstName
		Me.LastName = lastName
	End Sub
End Class

Dieser Ansatz funktioniert zwar, erfordert aber Konstruktor-Boilerplate-Code zur Initialisierung von Eigenschaften. Außerdem erlaubt sie der Klasse selbst, die Eigenschaften später zu ändern, was bei unveränderlichen Objekten nicht immer ideal ist. Das init-Schlüsselwort beseitigt dieses Problem, da es die Initialisierung nur bei der Objekterstellung zulässt und jede spätere Änderung blockiert.

Handhabung der Initialisierung mit schreibgeschützten Feldern und init-Accessoren

Mit dem Schlüsselwort init können Felder oder Eigenschaften während der Objekterstellung initialisiert werden, während sie danach unveränderlich bleiben. Während schreibgeschützte Felder Unveränderlichkeit bieten, bietet der init-Accessor eine ähnliche Funktion für Eigenschaften. Hier erfahren Sie, wie Sie die Unveränderlichkeit auf zwei Arten handhaben können: mit schreibgeschützten Feldern und init-Eigenschaften.

Verwendung von Nur-Lese-Feldern mit einem Konstruktor

In diesem Beispiel verwenden wir schreibgeschützte Felder für Vorname und Nachname, die während der Objektkonstruktion festgelegt werden. Diese Felder können nur einmal im Konstruktor zugewiesen werden und können danach nicht mehr geändert werden:

public class Person
{
    private readonly string firstName;
    private readonly string lastName;
    public string FirstName => firstName;
    public string LastName => lastName;
    public Person(string firstName, string lastName)
    {
        this.firstName = firstName;
        this.lastName = lastName;
    }
}

public class Person
{
    private readonly string firstName;
    private readonly string lastName;
    public string FirstName => firstName;
    public string LastName => lastName;
    public Person(string firstName, string lastName)
    {
        this.firstName = firstName;
        this.lastName = lastName;
    }
}

Public Class Person
'INSTANT VB NOTE: The field firstName was renamed since Visual Basic does not allow fields to have the same name as other class members:
	Private ReadOnly firstName_Conflict As String
'INSTANT VB NOTE: The field lastName was renamed since Visual Basic does not allow fields to have the same name as other class members:
	Private ReadOnly lastName_Conflict As String
	Public ReadOnly Property FirstName() As String
		Get
			Return firstName_Conflict
		End Get
	End Property
	Public ReadOnly Property LastName() As String
		Get
			Return lastName_Conflict
		End Get
	End Property
	Public Sub New(ByVal firstName As String, ByVal lastName As String)
		Me.firstName_Conflict = firstName
		Me.lastName_Conflict = lastName
	End Sub
End Class

Verwendung von init-Accessoren für die Initialisierung

Alternativ können wir den init-Accessor verwenden, um schreibgeschützte Eigenschaften zu erstellen, die bei der Objekterstellung initialisiert werden können, danach aber nicht mehr geändert werden können. Dadurch werden schreibgeschützte Felder überflüssig und die Syntax wird moderner:

public class Person
{
    public string FirstName { get; init; }
    public string LastName { get; init; }
}

public class Person
{
    public string FirstName { get; init; }
    public string LastName { get; init; }
}

Public Class Person
	Public Property FirstName() As String
	Public Property LastName() As String
End Class

Einführung in IronPDF

C# Init Schlüsselwort(Wie es für Entwickler funktioniert): Abbildung 2 - IronPDF: Die C# PDF-Bibliothek

IronPDF ist eine leistungsstarke Bibliothek zur PDF-Erzeugung und -Manipulation für C#-Entwickler. Sie vereinfacht die Arbeit mitPDFs durch Konvertierung von HTMLcSS, Bilder und andere Inhalte in PDF-Dokumente einfügen. Mit Funktionen wie pixelgenauem Rendering, plattformübergreifender Unterstützung und einfacher Integration in .NET-Projekte ist IronPDF ideal für Entwickler, die schnell hochwertige PDFs erstellen müssen. Sie kann mit .NET Core, Framework und Standard verwendet werden und unterstützt eine breite Palette von Plattformen, einschließlich Windows, Linux und macOS.

Fallbeispiel: Verwendung von IronPDF mit C# Init-Schlüsselwort

Um unveränderliche Objekte in einem C#-Projekt zu erstellen und gleichzeitig PDFs zu generieren, können Sie das Schlüsselwort init mit IronPDF kombinieren. Das Schlüsselwort init stellt die Integrität des Objekts nach seiner Initialisierung sicher, während IronPDF die Daten verarbeitet und PDFs auf der Grundlage dieses unveränderlichen Modells erzeugt.

Stellen Sie sicher, dass IronPDF in Ihrem Projekt korrekt referenziert wird. Sie können es über NuGet installieren:

Install-Package IronPdf

Install-Package IronPdf

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'Install-Package IronPdf

Hier ist das Code-Beispiel:

using IronPdf;
public class Person
{
    public int Id { get; init; }
    public string FirstName { get; init; }
    public string LastName { get; init; }
}
public class PDFGenerator
{
    public static void CreatePersonPDF(Person person)
    {
        var htmlContent = $@"
        <html>
        <body>
            <h1>Person Information</h1>
            <p>ID: {person.Id}</p>
            <p>First Name: {person.FirstName}</p>
            <p>Last Name: {person.LastName}</p>
        </body>
        </html>";
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        pdf.SaveAs($"Person_{person.Id}.pdf");
    }
}
class Program
{
    static void Main(string[] args)
    {
        var person = new Person
        {
            Id = 1,
            FirstName = "Iron",
            LastName = "Dev"
        };
        PDFGenerator.CreatePersonPDF(person);
    }
}

using IronPdf;
public class Person
{
    public int Id { get; init; }
    public string FirstName { get; init; }
    public string LastName { get; init; }
}
public class PDFGenerator
{
    public static void CreatePersonPDF(Person person)
    {
        var htmlContent = $@"
        <html>
        <body>
            <h1>Person Information</h1>
            <p>ID: {person.Id}</p>
            <p>First Name: {person.FirstName}</p>
            <p>Last Name: {person.LastName}</p>
        </body>
        </html>";
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        pdf.SaveAs($"Person_{person.Id}.pdf");
    }
}
class Program
{
    static void Main(string[] args)
    {
        var person = new Person
        {
            Id = 1,
            FirstName = "Iron",
            LastName = "Dev"
        };
        PDFGenerator.CreatePersonPDF(person);
    }
}

Imports IronPdf
Public Class Person
	Public Property Id() As Integer
	Public Property FirstName() As String
	Public Property LastName() As String
End Class
Public Class PDFGenerator
	Public Shared Sub CreatePersonPDF(ByVal person As Person)
		Dim htmlContent = $"
        <html>
        <body>
            <h1>Person Information</h1>
            <p>ID: {person.Id}</p>
            <p>First Name: {person.FirstName}</p>
            <p>Last Name: {person.LastName}</p>
        </body>
        </html>"
		Dim renderer = New ChromePdfRenderer()
		Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
		pdf.SaveAs($"Person_{person.Id}.pdf")
	End Sub
End Class
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim person As New Person With {
			.Id = 1,
			.FirstName = "Iron",
			.LastName = "Dev"
		}
		PDFGenerator.CreatePersonPDF(person)
	End Sub
End Class

Schlussfolgerung

C# Init Schlüsselwort(Wie es für Entwickler funktioniert): Abbildung 3 - IronPDF-Lizenzierungsseite

Zusammenfassend lässt sich sagen, dass das C#-Schlüsselwort init die Erstellung unveränderlicher Objekte ermöglicht und gleichzeitig Flexibilität bei der Initialisierung von Objekten bietet. Es handelt sich um eine sauberere und sicherere Alternative zu privaten Set-Accessors, die den Bedarf an Boilerplate-Code für Konstruktoren reduziert. Die Kombination des init-Schlüsselworts mit schreibgeschützten Feldern, Strukturen und Validierungslogik hilft Ihnen beim Aufbau robuster und sicherer Datenstrukturen, die die Unveränderlichkeit bewahren, ohne die Lesbarkeit oder Flexibilität zu beeinträchtigen. IronPDF bietet einekostenlos testen, und Lizenzen beginnen ab $749. Dadurch erhalten Sie Zugang zu allen Funktionen, einschließlich der Bearbeitung, Komprimierung und Sicherung von PDFs.

Kannapat Udonpant

Software-Ingenieur

LinkedIn

Bevor er Software-Ingenieur wurde, promovierte Kannapat an der Universität Hokkaido in Japan im Bereich Umweltressourcen. Während seines Studiums wurde Kannapat auch Mitglied des Vehicle Robotics Laboratory, das Teil der Abteilung für Bioproduktionstechnik ist. Im Jahr 2022 wechselte er mit seinen C#-Kenntnissen zum Engineering-Team von Iron Software, wo er sich auf IronPDF konzentriert. Kannapat schätzt an seiner Arbeit, dass er direkt von dem Entwickler lernt, der den Großteil des in IronPDF verwendeten Codes schreibt. Neben dem kollegialen Lernen genießt Kannapat auch den sozialen Aspekt der Arbeit bei Iron Software. Wenn er nicht gerade Code oder Dokumentationen schreibt, kann man Kannapat normalerweise beim Spielen auf seiner PS5 oder beim Wiedersehen mit The Last of Us antreffen.

< PREVIOUS
FileStream C# (Wie es für Entwickler funktioniert)

NÄCHSTES >
C# Semaphoreslim (Wie es für Entwickler funktioniert)