Có cách tiếp cận hợp lý nào đối với các tham số kiểu "mặc định" trong C # Generics không?

Trong các mẫu C ++, người ta có thể chỉ định rằng một tham số kiểu nhất định là một tham số mặc định. Tức là trừ khi được chỉ định rõ ràng, nó sẽ sử dụng kiểu T.

Điều này có thể được thực hiện hoặc gần đúng trong C #?

Tôi đang tìm kiếm một cái gì đó như:

public class MyTemplate<T1, T2=string> {}

Vì vậy, một phiên bản của kiểu không chỉ định rõ ràng T2:

MyTemplate<int> t = new MyTemplate<int>();

Về cơ bản sẽ là:

MyTemplate<int, string> t = new MyTemplate<int, string>();

Cuối cùng, tôi đang xem xét một trường hợp trong đó có một mẫu được sử dụng khá rộng rãi, nhưng tôi đang xem xét mở rộng với một tham số kiểu bổ sung. Tôi có thể phân loại phụ, tôi đoán vậy, nhưng tôi tò mò liệu có các lựa chọn khác trong mạch này không.

Phân lớp là lựa chọn tốt nhất.

Tôi sẽ phân lớp phụ lớp chung chung chính của bạn:

class BaseGeneric<T,U>

với một lớp cụ thể

class MyGeneric<T> : BaseGeneric<T, string>

Điều này giúp dễ dàng giữ logic của bạn ở một nơi (lớp cơ sở), nhưng cũng dễ dàng cung cấp cả hai tùy chọn sử dụng. Tùy thuộc vào lớp học, có thể có rất ít công việc bổ sung cần thiết để thực hiện điều này.

Một giải pháp là phân lớp. Một phương thức khác mà tôi sẽ sử dụng thay thế, là các phương thức gốc (kết hợp với từ khóa var).

public class MyTemplate<T1,T2>
{
     public MyTemplate(..args..) { ... } // constructor
}

public static class MyTemplate{

     public static MyTemplate<T1,T2> Create<T1,T2>(..args..)
     {
         return new MyTemplate<T1, T2>(... params ...);
     }

     public static MyTemplate<T1, string> Create<T1>(...args...)
     {
         return new MyTemplate<T1, string>(... params ...);
     }
}

var val1 = MyTemplate.Create<int,decimal>();
var val2 = MyTemplate.Create<int>();

Trong ví dụ trên val2là loại MyTemplate<int,string> và không một loại bắt nguồn từ nó.

Một loại class MyStringTemplate<T>:MyTemplate<T,string>không phải là cùng một loại với MyTemplate<T,string>. Điều này có thể gây ra một số vấn đề trong các tình huống nhất định. Ví dụ, bạn không thể truyền một phiên bản của MyTemplate<T,string>tới MyStringTemplate<T>.

bạn cũng có thể tạo một lớp Overload như vậy

public class MyTemplate<T1, T2> {
    public T1 Prop1 { get; set; }
    public T2 Prop2 { get; set; }
}

public class MyTemplate<T1> : MyTemplate<T1, string>{}

C # không hỗ trợ một tính năng như vậy.

Như bạn đã nói, bạn có thể phân lớp nó (nếu nó không được niêm phong và sao chép tất cả các khai báo của hàm tạo) nhưng đó là một điều hoàn toàn khác.

Rất tiếc, C # không hỗ trợ những gì bạn đang cố gắng thực hiện. Sẽ là một tính năng khó thực hiện vì kiểu mặc định cho một tham số sẽ phải tuân theo các ràng buộc chung và rất có thể sẽ gây đau đầu khi CLR cố gắng đảm bảo an toàn kiểu.