วิธีที่สะอาดในการแบ่ง DataTable ออกเป็นชิ้นขนาดคงที่ด้วย Linq คืออะไร

ดูเหมือนว่าจะเป็นกรณีการใช้งานในอุดมคติสำหรับวิธี Skip and Take ของ Linq ขึ้นอยู่กับสิ่งที่คุณต้องการบรรลุด้วยการแยกชิ้นส่วน สิ่งนี้ยังไม่ผ่านการทดสอบโดยสิ้นเชิง ไม่เคยป้อนรหัส IDE แต่วิธีการของคุณอาจมีลักษณะเช่นนี้

private List<List<DataRow>> ChunkifyTable(DataTable table, int chunkSize)
{
    List<List<DataRow>> chunks = new List<List<DataRow>>();
    for (int i = 0; i < table.Rows.Count / chunkSize; i++)
    {
        chunks.Add(table.Rows.Skip(i * chunkSize).Take(chunkSize).ToList());
    }
    
    return chunks;
}

สิ่งนี้สามารถอ่านได้ค่อนข้างมากและวนซ้ำตามลำดับเพียงครั้งเดียวเท่านั้น บางทีอาจช่วยให้คุณประหยัดคุณลักษณะประสิทธิภาพที่ไม่ดีของการเรียก Skip() / Take() ที่ซ้ำซ้อนซ้ำซ้อน:

public IEnumerable<IEnumerable<DataRow>> Chunkify(DataTable table, int size)
{
    List<DataRow> chunk = new List<DataRow>(size);

    foreach (var row in table.Rows)
    {
        chunk.Add(row);
        if (chunk.Count == size)
        {
            yield return chunk;
            chunk = new List<DataRow>(size);
        }
    }

    if(chunk.Any()) yield return chunk;
}

ต่อไปนี้เป็นแนวทางที่อาจใช้ได้ผล:

public static class Extensions
{
    public static IEnumerable<IEnumerable<T>> InPages<T>(this IEnumerable<T> enumOfT, int pageSize)
    {
        if (null == enumOfT) throw new ArgumentNullException("enumOfT");
        if (pageSize < 1) throw new ArgumentOutOfRangeException("pageSize");
        var enumerator = enumOfT.GetEnumerator();
        while (enumerator.MoveNext())
        {
            yield return InPagesInternal(enumerator, pageSize);
        }
    }
    private static IEnumerable<T> InPagesInternal<T>(IEnumerator<T> enumeratorOfT, int pageSize)
    {
        var count = 0;
        while (true)
        {
            yield return enumeratorOfT.Current;
            if (++count >= pageSize) yield break;
            if (false == enumeratorOfT.MoveNext()) yield break;
        }
    }
    public static string Join<T>(this IEnumerable<T> enumOfT, object separator)
    {
        var sb = new StringBuilder();
        if (enumOfT.Any())
        {
            sb.Append(enumOfT.First());
            foreach (var item in enumOfT.Skip(1))
            {
                sb.Append(separator).Append(item);
            }
        }
        return sb.ToString();
    }
}
[TestFixture]
public class Tests
{
    [Test]
    public void Test()
    {
        // Arrange
        var ints = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
        var expected = new[]
        {
            new[] { 1, 2, 3 },
            new[] { 4, 5, 6 },
            new[] { 7, 8, 9 },
            new[] { 10      },
        };

        // Act
        var pages = ints.InPages(3);

        // Assert
        var expectedString = (from x in expected select x.Join(",")).Join(" ; ");
        var pagesString = (from x in pages select x.Join(",")).Join(" ; ");

        Console.WriteLine("Expected : " + expectedString);
        Console.WriteLine("Pages    : " + pagesString);

        Assert.That(pagesString, Is.EqualTo(expectedString));
    }
}

เจค็อบเขียน

ดูเหมือนว่าจะเป็นกรณีการใช้งานในอุดมคติสำหรับวิธี Skip and Take ของ Linq ขึ้นอยู่กับสิ่งที่คุณต้องการบรรลุด้วยการแยกชิ้นส่วน สิ่งนี้ยังไม่ผ่านการทดสอบโดยสิ้นเชิง ไม่เคยป้อนรหัส IDE แต่วิธีการของคุณอาจมีลักษณะเช่นนี้

private List<List<DataRow>> ChunkifyTable(DataTable table, int chunkSize)
{
    List<List<DataRow>> chunks = new List<List<DaraRow>>();
    for (int i = 0; i < table.Rows.Count / chunkSize; i++)
    {
        chunks.Add(table.Rows.Skip(i * chunkSize).Take(chunkSize).ToList());
    }

    return chunks;
}

ขอบคุณสำหรับ Jacob นี้ - มีประโยชน์สำหรับฉัน แต่ฉันคิดว่าการทดสอบในตัวอย่างของคุณควรเป็น ‹= ไม่ใช่ ‹ หากคุณใช้ ‹ และจำนวนแถวน้อยกว่า chunkSize จะไม่มีการวนซ้ำ ในทำนองเดียวกันไม่ได้จับชิ้นส่วนสุดท้าย แต่จะจับได้เฉพาะชิ้นส่วนที่เต็มเท่านั้น ตามที่คุณระบุไว้ ตัวอย่างยังไม่ผ่านการทดสอบ ฯลฯ ดังนั้นนี่เป็นเพียง FYI ในกรณีที่มีคนอื่นใช้รหัสของคุณแบบคำต่อคำ ;-)

นี่เป็นแนวทางที่แตกต่างไปจากเดิมอย่างสิ้นเชิง ไม่มีการจัดสรรหน่วยความจำสำหรับชิ้นส่วน

public static IEnumerable<IEnumerable<DataRow>> Chunkify(
    this DataTable dataTable, int chunkSize)
{
    for (int i = 0; i < dataTable.Rows.Count; i += chunkSize)
    {
        yield return GetChunk(i, Math.Min(i + chunkSize, dataTable.Rows.Count));
    }
    IEnumerable<DataRow> GetChunk(int from, int toExclusive)
    {
        for (int j = from; j < toExclusive; j++)
        {
            yield return dataTable.Rows[j];
        }
    }
}

ตัวอย่างการใช้งาน:

var dataTable = GetTonsOfData();
foreach (var chunk in dataTable.Chunkify(1000))
{
    Console.WriteLine($"Processing chunk of {chunk.Count()} rows");
    foreach (var dataRow in chunk)
    {
        Console.WriteLine(dataRow[0]);
    }
}