Question

我有这样的通用类：

public class MyGen<T>
{
   public MyGen(T val)
   {
      Val = val;
   }
   public T Val { get; }
}

处理器类：

public class Proc
{
   public void Do<T>(params MyGen<T>[] arr)
   {
      ...
   }
}

是否可以执行以下操作：

var proc = new Proc();
proc.Do(new MyGen<int>(5), new MyGen<string>("bla"));

UPD ：具有基本非泛型类和泛型派生类的解决方案。我想它更好，因为没有拳击：

class Program
{
    static void Main(string[] args)
    {
        var proc = new Proc();
        proc.Do(new MyGen<int>(55), new MyGen<string>("dsdasd"));

        Console.Read();
    }
}

public class Proc
{
    public void Do(params MyGenBase[] arr)
    {
        foreach (var it in arr)
        {
            it.Do();
        }
    }
}

public abstract class MyGenBase
{
    public abstract void Do();
}

public class MyGen<T> : MyGenBase
{
    public MyGen(T val)
    {
        Val = val;
    }

    public T Val { get; }

    public override void Do()
    {
        Console.WriteLine(typeof(T));
    }
}

我在这里缺少任何缺点吗？请评论这种方法。

Answer 1

您的示例Do语句不会将数组作为参数，而是作为2个单独的参数。

如果使用带有2个对象的数组，那么你可以放置一个5和字符串＆＃34; bla＆＃34;在数组中。

var proc = new Proc();
var Items = new List<MyGen<object>>();
Items.Add(new MyGen<object>(5));
Items.Add(new MyGen<object>("bla"));
proc.Do(Items.ToArray());

Answer 2

你不能这样做。因为Do方法无法接受不同类型的MyGen类。因此，创建基类可能是一种选择;

public class BaseMyGen
{

}

public class MyGen<T> : BaseMyGen
{
    public MyGen(T val)
    {
        Val = val;
    }
    public T Val { get; }
}
public class Proc
{
    public void Do(params BaseMyGen[] arr)
    {
        var myGen1 = arr[0] as MyGen<int>;
        var myGen2 = arr[1] as MyGen<string>;
    }
}
var proc = new Proc();
proc.Do(new MyGen<int>(5), new MyGen<string>("bla"));

Answer 3

这是泛型的经典问题，并且有一个经典的解决方案。例如，List<T>实现了IEnumerable<T>，并且还实现了System.Collections.IEnumerable。这就是原因。

public interface IMyGen
{
    object Val { get; }
}
public class MyGen<T> : IMyGen
{
    public MyGen(T val)
    {
        Val = val;
    }
    public T Val { get; }

    object IMyGen.Val => this.Val;
}
public class Proc
{
    public void Do(params IMyGen[] arr)
    {

    }
}

如果由于显式接口实现导致的所有转换都太麻烦，您可以为非泛型属性指定一个不同的名称：

public interface IMyGen
{
    object Value { get; }
}
public class MyGen<T> : IMyGen
{
    public MyGen(T val)
    {
        Val = val;
    }
    public T Val { get; }

    public object Value => Val;
}
public class Proc
{
    public void Do(params IMyGen[] arr)
    {

    }
}

我不喜欢这种方法：一个属性有一个正确的名称。但有时你会坚持下去。

传递具有不同T的泛型类型的实例列表

3 个答案: