Speicher einen offenen generischen Typ in einem Array?

Question

ich habe ein Problem mit .NET Generika gegenüber. Das, was ich tun möchte, ist eine Reihe von Generika-Typen speichern (GraphicsItem):

public class GraphicsItem<T>
{
    private T _item;

    public void Load(T item)
    {
        _item = item;
    }
}

Wie kann ich so offen generischen Typen in einem Array speichern?

Answer 1

Implementieren einer nicht-generische Schnittstelle und verwenden Sie diese:

public class GraphicsItem<T> : IGraphicsItem
{
    private T _item;

    public void Load(T item)
    {
        _item = item;
    }

    public void SomethingWhichIsNotGeneric(int i)
    {
        // Code goes here...
    }
}

public interface IGraphicsItem
{
    void SomethingWhichIsNotGeneric(int i);
}

Dann verwenden Sie diese Schnittstelle als Element in der Liste:

var values = new List<IGraphicsItem>();

Answer 2

Wenn Sie heterogene GrpahicsItem der d GraphicsItem und GrpahicsItem Sie müssen abzuleiten sie von gemeinsamer Basisklasse oder implementieren gemeinsame Schnittstelle gespeichert werden sollen. Eine weitere Möglichkeit besteht darin, sie in Liste zu speichern

Answer 3

Sind Sie versuchen, eine Reihe von GraphicsItem in einem nicht-generische Methode zu erstellen?

Sie können nicht wie folgt vor:

static void foo()
{
  var _bar = List<GraphicsItem<T>>();
}

und dann die Liste füllt später.

Wahrscheinlicher Sie versuchen, so etwas zu tun?

static GraphicsItem<T>[] CreateArrays<T>()
{
    GraphicsItem<T>[] _foo = new GraphicsItem<T>[1];

    // This can't work, because you don't know if T == typeof(string)
    // _foo[0] = (GraphicsItem<T>)new GraphicsItem<string>();

    // You can only create an array of the scoped type parameter T
    _foo[0] = new GraphicsItem<T>();

    List<GraphicsItem<T>> _bar = new List<GraphicsItem<T>>();

    // Again same reason as above
    // _bar.Add(new GraphicsItem<string>());

    // This works
    _bar.Add(new GraphicsItem<T>());

    return _bar.ToArray();
}

Bitte beachten Sie eine generische Art Referenz gehen zu müssen, einen Array eines generischen Typs zu schaffen. Dies kann entweder bei Verfahren-Ebene oder auf Klassenebene (die T nach dem Verfahren unter Verwendung) (unter Verwendung des T nach der Klasse).

Wenn Sie die Methode wollen eine Reihe von GraphicsItem und GraphicsItem zurückzukehren, dann lassen Sie GraphicsItem erben von einer nicht-generische Basisklasse GraphicsItem und ein Array davon. Sie werden jedoch alle Arten Sicherheit verlieren.

Ich hoffe, das hilft.