Skip to content
TheChatArchiveThe Chat Archive
o1-mini-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

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

  1. User

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

    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();
        }
    
    }
    

    }

  2. Assistant

    Чтобы столбцы "Дата" и "ФиксированнаяДата" содержали только дату без времени, вы можете изменить их тип данных на string и сохранять отформатированные строки дат. Ниже представлены изменения, которые необходимо внести в ваш код для достижения этой цели.

    1. Изменение типа данных столбцов на string

    В методе CombineMagneteFiles_Click измените тип данных столбцов "Дата" и "ФиксированнаяДата" с DateTime на string.

    // Измените тип данных столбцов с DateTime на string
    combinedMagneteDataTable.Columns.Add("Дата", typeof(string));
    combinedMagneteDataTable.Columns.Add("ФиксированнаяДата", typeof(string));
    

    2. Сохранение отформатированных строк дат

    При присваивании значений этим столбцам используйте форматирование даты, чтобы сохранять только компонент даты без времени.

    Пример изменений:

    // Присваивание фиксированной даты как строки
    newRow["ФиксированнаяДата"] = fixedDate.ToString("dd.MM.yyyy");
    
    // Присваивание вычисленной даты как строки
    newRow["Дата"] = computedDate.ToString("dd.MM.yyyy");
    

    Убедитесь, что все места в методе CombineMagneteFiles_Click, где присваиваются значения этим столбцам, изменены соответствующим образом.

    3. Обновление привязки в DataGrid

    Поскольку столбцы теперь имеют тип string, вам не требуется форматировать их в привязке. Удалите StringFormat из привязок для этих столбцов.

    Пример изменений:

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

    4. Полный обновлённый метод CombineMagneteFiles_Click

    Ниже приведён полный обновлённый метод CombineMagneteFiles_Click с внесёнными изменениями:

    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(string));
        combinedMagneteDataTable.Columns.Add("ФиксированнаяДата", typeof(string));
        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.ToString("dd.MM.yyyy");
    
                // Столбец "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.ToString("dd.MM.yyyy");
                        // 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.ToString("dd.MM.yyyy");
                                computedTimeStr = fixedDate.ToString("HH:mm:ss.f");
                                newRow["ComputedTime"] = computedTimeStr;
                            }
                            else
                            {
                                newRow["Дата"] = computedDate.ToString("dd.MM.yyyy");
    
                                // Формат даты
                                computedDateStr = computedDate.ToString("dd.MM.yyyy");
    
                                // Вычисляем 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.ToString("dd.MM.yyyy");
                            computedDateStr = fixedDate.ToString("dd.MM.yyyy");
                            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.ToString("dd.MM.yyyy");
                    computedDateStr = fixedDate.ToString("dd.MM.yyyy");
                    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("Дата"),
            Width = new DataGridLength(200, DataGridLengthUnitType.Auto)
        });
    
        // Столбец "ФиксированнаяДата"
        dataGridCombined.Columns.Add(new DataGridTextColumn
        {
            Header = "ФиксированнаяДата",
            Binding = new Binding("ФиксированнаяДата"),
            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"),
            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);
        }
    }
    

    5. Дополнительные рекомендации

    А. Альтернативный подход: Использование DateTime с установленным временем на полночь

    Если вы хотите сохранить тип данных DateTime для столбцов "Дата" и "ФиксированнаяДата", но исключить время, вы можете установить время на 00:00:00. Это позволит сохранять даты как DateTime, но без значимого компонента времени.

    Изменения в коде:

    1. Определение столбцов остаётся DateTime:

      combinedMagneteDataTable.Columns.Add("Дата", typeof(DateTime));
      combinedMagneteDataTable.Columns.Add("ФиксированнаяДата", typeof(DateTime));
      
    2. Присваивание значений с обнулением времени:

      newRow["ФиксированнаяДата"] = fixedDate.Date;
      // ...
      newRow["Дата"] = computedDate.Date;
      
    3. Изменение привязок в DataGrid для отображения только даты:

      // Столбец "Дата"
      dataGridCombined.Columns.Add(new DataGridTextColumn
      {
          Header = "Дата",
          Binding = new Binding("Дата") { StringFormat = "dd.MM.yyyy" },
          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)
      });
      

    Этот подход сохраняет тип данных DateTime, что может быть полезно для дальнейших операций с датами, но отображает только компонент даты без времени.

    Б. Проверка и валидация

    Убедитесь, что все места в вашем коде, которые взаимодействуют с этими столбцами, обрабатывают их как строки или DateTime без компонента времени, в зависимости от выбранного подхода. Это предотвратит возможные ошибки при обработке данных.

    Заключение

    Внесение указанных изменений позволит столбцам "Дата" и "ФиксированнаяДата" содержать только дату без времени, отображая их в DataGrid как текстовые строки с форматом даты. Выберите подходящий для вашего приложения метод — использование строк или DateTime с обнулённым временем — в зависимости от ваших дальнейших потребностей в обработке данных.

    Если у вас возникнут дополнительные вопросы или потребуется помощь с другими аспектами вашего приложения, пожалуйста, дайте знать!