Übung – Verwenden von Wert- und Referenztypparametern

5 Minuten

In C# können Variablen in zwei Haupttypen, Werttypen und Referenztypen kategorisiert werden. Diese Typen beschreiben, wie Variablen ihre Werte speichern.

Werttypen wie int, bool, float, double und char enthalten direkt Werte. Referenztypen wie string, arrayund Objekte (z. B. Instanzen von Random) speichern ihre Werte nicht direkt. Stattdessen speichern Verweistypen eine Adresse, an der ihr Wert gespeichert wird.

Parameter, die per Wertübergabe und per Referenzübergabe übergeben werden

Wenn ein Argument an eine Methode übergeben wird, haben Werttypvariablen ihre Werte in die Methode kopiert. Jede Variable verfügt über eine eigene Kopie des Werts, sodass die ursprüngliche Variable nicht geändert wird.

Bei Verweistypen wird die Adresse des Werts an die Methode übergeben. Die Variable, die der Methode zugewiesen wird, verweist auf den Wert an dieser Adresse, sodass Vorgänge für diese Variable den Wert beeinflussen, auf den von der anderen verwiesen wird.

Hinweis

Es ist wichtig zu beachten, dass string es sich um einen Verweistyp handelt, aber unveränderlich ist. Das bedeutet, dass sie nach dem Zuweisen eines Werts nicht mehr geändert werden kann. Wenn In C# Methoden und Operatoren zum Ändern einer Zeichenfolge verwendet werden, ist das zurückgegebene Ergebnis tatsächlich ein neues Zeichenfolgenobjekt.

In dieser Übung erfahren Sie mehr über das Übergeben von Verweis- und Werttypargumenten an Methoden.

Testdurchlauf nach Wert

Löschen Sie im Visual Studio Code-Editor vorhandenen Code aus den vorherigen Übungen.
Geben Sie den folgenden Code in den Visual Studio Code-Editor ein:
```
int a = 3;
int b = 4;
int c = 0;

Multiply(a, b, c);
Console.WriteLine($"global statement: {a} x {b} = {c}");

void Multiply(int a, int b, int c) 
{
    c = a * b;
    Console.WriteLine($"inside Multiply method: {a} x {b} = {c}");
}
```
Die Variablen a, b, und c werden an die Multiply Methode übergeben. Die Werte der Variablen werden während der Methodenausführung gedruckt und nach Abschluss der Methode erneut gedruckt.

Ganze Zahlen sind Wertetypen, deren Werte beim Übergeben an Methoden kopiert werden. Was glauben Sie, wird die Ausgabe von c sein?
Speichern Sie Ihren Code und führen Sie ihn aus, um die folgende Ausgabe zu sehen.
```
inside Multiply method: 3 x 4 = 12
global statement: 3 x 4 = 0
```
Beachten Sie, dass der Wert von c nur innerhalb der Multiply Methode geändert wird. Außerhalb der Methode c behält sie ihren ursprünglichen Wert bei.

Testdurchlauf nach Verweis

Löschen Sie den vorherigen Code aus dem Visual Studio Code-Editor.
Geben Sie den folgenden Code in den Visual Studio Code-Editor ein:
```
int[] array = {1, 2, 3, 4, 5};

PrintArray(array);
Clear(array);
PrintArray(array);

void PrintArray(int[] array) 
{
    foreach (int a in array) 
    {
        Console.Write($"{a} ");
    }
    Console.WriteLine();
}

void Clear(int[] array) 
{
    for (int i = 0; i < array.Length; i++) 
    {
        array[i] = 0;
    }
}
```
Der Code beginnt mit array, das so initialisiert ist, dass es einige ganzzahlige Werte enthält. Die Werte werden mithilfe der PrintArray Methode angezeigt. Die Clear Methode wird für das Array aufgerufen, und dann wird das Array erneut gedruckt.

Arrays sind Referenztypen. Referenztypen speichern die Adresse ihrer Werte im Arbeitsspeicher. Was glauben Sie, wird die Ausgabe sein?
Speichern Sie Ihren Code und führen Sie ihn aus, um die folgende Ausgabe zu sehen.
```
1 2 3 4 5 
0 0 0 0 0
```
Beachten Sie, dass das Array außerhalb des Clear Methodenbereichs weiterhin verändert bleibt. Dies geschieht, weil die Clear Methode die werte aktualisiert hat, die an jeder Adresse gespeichert sind.

Testen mit Zeichenfolgen

Früher haben Sie gelernt, dass Zeichenfolgen ein unveränderlicher Typ sind. Obwohl es sich bei einer Zeichenfolge um einen Bezugstyp handelt, kann der Wert im Gegensatz zu einem Array nicht mehr geändert werden, nachdem sie zugewiesen wurde. Möglicherweise haben Sie dies bemerkt, wenn Sie Methoden wie string.Replace oder string.ToUpper verwendet haben. In dieser Aufgabe lernen Sie, einen häufigen Fehler beim Arbeiten mit Zeichenfolgen zu beheben.

Löschen Sie im Visual Studio Code-Editor vorhandenen Code aus den vorherigen Übungen.

Geben Sie den folgenden Code in den Visual Studio Code-Editor ein:

string status = "Healthy";

Console.WriteLine($"Start: {status}");
SetHealth(status, false);
Console.WriteLine($"End: {status}");

void SetHealth(string status, bool isHealthy) 
{
    status = (isHealthy ? "Healthy" : "Unhealthy");
    Console.WriteLine($"Middle: {status}");
}

Speichern Sie Ihren Code, und führen Sie diesen aus, um die folgende Ausgabe zu erhalten:
```
Start: Healthy
Middle: Unhealthy
End: Healthy
```
Wenn die SetHealth Methode den Status nicht ausgegeben hat, haben Sie möglicherweise angenommen, dass die Methode nicht ordnungsgemäß ausgeführt wurde. Stattdessen wurde eine neue Zeichenfolge mit dem Wert „Fehlerhaft“ erstellt, die dann im Methodenbereich verloren ging.

Um dieses Problem zu beheben, können Sie SetHealth stattdessen durch die globale Statusvariable ersetzen.

Aktualisieren Sie den Code wie folgt:

string status = "Healthy";

Console.WriteLine($"Start: {status}");
SetHealth(false);
Console.WriteLine($"End: {status}");

void SetHealth(bool isHealthy) 
{
    status = (isHealthy ? "Healthy" : "Unhealthy");
    Console.WriteLine($"Middle: {status}");
}

In diesem Code überschreiben Sie die globale status Variable mit dem neuen Zeichenfolgenwert.

Speichern Sie Ihren Code und führen Sie ihn aus, um die folgende Ausgabe zu beobachten.
```
Start: Healthy
Middle: Unhealthy
End: Unhealthy
```
Jetzt wird die aktualisierte Zeichenfolge erfasst und ordnungsgemäß gespeichert.

Rekapitulation

Hier erfahren Sie, was Sie bisher über Werttyp- und Referenztypparameter gelernt haben:

Variablen können als Werttypen und Referenztypen kategorisiert werden.
Werttypen enthalten direkt Werte, und Referenztypen speichern die Adresse des Werts.
Methoden, die Werttypargumente verwenden, erstellen eine eigene Kopie der Werte.
Methoden, die Änderungen an einem Arrayparameter vornehmen, wirken sich auf das ursprüngliche Eingabearray aus.
String ist ein unveränderlicher Referenztyp.
Methoden, die Änderungen an einem Zeichenfolgenparameter ausführen, wirken sich nicht auf die ursprüngliche Zeichenfolge aus.