Test in einer Live-Umgebung
Test in der Produktion ohne Wasserzeichen.
Funktioniert überall, wo Sie es brauchen.
DieC# 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.
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.
ref
**: Wird verwendet, um anzugeben, dass eine Variable als Referenz übergeben wird.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.
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.
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.
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
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.
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.
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.
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.
Bei der Arbeit mit dem Schlüsselwort "ref" ist es wichtig, den Unterschied zwischen zwei Referenz- und Werttypen zu verstehen.
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.
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
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.
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.
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.
Erfahren Sie mehr über IronPDF als 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 dietutorium zur Konvertierung von HTML in PDF um mehr über diese Funktion zu erfahren.
Die Arbeit mit Excel-Dateien in C# kann eine Herausforderung sein, aberIronXL-Funktionen diese Aufgabe zu vereinfachen. 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.
Optische Zeichenerkennung(OCR) kann komplex sein, aberironOCR entdecken zur Rationalisierung des Prozesses. 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.
BarCodes werden häufig in verschiedenen Branchen verwendet, und die Handhabung dieser Codes in Ihren Anwendungen ist jetzt mit demIronBarcode-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.
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.
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 einekostenlose Testversion von Iron Suiteso 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.
9 .NET API-Produkte für Ihre Bürodokumente