Коллекция родовых типов

Question

Если у меня есть общий класс:

public class MyClass<T> 
{ 
    public T Value; 
} 

Я хочу показать несколько элементов, таких как ...

new MyClass<string> 
new MyClass<int> 

... и добавить их в коллекцию. Как определить коллекцию, чтобы она могла содержать список общих типов? Затем я хочу выполнить итерацию через коллекцию и использовать свойство Value. Возможное?

Answer 1

Имейте свой общий класс наследовать от неосновной базы или реализуйте не общий интерфейс. Затем вы можете иметь коллекцию этого типа и использовать любой код, который вы используете для доступа к содержимому коллекции.

Вот пример.

public abstract class MyClass 
{ 
    public abstract Type Type { get; } 
} 

public class MyClass<T> : MyClass 
{ 
    public override Type Type 
    { 
     get { return typeof(T); } 
    } 

    public T Value { get; set; } 
} 

// VERY basic illustration of how you might construct a collection 
// of MyClass<T> objects. 
public class MyClassCollection 
{ 
    private Dictionary<Type, MyClass> _dictionary; 

    public MyClassCollection() 
    { 
     _dictionary = new Dictionary<Type, MyClass>(); 
    } 

    public void Put<T>(MyClass<T> item) 
    { 
     _dictionary[typeof(T)] = item; 
    } 

    public MyClass<T> Get<T>() 
    { 
     return _dictionary[typeof(T)] as MyClass<T>; 
    } 
} 

Answer 2

Я считаю, что ваша коллекция должна быть того же типа MyClass (как и в T, должна быть одинаковой), потому что компилятор не будет знать, какие типы вы добавили к каким элементам в коллекции.

Другими словами, если бы вы добавить 2 элементов в списке:

list.Add(new MyClass<string>()); 
list.Add(new MyClass<int>()); 

затем попытаться сослаться один:

var myItem = list[1]; 

компилятор не знает, что родовое был назначен список MyClass в элементе 1, поскольку элементы добавляются во время выполнения, но генерики определяются во время компиляции.

Я уверен, что то, что вы хотите сделать, не может быть сделано.

---

Если вы знаете количество элементов заранее, возможно, вы могли бы использовать Tuple?

Answer 3

Единственный способ, которым я могу думать, с верхней частью моей головы следующим образом (завернутый в приложении консоли для тестирования):

class Program 
{ 
    static void Main(string[] args) 
    { 
     var x = new MyClass<string>() { Value = "34" }; 
     var y = new MyClass<int>() { Value = 3 }; 

     var list = new List<IMyClass>(); 
     list.Add(x); 
     list.Add(y); 

     foreach (var item in list) 
     { 
      Console.WriteLine(item.GetValue); 
     } 
    } 

    private interface IMyClass 
    { 
     object GetValue { get; } 
    } 

    private class MyClass<T> : IMyClass 
    { 
     public T Value; 

     public object GetValue 
     { 
      get 
      { 
       return Value; 
      } 
     } 
    } 
} 

т.е. имеет MyClass реализовать пустой интерфейс и затем создать коллекции, которые содержат экземпляры классов, реализующих этот интерфейс.

Update: Я добавил метод «GetValue» к интерфейсу, который позволяет получить доступ к «Value» экземпляр MyClass как объект. Это примерно так же хорошо, как это получится, afaik, если вы хотите иметь коллекцию, содержащую смешанные типы.

Answer 4

Вы хотите определить базовый класс для MyClass, тогда ваши коллекции будут представлять собой список базового класса. Пример:

void Main() 
{ 
var a = new MyClass<string>(); 
var b = new MyClass<int>(); 
var c = new List<MyBase>(); 
c.Add(a); 
c.Add(b); 

} 

public class MyBase { } 
// Define other methods and classes here 
public class MyClass<T> : MyBase { 
public T Value { get; set;} 
} 

Answer 5

Вы хотите иметь коллекцию MyClass, для которых значение параметра типа T отличается в каждом конкретном случае. Это невозможно в .NET; в нем отсутствует эквивалент шаблона Java (?). Вместо этого вам нужно создать не общий базовый класс или интерфейс, который MyClass может реализовать. Например:

public interface IMyClass { 
    object Value { get; set; } 
} 
public class MyClass<T> : IMyClass { 
    public T Value { get; set; } 
    object IMyClass.Value { 
    get { return Value; } 
    set { Value = (T)value; } 
    } 
} 
List<IMyClass> m = new List<IMyClass> { new MyClass<string>(), new MyClass<int> }; 

Answer 6

У меня есть интерфейсы большинства моих родовых типов с «Нетипизированные» членов:

private interface IMyClass 
{ 
    object UntypedValue { get; } 
} 

private class MyClass<T> : IMyClass 
{ 
    T Value { get; set; } 

    object UntypedValue { get { return Value; } } 
} 

Вы также могли бы сделать это с помощью явного реализации интерфейса, но, на мой взгляд, это намного проще с помощью отдельного имени.(Есть некоторые CA намеки на явную реализацию интерфейса, а)

Answer 7

IList

Там нет никакого способа определить общую коллекцию, которая может принимать любой вкус вашего общего класса ... т.е. IList<MyClass>. Родовые классы - это всего лишь короткое сокращение для разработчика, чтобы сэкономить на написании кучи повторяющегося кода, но во время компиляции каждый вкус родового класса переводится в конкретный. т. е. если у вас есть MyClass<string>, MyClass<int>, MyClass<bool>, тогда компилятор будет генерировать 3 отдельных и разных класса. Единственный способ сделать то, что вы хотите, это иметь интерфейс для вашего общего.

public interface IMyGeneric { 
    Type MyType { get; set;}  
} 

class MyGeneric<T> : IMyGeneric { 

    public MyGeneric() { 
     MyType = typeof(T); 
    } 

    public Type MyType { 
     get; set; 
    } 
} 

, а затем вы можете сказать

IList<IMyGeneric> list = new List<IMyGeneric>(); 
list.add(new MyGeneric<string>()); 
list.add(new MyGeneric<int>()); 

Answer 8

Я думаю, что проблема здесь в том, что общие классы на самом деле не тот же тип вообще. Это просто шаблоны, которые создают все новые типы во время компиляции (если я правильно понимаю). Поэтому MyClass<int> и MyClass<string>полностью разных типов, в зависимости от времени выполнения. Они также могут быть MyIntClass и MyStringClass, которые вы, очевидно, не можете иметь в том же списке, без бокса. Они не (обязательно) наследуют один и тот же базовый класс, реализуют те же интерфейсы или что-то еще. Они такие же разные, как и любые другие два типа, и вы должны относиться к ним как таковым (хотя вы думаете, что знаете лучше).

Конечно, вы можете реализовать их интерфейс, наследовать базовый объект или любые другие параметры, уже заданные. Посмотрите на commongenius' answer за хороший способ сделать это.

Answer 9

С .Net 3 наблюдается CompositeCollection класс, который позволяет использовать несколько уникальных предметов или даже коллекции, которые должны содержаться внутри. Он используется разработчиками WPF для хранения и отображения различных элементов в Xaml. Но это не означает, что он не может использоваться в ситуациях, отличных от WPF.

Вот пример, где я хранить различные вещи из строк в десятичные и извлечь и перечислить на все предметы, то предметы определенного типа:

CompositeCollection cc = new CompositeCollection(); 

cc.Add(1); 
cc.Add("Item One"); 
cc.Add(1.0M); 
cc.Add(1.0); 
cc.Add("Done"); 

Console.WriteLine ("Every Item"); 

foreach (var element in cc) 
    Console.WriteLine ("\t" + element.ToString()); 

Console.WriteLine (Environment.NewLine + "Just Strings"); 

foreach (var str in cc.OfType<string>()) 
    Console.WriteLine ("\t" + str); 

/* Outputs: 

Every Item 
    1 
    Item One 
    1.0 
    1 
    Done 

Just Strings 
    Item One 
    Done 

*/