web-dev-qa-db-ja.com

クラスにさまざまなジェネリック型のリストを格納する

Class structure

私がやろうとしていることの写真を添付し​​ました。クラスにTのリストがあるとしましょう

public class MyClass<T> 
    where T : IMyInterface
{
    public List<T> list = new List<T>;
}

これで、別のクラスにMyClassのリストがあります。

public class AnotherClass
{
    public List<MyClass<IMyInterface>> list = new List<MyClass<IMyInterface>>;
}

MyClassに付けるTは何ですか？ Tを指定すると、そのクラスのすべての型が同じであると見なされますが、そうではありません。 IMyInterfaceを配置すると、これらのクラスにアクセスするときにIMyInterfaceをTにキャストできませんでした。

new AnotherClass().list.Add(new MyClass<T>());

ここのタイプは今何ですか？ AnotherClassジェネリックタイプのリストはIMyInterfaceですが、追加したいのはTです。これは動的にしたいのですが、まだIMyInterfaceの下にあります。

c#listclassgenericsdynamic
20
Lee Song

ジェネリックのTは、その有効期間を通じて同じでなければなりません。

例として

var a = new MyClass<int>();
a.list.Add(1); //since a's generic T is declared as int the list is now also int

var b = new MyClass<string>()
b.list.Add("string"); //in b its now declared as a string and avccepts only string

だからあなたがこれをしているとき。

var c = new MyClass<IMyInterface>();
c.list.Add(ObjectImplementingIMyInterface); //You must add something that implements IMyInterface

コンテンツについて知っている唯一のことは、オブジェクトの実行を分割する場合は、IMyInterfaceを実装していることです。その場合は、リフレクションを介してオブジェクトのタイプを確認する必要があります。

if(c.list[i].GetType() == typeof(ClassA_IMyInterface)
{
    //Execute on ClassA_IMyInterface
    //If you are after the ClassA 
    //and want to run something speciffic for it the cast
    ClassA clA = = (ClassA)c.list[i];
    //Now you have access to the implementation of ClassA instead of just the interface 
}
else if (c.list[i].GetType() == typeof(ClassB_IMyInterface)
{
    //Execute on ClassB_IMyInterface
}

以下は、ConsoleApplicationで作成した例で、そのレイアウトを示しています。

public class MyClass<T> where T : IMyInterface
{
    public List<T> list = new List<T>();
}
public interface IMyInterface
{
}
public class Foo : IMyInterface
{
}
public class Bar : IMyInterface
{
}
public class FooBar
{
    public void Test()
    {
        var content = new MyClass<IMyInterface>();
        content.list.Add(new Foo());
        if (content.list[0] is Foo)
        {
            //Execute on Foo 
            var g = (Foo)content.list[0];
            //Now you can access Foo's methods and not only the Interfaces
            Console.WriteLine("Foo");
        }
        else if (content.list[0] is Bar)
        {
            //Execute on Bar
            var g = (Bar)content.list[0];
            //Now you can access Bar's methods and not only the Interfaces
            Console.WriteLine("Bar");
        }
    }
}
6
Thomas Andreè Lian

あなたの問題は、これにジェネリックを使用する必要がないということだと思います。クラスを次のように指定した場合：

public class MyClass
{
    public IList<IMyInterface> list = new List<IMyImterface>();
}

次に、インターフェースを実装する任意のクラスの任意のインスタンスをこれに追加できます。

public class DummyClass : IMyInterface {}

public class AnotherClass {
{
    IList<MyClass> anotherList = new List<MyClass>();

    public void AMethod()
    {
        MyClass myList = new MyClass();
        myList.Add(new DummyClass());

        anotherList.Add(myList);
    }
}

次に、リストのすべてのアイテムにIMyInterfaceとして直接アクセスできます。または、特定のクラスのアイテムが必要な場合は、LINQを使用できます。

foreach (IMyImterface item in myList.Where(x => x is DummyClass))
{
    DummyClass dummy = (DummyClass)item;
}

// or
foreach (IMyImterface item in myList.OfType<DummyClass>())
{
    DummyClass dummy = (DummyClass)item;
}

または、キャストを試してnullかどうかを確認することもできます。

foreach (IMyIntetface item in myList)
{
    DummyClass dummy = item as DummyClass;
    if (dummy != null)
    {
        // do something
    }
}
5
Steve Harris

共変 ？

public interface IMyInterface { }
public class A : IMyInterface { }
public class B : IMyInterface { }

// Covariant interface
public interface IMyClass<out T> { }

// Inherit IMyClass
public class MyClass<T> : IMyClass<T> where T : IMyInterface 
{ 
    public List<T> list = new List<T>(); 
}

public class AnotherClass
{
    // Note the list using IMyClass instead of the concrete MyClass type
    // The covariant interface type would allow any IMyInterface conversion
    public List<IMyClass<IMyInterface>> list = new List<IMyClass<IMyInterface>>();

    public AnotherClass()
    {
        this.list.Add(new MyClass<A>());
        this.list.Add(new MyClass<B>());
    }
}
3
Eric

私はあなたが1つのリストに複数のジェネリック型を持ちたいことを意味していると思います。

var ac = new AnotherClass();
ac.list.Add(new MyClass<int>()); 
ac.list.Add(new MyClass<bool>()); 
ac.list.Add(new MyClass<double>());

これを行う簡単な方法は、リストをオブジェクトのリストとして定義することです。

public class AnotherClass
{
    public List<object> list = new List<object>();
}

ここでの問題は、ジェネリッククラスだけでなく、そのリストに好きなものを何でもできるということです。以下も可能です。

list.Add(1); 
list.Add("hello");

追加できるものを制限できる唯一の方法は、抽象基本クラスを使用することです。

public class MyClassBase 
{

}
public class MyClass<T> : MyClassBase
    where T : IMyInterface
{
    public List<T> list = new List<T>();
}

そして、それらのリストを持っています：

public class AnotherClass
{
    public List<MyClassBase> list = new List<MyClassBase>();
}

これらのオブジェクトにアクセスするときは、まだ型チェックを行う必要がありますが、少なくとも、オブジェクトがMyClassBaseを継承するオブジェクトに制限されていることがわかります。

3
Tim Rutter