нужно чтобы в столбец дата и фиксированная дата записывалась только дата без времени
можешь попробовать сделать значения даты текстовым например

using System;
using System.Collections.Generic;
using System.Data;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Data;

namespace TxtProcessorApp
{
    public partial class MagneteWindow : Window
    {
        private Dictionary<string, List<string[]>> magneteFileData;
        private DataTable combinedMagneteDataTable = null;

        public MagneteWindow(Dictionary<string, List<string[]>> loadedMagneteData)
        {
            InitializeComponent();
            magneteFileData = loadedMagneteData;
            PopulateMagneteTabControl();
        }

        private void PopulateMagneteTabControl()
        {
            MagneteTabControl.Items.Clear();

            foreach (var kvp in magneteFileData)
            {
                string fileName = kvp.Key;
                List<string[]> data = kvp.Value;

                DataGrid dataGrid = CreateDataGrid(data);

                TabItem tabItem = new TabItem
                {
                    Header = fileName,
                    Content = dataGrid
                };

                MagneteTabControl.Items.Add(tabItem);
            }
        }

        private DataGrid CreateDataGrid(List<string[]> data)
        {
            DataGrid dataGrid = new DataGrid
            {
                AutoGenerateColumns = true,
                IsReadOnly = true,
                CanUserAddRows = false,
                CanUserDeleteRows = false,
                Margin = new Thickness(0, 0, 0, 0)
            };

            // Добавление стилей для ячеек и заголовков столбцов
            Style cellStyle = new Style(typeof(DataGridCell));
            cellStyle.Setters.Add(new Setter(DataGridCell.PaddingProperty, new Thickness(5)));
            cellStyle.Setters.Add(new Setter(DataGridCell.HorizontalContentAlignmentProperty, HorizontalAlignment.Center));

            Style headerStyle = new Style(typeof(DataGridColumnHeader));
            headerStyle.Setters.Add(new Setter(DataGridColumnHeader.HorizontalContentAlignmentProperty, HorizontalAlignment.Center));
            headerStyle.Setters.Add(new Setter(DataGridColumnHeader.FontWeightProperty, FontWeights.Bold));

            dataGrid.CellStyle = cellStyle;
            dataGrid.ColumnHeaderStyle = headerStyle;

            DataTable dataTable = ConvertToDataTable(data);
            dataGrid.ItemsSource = dataTable.DefaultView;

            return dataGrid;
        }

        private DataTable ConvertToDataTable(List<string[]> data)
        {
            DataTable dt = new DataTable();

            if (data == null || data.Count == 0)
                return dt;

            // Определение столбцов только для исходных данных .magnete файлов
            dt.Columns.Add("Stan", typeof(string));
            dt.Columns.Add("Zeit", typeof(string));
            dt.Columns.Add("Noise", typeof(string));
            dt.Columns.Add("Time", typeof(string));
            dt.Columns.Add("TimeUTC", typeof(string));

            foreach (var row in data)
            {
                DataRow dr = dt.NewRow();
                dr["Stan"] = row.Length > 0 ? row[0].Trim() : string.Empty;
                dr["Zeit"] = row.Length > 1 ? row[1].Trim() : string.Empty;
                dr["Noise"] = row.Length > 2 ? row[2].Trim() : string.Empty;
                dr["Time"] = row.Length > 3 ? row[3].Trim() : string.Empty;
                dr["TimeUTC"] = row.Length > 4 ? row[4].Trim() : string.Empty;
                dt.Rows.Add(dr);
            }

            return dt;
        }

        // Метод логирования расчётов и ошибок
        private void LogCalculation(string message, string logFileName = "calculation_log.txt")
        {
            string logFilePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, logFileName);
            try
            {
                File.AppendAllText(logFilePath, $"{DateTime.Now}: {message}{Environment.NewLine}");
            }
            catch (Exception ex)
            {
                MessageBox.Show($"Не удалось записать лог: {ex.Message}", "Ошибка логирования", MessageBoxButton.OK, MessageBoxImage.Error);
            }
        }

        // Обработчик кнопки Объединить .magnete файлы
        private void CombineMagneteFiles_Click(object sender, RoutedEventArgs e)
        {
            if (!magneteFileData.Any())
            {
                MessageBox.Show("Нет загруженных .magnete файлов для объединения.", "Информация", MessageBoxButton.OK, MessageBoxImage.Information);
                return;
            }

            // Фиксированная дата (06.01.1980) в UTC
            DateTime fixedDate = new DateTime(1980, 1, 6, 0, 0, 0, DateTimeKind.Utc);

            // Объединяем все данные из .magnete файлов
            combinedMagneteDataTable = new DataTable();

            // Определение столбцов согласно требованиям
            combinedMagneteDataTable.Columns.Add("Дата", typeof(DateTime));
            combinedMagneteDataTable.Columns.Add("ФиксированнаяДата", typeof(DateTime));
            combinedMagneteDataTable.Columns.Add("Stan", typeof(string));
            combinedMagneteDataTable.Columns.Add("ComputedTime", typeof(string)); // Время в формате HH:mm:ss.f
            combinedMagneteDataTable.Columns.Add("Noise", typeof(string));
            combinedMagneteDataTable.Columns.Add("Zeit", typeof(string));
            combinedMagneteDataTable.Columns.Add("Zero1", typeof(int));
            combinedMagneteDataTable.Columns.Add("Zero2", typeof(int));
            combinedMagneteDataTable.Columns.Add("SequentialNumber1", typeof(int));
            combinedMagneteDataTable.Columns.Add("Time", typeof(string));
            combinedMagneteDataTable.Columns.Add("SequentialNumber2", typeof(int));
            combinedMagneteDataTable.Columns.Add("TimeUTC", typeof(string));

            int sequentialNumber = 1;
            List<string> errorMessages = new List<string>();

            foreach (var file in magneteFileData.Values)
            {
                foreach (var row in file)
                {
                    // Создание новой строки для объединённой таблицы
                    DataRow newRow = combinedMagneteDataTable.NewRow();

                    // Столбец "ФиксированнаяДата"
                    newRow["ФиксированнаяДата"] = fixedDate;

                    // Столбец "Stan"
                    string stanValue = row.Length > 0 ? row[0].Trim() : string.Empty;
                    newRow["Stan"] = stanValue;

                    // Столбец "Noise"
                    string noiseValue = row.Length > 2 ? row[2].Trim() : string.Empty;
                    newRow["Noise"] = noiseValue;

                    // Столбец "Zeit"
                    string zeitValue = row.Length > 1 ? row[1].Trim() : string.Empty;
                    newRow["Zeit"] = zeitValue;

                    // Столбцы "Zero1" и "Zero2"
                    newRow["Zero1"] = 0;
                    newRow["Zero2"] = 0;

                    // Столбцы "SequentialNumber1" и "SequentialNumber2"
                    newRow["SequentialNumber1"] = sequentialNumber;
                    newRow["SequentialNumber2"] = sequentialNumber;

                    // Столбец "Time" и "TimeUTC"
                    string timeValue = row.Length > 3 ? row[3].Trim() : string.Empty;
                    newRow["Time"] = timeValue;

                    string timeUtcValue = row.Length > 4 ? row[4].Trim() : string.Empty;
                    newRow["TimeUTC"] = timeUtcValue;

                    // Для логирования
                    string computedDateStr = "N/A";
                    string computedTimeStr = "N/A"; // Объявлено

                    // Обработка столбца "Stan" как секунд с фиксированной даты
                    if (double.TryParse(stanValue, NumberStyles.Any, CultureInfo.InvariantCulture, out double stanSeconds))
                    {
                        if (stanSeconds < 0)
                        {
                            string warning = $"Отрицательное значение Stan='{stanValue}' в строке: {string.Join("\t", row)}. Установка даты как фиксированной.";
                            errorMessages.Add(warning);
                            LogCalculation(warning);

                            newRow["Дата"] = fixedDate;
                            // Формат даты
                            computedDateStr = fixedDate.ToString("dd.MM.yyyy HH:mm:ss.fff");
                            // ComputedTime - фиксированное время минус 18 секунд (оставляет статус 00:00:00.0)
                            computedTimeStr = fixedDate.ToString("HH:mm:ss.f");
                            newRow["ComputedTime"] = computedTimeStr;
                        }
                        else
                        {
                            try
                            {
                                // Добавляем секунды к фиксированной дате
                                DateTime computedDate = fixedDate.AddSeconds(stanSeconds);

                                // Проверка, что дата находится в допустимом диапазоне
                                if (computedDate > DateTime.MaxValue || computedDate < DateTime.MinValue)
                                {
                                    string warning = $"Stan слишком велико='{stanSeconds}' в строке: {string.Join("\t", row)}. Установка даты как фиксированной.";
                                    errorMessages.Add(warning);
                                    LogCalculation(warning);

                                    newRow["Дата"] = fixedDate;
                                    computedDateStr = fixedDate.ToString("dd.MM.yyyy HH:mm:ss.fff");
                                    computedTimeStr = fixedDate.ToString("HH:mm:ss.f");
                                    newRow["ComputedTime"] = computedTimeStr;
                                }
                                else
                                {
                                    newRow["Дата"] = computedDate;

                                    // Формат даты
                                    computedDateStr = computedDate.ToString("dd.MM.yyyy HH:mm:ss.fff");

                                    // Вычисляем ComputedTime как остаток времени после вычитания 18 секунд
                                    TimeSpan timeOfDay = computedDate.TimeOfDay;

                                    // Вычитаем 18 секунд
                                    TimeSpan offsetTime = TimeSpan.FromSeconds(18);
                                    TimeSpan computedTime;

                                    if (timeOfDay >= offsetTime)
                                    {
                                        computedTime = timeOfDay - offsetTime;
                                    }
                                    else
                                    {
                                        // Если время дня меньше 18 секунд, устанавливаем время как 00:00:00.0
                                        computedTime = TimeSpan.Zero;
                                        string info = $"Время дня меньше 18 секунд в строке: {string.Join("\t", row)}. ComputedTime установлено как 00:00:00.0.";
                                        errorMessages.Add(info);
                                        LogCalculation(info);
                                    }

                                    // Округляем каждый TimeSpan.TotalSeconds до одного знака после запятой
                                    double totalSeconds = computedTime.TotalSeconds;
                                    double roundedSeconds = Math.Round(totalSeconds, 1, MidpointRounding.AwayFromZero);

                                    // Создаём TimeSpan из округлённого количества секунд
                                    TimeSpan roundedTime = TimeSpan.FromSeconds(roundedSeconds);

                                    // Форматируем ComputedTime с учетом одной десятичной части секунд
                                    computedTimeStr = roundedTime.ToString(@"hh\:mm\:ss\.f");
                                    newRow["ComputedTime"] = computedTimeStr;
                                }
                            }
                            catch (Exception ex)
                            {
                                string error = $"Ошибка при расчёте даты для Stan='{stanValue}' в строке: {string.Join("\t", row)}. Текст ошибки: {ex.Message}. Установка даты как фиксированной.";
                                errorMessages.Add(error);
                                LogCalculation(error);

                                newRow["Дата"] = fixedDate;
                                computedDateStr = fixedDate.ToString("dd.MM.yyyy HH:mm:ss.fff");
                                computedTimeStr = fixedDate.ToString("HH:mm:ss.f");
                                newRow["ComputedTime"] = computedTimeStr;
                            }
                        }
                    }
                    else
                    {
                        // Если парсинг не удался, устанавливаем фиксированную дату и время, и логируем
                        string error = $"Не удалось распарсить Stan='{stanValue}' в строке: {string.Join("\t", row)}. Установка даты как фиксированной.";
                        errorMessages.Add(error);
                        LogCalculation(error);

                        newRow["Дата"] = fixedDate;
                        computedDateStr = fixedDate.ToString("dd.MM.yyyy HH:mm:ss.fff");
                        computedTimeStr = fixedDate.ToString("HH:mm:ss.f");
                        newRow["ComputedTime"] = computedTimeStr;
                    }

                    combinedMagneteDataTable.Rows.Add(newRow);
                    sequentialNumber++;

                    // Логируем расчёты для каждой строки
                    string logMessage = $"Stan: '{stanValue}', ComputedDate: {computedDateStr}, ComputedTime: {computedTimeStr}";
                    LogCalculation(logMessage);
                }
            }

            // Создаём DataGrid с явно определёнными столбцами
            DataGrid dataGridCombined = new DataGrid
            {
                AutoGenerateColumns = false,
                IsReadOnly = true,
                CanUserAddRows = false,
                CanUserDeleteRows = false,
            };

            // Определяем столбцы вручную с необходимым форматированием
            // Столбец "Дата"
            dataGridCombined.Columns.Add(new DataGridTextColumn
            {
                Header = "Дата",
                Binding = new Binding("Дата") { StringFormat = "dd.MM.yyyy HH:mm:ss.fff" },
                Width = new DataGridLength(200, DataGridLengthUnitType.Auto)
            });

            // Столбец "ФиксированнаяДата"
            dataGridCombined.Columns.Add(new DataGridTextColumn
            {
                Header = "ФиксированнаяДата",
                Binding = new Binding("ФиксированнаяДата") { StringFormat = "dd.MM.yyyy" },
                Width = new DataGridLength(150, DataGridLengthUnitType.Auto)
            });

            // Столбец "Stan"
            dataGridCombined.Columns.Add(new DataGridTextColumn
            {
                Header = "Stan",
                Binding = new Binding("Stan"),
                Width = new DataGridLength(100, DataGridLengthUnitType.Auto)
            });

            // Столбец "ComputedTime"
            dataGridCombined.Columns.Add(new DataGridTextColumn
            {
                Header = "ComputedTime",
                Binding = new Binding("ComputedTime") { StringFormat = "HH:mm:ss.f" }, // Одна десятичная
                Width = new DataGridLength(150, DataGridLengthUnitType.Auto)
            });

            // Столбец "Noise"
            dataGridCombined.Columns.Add(new DataGridTextColumn
            {
                Header = "Noise",
                Binding = new Binding("Noise"),
                Width = new DataGridLength(100, DataGridLengthUnitType.Auto)
            });

            // Столбец "Zeit"
            dataGridCombined.Columns.Add(new DataGridTextColumn
            {
                Header = "Zeit",
                Binding = new Binding("Zeit"),
                Width = new DataGridLength(100, DataGridLengthUnitType.Auto)
            });

            // Скрытые столбцы "Zero1"
            dataGridCombined.Columns.Add(new DataGridTextColumn
            {
                Header = "Zero1",
                Binding = new Binding("Zero1"),
                Width = new DataGridLength(60, DataGridLengthUnitType.Auto),
                Visibility = Visibility.Collapsed
            });

            // Скрытые столбцы "Zero2"
            dataGridCombined.Columns.Add(new DataGridTextColumn
            {
                Header = "Zero2",
                Binding = new Binding("Zero2"),
                Width = new DataGridLength(60, DataGridLengthUnitType.Auto),
                Visibility = Visibility.Collapsed
            });

            // Скрытые столбцы "SequentialNumber1"
            dataGridCombined.Columns.Add(new DataGridTextColumn
            {
                Header = "SeqNum1",
                Binding = new Binding("SequentialNumber1"),
                Width = new DataGridLength(80, DataGridLengthUnitType.Auto),
                Visibility = Visibility.Collapsed
            });

            // Столбец "Time"
            dataGridCombined.Columns.Add(new DataGridTextColumn
            {
                Header = "Time",
                Binding = new Binding("Time"),
                Width = new DataGridLength(100, DataGridLengthUnitType.Auto)
            });

            // Скрытые столбцы "SequentialNumber2"
            dataGridCombined.Columns.Add(new DataGridTextColumn
            {
                Header = "SeqNum2",
                Binding = new Binding("SequentialNumber2"),
                Width = new DataGridLength(80, DataGridLengthUnitType.Auto),
                Visibility = Visibility.Collapsed
            });

            // Столбец "TimeUTC"
            dataGridCombined.Columns.Add(new DataGridTextColumn
            {
                Header = "TimeUTC",
                Binding = new Binding("TimeUTC"),
                Width = new DataGridLength(100, DataGridLengthUnitType.Auto)
            });

            // Присваиваем DataTable как источник данных
            dataGridCombined.ItemsSource = combinedMagneteDataTable.DefaultView;

            // Добавляем вкладку с объединёнными данными
            TabItem tabItemCombined = new TabItem
            {
                Header = "Объединённые данные",
                Content = dataGridCombined
            };

            MagneteTabControl.Items.Add(tabItemCombined);

            // Активируем кнопку редактирования и экспорта
            EditExportMagneteButton.IsEnabled = true;

            // Логируем основные события
            LogCalculation($"Файлы .magnete успешно объединены. Объединено строк: {combinedMagneteDataTable.Rows.Count}.");

            if (errorMessages.Any())
            {
                string allErrors = string.Join("\n", errorMessages);
                LogCalculation($"Обнаружены следующие проблемы:\n{allErrors}");
                MessageBox.Show($"Файлы .magnete объединены с ошибками. Подробности в файле логов.", "Внимание", MessageBoxButton.OK, MessageBoxImage.Warning);
            }
            else
            {
                MessageBox.Show($"Файлы .magnete успешно объединены. Объединено строк: {combinedMagneteDataTable.Rows.Count}", "Успех", MessageBoxButton.OK, MessageBoxImage.Information);
            }
        }

        private void EditAndExportMagnete_Click(object sender, RoutedEventArgs e)
        {
            if (combinedMagneteDataTable == null)
            {
                MessageBox.Show("Нет объединённых данных для редактирования.", "Информация", MessageBoxButton.OK, MessageBoxImage.Information);
                return;
            }

            // Создаём и открываем окно редактирования
            EditWindow editWindow = new EditWindow(combinedMagneteDataTable);
            editWindow.Owner = this;
            editWindow.ShowDialog();
        }

    }
}