Das new Operator-Keyword in C# ist vielseitig und erfüllt mehrere wesentliche Funktionen in der Sprache. Von der Instanziierung von Objekten bis hin zum Verbergen geerbter Mitglieder, das Verständnis ihrer Anwendungen ist entscheidend für eine effektive C#-Entwicklung. Diese Anleitung erforscht die vielfältigen Verwendungen des new Keywords und bietet klare Beispiele, um seine Stärke und Flexibilität zu veranschaulichen. Wir werden auch später in diesem Leitfaden einen Blick auf die IronPDF-Bibliotheksübersicht auf Iron Software werfen.

Einführung in die Objektinstanziierung

Die Objekterstellung ist der Prozess, bei dem der new Operator eine Instanz einer Klasse oder eines Structs erstellt. In C# wird dies hauptsächlich mithilfe des new Keywords erreicht, das den Konstruktor des angegebenen Typs aufruft und Speicher für das neue Objekt bereitstellt.

Erstellen von Instanzen mit new

Um eine Instanz eines Objekts zu erstellen, folgt dem new Operator der Klassenname und ein Paar Klammern. Wenn die Klasse einen Konstruktor hat, der Parameter benötigt, müssen Argumente innerhalb dieser Klammern bereitgestellt werden.

public class Book
{
    public string Title { get; set; }

    public Book(string title)
    {
        Title = title;
    }
}

Book book = new Book("The C# Programming Language");

public class Book
{
    public string Title { get; set; }

    public Book(string title)
    {
        Title = title;
    }
}

Book book = new Book("The C# Programming Language");

Public Class Book
	Public Property Title() As String

	Public Sub New(ByVal title As String)
		Me.Title = title
	End Sub
End Class

Private book As New Book("The C# Programming Language")

Public Class Book
	Public Property Title() As String

	Public Sub New(ByVal title As String)
		Me.Title = title
	End Sub
End Class

Private book As New Book("The C# Programming Language")

Standard-Konstruktoren und Konstruktoren ohne Parameter

Ein Standardkonstruktor wird von C# bereitgestellt, wenn in einer Klasse keine Konstruktoren explizit definiert sind. Sobald jedoch ein Konstruktor mit Parametern definiert ist, muss ein parameterloser Konstruktor explizit deklariert werden, falls erforderlich.

public class ExampleClass
{
    // Parameterless constructor
    public ExampleClass()
    {
        // Initialization code here
    }
}

public class ExampleClass
{
    // Parameterless constructor
    public ExampleClass()
    {
        // Initialization code here
    }
}

Public Class ExampleClass
	' Parameterless constructor
	Public Sub New()
		' Initialization code here
	End Sub
End Class

Public Class ExampleClass
	' Parameterless constructor
	Public Sub New()
		' Initialization code here
	End Sub
End Class

Fortgeschrittene Techniken zur Objekterstellung

In C# geht es bei der Objekterstellung nicht nur um die Instanziierung von Klassen; es ist ein Tor zur Nutzung der leistungsstarken Funktionen der Sprache für effizienteren, lesbaren und prägnanteren Code. Hier untersuchen wir fortgeschrittene Techniken wie das Arbeiten mit Arrays, die Verwendung von Typen und die Anwendung von Objektinitialisierern, um Ihre Kodierungsbemühungen zu optimieren.

Arrays und Sammlungen

Das Erstellen von Arrays eines bestimmten Array-Typs in C# ist eine grundlegende Fähigkeit, aber es sind die Feinheiten, die Ihre Kodierungsfähigkeiten steigern. Mit dem new Keyword können Sie Arrays instanziieren und ihren Typ und die Anzahl der zu enthaltenen Elemente angeben. Dies ist entscheidend für die Verwaltung von Variablensammlungen auf strukturierte Weise. Über grundlegende Arrays hinaus erleichtert new die Erstellung von mehrdimensionalen und gestaffelten Arrays, die komplexe Datenstrukturen aufnehmen.

// Single-dimensional array
int[] numbers = new int[5]; // Initializes an array for 5 integers

// Multidimensional array
int[,] matrix = new int[3, 2]; // A 3x2 matrix

// Jagged array (an array of arrays)
int[][] jaggedArray = new int[3][];
jaggedArray[0] = new int[4]; // First row has 4 columns
jaggedArray[1] = new int[5]; // Second row has 5 columns
jaggedArray[2] = new int[3]; // Third row has 3 columns

// Single-dimensional array
int[] numbers = new int[5]; // Initializes an array for 5 integers

// Multidimensional array
int[,] matrix = new int[3, 2]; // A 3x2 matrix

// Jagged array (an array of arrays)
int[][] jaggedArray = new int[3][];
jaggedArray[0] = new int[4]; // First row has 4 columns
jaggedArray[1] = new int[5]; // Second row has 5 columns
jaggedArray[2] = new int[3]; // Third row has 3 columns

' Single-dimensional array
Dim numbers(4) As Integer ' Initializes an array for 5 integers

' Multidimensional array
Dim matrix(2, 1) As Integer ' A 3x2 matrix

' Jagged array (an array of arrays)
Dim jaggedArray(2)() As Integer
jaggedArray(0) = New Integer(3){} ' First row has 4 columns
jaggedArray(1) = New Integer(4){} ' Second row has 5 columns
jaggedArray(2) = New Integer(2){} ' Third row has 3 columns

' Single-dimensional array
Dim numbers(4) As Integer ' Initializes an array for 5 integers

' Multidimensional array
Dim matrix(2, 1) As Integer ' A 3x2 matrix

' Jagged array (an array of arrays)
Dim jaggedArray(2)() As Integer
jaggedArray(0) = New Integer(3){} ' First row has 4 columns
jaggedArray(1) = New Integer(4){} ' Second row has 5 columns
jaggedArray(2) = New Integer(2){} ' Third row has 3 columns

Anonyme Typen

Anonyme Typen glänzen in Szenarien, die temporäre Datenstrukturen erfordern, ohne den Aufwand, eine formale Klasse zu deklarieren. Durch die Verwendung von new mit einer Eigenschafts-Initialisierersyntax können Sie Objekte spontan erstellen. Diese Funktion ist unglaublich nützlich für LINQ-Abfragen, bei denen Sie eine Teilmenge von Eigenschaften aus einem größeren Objekt auswählen oder Daten schnell gruppieren müssen, ohne einen bestimmten Typ zu erstellen.

var person = new { Name = "Alice", Age = 30 };
Console.WriteLine($"Name: {person.Name}, Age: {person.Age}");

// In LINQ
var results = from p in people
              select new { p.Name, p.Age };

var person = new { Name = "Alice", Age = 30 };
Console.WriteLine($"Name: {person.Name}, Age: {person.Age}");

// In LINQ
var results = from p in people
              select new { p.Name, p.Age };

Dim person = New With {
	Key .Name = "Alice",
	Key .Age = 30
}
Console.WriteLine($"Name: {person.Name}, Age: {person.Age}")

' In LINQ
Dim results = From p In people
	Select New With {
		Key p.Name,
		Key p.Age
	}

Dim person = New With {
	Key .Name = "Alice",
	Key .Age = 30
}
Console.WriteLine($"Name: {person.Name}, Age: {person.Age}")

' In LINQ
Dim results = From p In people
	Select New With {
		Key p.Name,
		Key p.Age
	}

Objekt-Initialisierer

Ein Objekt-Initialisierer stellt eine syntaktische Bequemlichkeit dar, die es Ihnen ermöglicht, eine Instanz einer Klasse zu erstellen und ihre Eigenschaften sofort festzulegen, ohne einen Konstruktor mit Parametern aufrufen zu müssen. Dies macht den Code nicht nur lesbarer, sondern verringert auch die Wahrscheinlichkeit von Fehlern, indem die Notwendigkeit mehrerer Konstruktoren für verschiedene Szenarien eliminiert wird. Objekt-Initialisierer sind besonders nützlich, wenn man mit komplexen Objekten arbeitet, da man nur die benötigten Eigenschaften festlegen kann.

public class Rectangle
{
    public int Width { get; set; }
    public int Height { get; set; }
    public Point Location { get; set; }
}

Rectangle rect = new Rectangle
{
    Width = 100,
    Height = 50,
    Location = new Point { X = 0, Y = 0 }
};

public class Rectangle
{
    public int Width { get; set; }
    public int Height { get; set; }
    public Point Location { get; set; }
}

Rectangle rect = new Rectangle
{
    Width = 100,
    Height = 50,
    Location = new Point { X = 0, Y = 0 }
};

Public Class Rectangle
	Public Property Width() As Integer
	Public Property Height() As Integer
	Public Property Location() As Point
End Class

Private rect As New Rectangle With {
	.Width = 100,
	.Height = 50,
	.Location = New Point With {
		.X = 0,
		.Y = 0
	}
}

Public Class Rectangle
	Public Property Width() As Integer
	Public Property Height() As Integer
	Public Property Location() As Point
End Class

Private rect As New Rectangle With {
	.Width = 100,
	.Height = 50,
	.Location = New Point With {
		.X = 0,
		.Y = 0
	}
}

Lokale Funktionen und Lambda-Ausdrücke

C# unterstützt lokale Funktionen und Lambda-Ausdrücke, die die Flexibilität und Prägnanz des Codes erhöhen.

Lokale Funktion

Eine lokale Funktion ist eine Methode, die innerhalb des Gültigkeitsbereichs einer anderen Methode definiert ist und als leistungsstarkes Werkzeug zur Organisation von Code und zur Kapselung von Funktionalität dient.

public void PerformOperation()
{
    int LocalFunction(int x)
    {
        return x * x;
    }
    Console.WriteLine(LocalFunction(5)); // Output: 25
}

public void PerformOperation()
{
    int LocalFunction(int x)
    {
        return x * x;
    }
    Console.WriteLine(LocalFunction(5)); // Output: 25
}

Public Sub PerformOperation()
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'	int LocalFunction(int x)
'	{
'		Return x * x;
'	}
	Console.WriteLine(LocalFunction(5)) ' Output: 25
End Sub

Public Sub PerformOperation()
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'	int LocalFunction(int x)
'	{
'		Return x * x;
'	}
	Console.WriteLine(LocalFunction(5)) ' Output: 25
End Sub

Lambda-Ausdrücke

Lambda-Ausdruck bietet eine prägnante Möglichkeit, Inline-Ausdrücke oder Methoden zu schreiben, ohne explizite Delegattypen zu benötigen.

Func<int, int> square = x => x * x;
Console.WriteLine(square(5)); // Output: 25

Func<int, int> square = x => x * x;
Console.WriteLine(square(5)); // Output: 25

Dim square As Func(Of Integer, Integer) = Function(x) x * x
Console.WriteLine(square(5)) ' Output: 25

Dim square As Func(Of Integer, Integer) = Function(x) x * x
Console.WriteLine(square(5)) ' Output: 25

Verwendung von 'new' in der Vererbung

In der Klassenvererbung kann new geerbte Mitglieder ausblenden, sodass abgeleitete Klassen ein Mitglied mit demselben Namen wie in ihren Basisklassen einführen können.

Vererbte Mitglieder ausblenden

Die Verwendung von new zum Verbergen eines Members in einer abgeleiteten Klasse überschreibt nicht dasselbe Mitglied; stattdessen führt es ein neues Mitglied ein, das sich von der Basisklassenversion unterscheidet.

public class BaseClass
{
    public void Display()
    {
        Console.WriteLine("Base display");
    }
}

public class DerivedClass : BaseClass
{
    public new void Display()
    {
        Console.WriteLine("Derived display");
    }
}

public class BaseClass
{
    public void Display()
    {
        Console.WriteLine("Base display");
    }
}

public class DerivedClass : BaseClass
{
    public new void Display()
    {
        Console.WriteLine("Derived display");
    }
}

Public Class BaseClass
	Public Sub Display()
		Console.WriteLine("Base display")
	End Sub
End Class

Public Class DerivedClass
	Inherits BaseClass

	Public Shadows Sub Display()
		Console.WriteLine("Derived display")
	End Sub
End Class

Public Class BaseClass
	Public Sub Display()
		Console.WriteLine("Base display")
	End Sub
End Class

Public Class DerivedClass
	Inherits BaseClass

	Public Shadows Sub Display()
		Console.WriteLine("Derived display")
	End Sub
End Class

Neues Verständnis mit Generics

Generics führen eine Abstraktionsebene in der C#-Programmierung ein, die es Entwicklern ermöglicht, Klassen, Methoden und Schnittstellen zu entwerfen, die auf generischen Typen basieren. In Verbindung mit dem new Keyword ermöglichen Generics, Typen dynamisch zu instanziieren, was die Wiederverwendbarkeit des Codes weiter steigert und Redundanz reduziert.

Die new()-Beschränkung in Generic Type

Die new()-Einschränkung ist ein Eckpfeiler der Verwendung von new mit Generika und gibt an, dass ein Typargument in einer generischen Klasse oder Methode einen öffentlichen parameterlosen Konstruktor haben muss. Diese Einschränkung ermöglicht es Ihnen, Instanzen Ihres generischen Typs innerhalb der Klasse oder Methode zu erstellen und macht Ihre generischen Klassen und Methoden flexibler und leistungsfähiger.

public class Container<t> where T : new()
{
    public T CreateItem()
    {
        return new T();
    }
}

public class Container<t> where T : new()
{
    public T CreateItem()
    {
        return new T();
    }
}

Public Class Container(Of T As {New})
    Public Function CreateItem() As T
        Return New T()
    End Function
End Class

Public Class Container(Of T As {New})
    Public Function CreateItem() As T
        Return New T()
    End Function
End Class

In diesem Beispiel kann Container Instanzen von T erstellen, vorausgesetzt, T hat einen parameterlosen Konstruktor. Diese Fähigkeit ist von unschätzbarem Wert beim Entwickeln von Bibliotheken oder Frameworks, die Objekterstellung erfordern, aber die spezifischen Typen im Voraus nicht kennen.

Einführung in IronPDF

IronPDF – Eine C#-Bibliothek für die PDF-Erstellung und -Manipulation sticht als ein leistungsstarkes Werkzeug hervor, das die Fähigkeiten von C# zur Arbeit mit PDF-Dateien nutzt. Durch die Einbindung von IronPDF können Entwickler programmgesteuert neue PDF-Dokumente aus HTML-Strings, Dateien oder URLs erstellen, vorhandene PDFs manipulieren und Inhalte extrahieren, alles durch die vertraute Syntax von C# und unter Nutzung des new Keywords für die Objekterstellung.

IronPDF überzeugt in der HTML-zu-PDF-Konvertierung, indem es den originalen Layouts und Stilen präzise erhält. Es ist ideal zur Erstellung von PDFs aus webbasierten Inhalten wie Berichten, Rechnungen und Dokumentationen. Mit Unterstützung für HTML-Dateien, URLs und rohe HTML-Strings erstellt IronPDF problemlos hochwertige PDF-Dokumente.

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()

		' 1. Convert HTML String to PDF
		Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
		Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
		pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")

		' 2. Convert HTML File to PDF
		Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
		Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
		pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

		' 3. Convert URL to PDF
		Dim url = "http://ironpdf.com" ' Specify the URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class

Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()

		' 1. Convert HTML String to PDF
		Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
		Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
		pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")

		' 2. Convert HTML File to PDF
		Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
		Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
		pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

		' 3. Convert URL to PDF
		Dim url = "http://ironpdf.com" ' Specify the URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class

Codebeispiel

using IronPdf;
using System;

namespace IronPdfExample
{
    class Program
    {
        static void Main(string[] args)
        {
            IronPdf.License.LicenseKey = "License-Key";

            // Create a new PDF document from HTML content
            var renderer = new ChromePdfRenderer();
            var pdf = renderer.RenderHtmlAsPdf("<h1>Hello, World!</h1><p>This is a PDF generated from HTML using IronPDF.</p>");

            // Save the PDF to a file
            string filePath = "HelloWorld.pdf";
            pdf.SaveAs(filePath);

            // Confirmation message
            Console.WriteLine($"PDF file has been generated at: {Environment.CurrentDirectory}\\{filePath}");
        }
    }
}

using IronPdf;
using System;

namespace IronPdfExample
{
    class Program
    {
        static void Main(string[] args)
        {
            IronPdf.License.LicenseKey = "License-Key";

            // Create a new PDF document from HTML content
            var renderer = new ChromePdfRenderer();
            var pdf = renderer.RenderHtmlAsPdf("<h1>Hello, World!</h1><p>This is a PDF generated from HTML using IronPDF.</p>");

            // Save the PDF to a file
            string filePath = "HelloWorld.pdf";
            pdf.SaveAs(filePath);

            // Confirmation message
            Console.WriteLine($"PDF file has been generated at: {Environment.CurrentDirectory}\\{filePath}");
        }
    }
}

Imports IronPdf
Imports System

Namespace IronPdfExample
	Friend Class Program
		Shared Sub Main(ByVal args() As String)
			IronPdf.License.LicenseKey = "License-Key"

			' Create a new PDF document from HTML content
			Dim renderer = New ChromePdfRenderer()
			Dim pdf = renderer.RenderHtmlAsPdf("<h1>Hello, World!</h1><p>This is a PDF generated from HTML using IronPDF.</p>")

			' Save the PDF to a file
			Dim filePath As String = "HelloWorld.pdf"
			pdf.SaveAs(filePath)

			' Confirmation message
			Console.WriteLine($"PDF file has been generated at: {Environment.CurrentDirectory}\{filePath}")
		End Sub
	End Class
End Namespace

Imports IronPdf
Imports System

Namespace IronPdfExample
	Friend Class Program
		Shared Sub Main(ByVal args() As String)
			IronPdf.License.LicenseKey = "License-Key"

			' Create a new PDF document from HTML content
			Dim renderer = New ChromePdfRenderer()
			Dim pdf = renderer.RenderHtmlAsPdf("<h1>Hello, World!</h1><p>This is a PDF generated from HTML using IronPDF.</p>")

			' Save the PDF to a file
			Dim filePath As String = "HelloWorld.pdf"
			pdf.SaveAs(filePath)

			' Confirmation message
			Console.WriteLine($"PDF file has been generated at: {Environment.CurrentDirectory}\{filePath}")
		End Sub
	End Class
End Namespace

In diesem Klassen-Program-Ausschnitt zeigt new IronPdf.ChromePdfRenderer() die Instanziierung eines IronPDF-Renderer-Objekts. Dieses Objekt wird dann verwendet, um ein neues PDF aus einem HTML-String zu erstellen, was die nahtlose Integration von Drittanbieter-Bibliotheken mit C#-Objekterstellungsmustern zeigt. IronPDF erfordert die Verwendung des new Keywords, um seine Klassen zu initiieren, was es zu einem relevanten Beispiel für Entwickler macht, die mehr über Objekterstellung und erweiterte Funktionen von C# lernen möchten.

Abschluss

Das new Keyword in C# ist ein Eckpfeiler der objektorientierten Programmierung, das es Entwicklern ermöglicht, Objekte zu instanziieren, Vererbung zu verwalten und Generika präzise und einfach zu nutzen. Durch praktische Beispiele, vom Erstellen einfacher Klasseninstanzen bis hin zur Nutzung fortschrittlicher Funktionen wie anonyme Typen und Objektinitialisierer, demonstriert dieser Leitfaden die Vielseitigkeit und Leistungsfähigkeit von new.

Die Integration von IronPDF zeigt, wie C# seine Reichweite über traditionelle Anwendungen hinaus erweitern kann, indem es die Erstellung und Manipulation von PDF-Dateien durch Code ermöglicht. IronPDF bietet eine kostenlose Testversion und Lizenzoptionen für Entwickler, um seine Funktionen zu erkunden, wobei die Lizenzen zu einem wettbewerbsfähigen Preis beginnen.