Rearranging a datatable

I'm importing an excel file into a datatable (dtImport) and rearranging that data into another datatable (dtImportParsed).
<br><br>Here's what that datatable (dtImport) looks like when I first import it.<br>

And this is how I'm trying to rearrange that datatable (dtImportParsed):<br>

<br><br>
I'm currently accomplishing this by using some nested for loops, but this takes a very long time. For example, a sheet with 36 columns and 4,000 rows takes about 30-40 minutes to complete. Is there an alternative method of accomplishing this that would speed things up?<br><br>
Here's my code:<br>

for (int c = 2; c < dtImport.Columns.Count; c++) //for each date column
            {
                for (int r = 1; r < dtImport.Rows.Count; r++)
                {
                    if (dtImportParsed.Rows.Count == 0)
                    {
                        DataRow dataRowImport = dtImportParsed.NewRow();
                        dataRowImport["Date"] = dtImport.Columns[c].ColumnName.ToString().Trim();
                        dataRowImport["account_id"] = dtImport.Rows[r]["account_id"].ToString().Trim();
                        dataRowImport[dtImport.Rows[r]["Event Name"].ToString().Trim()] = dtImport.Rows[r][c].ToString().Trim();
                        dtImportParsed.Rows.Add(dataRowImport);
                    }
                    else
                    {
                        for (int i = 0; i < dtImportParsed.Rows.Count; i++)
                        {
                            if (dtImportParsed.Rows[i]["account_id"].ToString() == dtImport.Rows[r]["account_id"].ToString())
                            {
                                if (dtImportParsed.Rows[i]["Date"].ToString() == dtImport.Columns[c].ColumnName.ToString())
                                {
                                    dtImportParsed.Rows[i][dtImport.Rows[r]["Event Name"].ToString().Trim()] = dtImport.Rows[r][c].ToString().Trim();
                                    break;
                                }
                            }
                            else if (i == dtImportParsed.Rows.Count - 1)
                            {
                                DataRow dataRowImport = dtImportParsed.NewRow();
                                dataRowImport["Date"] = dtImport.Columns[c].ColumnName.ToString().Trim();
                                dataRowImport["account_id"] = dtImport.Rows[r]["account_id"].ToString().Trim();
                                dataRowImport[dtImport.Rows[r]["Event Name"].ToString().Trim()] = dtImport.Rows[r][c].ToString().Trim();
                                dtImportParsed.Rows.Add(dataRowImport);
                            }
                        }
                    }

                }
            }

The algorithm you use to generate your expected result is too expensive! It will execute in order (c x r x i) where i > r because empty fields are injected in the final table; Actually it is an O(n³) algorithm! Also you preform it on DataTables via iterating DataRows that probably are not efficient for your requirement.

If your source data-set is not large (as you mentioned) and you have not memory restriction, I propose you to arrange expected data-set in memory using index-based data structures. Something like this:

var arrangeDragon = new Dictionary<string, Dictionary<string, Dictionary<string, string>>>();

The dragon enters! And eats the inner for.

for (int c = 2; c < dtImport.Columns.Count; c++) //for each date column
{
    for (int r = 1; r < dtImport.Rows.Count; r++)
    {
        // ...

        // instead of:     for (int i = 0; i < dtImportParsed.Rows.Count; i++) ...
        string date = dtImport.Columns[c].ColumnName.ToString().Trim();
        string accountId = dtImport.Rows[r]["account_id"].ToString();
        string eventName = dtImport.Rows [r]["Event Name"].ToString().Trim();

        if (!arrangeDragon.ContainsKey(date))
            arrangeDragon.Add(date, new Dictionary<string, Dictionary<string, string>>());

        if (!arrangeDragon[date].ContainsKey(accountId))
            arrangeDragon[date][accountId] = new Dictionary<string, string>();

        if (!arrangeDragon[date][accountId].ContainsKey(eventName))
            arrangeDragon[date][accountId][eventName] = dtImport.Rows[r][c].ToString().Trim();

        // ...
    }
}

These checks will execute in O(1) instead of O(i), so total overhead will decrease to O(n²) that is the nature of iterating table

Also retrieve order is O(1):

string data_field = arrangeDragon["1/1/2022"]["account1"]["Event1"];
Assert.AreEqual(data_field, "42");

Now you can iterate nested Dictionarys once and build the dtImportParsed.

If your data-set is large or host memory is low, you need other solutions that is not your problem as mentioned

Good luck