Ikona wiadomości
Przejdź do treści stopki
  1. IronPDF
  2. Blog IronPDF
  3. Pomoc .NET
  4. Słowo kluczowe Init w języku C#
POMOC .NET

C# Slowo kluczowe init (Jak to dziala dla programistow)

Jacob Mellor, Dyrektor Technologiczny @ Team Iron
Jacob Mellor
Zaktualizowano:

Słowo kluczowe init w C# 9.0 wprowadziło nowy sposób definiowania właściwości klas w celu tworzenia obiektów niezmiennych. W wcześniejszych wersjach języka C# właściwości były zazwyczaj używane wraz z akcesorami get i set do odczytu i zapisu w polach obiektów. Jednak dzięki init można ustawić właściwości jako zapisywalne tylko podczas inicjalizacji obiektu, a później uczynić je tylko do odczytu.

W tym samouczku omówimy użycie słowa kluczowego init w języku C# na praktycznych przykładach i scenariuszach z wykorzystaniem biblioteki IronPDF. Dowiesz się również o kluczowych różnicach między tradycyjnymi ustawnikami właściwości (set) a nowymi ustawnikami typu init-only.

Podstawowy przykład słowa kluczowego Init

Zacznijmy od prostego przykładu:

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

Słowo kluczowe C# Init (jak działa dla programistów): Rysunek 1 — Środowisko IDE zgłaszające błąd z powodu właściwości oznaczonych jako init-only

W tym przykładzie FirstName i LastName są oznaczone jako właściwości tylko do inicjalizacji. Oznacza to, że można je przypisywać wyłącznie podczas inicjalizacji obiektu. Po utworzeniu obiektu próba zmiany wartości spowoduje błąd kompilacji.

Dlaczego warto używać słowa kluczowego "Init"?

Głównym powodem użycia słowa kluczowego init jest uczynienie właściwości obiektu niezmiennymi po inicjalizacji. Tradycyjnie można było oznaczyć właściwości jako tylko do odczytu, aby osiągnąć niezmienność. Często jednak potrzebny jest konstruktor, który akceptuje wszystkie wartości niezbędne do ustawienia pól, co może prowadzić do powstawania szablonowego kodu konstruktora. Dzięki init możesz osiągnąć ten sam cel, używając inicjalizatorów obiektów bez pisania długich konstruktorów.

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

Inicjalizacja obiektów za pomocą właściwości typu Init-Only

Korzystanie z init działa płynnie z inicjalizatorami obiektów. Zamiast polegać na konstruktorach do ustawiania wartości, możesz zdefiniować potrzebne właściwości bezpośrednio podczas tworzenia obiektu.

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

Tworzy to prosty, niezmienny obiekt typu Point. Należy pamiętać, że wartości dla X i Y są ustalane podczas inicjalizacji i nie można ich później modyfikować.

Mieszanie init z konstruktorami

Chociaż głównym zastosowaniem init jest inicjalizacja obiektów za pomocą inicjalizatorów obiektów, w razie potrzeby nadal można użyć konstruktora. Jest to szczególnie przydatne podczas wymuszania określonych wartości właściwości podczas tworzenia obiektów.

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

Można używać zarówno konstruktorów, jak i właściwości init jednocześnie. Takie podejście zapewnia większą elastyczność, jednocześnie wymuszając niezmienność po utworzeniu obiektu.

Zalety Init w porównaniu z Private Set

Wcześniej programiści używali prywatnego akcesora set, aby ograniczyć modyfikację właściwości poza klasą.

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

Chociaż takie podejście działa, wymaga ono użycia szablonowego kodu konstruktora do zainicjowania właściwości. Ponadto pozwala to samej klasie na późniejsze modyfikowanie właściwości, co nie zawsze jest idealnym rozwiązaniem w przypadku obiektów niezmiennych. Słowo kluczowe init eliminuje ten problem, ponieważ pozwala na inicjalizację tylko w momencie tworzenia obiektu i blokuje wszelkie późniejsze modyfikacje.

Obsługa inicjalizacji za pomocą pól tylko do odczytu i akcesorów inicjalizacyjnych

Słowo kluczowe init może inicjalizować pola lub właściwości podczas tworzenia obiektu, a po tym procesie pozostają one niezmienne. Podczas gdy pola tylko do odczytu zapewniają niezmienność, akcesor init oferuje podobną funkcjonalność dla właściwości. Oto dwa sposoby radzenia sobie z niezmiennością: za pomocą pól tylko do odczytu i właściwości init.

Korzystanie z pól tylko do odczytu w konstruktorze

W tym przykładzie używamy pól tylko do odczytu dla firstName i lastName, które są ustawiane podczas tworzenia obiektu. Pola te można przypisać tylko raz w konstruktorze i nie można ich później modyfikować:

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

Wykorzystanie akcesorów Init do inicjalizacji

Alternatywnie możemy użyć akcesora init do utworzenia właściwości tylko do odczytu, które można zainicjować podczas tworzenia obiektu, ale których nie można później zmienić. Eliminuje to potrzebę stosowania pól tylko do odczytu i zapewnia bardziej nowoczesną składnię:

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

Wprowadzenie do IronPDF

Słowo kluczowe Init w języku C# (jak działa dla programistów): Rysunek 2 — IronPDF: biblioteka PDF dla języka C#

IronPDF to potężna biblioteka do generowania i edycji plików PDF przeznaczona dla programistów C#. Ułatwia pracę z plikami PDF poprzez konwersję HTML, CSS, obrazów i innych treści do dokumentów PDF. Dzięki takim funkcjom, jak renderowanie z dokładnością do piksela, obsługa wielu platform oraz łatwa integracja z projektami .NET, IronPDF jest idealnym rozwiązaniem dla programistów, którzy muszą szybko tworzyć pliki PDF o wysokiej jakości. Można go używać z .NET Core, .NET Framework i .NET Standard, a ponadto obsługuje szeroki zakres platform, w tym Windows, Linux i macOS.

Przykład: Korzystanie z IronPDF przy użyciu słowa kluczowego Init w języku C

Aby utworzyć obiekty niezmienne w projekcie C# podczas generowania plików PDF, można połączyć słowo kluczowe init z biblioteką IronPDF. Słowo kluczowe init zapewnia integralność obiektu po jego zainicjowaniu, podczas gdy IronPDF przetwarza dane i generuje pliki PDF w oparciu o ten niezmienny model.

Upewnij się, że w projekcie poprawnie odwołujesz się do IronPDF. Można ją zainstalować za pośrednictwem NuGet:

Install-Package IronPdf

Oto przykładowy kod:

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

Wnioski

Słowo kluczowe C# Init (jak działa dla programistów): Rysunek 3 — Strona licencyjna IronPDF

Podsumowując, słowo kluczowe init w języku C# pozwala tworzyć obiekty niezmienne, oferując jednocześnie elastyczność podczas inicjalizacji obiektów. Jest to czystsza i bezpieczniejsza alternatywa dla prywatnych akcesorów zestawów, zmniejszająca potrzebę stosowania szablonowego kodu konstruktora. Połączenie słowa kluczowego init z polami tylko do odczytu, strukturami i logiką walidacji pomaga tworzyć solidne i bezpieczne struktury danych, które zachowują niezmienność bez utraty czytelności lub elastyczności. IronPDF oferuje bezpłatną wersję próbną, a ceny licencji zaczynają się od $799. Daje to dostęp do wszystkich funkcji, w tym edycji, kompresji i zabezpieczania plików PDF.

Często Zadawane Pytania

Jak mogę przekonwertować HTML na PDF w języku C#?

Możesz użyć metody RenderHtmlAsPdf biblioteki IronPDF do konwersji ciągów HTML na pliki PDF. Możesz również konwertować pliki HTML na pliki PDF za pomocą metody RenderHtmlFileAsPdf.

Jaki jest cel słowa kluczowego init w języku C#?

Słowo kluczowe init pozwala zdefiniować właściwości, które można ustawić tylko podczas inicjalizacji obiektu, zapewniając jego niezmienność w późniejszym czasie. Ta funkcja jest szczególnie przydatna przy tworzeniu obiektów, które nie powinny ulegać zmianom po utworzeniu.

W jaki sposób słowo kluczowe init zwiększa niezmienność obiektów w języku C#?

Słowo kluczowe init umożliwia ustawienie właściwości wyłącznie podczas fazy inicjalizacji obiektu, uniemożliwiając wprowadzanie zmian po jej zakończeniu. Gwarantuje to, że obiekty pozostają niezmienne po ich utworzeniu.

Czy właściwości init mogą być używane z bibliotekami do generowania plików PDF?

Tak, właściwości init mogą być używane z bibliotekami takimi jak IronPDF do generowania plików PDF z obiektów niezmiennych, zapewniając spójność danych używanych w pliku PDF w całym procesie.

Jakie są zalety używania słowa kluczowego init w porównaniu z tradycyjnymi metodami ustawiającymi?

Użycie słowa kluczowego init zamiast tradycyjnych metod setterów sprzyja niezmienności, zmniejsza potrzebę stosowania długiego kodu konstruktora i gwarantuje, że właściwości obiektu nie mogą być modyfikowane po inicjalizacji.

Jak mogę zintegrować generowanie plików PDF z niezmiennymi właściwościami w języku C#?

Można tworzyć obiekty niezmienne przy użyciu właściwości init i przekazywać te obiekty do IronPDF, który może wykorzystać te dane do generowania spójnych i niezawodnych dokumentów PDF.

Jaką rolę odgrywa słowo kluczowe init w tworzeniu nowoczesnych aplikacji w języku C#?

Słowo kluczowe init odgrywa kluczową rolę w tworzeniu nowoczesnych aplikacji w języku C#, umożliwiając programistom definiowanie obiektów niezmiennych za pomocą zwięzłej składni, zwiększając bezpieczeństwo kodu i ograniczając liczbę błędów.

Jak zainstalować bibliotekę do generowania plików PDF w projekcie C#?

Bibliotekę taką jak IronPDF można zainstalować w projekcie C# za pomocą menedżera pakietów NuGet, używając polecenia: Install-Package IronPdf.

Dlaczego niezmienność jest ważna w tworzeniu aplikacji?

Niezmienność jest ważna, ponieważ zapewnia integralność i spójność danych w całej aplikacji, ułatwiając jej utrzymanie i zmniejszając prawdopodobieństwo wystąpienia błędów.

Jakie praktyczne przykłady ilustrują użycie słowa kluczowego init?

Praktycznym przykładem jest użycie słowa kluczowego init do zdefiniowania klasy z właściwościami, które można ustawić tylko podczas inicjalizacji, co gwarantuje, że utworzony obiekt pozostanie niezmieniony. Jest to szczególnie przydatne w sytuacjach, w których spójność danych ma kluczowe znaczenie.

Jacob Mellor, Dyrektor Technologiczny @ Team Iron
Jacob Mellor
  Czat z zespołem inżynierów teraz
Dyrektor ds. technologii

Jacob Mellor jest Chief Technology Officer w Iron Software i wizjonerskim inżynierem, pionierem technologii C# PDF. Jako pierwotny deweloper głównej bazy kodowej Iron Software, kształtuje architekturę produktów firmy od jej początku, przekształcając ją wspólnie z CEO Cameron Rimington w firmę liczą...

Czytaj więcej

Powiązane artykuły

30-dniowy okres próbny → Pełna wersja produktu. Bez ograniczeń. Bez karty. Bezpłatna próba

Zespol wsparcia Iron

Jestesmy online 24 godziny, 5 dni w tygodniu.
Czat
Email
Zadzwon do mnie