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

Die C# ref Schlüsselwort ist ein wichtiges Instrument, das jeder Anfänger kennen 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 Konsolencode-Beispiele untersuchen, die zeigen, 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 Schlüsselwort "ref" ändert dieses Verhalten und ermöglicht die Übergabe eines Parameters per Referenz. 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

• schlüsselwort ref**: Wird verwendet, um anzugeben, dass eine Variable als Referenz übergeben wird.
• Referenzvariablen: Typen, die auf den Speicherplatz verweisen, an dem die Daten gespeichert sind.
• Werttypen: Typen, die die eigentlichen Daten enthalten.
• Original-Variable: Die Variable außerhalb der Methode, die Änderungen widerspiegelt, die innerhalb der Methode unter Verwendung der Schlüsselwörter "ref" vorgenommen wurden.

Ü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 wird zwar die Zahl in der Methode "IncrementByOne" erhöht, der ursprüngliche Wert bleibt jedoch unverändert. Der Grund dafür ist, dass num eine Kopie der ursprünglichen Variable ist und sich Änderungen an ihr nicht auf das Original auswirken.

Verwendung des Schlüsselworts ref

Nun wollen wir sehen, wie das Schlüsselwort "ref" dieses Verhalten ändern kann. Durch die Verwendung von "ref" können Sie eine Variable per Verweis an die Methode übergeben, wie in einem der folgenden 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 Signatur der Methode als auch im Aufruf. Dies sagt C#, dass Sie die Variable "value" per Referenz übergeben wollen. Infolgedessen spiegeln sich die in der Methode "IncrementByOneRef" vorgenommenen Änderungen in der ursprünglichen Variable "value" wider.

Arbeiten mit Werttypen

Das Schlüsselwort "ref" ist besonders nützlich, wenn man mit Typen wie Integers, Doubles und Structs 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 Schlüsselwort "ref" üblicherweise mit Werttypen assoziiert wird, kann es auch für Variablen vom Typ "Referenz" 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 Methode "ChangeName" die Referenz der Variablen "Person" in ein neues Objekt "Person". Infolgedessen zeigt die ursprüngliche Variable "Person" nun auf ein anderes Objekt, das den Namen "Alice" trägt

Methodenüberladung mit Referenztypparametern

Sie können mehrere Methoden mit demselben Namen, aber unterschiedlichen Parametern haben. Dies wird als Methodenüberladung bezeichnet. Durch die Verwendung des Schlüsselworts "ref" wird das Überladen von Methoden noch 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 Methode Add, um sowohl mit den Typen int als auch double 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 ähnlich wie das "ref", hat aber einen etwas anderen Zweck. Während "ref" erwartet, dass die Variable initialisiert wird, bevor sie übergeben wird, wird das Schlüsselwort "out" verwendet, wenn eine Methode einem Parameter einen Wert zuweisen soll, 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 Methode Divide den Quotienten und weist ihn der Variablen Quotient mit dem Schlüsselwort out zu. Es ist erwähnenswert, dass Sie das "Ergebnis" nicht initialisieren müssen, bevor Sie es an die Methode übergeben.

Unterschied zwischen ref und out Schlüsselwort

Das Schlüsselwort "out" ähnelt dem Schlüsselwort "ref", unterscheidet sich aber deutlich von diesem. Ein "out"-Parameter braucht keinen Anfangswert, während ein "ref"-Parameter vor dem Methodenaufruf Anfangswerte haben muss.

Potenzielle Fallstricke

Die Schlüsselwörter "ref" und "out" können zwar mächtige Werkzeuge sein, sollten aber mit Bedacht eingesetzt werden. Die falsche Verwendung dieser Schlüsselwörter kann zu verwirrendem Code und unerwartetem Verhalten führen. Sie können zum Beispiel keine Nicht-Ref-Variable in einem ref- oder out-Parameter verwenden, ohne sie vorher zu initialisieren, da dies zu einem Kompilierungsfehler führen würde.

Erweiterte Verwendung des Schlüsselworts ref

Arbeiten mit Referenztypen und Werttypen

Bei der Arbeit mit dem Schlüsselwort "ref" ist es wichtig, den Unterschied zwischen zwei Referenz- und Werttypen zu verstehen.

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

• Werttyp: Die Variable enthält die Daten direkt, z. B. Ganzzahlen, Fließkommazahlen usw.

  Die Verwendung von "ref" bei Werttypen ermöglicht es, Änderungen außerhalb der Methode zu berücksichtigen, während sich Variablen vom Typ "Referenz" von Natur aus so verhalten.

Erweiterung Methode mit Schlüsselwort ref

Sie können das Schlüsselwort "ref" 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 Schlüsselwort "ref" entweder in die Signatur der Methode oder in den Methodenaufruf aufzunehmen, führt dies zu einem Compilerfehler bei der Kompilierung.

async-Methoden und ref-Parameter

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

Die Iron Suite stellt sich vor

Neben dem Verständnis von Schlüsselkonzepten wie dem ref-Schlüsselwort in C# gibt es eine Reihe leistungsfähiger 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

IronPDF ist ein wesentlicher Bestandteil der Iron Suite. Es handelt sich um eine Bibliothek, mit der Entwickler PDF-Dateien in C# erstellen, lesen und bearbeiten können. Wenn Sie HTML in PDF konvertieren wollen, hat IronPDF die Werkzeuge, die Sie brauchen. Überprüfen Sie die HTML-zu-PDF-Tutorial um mehr über diese Funktion zu erfahren.

IronXL Excel-Bearbeitung auf Knopfdruck

Die Arbeit mit Excel-Dateien in C# kann eine Herausforderung sein, aber IronXL vereinfacht diese Aufgabe. Es ermöglicht Ihnen, Excel-Dateien zu lesen, zu schreiben, zu bearbeiten und zu manipulieren, ohne dass Sie Excel installiert haben. Vom Importieren von Daten bis zum Erstellen neuer Tabellenkalkulationen - IronXL macht den Umgang mit Excel in C# einfach;

IronOCR Optische Zeichenerkennung für C#

Optische Zeichenerkennung (OCR) kann komplex sein, aber IronOCR strafft den Prozess. 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 dieser Codes in Ihren Anwendungen ist jetzt leichter zugänglich mit IronBarcode. 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 fragen sich vielleicht, wie diese Werkzeuge mit dem Schlüsselwort "ref" zusammenhängen, das wir besprochen haben. Bei der Arbeit an komplexen Projekten, die PDF, Excel, OCR oder Barcodes beinhalten, ist die effektive Verwendung des Schlüsselworts "ref" und anderer C#-Prinzipien entscheidend für die effiziente Verwaltung Ihres Codes.

Wenn Sie beispielsweise große Excel-Dateien mit IronXL bearbeiten, kann die Übergabe von Objekten per Referenz mit dem Schlüsselwort ref Ihren Code effizienter und wartbarer machen. Auch bei der Arbeit mit PDF-Dokumenten unter Verwendung von IronPDF können Methoden zum Einsatz kommen, bei denen das Schlüsselwort "ref" eine Rolle spielen kann.

Wenn Sie die Kernfunktionen der Sprache wie das Schlüsselwort ref verstehen und Zugang zu Werkzeugen wie der Iron Suite haben, verfügen Sie über eine leistungsstarke Kombination, um effiziente, robuste und vielseitige Anwendungen zu erstellen. 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 Sprache C# bietet mit Funktionen wie dem Schlüsselwort ref 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 der Iron Suite bietet eine kostenloser Testso können Sie die umfangreichen Funktionen ohne sofortige Investitionen erkunden und nutzen. Sollten Sie sich für eine Volllizenz 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.