C# Generics: Đơn giản hóa kiểu chữ ký

Question

Nếu tôi có một lớp mục chung mà trông như thế này:

abstract class Item<T> 
{ 
} 

Và một container của mục đó trông như thế này:

class Container<TItem, T> 
    where TItem : Item<T> 
{ 
} 

Kể từ TItem phụ thuộc vào T , nó có thể đơn giản hóa chữ ký loại của Container để nó chỉ mất một tham số kiểu?

class Container<TItem> 
    where TItem : Item // this doesn't actually work, because Item takes a type parameter 
{ 
} 

Vì vậy, tôi có thể nhanh chóng nó như sau::

class StringItem : Item<string> 
{ 
} 

var good = new Container<StringItem>(); 
var bad = new Container<StringItem, string>(); 

Trình biên dịch sẽ có thể suy ra rằng T là chuỗi khi TItem là StringItem, phải một cái gì đó này những gì tôi thực sự muốn là? Làm thế nào để tôi thực hiện điều này?

mong muốn sử dụng:

class MyItem : Item<string> 
{ 
} 

Container<MyItem> container = GetContainer(); 
MyItem item = container.GetItem(0); 
item.MyMethod(); 

Answer 1

này nên làm những gì bạn muốn tôi nghĩ. Rõ ràng bây giờ bạn đang làm Container<string> không phải Container<StringItem> nhưng vì bạn đã không bao gồm các ví dụ sử dụng, tôi không thể thấy nó là một vấn đề.

using System.Collections.Generic; 

namespace ConsoleApplication1 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      var myContainer = new Container<string>(); 

      myContainer.MyItems = new List<Item<string>>(); 
     } 
    } 

    public class Item<T> { } 

    public class Container<T> 
    { 
     // Just some property on your container to show you can use Item<T> 
     public List<Item<T>> MyItems { get; set; } 
    } 
} 

Làm thế nào về phiên bản sửa đổi này:

using System.Collections.Generic; 

namespace ConsoleApplication1 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      var myContainer = new Container<StringItem>(); 

      myContainer.StronglyTypedItem = new StringItem(); 
     } 
    } 

    public class Item<T> { } 

    public class StringItem : Item<string> { } 

    // Probably a way to hide this, but can't figure it out now 
    // (needs to be public because it's a base type) 
    // Probably involves making a container (or 3rd class??) 
    // wrap a private container, not inherit it 
    public class PrivateContainer<TItem, T> where TItem : Item<T> { } 

    // Public interface 
    public class Container<T> : PrivateContainer<Item<T>, T> 
    { 
     // Just some property on your container to show you can use Item<T> 
     public T StronglyTypedItem { get; set; } 
    } 
} 

Answer 2

Tôi nghĩ một giải pháp khả thi cho vấn đề của bạn là thêm giao diện IItem và cấu trúc mã sẽ như thế nào sau đây.

interface IItem { } 

abstract class Item<T> : IItem { } 

class Container<TItem> where TItem : IItem { } 

class StringItem: Item<string> { } 

Và bây giờ bạn có thể có Container<StringItem>:

var container = new Container<StringItem>();