C# Ref Keywords (Wie es für Entwickler funktioniert)

Das C#-Schlüsselwort ref ist ein wesentliches Werkzeug, über das jeder Anfänger lernen sollte. Es wird verwendet, um Argumente oder Args per Referenz statt per Wert zu übergeben, so dass Änderungen an der Referenztypvariable innerhalb der aufgerufenen Methode auch außerhalb der Methode sichtbar werden. In diesem Tutorial werden wir die Details des **ref-Schlüsselworts durchgehen und verschiedene Konsolencodebeispiele erkunden, die veranschaulichen, wie es funktioniert.

Einführung in das ref-Schlüsselwort

Wenn Sie einen Methodenparameter in C# übergeben, wird dieser standardmäßig als Wert übergeben. Das bedeutet, dass eine Kopie des Wertes des Parameters erstellt wird und dass alle Änderungen, die innerhalb der aufrufenden Methode vorgenommen werden, keine Auswirkungen auf die ursprüngliche Variable außerhalb der Methode haben. Das ref Schlüsselwort ändert dieses Verhalten, indem es ermöglicht, einen Parameter als Referenz zu übergeben. Wenn ein Parameter per Referenz übergeben wird, wirken sich alle Änderungen innerhalb der Methode direkt auf die ursprüngliche Variable außerhalb der Methode aus.

Wichtige Konzepte

• ref-Schlüsselwort: Wird verwendet, um anzuzeigen, dass eine Variable als Referenz übergeben wird.
• Referenzvariablen: Typen, die auf den Speicherort verweisen, an dem die Daten gespeichert sind.
• Werttypen: Typen, die die tatsächlichen Daten halten.
• Ursprüngliche Variable: Die Variable außerhalb der Methode, die Änderungen widerspiegelt, die innerhalb der Methode vorgenommen wurden, wenn das ref-Schlüsselwort verwendet wird.

Übergabe durch Referenz

Beginnen wir damit, das Konzept der Übergabe von Variablen per Referenz zu verstehen. Stellen Sie sich vor, Sie haben eine Methode, die eine ganze Zahl inkrementiert, wie im folgenden Code gezeigt:

class Program
{
//method returns incremented value
    static void IncrementByOne(int num)
    {
        num++;
    }

    static void Main()
    {
        int value = 5;
        IncrementByOne(value);
        Console.WriteLine(value);  // Output: 5
    }
}

class Program
{
//method returns incremented value
    static void IncrementByOne(int num)
    {
        num++;
    }

    static void Main()
    {
        int value = 5;
        IncrementByOne(value);
        Console.WriteLine(value);  // Output: 5
    }
}

Friend Class Program
'method returns incremented value
	Private Shared Sub IncrementByOne(ByVal num As Integer)
		num += 1
	End Sub

	Shared Sub Main()
		Dim value As Integer = 5
		IncrementByOne(value)
		Console.WriteLine(value) ' Output: 5
	End Sub
End Class

Im obigen Code bleibt, obwohl wir num innerhalb der IncrementByOne-Methode inkrementiert haben, der ursprüngliche value unverändert. Dies liegt daran, dass num eine Kopie der ursprünglichen Variable ist und Änderungen daran das Original nicht beeinflussen.

Verwendung des Schlüsselworts ref

Nun, lassen Sie uns sehen, wie das Schlüsselwort ref dieses Verhalten ändern kann. Durch die Verwendung von ref können Sie eine Variable als Referenz an die Methode übergeben, wie in einem der unten stehenden Codebeispiele gezeigt.

class Program
{
//ref int
    static void IncrementByOneRef(ref int num)
    {
        num++;
    }

    static void Main()
    {
        int value = 5;
        IncrementByOneRef(ref value);
        Console.WriteLine(value);  // Output: 6
    }
}

class Program
{
//ref int
    static void IncrementByOneRef(ref int num)
    {
        num++;
    }

    static void Main()
    {
        int value = 5;
        IncrementByOneRef(ref value);
        Console.WriteLine(value);  // Output: 6
    }
}

Friend Class Program
'ref int
	Private Shared Sub IncrementByOneRef(ByRef num As Integer)
		num += 1
	End Sub

	Shared Sub Main()
		Dim value As Integer = 5
		IncrementByOneRef(value)
		Console.WriteLine(value) ' Output: 6
	End Sub
End Class

Beachten Sie das Schlüsselwort ref sowohl in der Methodensignatur als auch beim Aufruf. Dies teilt C# mit, dass Sie die Variable value als Referenz übergeben möchten. Infolgedessen werden die Änderungen, die innerhalb der IncrementByOneRef-Methode vorgenommen werden, in der ursprünglichen value-Variable widergespiegelt.

Arbeiten mit Werttypen

Das ref-Schlüsselwort ist besonders nützlich, wenn man mit Typen wie Integer, Double und Strukturen arbeitet. Diese Typen werden direkt im Speicher gespeichert, und ihre Übergabe per Verweis kann zu Leistungsverbesserungen und einer präziseren Steuerung der Datenmanipulation führen.

Ändern von Referenzvariablen

Während das ref-Schlüsselwort üblicherweise mit Werttypen in Verbindung gebracht wird, kann es auch mit Referenztypvariablen verwendet werden. Referenztypen, wie Klassen und Arrays, speichern einen Verweis auf die tatsächlichen Daten im Speicher und nicht die Daten selbst. Das bedeutet, dass Sie es mit einer zeigerähnlichen Struktur zu tun haben, und die Übergabe per Verweis kann zu unterschiedlichen Ergebnissen führen, wie im folgenden Beispiel gezeigt wird:

class Person
{
    public string Name { get; set; }
}

class Program
{
    //method
    static void ChangeName(ref Person person)
    {
        //new object
        person = new Person { Name = "Alice" };
    }

    static void Main()
    {
        Person person = new Person { Name = "Bob" };
        ChangeName(ref person);
        Console.WriteLine(person.Name);  // Output: Alice
    }
}

class Person
{
    public string Name { get; set; }
}

class Program
{
    //method
    static void ChangeName(ref Person person)
    {
        //new object
        person = new Person { Name = "Alice" };
    }

    static void Main()
    {
        Person person = new Person { Name = "Bob" };
        ChangeName(ref person);
        Console.WriteLine(person.Name);  // Output: Alice
    }
}

Friend Class Person
	Public Property Name() As String
End Class

Friend Class Program
	'method
	Private Shared Sub ChangeName(ByRef person As Person)
		'new object
		person = New Person With {.Name = "Alice"}
	End Sub

	Shared Sub Main()
		Dim person As New Person With {.Name = "Bob"}
		ChangeName(person)
		Console.WriteLine(person.Name) ' Output: Alice
	End Sub
End Class

In diesem Beispiel ändert die ChangeName-Methode die Referenz der person-Variable auf ein neues Person-Objekt. Infolgedessen verweist die ursprüngliche person-Variable jetzt auf ein anderes Objekt, und ihr Name ist "Alice".

Methodenüberladung mit Referenztypparametern

Sie können mehrere Methoden mit demselben Namen, aber unterschiedlichen Parametern haben. Dies wird als Methodenüberladung bezeichnet. Wenn das ref-Schlüsselwort verwendet wird, wird das Überladen von Methoden leistungsfähiger.

class Calculator
{
    public static void Add(ref int x, int y)
    {
        x += y;
    }

    public static void Add(ref double x, double y)
    {
        x += y;
    }
}

class Program
{
    static void Main()
    {
        int intValue = 5;
        double doubleValue = 7.5;
        //ref parameter
        Calculator.Add(ref intValue, 3);
        Calculator.Add(ref doubleValue, 2.5);

        Console.WriteLine(intValue);      // Output: 8
        Console.WriteLine(doubleValue);   // Output: 10.0
    }
}

class Calculator
{
    public static void Add(ref int x, int y)
    {
        x += y;
    }

    public static void Add(ref double x, double y)
    {
        x += y;
    }
}

class Program
{
    static void Main()
    {
        int intValue = 5;
        double doubleValue = 7.5;
        //ref parameter
        Calculator.Add(ref intValue, 3);
        Calculator.Add(ref doubleValue, 2.5);

        Console.WriteLine(intValue);      // Output: 8
        Console.WriteLine(doubleValue);   // Output: 10.0
    }
}

Friend Class Calculator
	Public Shared Sub Add(ByRef x As Integer, ByVal y As Integer)
		x += y
	End Sub

	Public Shared Sub Add(ByRef x As Double, ByVal y As Double)
		x += y
	End Sub
End Class

Friend Class Program
	Shared Sub Main()
		Dim intValue As Integer = 5
		Dim doubleValue As Double = 7.5
		'ref parameter
		Calculator.Add(intValue, 3)
		Calculator.Add(doubleValue, 2.5)

		Console.WriteLine(intValue) ' Output: 8
		Console.WriteLine(doubleValue) ' Output: 10.0
	End Sub
End Class

Im obigen Beispiel überladen wir die Add-Methode, um sowohl mit int- als auch mit double-Datentypen zu arbeiten. Das Schlüsselwort ref ermöglicht es den Methoden, die ursprünglichen Variablen direkt zu ändern.

Verwendung des Schlüsselworts out

Ein weiteres verwandtes Schlüsselwort ist out. Es ist dem ref ähnlich, hat jedoch einen etwas anderen Zweck. Während ref erwartet, dass die Variable initialisiert wird, bevor sie übergeben wird, wird das Schlüsselwort out verwendet, wenn Sie möchten, dass eine Methode einem Parameter einen Wert zuweist, der nicht unbedingt einen Anfangswert hat:

class Program
{
    static void Divide(int dividend, int divisor, out int quotient)
    {
        quotient = dividend / divisor;
    }

    static void Main()
    {
        int result;
        Divide(10, 2, out result);
        Console.WriteLine(result);  // Output: 5
    }
}

class Program
{
    static void Divide(int dividend, int divisor, out int quotient)
    {
        quotient = dividend / divisor;
    }

    static void Main()
    {
        int result;
        Divide(10, 2, out result);
        Console.WriteLine(result);  // Output: 5
    }
}

Friend Class Program
	Private Shared Sub Divide(ByVal dividend As Integer, ByVal divisor As Integer, ByRef quotient As Integer)
		quotient = dividend \ divisor
	End Sub

	Shared Sub Main()
		Dim result As Integer = Nothing
		Divide(10, 2, result)
		Console.WriteLine(result) ' Output: 5
	End Sub
End Class

In diesem Beispiel berechnet die Divide-Methode den Quotienten und weist ihn der quotient-Variablen unter Verwendung des out-Schlüsselworts zu. Es ist erwähnenswert, dass Sie result nicht initialisieren müssen, bevor Sie es an die Methode übergeben.

Unterschied zwischen ref und out Schlüsselwort

Das Schlüsselwort out ist dem Schlüsselwort ref ähnlich, aber erheblich unterschiedlich. Ein out-Parameter benötigt keinen Anfangswert, während ein ref-Parameter vor dem Methodenaufruf Anfangswerte haben muss.

Potenzielle Fallstricke

Während die Keywords ref und out mächtige Werkzeuge sein können, sollten sie mit Bedacht eingesetzt werden. Die falsche Verwendung dieser Schlüsselwörter kann zu verwirrendem Code und unerwartetem Verhalten führen. Zum Beispiel können Sie eine nicht-ref Variable in einem ref oder out Parameter nicht verwenden, ohne sie zuerst zu initialisieren, da dies zu einem Kompilierungsfehler führen würde.

Erweiterte Verwendung des Schlüsselworts ref

Arbeiten mit Referenztypen und Werttypen

Das Verständnis des Unterschieds zwischen Referenztypen und Werttypen ist entscheidend, wenn man mit dem ref-Schlüsselwort arbeitet.

• Referenztyp: Die Variable bezieht sich auf den Speicherort im Arbeitsspeicher, an dem die Daten gespeichert sind, z.B. Objekte, Arrays usw.

• Wertetyp: Die Variable enthält direkt die Daten, z.B. Ganzzahlen, Gleitkommazahlen usw.

  Die Verwendung von ref mit Werttypen ermöglicht es, dass Änderungen außerhalb der Methode widergespiegelt werden, während Referenztyppvariablen von Natur aus so agieren.

Erweiterung Methode mit Schlüsselwort ref

Sie können das ref-Schlüsselwort auch mit Erweiterungsmethoden verwenden. Ein Beispiel:

public static class StringExtensions
{
//example
    public static void AppendValue(ref this string input, string value)
    {
        input += value;
    }
}

public static class StringExtensions
{
//example
    public static void AppendValue(ref this string input, string value)
    {
        input += value;
    }
}

Public Module StringExtensions
'example
	Public Sub AppendValue(ByRef Me input As String, ByVal value As String)
		input &= value
	End Sub
End Module

Compilerfehler und das Schlüsselwort ref

Wenn Sie vergessen, das ref-Schlüsselwort entweder in der Methodensignatur oder im Methodenaufruf einzuschließen, führt dies zur Kompilierzeit zu einem Compilerfehler.

Async-Methoden und Ref-Parameter

Beachten Sie, dass Sie ref-Parameter nicht mit Iterator-Methoden oder async-Methoden verwenden können, da diese das Übergeben des Parameters als Wert erfordern.

Die Iron Suite stellt sich vor

Neben dem Verstehen von Schlüsselkonzepten wie dem ref-Schlüsselwort in C# gibt es eine Reihe leistungsstarker Werkzeuge, die das Leben eines Entwicklers erheblich erleichtern können. Die Iron Suite ist eine Sammlung von robusten Tools und Bibliotheken, die IronPDF, IronXL, IronOCR und IronBarcode umfassen. Schauen wir uns diese Tools an und sehen wir, wie sie Ihre Codierungserfahrung ohne Argumente verbessern können.

IronPDF PDF-Verarbeitung leicht gemacht

Erfahren Sie mehr über IronPDF als wesentlicher Bestandteil der Iron Suite. Es ist eine Bibliothek, die es Entwicklern ermöglicht, PDF-Dateien in C# zu erstellen, zu lesen und zu bearbeiten. Wenn Sie HTML in PDF konvertieren wollen, hat IronPDF die Werkzeuge, die Sie brauchen. Schauen Sie sich das Tutorial zur Umwandlung von HTML in PDF an, um mehr über diese Funktion zu erfahren.

IronXL Excel-Bearbeitung auf Knopfdruck

Die Arbeit mit Excel-Dateien in C# kann herausfordernd sein, aber die IronXL-Funktionen vereinfachen diese Aufgabe. Es ermöglicht Ihnen, Excel-Dateien zu lesen, zu schreiben, zu bearbeiten und zu manipulieren, ohne dass Sie Excel installiert haben. IronXL erleichtert den Umgang mit Excel in C#, vom Importieren von Daten bis zum Erstellen neuer Tabellenkalkulationen.

IronOCR Optische Zeichenerkennung für C#

Optische Zeichenerkennung (OCR) kann komplex sein, aber entdecken Sie IronOCR, um den Prozess zu vereinfachen. Mit dieser Bibliothek können Sie Text aus Bildern lesen und in maschinenlesbaren Text umwandeln. Ganz gleich, ob Sie Text aus einem gescannten Dokument extrahieren oder Zeichen aus einem Bild erkennen müssen, IronOCR verfügt über die entsprechende Funktionalität.

IronBarcode Barcodeerzeugung und -lesung

Barcodes werden häufig in verschiedenen Branchen verwendet, und die Handhabung in Ihren Anwendungen ist jetzt einfacher mit der IronBarcode-Bibliothek. Mit dieser Bibliothek können Sie Barcodes in C# erstellen, lesen und mit ihnen arbeiten. IronBarcode unterstützt eine breite Palette von QR- und Barcode-Formaten.

Wie Iron Suite mit dem Schlüsselwort ref zusammenhängt

Sie könnten sich fragen, wie diese Tools mit dem ref-Schlüsselwort in Verbindung stehen, das wir besprochen haben. Beim Arbeiten an komplexen Projekten, die PDF, Excel, OCR oder Barcodes beinhalten, wird der effektive Einsatz des ref-Schlüsselworts und anderer C#-Prinzipien entscheidend sein, um Ihren Code effizient zu verwalten.

Zum Beispiel, wenn Sie große Excel-Dateien mit IronXL manipulieren, kann das Übergeben von Objekten nach Referenz mit dem ref-Schlüsselwort Ihren Code effizienter und wartungsfreundlicher machen. Ähnlich kann die Arbeit mit PDF-Dokumenten mit IronPDF Methoden umfassen, bei denen das ref-Schlüsselwort eine Rolle spielen kann.

Das Verständnis der Kernspracheigenschaften wie das ref-Schlüsselwort und der Zugang zu Tools wie der Iron Suite rüstet Sie mit einer kraftvollen Kombination aus, um effiziente, robuste und vielseitige Anwendungen zu entwickeln. Die Iron Suite ist so konzipiert, dass sie nahtlos mit Ihren vorhandenen C#-Kenntnissen zusammenarbeitet und Ihnen hilft, professionellere und anspruchsvollere Lösungen zu erstellen.

Schlussfolgerung

Die C#-Sprache bietet mit Funktionen wie dem ref-Schlüsselwort leistungsstarke Möglichkeiten für Entwickler. In Kombination mit der Iron Suite, zu der IronPDF, IronXL, IronOCR und IronBarcode gehören, werden die Möglichkeiten sogar noch umfangreicher.

Jedes Produkt in der Iron Suite bietet eine kostenlose Testversion der Iron Suite, sodass Sie die umfangreichen Funktionen erkunden und nutzen können, ohne sofortige Investitionen tätigen zu müssen. Sollten Sie sich für eine Vollversion entscheiden, beginnen die Preise bei $749 für einzelne Komponenten.

Wenn die gesamte Iron Suite Ihren Bedürfnissen entspricht, wartet ein hervorragendes Angebot auf Sie. Sie können die komplette Suite zum Preis von nur zwei Einzelkomponenten erwerben.