Question

以Execute批量调用rulesObjs方法的好方法是什么？让我们说这个列表有超过10,000个对象，我希望一次只能调用Execute不超过500个。

    public static List<object> ExecutePolicy()
    {
        Policy policy = new Policy();

        List<object> rules = GetRules();

        object[] rulesObjs = rules.ToArray();

        // Call this method with array of object, but in batches.
        policy.Execute(rulesObjs);

        return rulesObjs.ToList();
    }

    private static List<object> GetRules()
    {
        // get the rules via some process
        return new List<object>();
    }
}

public sealed class Policy
{
    public void Execute(params object[] rules)
    {
        // Process rules...
    }
}

我无法控制Execute()方法。

Answer 1

List<object> rules = GetRules();
int batchSize = 500;
int currentBatch = 0;

while (currentBatch * batchSize < rules.Count)
{
    object[] nextBatch = rules.Skip(currentBatch * batchSize)
        .Take(batchSize).ToArray();
    //use batch
    currentBatch++;
}

Answer 2

好吧，如果您可以控制Execute()方法，那么最好的方法是将索引传递给该方法，以便它知道从哪个索引开始。

public void Execute(int startIndex, /*optional*/ int endIndex, params object[] rules)
{
    // Process rules...
}

不要担心一次传递过多数据。在幕后，你的数组只是一个指针，所以你只是传递一个引用。

如果您无法控制Execute()方法，则可以使用Array.Copy为您的部分创建一个新数组，并处理该新数组。

Answer 3

引用System.Linq可以使用skip and take：

int total = 10000;
int chunkSize = 500;
for (int i = 0; i < total; i += chunkSize )
{
    var chunk = rulesObjs.Skip(i).Take(chunkSize).ToArray();

    policy.Execute(chunk);
}

拆分对象数组，然后批量处理

3 个答案: