Apakah penggunaan kata kunci ref, out dan in dalam C#?

Dalam C#, kebanyakan kaedah boleh mempunyai sifar atau lebih parameter, yang mentakrifkan data yang mesti diberikan kepada kaedah tersebut. Sebarang kod yang memanggil kaedah mesti menghantar data (dipanggil parameter) kepada kaedah tersebut. Kaedah mengisytiharkan inputnya sebagai parameter, dan ia disediakan sebagai parameter oleh kod panggilan.

Sebagai contoh, pertimbangkan kaedah berikut dan panggilan kaedah seterusnya.

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

Dalam contoh di atas, ucapan ialah parameter kaedah Greet() dan "Hello" ialah parameter yang dihantar kepada kaedah tersebut.

Apabila anda memanggil kaedah dan lulus hujah, ia dihantar mengikut nilai, yang bermaksud salinan nilai dibuat apabila dihantar kepada kaedah. Sebarang perubahan yang dibuat pada parameter di dalam kaedah tidak ditunjukkan pada pembolehubah asal.

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
}

Apabila anda melepasi pembolehubah jenis rujukan (seperti objek), C# masih menyalin nilai rujukan kerana pembolehubah memegang rujukan, bukan objek sebenar. Jadi walaupun anda memberikan salinan pembolehubah rujukan, mereka semua merujuk kepada objek yang sama dalam ingatan. Oleh itu, sebarang perubahan yang dibuat kepada objek oleh pembolehubah di dalam kaedah boleh dilihat oleh pembolehubah di luar kaedah.

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
}

Walau bagaimanapun, jika anda menukar nilai pembolehubah itu sendiri di dalam kaedah, perubahan itu tidak akan ditunjukkan di luar kaedah kerana hanya salinan yang diubah, bukan objek sebenar. Sebagai contoh, kita boleh menetapkan parameter kepada null di dalam kaedah dan pembolehubah sebenar akan kekal tidak berubah.

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# membenarkan penggunaan tiga kata kunci pengubah suai berbeza untuk mengawal parameter sesuatu kaedah.

pengubah suai

C# membolehkan anda menghantar parameter dengan rujukan menggunakan pengubah ref. Tidak kira sama ada pembolehubah yang diluluskan adalah jenis rujukan atau jenis nilai. Parameter dan argumen akan merujuk lokasi memori yang sama.

Dalam contoh di bawah, menetapkan parameter u kepada null juga akan menjadikan pembolehubah john null, sekali gus membuang pengecualian rujukan null.

Contoh

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 yang diluluskan menggunakan pengubah suai ref mesti dimulakan sebelum lulus.

out modifier

Ia serupa dengan ref modifier, kecuali:

• Parameter tidak perlu dimulakan sebelum memasuki fungsi

• Parameter mesti dimulakan (diberikan) sebelum keluar dari fungsi

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
   };
}

ref, pembolehubah yang ditandakan oleh pengubah keluar diluluskan melalui rujukan.

out > pembolehubah digunakan untuk mendapatkan berbilang nilai pulangan ​​daripada fungsi seperti ini -

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;
}

ref dan out parameter, tetapi perbezaannya ialah parameter yang diterima dalam parameter Kaedah tidak boleh mengubah suai nilai parameter ini. Jika pengubahsuaian dicuba, pengkompil C# akan menjana ralat masa kompilasi.

inParameter boleh mengelakkan penyalinan memori jenis nilai besar ke dalam pembolehubah parameter sambil menghalang objek daripada diubah suai secara tidak sengaja. Ini berguna apabila menghantar jenis nilai besar kepada kaedah.

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;
}

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; }
}

9
8
60000
60000
60000
50000

Salin selepas log masuk

Atas ialah kandungan terperinci Apakah penggunaan kata kunci ref, out dan in dalam C#?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!