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

Es gibt ein bestimmtes Schlüsselwort in C#, das eine besondere Bedeutung hat, und das ist das Schlüsselwort this. Dieses Schlüsselwort bezieht sich auf die aktuelle Klasseninstanz, in der es verwendet wird. Er kann unter anderem dazu verwendet werden, um zwischen Variablen auf Klassenebene und Methodenparametern zu unterscheiden, die denselben Namen haben. Wenn Sie zum Beispiel eine Instanzvariable und einen Methodenparameter mit demselben Namen haben, kann "this" ein Lebensretter sein!

Die Grundlagen dieses Schlüsselworts

In einer öffentlichen Klasse, wie zum Beispiel Mitarbeiter, können Sie öffentliche Instanzvariablen wie id oder Name haben. Wenn Sie diesen Instanzvariablen innerhalb einer Methode Werte zuweisen wollen, stoßen Sie möglicherweise auf ein häufiges Problem: Was ist, wenn die Methodenparameter denselben Namen haben wie die Instanzvariablen?

Hier ist eine Lösung: Verwenden Sie die schlüsselwort "this! Im folgenden Beispiel einer Methode innerhalb der öffentlichen Klasse "Employee" wird das Schlüsselwort "this" verwendet, um zwischen den Instanzvariablen und den Methodenparametern zu unterscheiden, die denselben Namen haben.

public void Display(int id, string name)
{
    this.id = id;
    this.name = name;
}

public void Display(int id, string name)
{
    this.id = id;
    this.name = name;
}

Public Sub Display(ByVal id As Integer, ByVal name As String)
	Me.id = id
	Me.name = name
End Sub

In diesem Fall bezieht sich "this.id" auf die Instanzvariable, und "id" ist der Methodenparameter.

this"-Schlüsselwort in Konstruktorüberladung

Durch die Nutzung des Schlüsselworts "this" wird die Überladung von Konstruktoren zu einer leistungsfähigen Technik innerhalb derselben Klasse. Wenn eine Klasse, wie z.B. eine "Student"-Klasse, mehrere Konstruktoren mit unterschiedlichen Parametern hat, ermöglicht das Schlüsselwort "this", dass ein Konstruktor einen anderen aufruft, so dass kein redundanter Code erforderlich ist.

Betrachten Sie das folgende Beispiel, in dem "this" in einem parametrisierten Konstruktor verwendet wird:

public class Student
{
    private string name;
    private int id;

    public Student() : this("Default", 0)
    {
    }

    public Student(string name, int id)
    {
        this.name = name;
        this.id = id;
    }
}

public class Student
{
    private string name;
    private int id;

    public Student() : this("Default", 0)
    {
    }

    public Student(string name, int id)
    {
        this.name = name;
        this.id = id;
    }
}

Public Class Student
	Private name As String
	Private id As Integer

	Public Sub New()
		Me.New("Default", 0)
	End Sub

	Public Sub New(ByVal name As String, ByVal id As Integer)
		Me.name = name
		Me.id = id
	End Sub
End Class

In dem parameterlosen Konstruktor wird "this("Standard", 0)ruft den parametrisierten Konstruktor auf, wobei "Default" als Name und als ID festgelegt wird.

Erforschung von "this" in Erweiterungsmethoden

Erweiterungsmethoden in C# bieten eine Möglichkeit, Methoden zu bestehenden Typen hinzuzufügen, ohne den ursprünglichen Typ zu verändern. Hier bewirkt das Schlüsselwort "this" etwas Magisches. Er wird in der Parameterliste der Erweiterungsmethode verwendet, um auf den Typ zu verweisen, der erweitert wird.

Betrachten Sie das folgende Beispiel für eine Erweiterungsmethode:

public static class StringExtensions
{
    public static bool IsNullOrEmpty(this string str)
    {
        return string.IsNullOrEmpty(str);
    }
}

public static class StringExtensions
{
    public static bool IsNullOrEmpty(this string str)
    {
        return string.IsNullOrEmpty(str);
    }
}

Public Module StringExtensions
	<System.Runtime.CompilerServices.Extension> _
	Public Function IsNullOrEmpty(ByVal str As String) As Boolean
		Return String.IsNullOrEmpty(str)
	End Function
End Module

Hier sagt this string str C#, dass es sich um eine Erweiterungsmethode für den Typ String handelt. Jetzt können Sie diese Methode auf jedes beliebige String-Objekt anwenden, z.B. if(myString.IsNullOrEmpty()).

dies" in Indexern

Das Schlüsselwort this kann auch bei der Definition von Indexern verwendet werden. Ein Indexer ermöglicht es, Instanzen einer Klasse genau wie Arrays zu indizieren. So können Sie mit einer indexähnlichen Notation auf Daten innerhalb von Objekten zugreifen. In einem Indexer folgt auf this ein Array-Index, der normalerweise int index ist.

Hier ist ein einfaches Beispiel für einen Indexer:

public class Test
{
    private int [] array = new int [100];

    public int this [int index]
    {
        get { return array [index]; }
        set { array [index] = value; }
    }
}

public class Test
{
    private int [] array = new int [100];

    public int this [int index]
    {
        get { return array [index]; }
        set { array [index] = value; }
    }
}

Public Class Test
	Private array(99) As Integer

	Default Public Property Item(ByVal index As Integer) As Integer
		Get
			Return array (index)
		End Get
		Set(ByVal value As Integer)
			array (index) = value
		End Set
	End Property
End Class

In dieser Klasse Test definiert das Schlüsselwort this einen Indexer, der verwendet werden kann, um Werte im Instanzfeld array zu erhalten oder zu setzen.

this" und statische Mitglieder

Eine Sache, die man bei this beachten sollte, ist, dass es nicht verwendet werden kann, um auf statische Mitglieder oder Methoden zu verweisen. Dies liegt daran, dass sich "this" auf die aktuelle Instanz bezieht und statische Mitglieder zur Klasse selbst gehören, nicht zu einer Instanz der Klasse.

public class Program
{
    public static void Main(string [] args)
    {
        // Can't use `this` here, because 'Main' is a static method.
    }
}

public class Program
{
    public static void Main(string [] args)
    {
        // Can't use `this` here, because 'Main' is a static method.
    }
}

Public Class Program
	Public Shared Sub Main(ByVal args() As String)
		' Can't use `this` here, because 'Main' is a static method.
	End Sub
End Class

Denken Sie also daran, dass "this" für Instanzen, nicht für Klassen oder statische Mitglieder gilt!

this"-Schlüsselwort und Eigenschaften

Genau wie Instanzvariablen und Methodenparameter kann das Schlüsselwort "this" auch für Eigenschaften verwendet werden. In C# ist eine Eigenschaft ein Element, das einen flexiblen Mechanismus zum Lesen, Schreiben oder Berechnen des Wertes eines privaten Feldes bietet. Eigenschaften können so verwendet werden, als wären sie öffentliche Datenmitglieder, aber in Wirklichkeit sind sie spezielle Methoden, die Accessors genannt werden.

Schauen wir uns ein einfaches Beispiel für die Verwendung von "this" in einer Eigenschaft an:

public class Employee
{
    private string name;

    public string Name
    {
        get { return this.name; }
        set { this.name = value; }
    }
}

public class Employee
{
    private string name;

    public string Name
    {
        get { return this.name; }
        set { this.name = value; }
    }
}

Public Class Employee
'INSTANT VB NOTE: The field name was renamed since Visual Basic does not allow fields to have the same name as other class members:
	Private name_Conflict As String

	Public Property Name() As String
		Get
			Return Me.name_Conflict
		End Get
		Set(ByVal value As String)
			Me.name_Conflict = value
		End Set
	End Property
End Class

In der obigen Klasse wird das Schlüsselwort "this" verwendet, um in den Zugriffsfunktionen "get" und "set" der Eigenschaft "Name" auf die private Zeichenfolge "name" zu verweisen.

Erkundung von "dies" und Delegierten

Ein weiterer Ort, an dem "dies" auftaucht, sind die Delegierten. Ein Delegat in C# ist vergleichbar mit einem Funktionszeiger in C oder C++. Es handelt sich um eine Variable vom Typ Referenz, die den Verweis auf eine Methode enthält. Delegate-Methoden können, genau wie Erweiterungsmethoden, this verwenden, um auf die aktuelle Instanz zuzugreifen.

Hier ist ein Beispiel für einen Delegaten, der this verwendet:

public delegate void DisplayDelegate();

public class Student
{
    public int Id { get; set; }
    public string Name { get; set; }

    public void Display()
    {
        DisplayDelegate displayDelegate = new DisplayDelegate(this.DisplayDetails);
        displayDelegate();
    }

    private void DisplayDetails()
    {
        Console.WriteLine("ID: " + Id + ", Name: " + Name);
    }
}

public delegate void DisplayDelegate();

public class Student
{
    public int Id { get; set; }
    public string Name { get; set; }

    public void Display()
    {
        DisplayDelegate displayDelegate = new DisplayDelegate(this.DisplayDetails);
        displayDelegate();
    }

    private void DisplayDetails()
    {
        Console.WriteLine("ID: " + Id + ", Name: " + Name);
    }
}

Public Delegate Sub DisplayDelegate()

Public Class Student
	Public Property Id() As Integer
	Public Property Name() As String

	Public Sub Display()
		Dim displayDelegate As New DisplayDelegate(AddressOf Me.DisplayDetails)
		displayDelegate()
	End Sub

	Private Sub DisplayDetails()
		Console.WriteLine("ID: " & Id & ", Name: " & Name)
	End Sub
End Class

In der Schülerklasse wird mit "this.DisplayDetails" eine neue Instanz des Delegaten erstellt, die auf die Methode "DisplayDetails" des aktuellen Objekts verweist.

Implementierung des this-Schlüsselworts mit IronPDF

Betrachten wir ein Beispiel, in dem Sie das Schlüsselwort "this" in Verbindung mit IronPDF, eine leistungsstarke .NET-Bibliothek für die Bearbeitung und erstellung von PDF-Dateien mit HTML.

Betrachten wir eine Klasse namens PDFHandler, die die IronPDF-Bibliothek verwendet, um verschiedene Operationen mit PDF-Dateien durchzuführen:

using IronPdf;

public class PDFHandler
{
    private string path;

    public PDFHandler(string path)
    {
        this.path = path;
    }

    public void GeneratePDF(string content)
    {
        var Renderer = new IronPdf.ChromePdfRenderer();
        var PDF = Renderer.RenderHtmlAsPdf(content);
        PDF.SaveAs(this.path);
    }
}

using IronPdf;

public class PDFHandler
{
    private string path;

    public PDFHandler(string path)
    {
        this.path = path;
    }

    public void GeneratePDF(string content)
    {
        var Renderer = new IronPdf.ChromePdfRenderer();
        var PDF = Renderer.RenderHtmlAsPdf(content);
        PDF.SaveAs(this.path);
    }
}

Imports IronPdf

Public Class PDFHandler
	Private path As String

	Public Sub New(ByVal path As String)
		Me.path = path
	End Sub

	Public Sub GeneratePDF(ByVal content As String)
		Dim Renderer = New IronPdf.ChromePdfRenderer()
		Dim PDF = Renderer.RenderHtmlAsPdf(content)
		PDF.SaveAs(Me.path)
	End Sub
End Class

In dieser "PDFHandler"-Klasse wird das Schlüsselwort "this" verwendet, um auf das Feld "path" der aktuellen Instanz zu verweisen. Dieses Feld wird verwendet, um die erzeugte PDF-Datei unter dem angegebenen Pfad zu speichern.

Wenn wir eine neue Instanz von PDFHandler erstellen und die Methode GeneratePDF aufrufen, erlaubt uns das Schlüsselwort this, den bei der Objekterstellung angegebenen Pfad zu verwenden:

class Program
{
    static void Main(string [] args)
    {
        PDFHandler pdfHandler = new PDFHandler("C:\\ThisKeyowrd.pdf");
        pdfHandler.GeneratePDF("Hello World!");
    }
}

class Program
{
    static void Main(string [] args)
    {
        PDFHandler pdfHandler = new PDFHandler("C:\\ThisKeyowrd.pdf");
        pdfHandler.GeneratePDF("Hello World!");
    }
}

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim pdfHandler As New PDFHandler("C:\ThisKeyowrd.pdf")
		pdfHandler.GeneratePDF("Hello World!")
	End Sub
End Class

Hier macht this den Code lesbarer und verständlicher, besonders wenn man mit Bibliotheken wie IronPDF arbeitet.

Schlussfolgerung

Mittlerweile sollten Sie das this-Schlüsselwort in C# gut verstehen, einschließlich seiner weitreichenden Verwendungsmöglichkeiten, von einfachen Instanzvariablen bis hin zu komplexen Zusammenhängen wie Konstruktoren, Erweiterungsmethoden, Eigenschaften, Delegaten, anonymen Methoden und sogar bei der Verwendung beliebter Bibliotheken wie IronPDF.

Denken Sie daran, IronPDF bietet eine kostenloser Testso können Sie alles, was Sie heute gelernt haben, unter Beweis stellen. Wenn Sie sich entscheiden, damit fortzufahren, beginnen die Lizenzen nur mit $749. IronPDF kann eine wertvolle Ergänzung zu Ihrem C#-Entwicklungs-Toolkit sein und die Handhabung von PDF-Dateien in Ihren Anwendungen vereinfachen.