Was ist die Verwendung der Schlüsselwörter „ref“, „out“ und „in“ in C#?

In C# können die meisten Methoden null oder mehr Parameter haben, die die Daten definieren, die der Methode bereitgestellt werden müssen. Jeder Code, der eine Methode aufruft, muss Daten (sogenannte Parameter) an die Methode übergeben. Eine Methode deklariert ihre Eingaben als Parameter und sie werden vom aufrufenden Code als Parameter bereitgestellt.

Betrachten Sie beispielsweise die folgende Methode und die nachfolgenden Methodenaufrufe.

static void Greet(string greeting){
   Console.WriteLine(greeting);
}
...
Greet("Hello");

Im obigen Beispiel ist Greeting der Parameter der Greet()-Methode und „Hello“ der an die Methode übergebene Parameter.

Wenn Sie eine Methode aufrufen und Argumente übergeben, werden diese als Wert übergeben, was bedeutet, dass bei der Übergabe an die Methode eine Kopie des Werts erstellt wird. Alle an den Parametern innerhalb der Methode vorgenommenen Änderungen wirken sich nicht auf die ursprünglichen Variablen aus.

using System;
int number = 8;
Increase(number);
Console.WriteLine(number); // prints 8
static void Increase(int num){
   num = num + 1;
   Console.WriteLine(num); // prints 9
}

Wenn Sie eine Referenztypvariable (z. B. ein Objekt) übergeben, kopiert C# die Referenz immer noch nach Wert, da die Variable die Referenz und nicht das eigentliche Objekt enthält. Selbst wenn Sie also eine Kopie der Referenzvariablen übergeben, verweisen alle auf dasselbe Objekt im Speicher. Daher sind alle Änderungen, die durch Variablen innerhalb der Methode am Objekt vorgenommen werden, für Variablen außerhalb der Methode sichtbar.

using System;
var john = new User{
   Name = "John",
   Salary = 50000
};
Promote(john);
Console.WriteLine(john.Salary); // prints 60000
static void Promote(User u){
   u.Salary += 10000;
   Console.WriteLine(u.Salary); // prints 60000
}

Wenn Sie jedoch den Wert der Variablen selbst innerhalb der Methode ändern, wird die Änderung nicht außerhalb der Methode widergespiegelt, da nur die Kopie geändert wird, nicht das eigentliche Objekt. Beispielsweise können wir innerhalb einer Methode einen Parameter null zuweisen und die tatsächliche Variable bleibt unverändert.

using System;
var john = new User{
   Name = "John",
   Salary = 50000
};
Promote(john);
Console.WriteLine(john.Salary); // prints 50000
static void Promote(User u){
   u = null;
}

C# ermöglicht die Verwendung von drei verschiedenen Modifikatorschlüsselwörtern, um die Parameter einer Methode zu steuern.

ref-Modifikator

C# ermöglicht es Ihnen, Parameter mithilfe des ref-Modifikators als Referenz zu übergeben. Es spielt keine Rolle, ob die übergebene Variable ein Referenztyp oder ein Werttyp ist. Argument und Argument verweisen auf denselben Speicherort.

Im folgenden Beispiel führt das Setzen des Parameters u auf Null auch dazu, dass die John-Variable null wird und somit eine Nullreferenzausnahme ausgelöst wird.

Beispiel

using System;
var john = new User{
   Name = "John",
   Salary = 50000
};
Promote(ref john);
Console.WriteLine(john.Salary); // throws System.NullReferenceException
static void Promote(ref User u){
   u = null;
}

Parameter, die mit dem Ref-Modifikator übergeben werden, müssen vor der Übergabe initialisiert werden.

out-Modifikator

Er ähnelt dem ref-Modifikator, außer:

• Parameter müssen vor dem Aufrufen der Funktion nicht initialisiert werden

• Parameter müssen vor dem Verlassen der Funktion initialisiert (zugewiesen) werden

Im folgenden Beispiel initialisiert die Hire-Funktion ein neues Benutzerobjekt, das über den Out-Modifikator an sie übergeben wird. Beachten Sie, dass die Variable john beim Aufruf der Hire-Methode spontan deklariert wird.

using System;
Hire(out User john);
Console.WriteLine(john.Salary); // prints 50000
static void Hire(out User u){
   u = new User{
      Name = "John",
      Salary = 50000
   };
}

Wie der Modifikator ref werden mit dem Modifikator out markierte Variablen als Referenz übergeben.

Normalerweise werden out >-Variablen verwendet, um mehrere Rückgabewerte von einer Funktion wie dieser zu erhalten –

using System;
var john = new User{
   Name = "John",
   Salary = 50000
};
bool shouldPromote = Raise(john.Salary, out double hike);
Console.WriteLine(shouldPromote); // True
Console.WriteLine($"Hike Amount = {hike}"); // prints 5000
static bool Raise(int salary, out double hike){
   hike = salary * 0.1;
   return hike < 7000;
}

in-Modifikator

Es ähnelt den Parametern ref und out, der Unterschied besteht jedoch darin, dass es akzeptiert in Parameter Die Methode kann den Wert dieses Parameters nicht ändern. Wenn eine Änderung versucht wird, generiert der C#-Compiler einen Fehler bei der Kompilierung.

in Parameter können das Kopieren des Speichers großer Werttypen in Parametervariablen vermeiden und gleichzeitig verhindern, dass das Objekt versehentlich geändert wird. Dies ist nützlich, wenn große Werttypen an Methoden übergeben werden.

var point = new Coord();
Verify(point);
static void Verify(in Coord c){
   // error: Cannot assign to variable 'in Coord' because it is a readonly variable
   c = new Coord();
}
struct Coord{
   public int X;
   public int Y;
}

Beispiel

Echtzeitdemonstration

using System;
class Program{
   static void Main(){
      int number = 8;
      Increase(number);
      Console.WriteLine(number); // prints 8
      var john = new User { Name = "John", Salary = 50000 };
      Promote(john);
      Console.WriteLine(john.Salary); // prints 60000
      Leave(john);
      Console.WriteLine(john.Salary); // prints 60000

      LeaveByRef(ref john);
      Console.WriteLine(john?.Salary); // prints nothing

      User dave;
      Hire(out dave);
      Console.WriteLine(dave.Salary); // prints 50000
   }
   static void Increase(int num){
      num = num + 1;
      Console.WriteLine(num); // prints 9
   }
   static void Promote(User u){
      u.Salary += 10000;
      Console.WriteLine(u.Salary); // prints 60000
   }
   static void Leave(User u){
      u = null;
   }
   static void LeaveByRef(ref User u){
      u = null;
   }
   static void Hire(out User u){
      u = new User{
         Name = "John",
         Salary = 50000
      };  
   }
}
class User{
   public string Name { get; set; }
   public int Salary { get; set; }
}

Ausgabe

9
8
60000
60000
60000
50000

Das obige ist der detaillierte Inhalt vonWas ist die Verwendung der Schlüsselwörter „ref“, „out“ und „in“ in C#?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!