Скопируйте результаты запроса LINQ в существующую таблицу данных с более высокой производительностью

Вы можете использовать оператор ToLookup LINQ и создать эффективную структуру Lookup<DateTime, DataRow> из содержимого файла Table_2. Эта структура только для чтения будет содержать один IGrouping<DateTime, DataRow> для каждой уникальной даты, и каждая группа будет содержать все DataRow, связанные с этой датой:

var lookup = Table_2.AsEnumerable().ToLookup(r => r.Field<DateTime>("Date"));

Тогда для каждой строки Table_1 вы сможете быстро найти все связанные строки Table_2:

foreach (DataRow row1 in Table_1.Rows)
{
    DateTime date = row1.Field<DateTime>("Date");
    IEnumerable<DataRow> group = lookup[date];
    if (group == null) continue;
    foreach (DataRow row2 in group)
    {
        int id = row2.Field<int>("ID");
        row1[$"A_{id}"] = row2.Field<double>("A");
        row1[$"B_{id}"] = row2.Field<double>("B");
        row1[$"C_{id}"] = row2.Field<double>("C");
    }
}

Обновлять: Похоже, ваша проблема с производительностью связана не с объединением двух DataTable, а с обновлением чрезвычайно широкого DataTable, содержащего сотни или даже тысячи DataColumn. Очевидно, DataTable не оптимизированы для таких сценариев. Сложность обновления любого столбца DataRow составляет O (n²), где N — общее количество столбцов. Чтобы решить эту проблему, вы можете экспортировать все значения, хранящиеся в DataRow, через свойство ItemArray, манипулировать этими значениями и, наконец, импортировать их обратно через то же свойство. Производительность можно улучшить еще больше, используя методы BeginLoadData и EndLoadData.

Table_1.BeginLoadData();
foreach (DataRow row1 in Table_1.Rows)
{
    DateTime date = row1.Field<DateTime>("Date");
    IEnumerable<DataRow> group = lookup[date];
    if (group == null) continue;
    object[] values = row1.ItemArray; // Export the raw data
    foreach (DataRow row2 in group)
    {
        int id = row2.Field<int>("ID");
        values[Table_1.Columns[$"A_{id}"].Ordinal] = row2.Field<double>("A");
        values[Table_1.Columns[$"B_{id}"].Ordinal] = row2.Field<double>("B");
        values[Table_1.Columns[$"C_{id}"].Ordinal] = row2.Field<double>("C");
    }
    row1.ItemArray = values; // Import the updated data
}
Table_1.EndLoadData();

Я рекомендую использовать другой подход. DataTable не особенно быстрый объект, и поиск столбцов для установки значений происходит медленно. Создание нового DataTable для замены Table_1 может быть намного быстрее, поскольку вы можете использовать метод DataRowCollection.Add() для быстрого добавления строк.

Использование Dictionary для преобразования Table_2 также обеспечивает гораздо более быстрый поиск, чем ElementAt.

var joinDict = (from T2 in Table_2.AsEnumerable()
                select new {
                    Date = T2.Field<string>("Date"),
                    ID = T2.Field<int>("ID"),
                    A = T2.Field<double>("A"),
                    B = T2.Field<double>("B"),
                    C = T2.Field<double>("C"),
                })
                .ToDictionary(t2 => (t2.Date, t2.ID));

List<int> ids = Table_2.AsEnumerable().Select(s => s.Field<int>("ID")).Distinct().OrderBy(x => x).ToList();

var ans = Table_1.Clone();
for (int i = 0; i < ids.Count; i++) {
    ans.Columns.Add($"A_{ids[i]}", typeof(double));
    ans.Columns.Add($"B_{ids[i]}", typeof(double));
    ans.Columns.Add($"C_{ids[i]}", typeof(double));
}

foreach (DataRow row in Table_1.Rows) {
    var newRow = new List<object> { row.Field<string>("Date") };
    foreach (var id in ids) {
        if (joinDict.TryGetValue((row.Field<string>("Date"), id), out var t2))
            newRow.AddRange(new object[] { t2.A, t2.B, t2.C });
        else
            newRow.AddRange(new object[] { 0.0, 0.0, 0.0 });
    }
    ans.Rows.Add(newRow.ToArray());
}
Table_1 = ans;

При тестировании со 100 днями в Table_1 и 500 строками в день в Table_2 75% населения я получаю ускорение примерно в 128 раз.