C# Neu (Wie es für Entwickler funktioniert)

Das Operator-Schlüsselwort new in C# ist vielseitig und erfüllt mehrere wichtige Funktionen in der Sprache. Von der Instanziierung von Objekten bis zum Verstecken von vererbten Mitgliedern ist das Verständnis ihrer Anwendungen entscheidend für eine effektive C#-Entwicklung. Dieser Leitfaden erforscht die neue die verschiedenen Verwendungszwecke des Schlüsselworts mit anschaulichen Beispielen, die seine Leistungsfähigkeit und Flexibilität veranschaulichen. Wir erforschen auch die IronPDF bibliothek weiter unten in diesem Handbuch.

Einführung in die Objektinstanziierung

Die Instanziierung von Objekten ist der Prozess, bei dem der new-Operator eine Instanz einer Klasse oder Struktur erzeugt. In C# wird dies hauptsächlich mit dem Schlüsselwort new erreicht, das den Konstruktor des angegebenen Typs aufruft und Speicher für das neue Objekt zuweist.

Erstellen von Instanzen mit neuen

Um eine Instanz eines Objekts zu erstellen, folgt auf den new-Operator der Klassenname und ein Paar Klammern. Wenn die Klasse einen Konstruktor hat, der Parameter benötigt, müssen die Argumente innerhalb dieser Klammern angegeben 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")

Standard- und parameterlose Konstrukteure

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

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

Fortgeschrittene Techniken der Objekterstellung

In C# geht es bei der Objekterstellung nicht nur um die Instanziierung von Klassen; es ist ein Einstieg in die Nutzung der leistungsstarken Funktionen der Sprache für effizienteren, lesbaren und prägnanten Code. Hier erforschen wir fortgeschrittene Techniken wie die Arbeit mit Arrays, die Verwendung von Typen und den Einsatz von Objektinitialisierern, um Ihre Programmierarbeit zu rationalisieren.

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 Programmierfähigkeiten verbessern. Mit dem Schlüsselwort new können Sie Arrays instanziieren, indem Sie deren Typ und die Anzahl der Elemente angeben, die sie enthalten sollen. Dies ist für die strukturierte Verwaltung von Variablensammlungen von entscheidender Bedeutung. Über einfache Arrays hinaus erleichtert new die Erstellung mehrdimensionaler und gezackter Arrays, die komplexe Datenstrukturen aufnehmen können.

// 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

Anonyme Typen

Anonyme Typen eignen sich hervorragend für Szenarien, in denen temporäre Datenstrukturen benötigt werden, ohne dass der Overhead der Deklaration einer formalen Klasse entsteht. Durch die Verwendung von new mit einer Property-Initialisierungssyntax können Sie Objekte im Handumdrehen 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 müssen, oder um Daten schnell zu gruppieren, 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
	}

Objekt-Initialisierer

Ein Objektinitialisierer 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 aufzurufen. Dies macht den Code nicht nur lesbarer, sondern verringert auch die Fehlerwahrscheinlichkeit, da nicht mehr mehrere Konstruktoren für verschiedene Szenarien benötigt werden. Objektinitialisierer sind besonders praktisch, wenn Sie mit komplexen Objekten arbeiten, denn sie ermöglichen es Ihnen, nur die benötigten Eigenschaften zu setzen.

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
	}
}

Lokale Funktionen und Lambda-Ausdruck

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

Lokale Funktion

Eine lokale Funktion ist eine Methode, die innerhalb des Geltungsbereichs einer anderen Methode definiert ist und als leistungsfähiges Werkzeug zur Organisation von Code und zur Kapselung von Funktionen 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

Lambda-Ausdrücke

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

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

Verwendung von 'new' in der Vererbung

Bei der Klassenvererbung kann new vererbte Mitglieder ausblenden, so dass abgeleitete Klassen ein Mitglied mit demselben Namen wie in ihren Basisklassen einführen können.

Vererbte Mitglieder ausblenden

Die Verwendung von new, um ein Mitglied in einer abgeleiteten Klasse auszublenden, bedeutet nicht, dass dasselbe Mitglied überschrieben wird; stattdessen wird ein neues Mitglied eingeführt, das sich von der Version der Basisklasse 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

Neues mit Generika verstehen

Generics führen eine Abstraktionsebene in die C#-Programmierung ein, die es Entwicklern ermöglicht, Klassen, Methoden und Schnittstellen zu entwerfen, die mit generischen Typen arbeiten. In Verbindung mit dem Schlüsselwort new ermöglichen Generics die dynamische Instanziierung von Typen, wodurch die Wiederverwendbarkeit von Code weiter verbessert und Redundanz reduziert wird.

Die new()-Beschränkung in Generic Type

Die neue() Constraint ist ein Eckpfeiler der Verwendung von new mit Generics und legt fest, 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, wodurch Ihre generischen Klassen und Methoden flexibler und leistungsfähiger werden.

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

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

public class Container(Of T) where T : New() {
	public T CreateItem() { Return New T(); }
}

In diesem Beispiel wird Container kann Instanzen von T erzeugen, sofern T einen parameterlosen Konstruktor hat. Diese Fähigkeit ist von unschätzbarem Wert bei der Entwicklung von Bibliotheken oder Frameworks, die die Erstellung von Objekten erfordern, aber die spezifischen Typen nicht im Voraus kennen.

Einführung in IronPDF

IronPDF zeichnet sich als leistungsfähiges Werkzeug aus, das die Möglichkeiten von C# für die Arbeit mit PDF-Dateien nutzt. Durch die Integration von IronPDF können Entwickler programmatisch neue PDF-Dokumente aus HTML-Stringssie können mit der vertrauten Syntax von C# und dem Schlüsselwort new für die Instanziierung von Objekten Dateien oder URLs erstellen, vorhandene PDFs bearbeiten und Inhalte extrahieren.

Code-Beispiel

using IronPdf;
using System;
namespace IronPdfExample
{
    class Program
    {
//static void main
        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
        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
'static void main
		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 dieser Klasse Programmausschnitt, new IronPDF.ChromePdfRenderer() demonstriert die Instanziierung eines IronPDF-Renderer-Objekts. Dieses Objekt wird dann verwendet, um eine neue PDF-Datei aus einer HTML-Zeichenkette zu erstellen, was die nahtlose Integration von Bibliotheken von Drittanbietern mit den Objekterstellungsmustern von C# veranschaulicht. IronPDF erfordert die Verwendung des Schlüsselworts new, um seine Klassen zu initiieren, was es zu einem relevanten Beispiel für Entwickler macht, die etwas über die Instanziierung von Objekten lernen und fortgeschrittene Funktionen von C# erkunden möchten.

Ausgabe

Wenn Sie das Programm ausführen, sehen Sie auf der Konsole die folgende Meldung:

Und wenn Sie die PDF-Datei öffnen, sehen Sie dies:

Schlussfolgerung

Das Schlüsselwort new in C# ist ein Eckpfeiler der objektorientierten Programmierung und ermöglicht es Entwicklern, Objekte zu instanziieren, Vererbung zu verwalten und Generika mit Präzision und Leichtigkeit zu verwenden. Anhand praktischer Beispiele, von der Erstellung einfacher Klasseninstanzen bis hin zur Nutzung fortgeschrittener Funktionen wie anonymer Typen und Objektinitialisierer, demonstriert dieses Handbuch die Vielseitigkeit und Leistungsfähigkeit von new.

Die Integration von IronPDF zeigt, wie C# seine Reichweite über herkömmliche Anwendungen hinaus erweitern kann, indem es die Erzeugung und Bearbeitung von PDF-Dateien durch Code ermöglicht. IronPDF bietet eine kostenloser Test für Entwickler, um seine Funktionen zu erkunden, mit Lizenzen ab $749.