Kapan harus digunakan dalam vs ref vs keluar

Seseorang bertanya kepada saya di suatu hari kapan mereka harus menggunakan kata kunci parameter outbukan ref. Sementara saya (saya pikir) memahami perbedaan antara kata kunci refdan out(yang telah ditanyakan sebelumnya ) dan penjelasan terbaik tampaknya adalah ref== indan out, apa adalah beberapa contoh (hipotesis atau kode) di mana saya harus selalu menggunakan outdan tidak ref.

Karena reflebih umum, mengapa Anda ingin menggunakannya out? Apakah itu hanya gula sintaksis?

Anda harus menggunakan outkecuali Anda perlu ref.

Itu membuat perbedaan besar ketika data perlu diolah misalnya untuk proses lain, yang bisa mahal. Jadi, Anda ingin menghindari membuat nilai awal ketika metode tidak memanfaatkannya.

Di luar itu, ia juga menunjukkan kepada pembaca deklarasi atau seruan apakah nilai awal itu relevan (dan berpotensi dipertahankan), atau dibuang.

Sebagai perbedaan kecil, parameter keluar tidak perlu diinisialisasi.

Contoh untuk out:

string a, b;
person.GetBothNames(out a, out b);

di mana GetBothNames adalah metode untuk mengambil dua nilai secara atom, metode ini tidak akan mengubah perilaku apa pun a dan b. Jika panggilan masuk ke server di Hawaii, menyalin nilai awal dari sini ke Hawaii adalah pemborosan bandwidth. Cuplikan serupa menggunakan ref:

string a = String.Empty, b = String.Empty;
person.GetBothNames(ref a, ref b);

dapat membingungkan pembaca, karena sepertinya nilai awal a dan b relevan (meskipun nama metode menunjukkan mereka tidak).

Contoh untuk ref:

string name = textbox.Text;
bool didModify = validator.SuggestValidName(ref name);

Di sini nilai awal relevan dengan metode.

Gunakan untuk menunjukkan bahwa parameter tidak digunakan, hanya atur. Ini membantu penelepon memahami bahwa Anda selalu menginisialisasi parameter.

Juga, ref dan out tidak hanya untuk tipe nilai. Mereka juga memungkinkan Anda mengatur ulang objek yang dirujuk oleh tipe referensi dalam suatu metode.

Anda benar karena, secara semantis, refmenyediakan fungsionalitas "masuk" dan "keluar", sedangkan outhanya menyediakan fungsionalitas "keluar". Ada beberapa hal yang perlu dipertimbangkan:

1. outmensyaratkan bahwa metode yang menerima parameter HARUS, pada titik tertentu sebelum kembali, menetapkan nilai ke variabel. Anda menemukan pola ini di beberapa kelas penyimpanan data kunci / nilai seperti Dictionary<K,V>, di mana Anda memiliki fungsi seperti TryGetValue. Fungsi ini mengambil outparameter yang menyimpan nilai apa yang akan diambil jika diambil. Tidak masuk akal bagi penelepon untuk memberikan nilai ke fungsi ini, jadi outdigunakan untuk menjamin bahwa beberapa nilai akan berada dalam variabel setelah panggilan, bahkan jika itu bukan data "nyata" (dalam kasus di TryGetValuemana kuncinya tidak ada).
2. outdan refparameter diatur secara berbeda ketika berhadapan dengan kode interop

Selain itu, sebagai tambahan, penting untuk dicatat bahwa meskipun tipe referensi dan tipe nilai berbeda dalam sifat nilainya, setiap variabel dalam aplikasi Anda menunjuk ke lokasi memori yang menyimpan nilai , bahkan untuk tipe referensi. Kebetulan, dengan tipe referensi, nilai yang terkandung dalam lokasi memori itu adalah yang lainlokasi memori. Ketika Anda meneruskan nilai ke suatu fungsi (atau melakukan tugas variabel lain apa pun), nilai variabel itu disalin ke variabel lain. Untuk tipe nilai, itu berarti bahwa seluruh konten tipe disalin. Untuk jenis referensi, itu berarti bahwa lokasi memori disalin. Either way, itu membuat salinan data yang terkandung dalam variabel. Satu-satunya relevansi nyata yang berhubungan dengan penugasan semantik; saat menetapkan variabel atau meneruskan dengan nilai (default), ketika tugas baru dibuat ke variabel asli (atau baru), itu tidak mempengaruhi variabel lainnya. Dalam hal tipe referensi, ya, perubahan dibuat pada instancetersedia di kedua sisi, tetapi itu karena variabel aktual hanyalah sebuah penunjuk ke lokasi memori lain; konten variabel - lokasi memori - tidak benar-benar berubah.

Melewati refkata kunci mengatakan bahwa variabel asli dan parameter fungsi sebenarnya akan menunjuk ke lokasi memori yang sama. Ini, sekali lagi, hanya mempengaruhi semantik penugasan. Jika nilai baru ditetapkan ke salah satu variabel, maka karena yang lain menunjuk ke lokasi memori yang sama, nilai baru akan tercermin di sisi lain.

Itu tergantung pada konteks kompilasi (Lihat Contoh di bawah).

outdan refkeduanya menunjukkan variabel lewat referensi, namun refmembutuhkan variabel yang diinisialisasi sebelum diteruskan, yang dapat menjadi perbedaan penting dalam konteks Marshaling (Interop: UmanagedToManagedTransition atau sebaliknya)

MSDN memperingatkan :

Jangan bingung konsep lewat referensi dengan konsep tipe referensi. Kedua konsep itu tidak sama. Parameter metode dapat dimodifikasi oleh ref terlepas dari apakah itu tipe nilai atau tipe referensi. Tidak ada tinju dari tipe nilai ketika dilewatkan oleh referensi.

Dari Dokumen MSDN resmi:

• out:

Kata kunci keluar menyebabkan argumen dilewatkan dengan referensi. Ini mirip dengan kata kunci ref, kecuali bahwa ref mengharuskan variabel diinisialisasi sebelum diteruskan

• ref:

Kata kunci ref menyebabkan argumen dilewatkan dengan referensi, bukan oleh nilai. Efek lewat referensi adalah bahwa setiap perubahan pada parameter dalam metode ini tercermin dalam variabel argumen yang mendasari dalam metode panggilan. Nilai parameter referensi selalu sama dengan nilai variabel argumen yang mendasarinya.

Kami dapat memverifikasi bahwa keluar dan ref memang sama ketika argumen diberikan:

Contoh CIL :

Perhatikan contoh berikut

static class outRefTest{
    public static int myfunc(int x){x=0; return x; }
    public static void myfuncOut(out int x){x=0;}
    public static void myfuncRef(ref int x){x=0;}
    public static void myfuncRefEmpty(ref int x){}
    // Define other methods and classes here
}

di CIL, instruksi myfuncOutdan myfuncRefidentik seperti yang diharapkan.

outRefTest.myfunc:
IL_0000:  nop         
IL_0001:  ldc.i4.0    
IL_0002:  starg.s     00 
IL_0004:  ldarg.0     
IL_0005:  stloc.0     
IL_0006:  br.s        IL_0008
IL_0008:  ldloc.0     
IL_0009:  ret         

outRefTest.myfuncOut:
IL_0000:  nop         
IL_0001:  ldarg.0     
IL_0002:  ldc.i4.0    
IL_0003:  stind.i4    
IL_0004:  ret         

outRefTest.myfuncRef:
IL_0000:  nop         
IL_0001:  ldarg.0     
IL_0002:  ldc.i4.0    
IL_0003:  stind.i4    
IL_0004:  ret         

outRefTest.myfuncRefEmpty:
IL_0000:  nop         
IL_0001:  ret         

nop : tidak ada operasi, ldloc : load local, stloc : stack local, ldarg : load argumen, bs.s : branch to target ....

(Lihat: Daftar instruksi CIL )

Di bawah ini adalah beberapa catatan yang saya tarik dari artikel proyek ini di C # Out Vs Ref

1. Ini harus digunakan hanya ketika kita mengharapkan banyak keluaran dari suatu fungsi atau metode. Pemikiran tentang struktur juga bisa menjadi pilihan yang baik untuk hal yang sama.
2. REF dan OUT adalah kata kunci yang menentukan bagaimana data dilewatkan dari pemanggil ke callee dan sebaliknya.
3. Dalam REF data melewati dua arah. Dari penelepon ke callee dan sebaliknya.
4. In Out data hanya melewati satu cara dari callee ke caller. Dalam hal ini jika Penelepon mencoba mengirim data ke callee itu akan diabaikan / ditolak.

Jika Anda adalah orang visual maka silakan lihat video tabung Anda ini yang menunjukkan perbedaan praktis https://www.youtube.com/watch?v=lYdcY5zulXA

Gambar di bawah menunjukkan perbedaan lebih secara visual

Anda perlu menggunakan refjika Anda berencana untuk membaca dan menulis ke parameter. Anda perlu menggunakan outjika Anda hanya berencana untuk menulis. Akibatnya, outadalah ketika Anda membutuhkan lebih dari satu nilai kembali, atau ketika Anda tidak ingin menggunakan mekanisme pengembalian normal untuk keluaran (tetapi ini harus jarang terjadi).

Ada mekanik bahasa yang membantu kasus penggunaan ini. Refparameter harus diinisialisasi sebelum diteruskan ke metode (menekankan pada fakta bahwa mereka baca-tulis), dan outparameter tidak dapat dibaca sebelum diberi nilai, dan dijamin telah dituliskan pada akhir metode (menekankan pada fakta bahwa mereka hanya menulis). Bertentangan dengan prinsip-prinsip ini menghasilkan kesalahan waktu kompilasi.

int x;
Foo(ref x); // error: x is uninitialized

void Bar(out int x) {}  // error: x was not written to

Misalnya, int.TryParsemengembalikan a booldan menerima out intparameter:

int value;
if (int.TryParse(numericString, out value))
{
    /* numericString was parsed into value, now do stuff */
}
else
{
    /* numericString couldn't be parsed */
}

Ini adalah contoh yang jelas dari situasi di mana Anda perlu menampilkan dua nilai: hasil numerik dan apakah konversi berhasil atau tidak. Para penulis CLR memutuskan untuk memilih di outsini karena mereka tidak peduli tentang apa yang intseharusnya terjadi sebelumnya.

Untuk ref, Anda dapat melihat Interlocked.Increment:

int x = 4;
Interlocked.Increment(ref x);

Interlocked.Incrementsecara atom meningkatkan nilai x. Karena Anda perlu membaca xuntuk menambahnya, ini adalah situasi di mana reflebih tepat. Anda benar-benar peduli tentang apa xyang sebelum itu diteruskan Increment.

Dalam versi C # berikutnya, bahkan mungkin untuk mendeklarasikan variabel dalam outparameter, menambahkan lebih banyak penekanan pada sifat hanya-keluaran mereka:

if (int.TryParse(numericString, out int value))
{
    // 'value' exists and was declared in the `if` statement
}
else
{
    // conversion didn't work, 'value' doesn't exist here
}

outadalah versi yang lebih kendala ref.

Di tubuh metode, Anda harus menetapkan semua outparameter sebelum meninggalkan metode. Juga nilai yang ditetapkan ke outparameter diabaikan, sedangkan refmengharuskan mereka untuk ditugaskan.

Jadi outmemungkinkan Anda untuk melakukan:

int a, b, c = foo(out a, out b);

di mana refakan membutuhkan a dan b untuk ditugaskan.

Bagaimana kedengarannya:

keluar = hanya initialize / mengisi parameter (parameter harus kosong) mengembalikannya keluar polos

ref = referensi, parameter standar (mungkin dengan nilai), tetapi fungsi tersebut dapat modifiy itu.

Anda dapat menggunakan outkata kunci kontekstual dalam dua konteks (masing-masing adalah tautan ke informasi terperinci), sebagai pengubah parameter atau dalam deklarasi parameter tipe umum pada antarmuka dan delegasi. Topik ini membahas pengubah parameter, tetapi Anda dapat melihat topik lainnya ini untuk informasi tentang deklarasi parameter tipe umum.

Kata outkunci menyebabkan argumen dilewatkan oleh referensi. Ini seperti refkata kunci, kecuali yang refmengharuskan variabel diinisialisasi sebelum dilewatkan. Untuk menggunakan outparameter, definisi metode dan metode panggilan harus secara eksplisit menggunakan outkata kunci. Sebagai contoh: C #

class OutExample
{
    static void Method(out int i)
    {
        i = 44;
    }
    static void Main()
    {
        int value;
        Method(out value);
        // value is now 44
    }
}

Meskipun variabel yang dikirimkan sebagai outargumen tidak harus diinisialisasi sebelum dikirimkan, metode yang dipanggil diperlukan untuk menetapkan nilai sebelum metode kembali.

Meskipun refdan outkata kunci menyebabkan perilaku run-time yang berbeda, mereka tidak dianggap sebagai bagian dari tanda tangan metode pada waktu kompilasi. Oleh karena itu, metode tidak dapat kelebihan beban jika satu-satunya perbedaan adalah bahwa satu metode mengambil refargumen dan yang lain mengambil outargumen. Kode berikut, misalnya, tidak akan dikompilasi: C #

class CS0663_Example
{
    // Compiler error CS0663: "Cannot define overloaded 
    // methods that differ only on ref and out".
    public void SampleMethod(out int i) { }
    public void SampleMethod(ref int i) { }
}

Akan tetapi, overloading dapat dilakukan jika salah satu metode menggunakan argumen refatau outargumen dan yang lainnya tidak menggunakan, seperti ini: C #

class OutOverloadExample
{
    public void SampleMethod(int i) { }
    public void SampleMethod(out int i) { i = 5; }
}

Properti bukan variabel dan karena itu tidak dapat dilewatkan sebagai outparameter.

Untuk informasi tentang melewati array, lihat Menggunakan Passing Arrays refdan out(C # Programming Guide).

Anda tidak dapat menggunakan refdan outkata kunci untuk jenis metode berikut:

Async methods, which you define by using the async modifier.

Iterator methods, which include a yield return or yield break statement.

Contoh

Mendeklarasikan suatu outmetode berguna ketika Anda ingin suatu metode mengembalikan banyak nilai. Contoh berikut digunakan outuntuk mengembalikan tiga variabel dengan pemanggilan metode tunggal. Perhatikan bahwa argumen ketiga ditugaskan ke nol. Ini memungkinkan metode untuk mengembalikan nilai secara opsional. C #

class OutReturnExample
{
    static void Method(out int i, out string s1, out string s2)
    {
        i = 44;
        s1 = "I've been returned";
        s2 = null;
    }
    static void Main()
    {
        int value;
        string str1, str2;
        Method(out value, out str1, out str2);
        // value is now 44
        // str1 is now "I've been returned"
        // str2 is (still) null;
    }
}

Bagaimana cara menggunakan inatau outatau refdalam C #?

• Semua kata kunci di C#memiliki fungsi yang sama tetapi dengan beberapa batasan .
• in argumen tidak dapat dimodifikasi oleh metode yang dipanggil.
• ref argumen dapat dimodifikasi.
• ref harus diinisialisasi sebelum digunakan oleh penelepon itu dapat dibaca dan diperbarui dalam metode ini.
• out argumen harus diubah oleh pemanggil.
• out argumen harus diinisialisasi dalam metode ini
• Variabel yang dikirimkan sebagai inargumen harus diinisialisasi sebelum diteruskan dalam pemanggilan metode. Namun, metode yang dipanggil mungkin tidak menetapkan nilai atau mengubah argumen.

Anda tidak dapat menggunakan in, refdan outkata kunci untuk jenis berikut metode:

• Metode Async , yang Anda tetapkan dengan menggunakan asyncpengubah.
• Metode iterator , yang mencakup a yield returnatau yield breakpernyataan.

Hanya untuk mengklarifikasi pada komentar OP bahwa penggunaan pada ref dan out adalah "referensi ke tipe nilai atau struct yang dinyatakan di luar metode", yang telah ditetapkan secara tidak benar.

Pertimbangkan penggunaan ref pada StringBuilder, yang merupakan tipe referensi:

private void Nullify(StringBuilder sb, string message)
{
    sb.Append(message);
    sb = null;
}

// -- snip --

StringBuilder sb = new StringBuilder();
string message = "Hi Guy";
Nullify(sb, message);
System.Console.WriteLine(sb.ToString());

// Output
// Hi Guy

Seperti terlampir dalam hal ini:

private void Nullify(ref StringBuilder sb, string message)
{
    sb.Append(message);
    sb = null;
}

// -- snip --

StringBuilder sb = new StringBuilder();
string message = "Hi Guy";
Nullify(ref sb, message);
System.Console.WriteLine(sb.ToString());

// Output
// NullReferenceException

Argumen yang diteruskan sebagai ref harus diinisialisasi sebelum meneruskan ke metode sedangkan parameter out tidak perlu diinisialisasi sebelum meneruskan ke metode.

mengapa Anda ingin menggunakannya?

Untuk memberi tahu orang lain bahwa variabel akan diinisialisasi ketika kembali dari metode yang disebut!

Seperti disebutkan di atas: "untuk parameter keluar, metode panggilan diperlukan untuk menetapkan nilai sebelum metode kembali ."

contoh:

Car car;
SetUpCar(out car);
car.drive();  // You know car is initialized.

Pada dasarnya keduanya refdan outuntuk melewatkan objek / nilai antar metode

Kata kunci keluar menyebabkan argumen dilewatkan dengan referensi. Ini seperti kata kunci ref, kecuali bahwa ref mengharuskan variabel diinisialisasi sebelum dilewatkan.

out : Argumen tidak diinisialisasi dan harus diinisialisasi dalam metode

ref : Argumen sudah diinisialisasi dan dapat dibaca dan diperbarui dalam metode ini.

Apa penggunaan "ref" untuk tipe referensi?

Anda dapat mengubah referensi yang diberikan ke contoh berbeda.

Tahukah kamu?

1. Meskipun kata kunci ref dan out menyebabkan perilaku run-time yang berbeda, mereka tidak dianggap sebagai bagian dari tanda tangan metode pada waktu kompilasi. Oleh karena itu, metode tidak dapat kelebihan beban jika satu-satunya perbedaan adalah bahwa satu metode mengambil argumen ref dan yang lain mengambil argumen keluar.

2. Anda tidak dapat menggunakan kata kunci ref dan out untuk jenis metode berikut:

   • Metode Async, yang Anda tetapkan dengan menggunakan pengubah async.
   • Metode iterator, yang mencakup pengembalian imbal hasil atau pernyataan istirahat.

3. Properti bukan variabel dan karenanya tidak dapat diteruskan sebagai parameter.

Catatan tambahan tentang C # 7:
Dalam C # 7 tidak perlu untuk predeclare variabel menggunakan. Jadi kode seperti ini:

public void PrintCoordinates(Point p)
{
  int x, y; // have to "predeclare"
  p.GetCoordinates(out x, out y);
  WriteLine($"({x}, {y})");
}

Dapat ditulis seperti ini:

public void PrintCoordinates(Point p)
{
  p.GetCoordinates(out int x, out int y);
  WriteLine($"({x}, {y})");
}

Sumber: Apa yang baru dalam C # 7.

Masih merasakan perlunya ringkasan yang baik, inilah yang saya kemukakan.

Ringkasan,

Ketika kita berada di dalam fungsi , ini adalah bagaimana kita menentukan kontrol akses data variabel ,

in = R

out = harus W sebelum R

ref = R + W

Penjelasan,

in

Fungsi hanya dapat membaca variabel itu.

out

Variabel tidak boleh diinisialisasi terlebih dahulu karena,
berfungsi HARUS MENULIS sebelum BACA .

ref

Fungsi dapat BACA / MENULIS ke variabel itu.

Mengapa dinamai demikian?

Berfokus pada tempat data diubah,

in

Data hanya harus diatur sebelum memasukkan fungsi (dalam).

out

Data hanya harus diatur sebelum meninggalkan fungsi (keluar).

ref

Data harus diatur sebelum memasukkan fungsi (dalam).
Data dapat diatur sebelum meninggalkan fungsi (keluar).

Perlu dicatat bahwa inini adalah kata kunci yang valid pada C # ver 7.2 :

Pengubah parameter in tersedia dalam C # 7.2 dan yang lebih baru. Versi sebelumnya menghasilkan kesalahan kompiler CS8107 ("Fitur 'referensi hanya baca' tidak tersedia di C # 7.0. Silakan gunakan versi bahasa 7.2 atau lebih tinggi.") Untuk mengkonfigurasi versi bahasa kompiler, lihat Memilih versi bahasa C #.

...

Kata kunci dalam menyebabkan argumen dilewatkan dengan referensi. Itu membuat parameter formal alias untuk argumen, yang harus berupa variabel. Dengan kata lain, operasi apa pun pada parameter dilakukan atas argumen. Ini seperti kata kunci ref atau out, kecuali dalam argumen tidak dapat dimodifikasi dengan metode yang disebut. Sementara argumen ref dapat dimodifikasi, argumen out harus dimodifikasi dengan metode yang dipanggil, dan modifikasi tersebut dapat diamati dalam konteks pemanggilan.