Constrain chung là một loại nullable

Question

Tôi đang tìm kiếm cái gì sử dụng mẫu như thế này:

Foo<string> stringFoo = new Foo<string>("The answer is"); 
Foo<int> intFoo = new Foo<int>(42); 
// The Value of intFoo & stringFoo are strongly typed 
stringFoo.Nullify(); 
intFoo.Nullify(); 
if (stringFoo == null && intFoo == null) 
    MessageBox.Show("Both are null); 

Với lớp này Foo, tôi có thể tự động quấn T thành một nullable:

public class Foo1<T> 
    where T : struct 
{ 
    private T? _value; 

    public Foo(T? initValue) 
    { 
     _value = initValue; 
    } 

    public T? Value { get { return _value; } } 

    public void Nullify { _value = null; } 

} 

Điều này làm việc cho nguyên thủy, nhưng không phải với String hoặc các lớp khác.

hương vị Tiếp làm việc cho chuỗi, nhưng không phải nguyên thủy:

public class Foo2<T> 
{ 
    private T _value; 

    public Foo(T initValue) 
    { 
     _value = initValue; 
    } 

    public T Value { get { return _value; } } 

    public void Nullify { _value = default(T); } 

} 

tôi có thể sử dụng Nullable<int> cho foo2 và mã sẽ làm việc như thế này:

Foo2<int?> intFoo = new Foo<int?>(42); 

Nhưng điều này là dễ bị lỗi vì nó không thành công cho Foo2. Nếu tôi có thể hạn chế T là các loại hỗ trợ nullability thì điều đó sẽ ổn thôi.

Vì vậy, sau khi tất cả điều đó, có cách nào để hạn chế T là một loại nullable không?

Một số lưu ý bổ sung: .NET 4.0, VS2010. Và tôi đã tìm thấy một câu hỏi tương tự như vậy ở đây, nhưng không có câu trả lời thành công.

Answer 1

Bạn có thể có thể làm cho các nhà xây dựng của Foo<T> nội bộ, và yêu cầu các trường hợp mới chỉ có thể được tạo ra thông qua một lớp nhà máy:

public class Foo<T> 
{ 
    private T value; 
    internal Foo(T value) 
    { 
     this.value = value; 
    } 

    public void Nullify() 
    { 
     this.value = default(T); 
    } 

    public T Value { get { return this.value; } } 
} 

public class Foo 
{ 
    public static Foo<T> Create<T>(T value) where T : class 
    { 
     return new Foo<T>(value); 
    } 

    public static Foo<T?> Create<T>(T? value) where T : struct 
    { 
     return new Foo<T?>(value); 
    } 
} 

Answer 2

Không có hạn chế, bạn có thể áp dụng cho điều này, nhưng bạn thể kiểm tra cho nó ở thời gian thực hiện:

if (default(T) != null) 
{ 
    throw new SomeAppropriateException(typeof(T) + " is not a nullable type"); 
} 

Bạn có thể thậm chí đặt đó vào một constructor tĩnh, mà sẽ chắc chắn rằng nó chỉ thực hiện một lần cho mỗi loại được xây dựng - và bất kỳ ai đang cố gắng sử dụng Foo<int> ở bất cứ nơi nào sẽ có một thời gian khó bỏ qua TypeInitializerException. Đó không phải là điều rất thân thiện đối với một API công khai công khai, nhưng tôi cho rằng nó hợp lý đối với nội bộ.

EDIT: Có một khủng khiếp cách làm cho nó khó khăn hơn để tạo ra các trường hợp Foo<int> ... bạn có thể sử dụng (quy tắc sử dụng độ phân giải quá tải cùng với các thông số mặc định và một vài loại generic hạn chế) ghastly code in this blog post và đánh dấu quá tải nhằm vào một loại giá trị không nullable như lỗi thời với một lỗi. Bằng cách đó, Foo<int> vẫn sẽ là một loại hợp lệ, nhưng bạn sẽ khó ép để tạo ra một thể hiện của nó. Tôi sẽ không để khuyên bạn nên làm điều này mặc dù ...

Answer 3

tôi không thích nó nhiều như cú pháp của foo1, nhưng đây là Foo3:

public class Foo3<T> 
    where T : struct 
{ 

    private T _value; 
    private T _nullValue; 

    public Foo3(T initValue) 
     : this(initValue, default(T)) 
    { 
    } 

    public Foo3(T initValue, T nullValue) 
    { 
     _value = initValue; 
     _nullValue = nullValue; 
    } 

    public T Value { get { return _value; } } 

    public bool IsNull 
    { 
     get 
     { 
      return object.Equals(_value, _nullValue); 
     } 
    } 

    public void Nullify() { _value = _nullValue; } 

} 

Và sau đó sử dụng của tôi trở thành:

Foo3<string> stringFoo = new Foo<string>("The answer is"); 
Foo3<int> intFoo = new Foo<int>(42, int.MinValue); 
stringFoo.Nullify(); 
intFoo.Nullify(); 
if (stringFoo.IsNull && intFoo.IsNull) 
    MessageBox.Show("Both are null); 

Đây vẫn là lỗi dễ xảy ra vì việc nhận thuộc tính Giá trị của Foo3 (và Foo2) không đơn giản. Foo1 là tốt nhất bởi vì tự động bọc giá trị sẽ null hỗ trợ.

Tôi có thể chỉ cần ValueTypeFoo và ObjectFoo và xử lý hai câu.