C# 在分机上使用累加器

我有以下范围类别和扩展：

public class Range<T> where T : IComparable<T> {
  public T Minimum { get; set; }
  public T Maximum { get; set; }

  public Range(T minimum, T maximum) {
    Minimum = minimum;
    Maximum = maximum; 
  } // Range
}

public static IEnumerable<T> Expand<T>(this Range<T> range, Func<T, T> accumulator) where T : IComparable<T> {

  T current = range.Minimum;

  while (current.CompareTo(range.Maximum) <= 0) {
    yield return current;
    current = accumulator(current);
  }

}

例如，如果我使用：

List<Int32> result = range.Expand(x => 2 * x).ToList();

List result=range.Expand（x=>2*x.ToList（）；

创建此扩展的正确方法是什么

更新

如果使用以下工具，我的作品会起作用：

List<Int32> result = range.Expand(x => ++x).ToList();

List result=range.Expand（x=>++x.ToList（）；

但我在使用时也会遇到同样的异常：

List<Int32> result = range.Expand(x => x++).ToList();

List result=range.Expand（x=>x++）.ToList（）；

---

为什么会这样？

代码的问题是您没有获得范围内的下一个项目。当累加器中有

++x

时，累加器将为您完成工作。您应该在

循环期间移动到
中的下一项。由于您使用的是通用的
范围
，因此必须定义如何获取下一项

我认为最合适的名称是映射而不是累加器

public class Range<T>
{
    public T Minimum { get; set; }
    public T Maximum { get; set; }
    public Func<T, T> Next { get; set; }
    public Range(T min, T max) { Minimum = min; Maximum = max; }
}

public static IEnumerable<T> Expand<T>(this Range<T> range, Func<T, T> map) where T : IComparable<T>
{
    T current = range.Minimum;
    while (current.CompareTo(range.Maximum) <= 0)
    {
        var result = map(current);
        yield return result;
        current = range.Next(current);
    }
}


Range<Int32> range = new Range<Int32>(20, 24);
range.Next = x => x + 1;
List<Int32> expect = new List<Int32> { 40, 21, 44, 23, 48 };
List<Int32> result = range.Expand(x => x % 2 == 0 ? x * 2 : x).ToList();
Assert.Equal(expect, result);

公共类范围
{
公共T最小值{get；set；}
公共T最大值{get；set；}
public Func Next{get；set；}
公共范围（最小值，最大值）{最小值=最小值；最大值=最大值；}
}
公共静态IEnumerable扩展（此范围，Func映射），其中T:IComparable
{
T电流=范围。最小值；
而（当前）比（最大范围）x+1；
List expect=新列表{40,21,44,23,48}；
List result=range.Expand（x=>x%2==0？x*2:x）.ToList（）；
断言。相等（期望、结果）；
您的代码将生成20、21、21、21、21、21、21、…直到时间结束或数组的最大范围如果T是一个类，该如何定义一个类的范围？您的实现是否有构造函数？@SirRufo:我明白了…因为它是在前一个数组的基础上添加的…但这样做比使用累加器更好吗？@dotctoRT是一个泛型…但在我的示例中，我使用Int32
List<Int32> result = range.Expand(x => x++).ToList();

public class Range<T>
{
    public T Minimum { get; set; }
    public T Maximum { get; set; }
    public Func<T, T> Next { get; set; }
    public Range(T min, T max) { Minimum = min; Maximum = max; }
}

public static IEnumerable<T> Expand<T>(this Range<T> range, Func<T, T> map) where T : IComparable<T>
{
    T current = range.Minimum;
    while (current.CompareTo(range.Maximum) <= 0)
    {
        var result = map(current);
        yield return result;
        current = range.Next(current);
    }
}


Range<Int32> range = new Range<Int32>(20, 24);
range.Next = x => x + 1;
List<Int32> expect = new List<Int32> { 40, 21, 44, 23, 48 };
List<Int32> result = range.Expand(x => x % 2 == 0 ? x * 2 : x).ToList();
Assert.Equal(expect, result);