Bagaimanakah Kekangan Generik Kekangan Mempengaruhi Pemuatan Lebihan Kaedah C#?

Kekangan dan Lebihan Muatan

Dalam C#, kekangan generik boleh digunakan untuk menaip parameter untuk mengehadkan jenis yang boleh digunakan. Walau bagaimanapun, apabila kekangan diletakkan pada parameter, ia menjejaskan proses penyelesaian beban lampau.

Pertimbangkan kod berikut:

static void Foo<T>(T a) where T : struct { } // 1

static void Foo<T>(T? a) where T : struct { } // 2

Kedua-dua fungsi ini melebihkan Foo dan dibezakan berdasarkan kebolehtebalan daripada T. Walau bagaimanapun, cuba untuk menambah lebihan ketiga dengan kekangan pada jenis kelas gagal:

static void Foo<T>(T a) where T : class { } // 3

Ini kerana parameter fungsi ini sepadan dengan parameter Foo(T a) di mana T : struct. Untuk mengatasi masalah ini, kita mesti meletakkan kekangan pada parameter yang berbeza:

class RequireStruct<T> where T : struct { }
class RequireClass<T> where T : class { }

static void Foo<T>(T a, RequireStruct<T> ignore = null) where T : struct { } // 1
static void Foo<T>(T? a) where T : struct { } // 2
static void Foo<T>(T a, RequireClass<T> ignore = null) where T : class { } // 3

Kini, Foo boleh terlebih beban untuk mengendalikan ketiga-tiga kes:

• Jenis nilai biasa (cth. int) dipetakan ke Foo(T a, RequireStruct ignore = null) di mana T : struct.
• Jenis nilai nullable (cth. int?) dipetakan ke Foo(T? a) di mana T : struct.
• Jenis rujukan (cth. rentetan) dipetakan ke Foo< T>(T a, RequireClass abaikan = null) di mana T : kelas.

Atas ialah kandungan terperinci Bagaimanakah Kekangan Generik Kekangan Mempengaruhi Pemuatan Lebihan Kaedah C#?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!