Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF-Blog
  3. .NET-Unterstützung
  4. C# Init-Schlüsselwort
.NET HILFE

C# init Schlüsselwort (Wie es für Entwickler funktioniert)

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
Aktualisiert:

Das init-Schlüsselwort in C# 9.0 führte eine neue Möglichkeit ein, Klassen-Eigenschaften zur Erstellung unveränderlicher Objekte zu definieren. In früheren Versionen von C# wurden Eigenschaften typischerweise mit get- und set-Accessoren verwendet, um auf Objektfelder zuzugreifen und sie zu ändern. Mit init können jedoch beschreibbare Eigenschaften nur während der Objektinitialisierung festgelegt werden und sind danach schreibgeschützt.

Dieses Tutorial wird die Verwendung des init-Schlüsselworts in C# mit praktischen Beispielen und Szenarien anhand der IronPDF-Bibliothek erforschen. Sie werden auch über die wesentlichen Unterschiede zwischen herkömmlichen Eigenschafts-Settern (set) und den neuen nur-init-Settern lernen.

Basisches 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",
    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",
    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",
	.LastName = "Dev"
}

' person.FirstName = "Jane";  // This will give a compile-time error.
$vbLabelText   $csharpLabel

C# Init-Schlüsselwort (Wie es für Entwickler funktioniert): Abbildung 1 - IDE wirft einen Fehler aufgrund von Eigenschaften, die als nur-init markiert sind

In diesem Beispiel sind FirstName und LastName als nur-init-Eigenschaften markiert. Das bedeutet, dass sie nur während der Objektinitialisierung zugewiesen werden können. Nach der Erstellung des Objekts führt der Versuch, die Werte zu ändern, zu einem Compilerfehler.

Warum das Schlüsselwort Init verwenden?

Der Hauptgrund für die Verwendung des init-Schlüsselworts ist es, die Objekt-Eigenschaften nach der Initialisierung unveränderlich zu machen. Traditionell konnte man Eigenschaften als schreibgeschützt markieren, um Unveränderlichkeit zu erreichen. Allerdings benötigte man häufig einen Konstruktor, der alle notwendigen Werte akzeptiert, um die Felder zu setzen, was zu Konstruktor-Standardcode führen kann. Mit init kann man das gleiche Ziel mit Objektinitialisierern erreichen, ohne lange Konstruktoren schreiben zu müssen.

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"
}
$vbLabelText   $csharpLabel

Objektinitialisierung mit Init-Only-Eigenschaften

Die Verwendung von init funktioniert nahtlos mit Objektinitialisierern. Statt auf Konstruktoren zu setzen, um Werte zu setzen, können Sie die benötigten Eigenschaften direkt bei der Objekterstellung 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
$vbLabelText   $csharpLabel

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

Mixing init mit Konstruktoren

Obwohl der primäre Anwendungsfall für init die Objektinitialisierung über Objektinitialisierer ist, können Sie bei Bedarf immer noch einen Konstruktor verwenden. Dies ist besonders nützlich, wenn bestimmte Eigenschaftswerte während der Objekterstellung 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
$vbLabelText   $csharpLabel

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

Vorteile von Init gegenüber Private Set

Früher verwendeten Entwickler einen privaten Set-Accessor, um die Eigenschaftsänderung 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
$vbLabelText   $csharpLabel

Obwohl dieser Ansatz funktioniert, erfordert er Konstruktor-Standardcode, um Eigenschaften zu initialisieren. Außerdem erlaubt es der Klasse selbst, die Eigenschaften später zu ändern, was nicht immer ideal für unveränderliche Objekte ist. Das init-Schlüsselwort behebt dieses Problem, da es nur die Initialisierung zum Zeitpunkt der Objekterstellung erlaubt und jede nachträgliche Änderung blockiert.

Handhabung der Initialisierung mit schreibgeschützten Feldern und Init Accessors

Das init-Schlüsselwort kann Felder oder Eigenschaften während der Objekterstellung initialisieren, während sie danach unveränderlich bleiben. Während schreibgeschützte Felder Unveränderlichkeit bieten, bietet der init-Accessor eine ähnliche Fähigkeit für Eigenschaften. So können Sie Unveränderlichkeit auf zwei Arten handhaben: mit schreibgeschützten Feldern und init-Eigenschaften.

Nutzung von schreibgeschützten Feldern mit einem Konstruktor

In diesem Beispiel verwenden wir schreibgeschützte Felder für firstName und lastName, die während der Objekterstellung gesetzt 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
$vbLabelText   $csharpLabel

Verwendung von Init Accessors für die Initialisierung

Alternativ können wir den init-Accessor verwenden, um schreibgeschützte Eigenschaften zu erstellen, die während der Objekterstellung initialisiert, danach aber nicht mehr geändert werden dürfen. Dies erspart die Notwendigkeit für schreibgeschützte Felder und bietet eine modernere Syntax:

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
$vbLabelText   $csharpLabel

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 PDF-Erzeugungs- und Manipulationsbibliothek, die für C#-Entwickler entwickelt wurde. Es vereinfacht die Arbeit mit PDFs, indem HTML, CSS, Bilder und andere Inhalte in PDF-Dokumente konvertiert werden. 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 können es mit .NET Core, Framework und Standard verwenden, und es unterstützt eine Vielzahl von Plattformen, einschließlich Windows, Linux und macOS.

Fall: Verwendung von IronPDF mit C# Init Keyword

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

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

Install-Package IronPdf

Hier ist das Codebeispiel:

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
$vbLabelText   $csharpLabel

Abschluss

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

Zusammenfassend ermöglicht das C# init-Schlüsselwort die Erstellung unveränderlicher Objekte und bietet Flexibilität während der Objektinitialisierung. Es ist eine sauberere und sichere Alternative zu privaten Set-Accessoren und reduziert die Notwendigkeit für Konstruktor-Standardcode. Die Kombination des init-Schlüsselworts mit schreibgeschützten Feldern, Strukturen und Validierungslogik hilft Ihnen, robuste und sichere Datenstrukturen zu erstellen, die Unveränderlichkeit bewahren, ohne Lesbarkeit oder Flexibilität zu opfern. IronPDF bietet eine kostenlose Testversion, und Lizenzen beginnen ab liteLicense. Dies gibt Ihnen Zugang zu seinen vollständigen Funktionen, einschließlich Bearbeiten, Komprimieren und Sichern von PDFs.

Häufig gestellte Fragen

Wie kann ich HTML in PDF in C# konvertieren?

Sie können die RenderHtmlAsPdf-Methode von IronPDF verwenden, um HTML-Strings in PDFs zu konvertieren. Sie können auch HTML-Dateien mit RenderHtmlFileAsPdf in PDFs konvertieren.

Was ist der Zweck von init in C#?

Das init ermöglicht es, Eigenschaften zu definieren, die nur während der Objektinitialisierung gesetzt werden können, was danach die Unveränderlichkeit gewährleistet. Diese Funktion ist besonders nützlich für die Erstellung von Objekten, die sich nicht mehr ändern sollen, sobald sie erstellt wurden.

Wie verbessert init die Unveränderlichkeit von Objekten in C#?

Das init ermöglicht es, Eigenschaften nur während der Initialisierungsphase des Objekts festzulegen, was Änderungen danach verhindert. Dies garantiert, dass Objekte nach ihrer Erstellung unveränderlich bleiben.

Können init-Eigenschaften mit Bibliotheken zur PDF-Erstellung verwendet werden?

Ja, init-Eigenschaften können mit Bibliotheken wie IronPDF verwendet werden, um PDFs aus unveränderlichen Objekten zu generieren, wodurch sichergestellt wird, dass die für das PDF verwendeten Daten während des gesamten Prozesses konsistent bleiben.

Welche Vorteile bietet die Verwendung von init gegenüber traditionellen Setzmethoden?

Der Einsatz von init gegenüber traditionellen Setzmethoden fördert die Unveränderlichkeit, reduziert den Bedarf an umfangreichem Konstruktorkode und stellt sicher, dass Objekteigenschaften nach der Initialisierung nicht mehr geändert werden können.

Wie kann ich die PDF-Erstellung mit unveränderlichen Eigenschaften in C# integrieren?

Sie können unveränderliche Objekte mit init-Eigenschaften erstellen und diese Objekte an IronPDF übergeben, das die Daten nutzen kann, um konsistente und zuverlässige PDF-Dokumente zu erzeugen.

Welche Rolle spielt das init bei der Erstellung moderner C#-Anwendungen?

Das init spielt eine entscheidende Rolle bei der Erstellung moderner C#-Anwendungen, indem es Entwicklern ermöglicht, unveränderliche Objekte mit prägnanter Syntax zu definieren, was die Code-Sicherheit erhöht und Fehler reduziert.

Wie kann ich eine Bibliothek zur PDF-Erstellung in einem C#-Projekt installieren?

Sie können eine Bibliothek wie IronPDF in Ihrem C#-Projekt installieren, indem Sie den NuGet-Paketmanager mit dem Befehl verwenden: Install-Package IronPdf.

Warum ist Unveränderlichkeit in der Anwendungsentwicklung wichtig?

Unveränderlichkeit ist wichtig, weil sie die Datenintegrität und Konsistenz innerhalb Ihrer Anwendung gewährleistet, was die Wartung erleichtert und die Wahrscheinlichkeit von Fehlern reduziert.

Welche praktischen Beispiele veranschaulichen die Verwendung von init?

Ein praktisches Beispiel ist die Verwendung von init, um eine Klasse mit Eigenschaften zu definieren, die nur während der Initialisierung gesetzt werden können, wodurch sichergestellt wird, dass das erstellte Objekt unverändert bleibt. Dies ist insbesondere in Szenarien nützlich, in denen Datenkonsistenz von entscheidender Bedeutung ist.

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
  Jetzt mit dem Ingenieurteam chatten
Chief Technology Officer

Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der führend in der C# PDF-Technologie ist. Als ursprünglicher Entwickler der Iron Software-Kerncodebasis hat er die Produktarchitektur des Unternehmens seit seiner Gründung gestaltet und zusammen mit CEO Cameron Rimington in ein Unternehmen ...

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen