Серьезность Код Описание Проект Файл Строка Состояние подавления
Ошибка (активно) CS0103 Имя "computedTimeStr" не существует в текущем контексте. magn C:\Users\bonia\source\repos\magn\MagneteWindow.xaml.cs 209 

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 файлы имеют как минимум 5 столбцов
            dt.Columns.Add("Stan", typeof(string));      // Количество секунд с 06.01.1980
            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; // Stan может содержать дробные числа
                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)); // Изменён тип на string для отображения дробных секунд
            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)
                {
                    if (row.Length < 5)
                    {
                        string error = $"Недостаточно столбцов в строке: {string.Join("\t", row)}";
                        errorMessages.Add(error);
                        LogCalculation($"Ошибка: {error}");
                        continue; // Пропускаем строки с недостаточным количеством столбцов
                    }

                    // Создание новой строки для объединённой таблицы
                    DataRow newRow = combinedMagneteDataTable.NewRow();

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

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

                    // Столбец "Noise"
                    newRow["Noise"] = row[2].Trim();

                    // Столбец "Zeit"
                    newRow["Zeit"] = row[1].Trim();

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

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

                    // Столбец "Time"
                    newRow["Time"] = row[3].Trim();

                    // Столбец "TimeUTC"
                    newRow["TimeUTC"] = row[4].Trim();

                    // Для логирования
                    string computedDateStr = "N/A";
                    string computedUtcDateStr = "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.f");
                            computedUtcDateStr = fixedDate.ToUniversalTime().ToString("dd.MM.yyyy HH:mm:ss.f");
                            newRow["ComputedTime"] = computedTimeStr = fixedDate.ToUniversalTime().ToString("HH:mm:ss.f");
                        }
                        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.f");
                                    computedUtcDateStr = fixedDate.ToUniversalTime().ToString("dd.MM.yyyy HH:mm:ss.f");
                                    newRow["ComputedTime"] = fixedDate.ToUniversalTime().ToString("HH:mm:ss.f");
                                }
                                else
                                {
                                    newRow["Дата"] = computedDate;
                                    // Формат с одной десятичной цифрой
                                    computedDateStr = computedDate.ToString("dd.MM.yyyy HH:mm:ss.f");
                                    computedUtcDateStr = computedDate.ToUniversalTime().ToString("dd.MM.yyyy HH:mm:ss.f");
                                    newRow["ComputedTime"] = computedDate.ToUniversalTime().ToString("HH:mm:ss.f");
                                }
                            }
                            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.f");
                                computedUtcDateStr = fixedDate.ToUniversalTime().ToString("dd.MM.yyyy HH:mm:ss.f");
                                newRow["ComputedTime"] = fixedDate.ToUniversalTime().ToString("HH:mm:ss.f");
                            }
                        }
                    }
                    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.f");
                        computedUtcDateStr = fixedDate.ToUniversalTime().ToString("dd.MM.yyyy HH:mm:ss.f");
                        newRow["ComputedTime"] = fixedDate.ToUniversalTime().ToString("HH:mm:ss.f");
                    }

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

                    // Логируем расчёты для каждой строки
                    string logMessage = $"Stan: '{stanValue}', ComputedDate: {computedDateStr}, ComputedTimeUTC: {computedUtcDateStr}";
                    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.f" }, // С одной десятичной
                Width = new DataGridLength(150, 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 (UTC)"
            dataGridCombined.Columns.Add(new DataGridTextColumn
            {
                Header = "ComputedTime (UTC)",
                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();
        }
    }
}

<Window x:Class="TxtProcessorApp.MagneteWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:local="clr-namespace:TxtProcessorApp"
        Title=".magnete Файлы" Height="700" Width="1000">
    <Grid Margin="10">
        <Grid.RowDefinitions>
            <RowDefinition Height="*"/>
            <!-- Центр для TabControl -->
            <RowDefinition Height="Auto"/>
            <!-- Нижняя панель с кнопками -->
        </Grid.RowDefinitions>

        <!-- TabControl для отображения .magnete файлов -->
        <TabControl x:Name="MagneteTabControl" Grid.Row="0" Margin="0,0,0,10">
            <!-- Вкладки будут добавляться динамически -->
        </TabControl>

        <!-- Кнопки объединения файлов и редактирования -->
        <StackPanel Grid.Row="1" Orientation="Horizontal" HorizontalAlignment="Left">
            <Button Content="Объединить .magnete файлы" Width="200" Height="30" Click="CombineMagneteFiles_Click"/>
            <Button Content="Редактировать и Экспортировать" Width="200" Height="30" Margin="10,0,0,0" Click="EditAndExportMagnete_Click" IsEnabled="False" x:Name="EditExportMagneteButton"/>
        </StackPanel>
    </Grid>
</Window>