सी # जेनरिक: सरल बनाएँ प्रकार हस्ताक्षर

Question

अगर मैं एक सामान्य मद वर्ग है कि इस तरह दिखता है:

abstract class Item<T> 
{ 
} 

और आइटम के एक कंटेनर है कि इस तरह दिखता है:

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

के बाद से TItem टी पर निर्भर करता है , क्या कंटेनर के प्रकार हस्ताक्षर को सरल बनाना संभव है ताकि इसमें केवल एक प्रकार का पैरामीटर लगे?

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

तो मैं यह दृष्टांत कर सकते हैं इस प्रकार है::

class StringItem : Item<string> 
{ 
} 

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

संकलक निकालना कि टी स्ट्रिंग है जब TItem StringItem है में सक्षम है, है ना होना चाहिए कुछ इस क्या मैं सच में चाहते है? मैं यह कैसे करूं?

वांछित उपयोग:

class MyItem : Item<string> 
{ 
} 

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

Answer 1

यह आपको क्या मुझे लगता है कि चाहते हैं क्या करना चाहिए। जाहिर है अब आप Container<string>Container<StringItem> नहीं कर रहे हैं, लेकिन जैसा कि आपने उपयोग उदाहरण शामिल नहीं किए हैं, मैं इसे एक समस्या नहीं देख सकता।

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; } 
    } 
} 

कैसे इस संशोधित संस्करण के बारे में:

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

मुझे लगता है कि आपकी समस्या का एक संभव समाधान इंटरफेस IItem जोड़ रहा है और कोड संरचना निम्नलिखित की तरह हो जाएगा।

interface IItem { } 

abstract class Item<T> : IItem { } 

class Container<TItem> where TItem : IItem { } 

class StringItem: Item<string> { } 

और अब आप कर सकते हैं Container<StringItem>:

var container = new Container<StringItem>();