将数据库中的结果拆分为 10 个“块”

Question

下午，

我需要一只手将 1200 多个结果分成 10 个“块”，以便我可以使用亚马逊 MWS API 处理这些结果。任何人都可以就我将如何做这件事提供任何指导吗？

 List<string> prodASIN = dc.aboProducts.Select(a => a.asin).Take(10).ToList();

我目前有这个，它有效。但是我有 1200 多个结果，需要遍历每 10 个结果，以便我可以处理它们并将它们传递给亚马逊 MWS API

Answer 1

我知道这个问题已经得到解答，但我不能拒绝你this little extension method 我曾经提出过，从那以后对我很有帮助。

你可以这样做：

foreach(var list in prodASINs.ToChunks(10))
{
    // send list
}

Answer 2

为什么不试试这样的：

//Load all the database entries into Memory
List<string> prodASINs = dc.aboProducts.Select(a => a.asin).ToList();
var count = prodASINs.Count();
//Loop through passing 10 at a time to AWS
for (var i = 0; i < count; i++)
{
    var prodASINToSend = prodASINs.Skip(i * 10).Take(10).ToList(); 
    //Send to AWS
}

或者，如果您不想将它们全部加载到内存中。

var count = dc.aboProducts.Count();
for (var i = 0; i < count; i++)
{
    List<string> prodASIN = dc.aboProducts.OrderBy(a => a.Id).Select(a => a.asin).Skip(i * 10).Take(10).ToList(); 
    //Send to AWS
}

Answer 3

抱歉，这不是 LINQ 特定的，但也许它会有所帮助...

在使用 MWS 和 ERP 软件处理数据时，我所做的其中一件事是向数据库中添加一个控制列，例如“addASIN”。在数据库中，我将控制列定义为布尔值（或 TINYINT( 1) 在 MySQL 中) 并将所有新条目的标志默认为 0，并在添加条目时将其设置为 1。

如果你能做到，那么你可以做类似的事情

SELECT asin FROM datasource WHERE addedASIN = 0 LIMIT 10;

然后，一旦 MWS 返回成功添加，则使用

更新标志

UPDATE datasource SET addedASIN = 1 WHERE asin = 'asinnumber';

我发现这样做的好处是您的数据库将能够以最少的数据重复来停止和启动 - 例如在我的情况下（以及启动此控制列的原因）我们的网络连接可能不稳定，所以我在订单导入期间发现我会失去连接，导致订单丢失，或者订单被上传到我们的系统两次。

此解决方案通过最多两次添加由于连接丢失而导致的 1 个订单，并且为了将该订单上传两次，需要在将数据发送到我们的 ERP 系统之间丢失连接，我们的 ERP 系统确认已添加并更新数据库，往返大约需要 30 秒。

Answer 4

切片扩展（用于数组）：

    public static T[] Slice<T>(this T[] source, int index, int length)
    {
        T[] slice = new T[length];
        Array.Copy(source, index, slice, 0, length);
        return slice;
    }

Array.Copy 非常快，比 Select/Skip/Take 模式快很多。虽然这种方法不是我发现的禁食方法，但最近的测试表明它比用于拆分列表和数组的 Skip/Take 模式快了近 400 倍。

按原样使用：

const int arraySize = 10;
List<string> listSource = whatever;
string[] source = listSource.ToArray();

for (int i = 0; i < source.Length; i += arraySize)
{
    List<string> buffer = source.Slice(i, arraySize).ToList();
    DoSomething(buffer);
}

Answer 5

List<T> 有一个名为GetRange() 的内置函数，它是专门为你想要做的事情而设计的。它非常快，不需要 Linq、casting 等......

List<string> prodASINs = dc.aboProducts.Select(a => a.asin).ToList(); 

for(int i = 0; i < prodASINs.Count; i += 10)
{

    List<string> buffer = prodASINs.GetRange(i, 10);
    // do something with buffer
}

就是这样。很简单。

---

测试结果：GetRange vs. Slice vs. Linq List<string> 有 5000 个字符串 如您所见，使用 Linq 的 Skip/Take 方法比 Slice<T>() 慢 383 倍以上，比 GetRange() 慢 4,736 倍

================================================ ====================================

GetRange took on average 168 ticks
Slice took on average 2073 ticks
Linq took on average 795643 ticks

使用的测试方法（自己试试）：

private static void GetRangeVsSliceVsLinq()
{
    List<string> stringList = new List<string>();
    for (int i = 0; i < 5000; i++)
    {
        stringList.Add("This is a test string " + i.ToString());
    }

    Stopwatch sw = new Stopwatch();

    long m1 = 0, m2 = 0, m3 = 0;


    for (int x = 0; x < 10; x++)
    {
        Console.WriteLine("Iteration {0}", x + 1);
        Console.WriteLine();

        sw.Reset();
        sw.Start();

        for (int i = 0; i < stringList.Count; i += 10)
        {
            List<string> buffer = stringList.GetRange(i, 10);
        }
        sw.Stop();
        Console.WriteLine("GetRange took {0} msecs", sw.ElapsedMilliseconds);
        Console.WriteLine("GetRange took {0} ticks", sw.ElapsedTicks);
        m1 += sw.ElapsedTicks;

        sw.Reset();
        sw.Start();

        string[] sliceArray = stringList.ToArray();
        for (int i = 0; i < sliceArray.Length; i += 10)
        {
            List<string> buffer = sliceArray.Slice(i, 10).ToList();
        }
        sw.Stop();
        Console.WriteLine("Slice took {0} msecs", sw.ElapsedMilliseconds);
        Console.WriteLine("Slice took {0} ticks", sw.ElapsedTicks);
        m2 += sw.ElapsedTicks;

        sw.Reset();
        sw.Start();

        var count = stringList.Count();
        for (var i = 0; i < count; i++)
        {
            var buffer = stringList.Skip(i * 10).Take(10).ToList();
        }

        sw.Stop();
        Console.WriteLine("Skip/Take took {0} msecs", sw.ElapsedMilliseconds);
        Console.WriteLine("Skip/Take took {0} ticks", sw.ElapsedTicks);
        m3 += sw.ElapsedTicks;

        Console.WriteLine();
    }

    Console.WriteLine();
    Console.WriteLine("GetRange took on average {0} ticks", m1 / 10);
    Console.WriteLine("Slice took on average {0} ticks", m2 / 10);
    Console.WriteLine("Linq took on average {0} ticks", m3 / 10);

}