metode c # dengan params tanpa batas atau metode dengan array atau daftar?

Baru-baru ini saya mengetahui bahwa Anda dapat membuat beberapa metode dengan parameter tidak terbatas, misalnya:

SomeMethod(params int[] numbers);

tetapi pertanyaan saya adalah, apa perbedaan antara itu dan hanya membuat metode yang menerima daftar atau array?

SomeMethod(int[] numbers);
SomeMethod(List<int> numbers);

mungkin itu berdampak pada kinerja? Saya tidak sepenuhnya mengerti atau melihat dengan cara apa Anda lebih suka yang dengan parameter tidak terbatas.

Pencarian cepat di google tidak membantu, saya harap Anda bisa membantu saya.

apa perbedaan antara itu dan hanya membuat metode yang menerima daftar atau array?

Perbedaan antara

void M(params int[] x)

dan

void N(int[] x)

adalah M dapat disebut seperti ini:

M(1, 2, 3)

atau seperti ini:

M(new int[] { 1, 2, 3 });

tetapi N hanya bisa dipanggil dengan cara kedua , bukan cara pertama .

mungkin itu berdampak pada kinerja?

Dampaknya terhadap kinerja adalah apakah Anda menelepon M dengan cara pertama atau cara kedua, baik cara Anda membuat array dibuat. Membuat array memiliki dampak kinerja karena membutuhkan waktu dan memori. Ingatlah bahwa dampak kinerja harus diukur terhadap sasaran kinerja; tidak mungkin bahwa biaya menciptakan array tambahan adalah faktor gating yang merupakan perbedaan antara keberhasilan dan kegagalan di pasar.

Saya tidak sepenuhnya mengerti atau melihat dengan cara apa Anda lebih suka yang dengan parameter tidak terbatas.

Ini murni dan sepenuhnya merupakan kemudahan bagi pembuat kode yang memanggil metode; hanya lebih pendek dan lebih mudah untuk ditulis

M(1, 2, 3);

alih-alih menulis

M(new int[] { 1, 2, 3 });

Ini hanya menghemat beberapa penekanan tombol di sisi pemanggil. Itu semuanya.

Beberapa pertanyaan yang tidak Anda tanyakan tetapi mungkin ingin tahu jawabannya:

Apa sebutan fitur ini?

Metode yang memungkinkan sejumlah variabel argumen untuk dilewatkan di sisi pemanggil disebut variadic . Metode Params adalah bagaimana C # mengimplementasikan metode variadic.

Bagaimana cara kerja resolusi berlebihan dengan metode variadic?

Ketika dihadapkan dengan masalah resolusi kelebihan beban, C # akan mempertimbangkan bentuk "normal" dan "diperluas", dan bentuk "normal" selalu menang jika keduanya berlaku. Sebagai contoh, pertimbangkan ini:

void P(params object[] x){}

dan kami memiliki panggilan

P(null);

Ada dua kemungkinan yang berlaku. Dalam bentuk "normal", kami memanggil Pdan meneruskan referensi nol untuk array. Dalam formulir "diperluas", kami menyebutnya P(new object[] { null }). Dalam hal ini, bentuk normal menang. Jika kami menerima panggilan P(null, null)maka formulir normal tidak dapat diterapkan dan formulir yang diperluas akan menang secara default.

Tantangan : Misalkan kita memiliki var s = new[] { "hello" };dan menelepon P(s);. Jelaskan apa yang terjadi di situs panggilan dan mengapa. Anda mungkin akan terkejut!

Tantangan : Misalkan kita memiliki keduanya void P(object x){}dan void P(params object[] x){}. Apa yang P(null)dilakukan, dan mengapa?

Tantangan : Misalkan kita memiliki keduanya void M(string x){}dan void M(params string[] x){}. Apa yang M(null)dilakukan, dan mengapa? Bagaimana ini berbeda dari kasus sebelumnya?

Baru saja melakukan prototipe kecil. Jawabannya paramsadalah gula sintaksis untuk melewatkan dalam array. Itu tidak terlalu mengejutkan. Saya membuat dua versi dari metode yang sama, di mana satu-satunya perbedaan adalah kata kunci "params". IL yang dihasilkan untuk keduanya identik, kecuali bahwa a System.ParamArrayAttributediterapkan pada paramsversi.

Lebih lanjut, IL yang dihasilkan di situs panggilan juga sama antara saya memanggil metode dengan yang dinyatakan secara manual new int[]dan memanggil metode hanya menggunakan paramsargumen.

Jadi, jawabannya sepertinya "kenyamanan". Tampaknya tidak ada perbedaan dalam kinerja. Anda juga dapat memanggil paramsfungsi dengan array, jadi itu juga tidak terlalu mengejutkan. Turun ke jika pengguna metode Anda lebih mudah untuk memanggilnya dengan sejumlah parameter (misalnya someMethod(1, 2, 3)) daripada harus selalu membuat koleksi terlebih dahulu (misalnya someMethod(new List<int>() { 1, 2, 3 } )).

Fitur parameter tak terbatas menawarkan manfaat berikut dalam banyak skenario:

1. Kopling longgar
2. Dapat digunakan kembali yang disempurnakan
3. Kinerja aplikasi secara keseluruhan lebih baik

Berikut adalah contoh di mana opsi parameter tak terbatas adalah pilihan yang bagus

Pertimbangkan bahwa aplikasi untuk mengirim email perlu dibangun.

Fungsi yang mengirim email harus dapat menangani nilai tunggal atau ganda untuk bidang 'Ke', 'CC' dan 'BCC'.

Jika jenis parameter ditetapkan menjadi array atau daftar untuk semua bidang (Ke, CC, BCC), maka fungsi panggilan akan dipaksa untuk berurusan dengan semua kerumitan mendefinisikan 3 array atau daftar untuk memanggil fungsi pengirim email .

Bahkan jika pemanggil ingin mengirim email hanya ke satu alamat, fungsi pengirim email akan memaksa pemanggil untuk menentukan dan mengirim 3 array yang berbeda sebagai parameter.

Jika fungsi pengirim email mengambil pendekatan params tidak terbatas, maka fungsi pemanggil tidak perlu berurusan dengan semua kompleksitas.

Pendekatan parameter tak terbatas berkontribusi pada kinerja runtime aplikasi yang lebih baik dengan menghindari pembuatan array atau daftar di mana pun tidak perlu.

Dari perspektif non-kinerja , gaya, paramskata kunci sangat baik untuk dimiliki ketika Anda ingin mengirim daftar parameter opsional.

Secara pribadi, saya akan menggunakan paramsketika kode saya seperti

SomeMethod('Option1', 'Option17');

void SomeMethod(params string[] options)
{
    foreach(var option in options)
    {
        switch(option): ...
    }
}

Bagian yang menyenangkan tentang ini adalah saya dapat menggunakan metode ini di semua tempat tanpa harus membuat array atau daftar setiap waktu.

Saya akan menggunakan arrayatau listketika saya tahu saya akan selalu melewati fungsi ini satu set data yang sudah disatukan seperti

List<User> users = GetUsersFromDB();
SomeMethod(users);

Saya melihat manfaat dari paramsfleksibilitas yang ditambahkannya. Ini mungkin dampak yang relatif kecil untuk kode Anda, tetapi masih merupakan alat yang bagus untuk memilikinya.

Konvensi panggilan berbeda. Sebagai contoh ...

public class Test
{
    public void Method1( params int[] nums )
    {
        nums.ToList().ForEach( n => Console.WriteLine(n) );
    }

    public void Method2( List<int> nums )
    {
        nums.ForEach( n  => Console.WriteLine(n) );
    }   
}

void Main()
{   
    var t = new Test();
    t.Method1( 1, 2, 3, 4 );
    t.Method2( new List<int>() { 1, 2, 3, 4 } );
}

Dalam kasus pertama, Anda dapat mengirimkan sebanyak int sebagai parameter terpisah ke metode. Pada yang kedua, Anda perlu membuat instance daftar dan meneruskannya.