Akademi C# · Pelajaran

Kaedah Generik

Parameter jenis pada kaedah.

Pelajaran 1 daripada 413 langkah

Kaedah Generik ialah pelajaran Akademi C# percuma di CoddyKit. Ini ialah pelajaran 1 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Akademi C#, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Akademi C# merangkumi sejumlah 4 pelajaran.

Apakah Kaedah Generik

Kaedah generik mengisytiharkan satu atau lebih parameter jenisnya sendiri, yang ditulis dalam kurungan sudut selepas nama kaedah. Isi kaedah yang sama kemudiannya boleh berfungsi untuk pelbagai jenis tanpa penukaran jenis atau penduaan.

Parameter jenis ialah ruang letak seperti T. Pengompil menggantikannya dengan jenis sebenar di tempat panggilan, sambil memastikan semua perkara ditaip dengan kukuh.

void Print<T>(T value)
{
    Console.WriteLine(value);
}

Mengisytiharkan Parameter Jenis

Senarai parameter jenis <T> terletak di antara nama kaedah dengan senarai parameter. Anda boleh menggunakan T sebagai jenis parameter, jenis nilai pulangan atau jenis pemboleh ubah setempat dalam isi kaedah.

Mengikut kebiasaan, parameter jenis tunggal dinamakan T; nama deskriptif seperti TKey juga lazim digunakan.

T Echo<T>(T input)
{
    return input;
}

Panggilan dengan Inferens Jenis

Biasanya Anda tidak perlu menentukan argumen jenis secara eksplisit. Pengompil membuat inferens terhadap T berdasarkan argumen yang Anda berikan.

Di sini, Echo(42) membuat inferens bahawa T = int, manakala Echo("hi") membuat inferens bahawa T = string. Inferens jenis menjadikan panggilan generik kemas dan mudah dibaca.

using System;

class Program
{
    static T Echo<T>(T input) => input;

    static void Main()
    {
        Console.WriteLine(Echo(42));
        Console.WriteLine(Echo("hi"));
    }
}

Argumen Jenis Eksplisit

Apabila inferens tidak dapat menentukan jenis, atau apabila Anda mahu menyatakannya dengan jelas, berikan argumen jenis dalam tanda kurung sudut pada tempat panggilan.

Hal ini diperlukan apabila tiada argumen yang membawa maklumat jenis, contohnya kaedah yang T-nya hanya muncul dalam jenis pulangan.

T Create<T>() where T : new() => new T();

// call:
var list = Create<int>();

Berbilang Parameter Jenis

Kaedah generik boleh mengisytiharkan beberapa parameter jenis yang dipisahkan dengan koma. Setiap parameter dibuat inferensnya atau diberikan nilainya secara berasingan.

Contoh lazim ialah kaedah pertukaran atau pembina pasangan yang menggabungkan dua jenis berbeza.

(TSecond, TFirst) Flip<TFirst, TSecond>(TFirst a, TSecond b)
{
    return (b, a);
}

Pertukaran Generik

Kaedah generik amat berguna untuk utiliti yang tidak bergantung pada jenis konkrit. Pertukaran menyusun semula dua nilai daripada sebarang jenis yang sepadan.

Kata kunci ref membolehkan kaedah mengubah suai pemboleh ubah pemanggil secara terus di tempatnya.

using System;

class Program
{
    static void Swap<T>(ref T a, ref T b)
    {
        T temp = a;
        a = b;
        b = temp;
    }

    static void Main()
    {
        int x = 1, y = 2;
        Swap(ref x, ref y);
        Console.WriteLine($"{x} {y}");
    }
}

Kekangan pada Parameter Kaedah

Kaedah generik boleh mengehadkan parameter jenisnya dengan klausa where. Kekangan memberitahu pengompil operasi yang dibenarkan terhadap T.

Di bawah, where T : IComparable<T> membolehkan badan kaedah memanggil CompareTo dengan selamat.

T Max<T>(T a, T b) where T : IComparable<T>
{
    return a.CompareTo(b) >= 0 ? a : b;
}

Kaedah Generik dalam Kelas Bukan Generik

Sebuah kelas tidak perlu generik untuk mengandungi kaedah generik. Kelas utiliti statik biasanya mengandungi kaedah sedemikian.

Hal ini memastikan pembantu kegunaan umum dikumpulkan bersama tanpa memaksa seluruh kelas membawa parameter jenis.

static class Util
{
    public static T First<T>(T[] items) => items[0];
}

Inferens daripada Tatasusunan

Inferens jenis juga berfungsi melalui argumen tatasusunan dan koleksi. Dengan memberikan int[], T = int dibuat inferensnya secara automatik.

Hal ini menjadikan algoritma generik terasa seperti ciri bahasa yang terbina dalam.

using System;

class Program
{
    static T First<T>(T[] items) => items[0];

    static void Main()
    {
        int[] nums = { 10, 20, 30 };
        Console.WriteLine(First(nums));
    }
}

Mengapa Tidak Gunakan objek Sahaja?

Sebelum generik diperkenalkan, kod menggunakan object dan penukaran jenis. Hal ini menghilangkan keselamatan jenis dan membungkus jenis nilai, sekali gus menjejaskan prestasi.

Kaedah generik mengelakkan pembungkusan bagi jenis nilai dan mengesan kesilapan jenis pada masa pengompilan, bukannya membuang ralat pada masa jalan.

// Unsafe: needs a cast and can fail at runtime
object Echo(object o) => o;
int n = (int)Echo(5);

Memulangkan Jenis Berbeza

Jenis pulangan itu sendiri boleh bersifat generik, lalu membolehkan satu kaedah membentuk keluarannya mengikut pemanggil. default(T) menghasilkan nilai sifar bagi jenis nilai atau null bagi jenis rujukan.

Hal ini berguna untuk nilai sandaran yang selamat apabila tiada nilai tersedia.

T OrDefault<T>(bool ok, T value)
{
    return ok ? value : default(T);
}

Semakan Pantas

Uji pemahaman Anda tentang kaedah generik.

Jawab dalam pelajaran interaktif

Imbas Kembali

Kaedah generik mengisytiharkan parameter jenisnya sendiri dalam tanda kurung sudut selepas nama. Pengompil biasanya membuat inferens jenis daripada argumen, tetapi Anda boleh memberikannya secara eksplisit.

Kaedah ini mengekalkan keselamatan jenis, mengelakkan pembungkusan, dan boleh membawa kekangan where. Anda boleh meletakkannya dalam mana-mana kelas, sama ada generik atau tidak.

Percuma untuk bermula

Pelajari C# dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 93
Pelajaran: 346

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Kaedah Generik” percuma?

Ya — teks penuh “Kaedah Generik” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Akademi C#, tingkat taraf kepada CoddyKit PRO. Kursus Akademi C# merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Kaedah Generik”?

Parameter jenis pada kaedah. Anda berlatih Akademi C# menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Akademi C#?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Akademi C# di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 1 daripada 4.

Berapa lamakah pelajaran “Kaedah Generik” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Akademi C# ini?

Ya. Setiap pelajaran Akademi C# menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Akademi C#