在 foreach 循环中使用泛型类型

Question

我真的不知道如何将泛型类型与 IEnumerable 一起使用，以便我可以遍历给定泛型值包含的值。

考虑以下类（注意这里的类仅用于示例目的）：

public class Parameter<T> : IParameter<T> where T : IEnumerable<T>
{
  public List<UInt64> output = new List<UInt64>();

   private T _value;
   public T Value
   {
       get => ...;
       set
       {

           // I want to be able to apply special treat to the value
           // Value can be of any type: int, int[], bool, bool[]
           foreach (var v in value)
           {
               output.Add(Convert.UInt64(v) + 5);
           }

           ...

       }
   }
}

public interface IParameter<T> where T : IEnumerable<T>
{
   T Value { get; set; }
}

然后我有一个测试模块来实例化一些参数，但我什至无法在这里编译。我什至尝试在下面将 bool[] 替换为 IEnumerable，但编译器也不喜欢它。

public class TestModule : ModuleBase, ITestModule
{
    public IParameter<bool[]> Test1 { get; set; } = new Parameter<bool[]>();
    public IParameter<uint[]> Test2 { get; set; } = new Parameter<uint[]>();
    ...
    public IParameter<int> Test3 { get; set; } = new Parameter<int>();
}

我确实考虑过对 Parameter() 类使用重载，但我认为为每个支持的类型创建一个类是多余的（考虑到它仅适用于 Value 属性）。

Answer 1

您的问题是您的通用参数指定不正确。

public class Parameter<T> : IParameter<T> where T : IEnumerable<T>

暗示任何类型的 T 都是相同类型的可枚举，例如，bool[] 类型的 T 应该是 IEnumerable<bool[]>，这显然是不正确的。

编译它的一种方法是：

    public class Parameter<TEnumerable, TType> : IParameter<TEnumerable, TType> where TEnumerable : IEnumerable<TType>
    {
        public List<ulong> output = new List<ulong>();

        private TEnumerable _value;
        public TEnumerable Value
        {
            get => { return null; }
            set
            {

                // I want to be able to apply special treat to the value
                // Value can be of any type: int, int[], bool, bool[]
                foreach (Q v in value)
                {
                    output.Add(Convert.ToUInt64(v) + 5);
                }
            }
        }
    }

    public interface IParameter<TEnumerable, TType> where TEnumerable : IEnumerable<TType>
    {
        TEnumerable Value { get; set; }
    }

    public class TestModule
    {
        public IParameter<bool[], bool> Test1 { get; set; } = new Parameter<bool[], bool>();
        public IParameter<uint[], uint> Test2 { get; set; } = new Parameter<uint[], uint>();
        public IParameter<int[], int> Test3 { get; set; } = new Parameter<int[], int>();
    }

至于您的附加评论，不，您无法避免必须指定这两种类型，因为 IEnumerable 不是您制定代码的形式的 T 。您在这里有 2 个单独的参数，因此，如果您必须按照您的方式进行操作，则必须使用 2 个通用参数。

一个更简单的解决您的问题的方法是这样的，它或多或少地服务于相同的目的，虽然我真的不知道您的要求，所以这可能足够也可能不够（为清楚起见省略了接口）：

    public class Parameter<TType>
    {
        public List<ulong> output = new List<ulong>();

        private IEnumerable<TType> _value;
        public IEnumerable<TType> Value
        {
            get => { return null; }
            set
            {

                // I want to be able to apply special treat to the value
                // Value can be of any type: int, int[], bool, bool[]
                foreach (TType v in value)
                {
                    output.Add(Convert.ToUInt64(v) + 5);
                }
            }
        }
    }

    public class TestModule
    {
        public Parameter<bool> Test1 { get; set; } = new Parameter<bool>();
        public Parameter<uint> Test2 { get; set; } = new Parameter<uint>();
        public Parameter<int> Test3 { get; set; } = new Parameter<int>();
    }