Ajout d'un tableau dans une table de données avec des colonnes limitées

Solution 1

Exemple de code; ce n'est pas la meilleure ou la plus courte implémentation, mais c'est une mise en œuvre claire et compréhensible pour les programmeurs novices .

public static class Extensions
{
    public static IEnumerable<IEnumerable<T>> Split<T>(this T[] array, int size)
    {
        for (var i = 0; i < (float)array.Length / size; i++)
        {
            yield return array.Skip(i * size).Take(size);
        }
    }

    public static void FillDataTable<T>(this DataTable dataTable, T[] input)
    {
        IEnumerable<IEnumerable<T>> rowValues = input.Split(dataTable.Columns.Count);
        foreach (IEnumerable<T> rowValue in rowValues)
        {
            DataRow row = dataTable.NewRow();

            T[] cellValues = rowValue.ToArray();
            for (int columnIndex = 0; columnIndex < cellValues.Length; columnIndex++)
            {
                // 'Safe'-check in case the original array didn't contain enough values. The cell value will remain 'null'
                if (columnIndex < dataTable.Columns.Count)
                {
                    row[columnIndex] = cellValues[columnIndex];
                }
            }

            dataTable.Rows.Add(row);
        }
    }
}

static class Program
{
    /// <summary>
    /// The main entry point for the application.
    /// </summary>
    [STAThread]
    static void Main()
    {
        int[] input = { 1, 2, 3, 4, 5, 6, 7, 8 };

        DataTable dataTable = new DataTable();
        dataTable.Columns.Add("v1");
        dataTable.Columns.Add("v2");
        dataTable.Columns.Add("v3");
        dataTable.Columns.Add("v4");

        dataTable.FillDataTable(input);    
    }
}

Solution 2 strong>

Une solution plus avancée et sécurisée pour les bords qui utilise des méthodes d'extension pour diviser le tableau d'origine en plusieurs sous-tableaux et remplissez une table de données.

string[] arr = { "1", "2", "3", "4", "5", "6", "7" };

int rowCount = arr.Length / dt.Columns.Count;
for (int rowIndex = 0; rowIndex < rowCount; rowIndex++)
{
    DataRow row = dt.NewRow();
    for (int columnIndex = 0; columnIndex < dt.Columns.Count; columnIndex++)
    {
        // In case of 2 rows:

        // row 1: (0 * 4) + 0 = 0
        // row 1: (0 * 4) + 1 = 1
        // row 1: (0 * 4) + 2 = 2
        // row 1: (0 * 4) + 3 = 3

        // row 2: (1 * 4) + 0 = 4
        // row 2: (1 * 4) + 1 = 5
        // row 2: (1 * 4) + 2 = 6
        // row 2: (1 * 4) + 3 = 7

        row[columnIndex] = arr[(rowIndex * dt.Columns.Count) + columnIndex];
    }

    dt.Rows.Add(row);
}

Ce que je veux dire, c'est que vous pouvez faire quelque chose comme ceci:

new row
row[0] = arr[0];
row[1] = arr[1];
row[2] = arr[2];
row[3] = arr[3];
new row
row[0] = arr[4];
row[1] = arr[5];
row[2] = arr[6];
row[3] = arr[7];
new row
row[0] = arr[8];
row[1] = arr[9];
row[2] = arr[10];
row[3] = arr[11];
new row
row[0] = arr[12];
row[1] = arr[13];
row[2] = arr[14];
row[3] = arr[15];
...

MODIFIER : prenez ceci comme exemple:

var arr = Enumerable.Range(1, 40).ToArray();

for (int i = 0; i < arr.Length; i++)
{
    if (i % 4 == 0) { Console.WriteLine("new row"); }
    Console.WriteLine($"row[{i % 4}] = arr[{i}];");
}

Cela a fonctionné pour moi, il faut ajouter des crochets pour les cas de bord mais le concept est assez simple.

        string[] arr = { "1", "2", "3", "4", "5", "6", "7", "8" };
        DataTable dt = new DataTable();
        dt.Columns.Add("v1");
        dt.Columns.Add("v2");
        dt.Columns.Add("v3");
        dt.Columns.Add("v4");
        DataRow row = dt.NewRow();

        int col = 0;
        foreach (var val in arr)
        {
            if (col > 3)
            {
                col = 0;
                dt.Rows.Add(row);
                row = dt.NewRow();
                row[col] = val;
            }
            else
            {
                row[col] = val;
                col++;
            }
        }
        dt.Rows.Add(row);