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

Die Grundlagen dieses Schlüsselworts

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

Hier ist die Lösung: Verwenden Sie das Schlüsselwort this in der C#-Dokumentation ! Im folgenden Beispiel einer Methode innerhalb der öffentlichen Klasse Employee wird das Schlüsselwort this verwendet, um zwischen den Instanzvariablen und den Methodenparametern mit demselben Namen zu unterscheiden.

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

    public void Display(int id, string name)
    {
        // Use `this.id` to refer to the instance variable, 
        // and `id` for the method parameter.
        this.id = id;
        this.name = name;
    }
}

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

    public void Display(int id, string name)
    {
        // Use `this.id` to refer to the instance variable, 
        // and `id` for the method parameter.
        this.id = id;
        this.name = name;
    }
}

Public Class Employee
	Private id As Integer
	Private name As String

	Public Sub Display(ByVal id As Integer, ByVal name As String)
		' Use `this.id` to refer to the instance variable, 
		' and `id` for the method parameter.
		Me.id = id
		Me.name = name
	End Sub
End Class

In diesem Fall bezieht sich this.id auf die Instanzvariable und id auf den Methodenparameter.

this Schlüsselwort in Konstruktorüberladung

Durch die Nutzung des Schlüsselworts this wird die Konstruktorüberladung zu einer leistungsstarken Technik innerhalb derselben Klasse. Wenn eine Klasse, wie zum Beispiel eine Student Klasse, mehrere Konstruktoren mit unterschiedlichen Parametern hat, ermöglicht das Schlüsselwort this, dass ein Konstruktor einen anderen aufruft, wodurch redundanter Code vermieden wird.

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)
    {
        // Default constructor delegates to the parameterized constructor
        // with "Default" as the name and 0 as the id.
    }

    public Student(string name, int id)
    {
        // Assign the parameters to the instance variables
        this.name = name;
        this.id = id;
    }
}

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

    public Student() : this("Default", 0)
    {
        // Default constructor delegates to the parameterized constructor
        // with "Default" as the name and 0 as the id.
    }

    public Student(string name, int id)
    {
        // Assign the parameters to the instance variables
        this.name = name;
        this.id = id;
    }
}

Public Class Student
	Private name As String
	Private id As Integer

	Public Sub New()
		Me.New("Default", 0)
		' Default constructor delegates to the parameterized constructor
		' with "Default" as the name and 0 as the id.
	End Sub

	Public Sub New(ByVal name As String, ByVal id As Integer)
		' Assign the parameters to the instance variables
		Me.name = name
		Me.id = id
	End Sub
End Class

Im parameterlosen Konstruktor ruft this("Default", 0) den parametrisierten Konstruktor auf und setzt dabei Default als Namen und 0 als ID.

Erkundung von this in Erweiterungsmethoden

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

Betrachten Sie das folgende Beispiel einer Erweiterungsmethode:

public static class StringExtensions
{
    // This extension method can be called on any string instance
    public static bool IsNullOrEmpty(this string str)
    {
        return string.IsNullOrEmpty(str);
    }
}

public static class StringExtensions
{
    // This extension method can be called on any string instance
    public static bool IsNullOrEmpty(this string str)
    {
        return string.IsNullOrEmpty(str);
    }
}

Public Module StringExtensions
	' This extension method can be called on any string instance
	<System.Runtime.CompilerServices.Extension> _
	Public Function IsNullOrEmpty(ByVal str As String) As Boolean
		Return String.IsNullOrEmpty(str)
	End Function
End Module

Hier teilt this string str C# mit, dass es sich um eine Erweiterungsmethode für den String-Typ handelt. Diese Methode können Sie nun auf beliebige String-Objekte anwenden, wie zum Beispiel if(myString.IsNullOrEmpty()).

this in Indexern

Das Schlüsselwort this kann auch zur Definition von Indexern verwendet werden. Ein Indexer ermöglicht es, Instanzen einer Klasse genauso wie Arrays zu indizieren. Dies hilft Ihnen, auf Daten innerhalb von Objekten mit indexähnlicher Notation zuzugreifen. In einem Indexer folgt auf this ein Array-Index, der üblicherweise int index lautet.

Hier ist ein einfaches Beispiel für einen Indexer:

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

    // Define an indexer for the class
    public int this[int index]
    {
        get { return array[index]; }
        set { array[index] = value; }
    }
}

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

    // Define an indexer for the class
    public int this[int index]
    {
        get { return array[index]; }
        set { array[index] = value; }
    }
}

Public Class Test
	Private array(99) As Integer

	' Define an indexer for the class
	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 abzurufen oder festzulegen.

this und statische Mitglieder

Eine Sache ist bei this zu beachten: Es kann nicht verwendet werden, um auf statische Member oder Methoden zu verweisen. Dies liegt daran, dass this sich auf die aktuelle Instanz bezieht, statische Member aber 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

Merken Sie sich also: this gilt für Instanzen, nicht für Klassen- oder statische Member!

this Schlüsselwort und Eigenschaften

Genau wie bei Instanzvariablen und Methodenparametern kann das Schlüsselwort this auch mit Eigenschaften verwendet werden. In C# ist eine Eigenschaft ein Mitglied, das einen flexiblen Mechanismus zum Lesen, Schreiben oder Berechnen des Werts eines privaten Felds bereitstellt. Eigenschaften können verwendet werden, als ob sie öffentliche Datenmitglieder wären, sind aber tatsächlich spezielle Methoden, sogenannte Accessoren.

Betrachten wir ein einfaches Beispiel mit this in einer Eigenschaft:

public class Employee
{
    private string name;

    public string Name
    {
        get { return this.name; }
        set { this.name = value; } // Use `this` to refer to the instance variable
    }
}

public class Employee
{
    private string name;

    public string Name
    {
        get { return this.name; }
        set { this.name = value; } // Use `this` to refer to the instance variable
    }
}

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 ' Use `this` to refer to the instance variable
	End Property
End Class

In der oben genannten Klasse wird das Schlüsselwort this verwendet, um auf die private Zeichenkette name in den Getter- und Setter-Methoden der Eigenschaft Name zu verweisen.

Erkundung von this und Delegierten

Eine weitere Stelle, an der this auftaucht, sind die Delegierten. Ein Delegate in C# ist ähnlich wie ein Funktionszeiger in C oder C++. Es ist eine Referenztyp-Variable, die die Referenz auf eine Methode enthält. Delegatenmethoden 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()
    {
        // `this.DisplayDetails` refers to the method instance of the current object.
        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()
    {
        // `this.DisplayDetails` refers to the method instance of the current object.
        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()
		' `this.DisplayDetails` refers to the method instance of the current object.
		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 Studentenklasse erstellt this.DisplayDetails eine neue Instanz des Delegaten, die auf die Methode DisplayDetails des aktuellen Objekts verweist.

Implementierung des Schlüsselworts this mit IronPDF

Schauen wir uns ein Beispiel an, bei dem Sie das Schlüsselwort this in Verbindung mit IronPDF verwenden könnten, einer leistungsstarken .NET Bibliothek zum Bearbeiten und Erstellen von PDF-Dateien mit HTML .

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

using IronPdf;

public class PDFHandler
{
    private string path;

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

    public void GeneratePDF(string content)
    {
        // Creating a renderer to convert HTML content to PDF
        var Renderer = new IronPdf.ChromePdfRenderer();
        var PDF = Renderer.RenderHtmlAsPdf(content);

        // Save the generated PDF to the path specified by the current instance
        PDF.SaveAs(this.path);
    }
}

using IronPdf;

public class PDFHandler
{
    private string path;

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

    public void GeneratePDF(string content)
    {
        // Creating a renderer to convert HTML content to PDF
        var Renderer = new IronPdf.ChromePdfRenderer();
        var PDF = Renderer.RenderHtmlAsPdf(content);

        // Save the generated PDF to the path specified by the current instance
        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)
		' Creating a renderer to convert HTML content to PDF
		Dim Renderer = New IronPdf.ChromePdfRenderer()
		Dim PDF = Renderer.RenderHtmlAsPdf(content)

		' Save the generated PDF to the path specified by the current instance
		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 das erzeugte PDF unter dem angegebenen Pfad zu speichern.

Wenn wir eine neue Instanz von PDFHandler erstellen und die Methode GeneratePDF aufrufen, ermöglicht uns das Schlüsselwort this die Verwendung des bei der Objekterstellung angegebenen path:

class Program
{
    static void Main(string[] args)
    {
        // Initialize PDFHandler with a specified file path
        PDFHandler pdfHandler = new PDFHandler("C:\\ThisKeyword.pdf");
        pdfHandler.GeneratePDF("Hello World!");
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Initialize PDFHandler with a specified file path
        PDFHandler pdfHandler = new PDFHandler("C:\\ThisKeyword.pdf");
        pdfHandler.GeneratePDF("Hello World!");
    }
}

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Initialize PDFHandler with a specified file path
		Dim pdfHandler As New PDFHandler("C:\ThisKeyword.pdf")
		pdfHandler.GeneratePDF("Hello World!")
	End Sub
End Class

Hier sorgt this dafür, dass der Code lesbarer und verständlicher wird, insbesondere bei der Verwendung von Bibliotheken wie IronPDF.

Abschluss

Inzwischen sollten Sie ein gutes Verständnis des Schlüsselworts this in C# haben, einschließlich seiner vielfältigen Verwendungsmöglichkeiten, von einfachen Instanzvariablen bis hin zu komplexen Kontexten wie Konstruktoren, Erweiterungsmethoden, Eigenschaften, Delegaten, anonymen Methoden und sogar bei der Verwendung beliebter Bibliotheken wie IronPDF.

Denken Sie daran, IronPDF bietet eine kostenlose Testversion von IronPDF an, sodass Sie alles, was Sie heute gelernt haben, testen können. Wenn Sie sich entscheiden, damit weiterzuarbeiten, beginnen die Lizenzen bereits bei $liteLicense. IronPDF kann eine wertvolle Ergänzung zu Ihrem C#-Entwicklungstoolkit sein, um die Aufgabe der PDF-Dateiverarbeitung in Ihren Anwendungen zu vereinfachen.