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

ошибка появляется после того как была нажата кнопка сформировать файл, такое только у…

  1. User

    ошибка появляется после того как была нажата кнопка сформировать файл, такое только у magnete файла, после нажатия кнопки он не отображается в таблице в mainwindow, и если начать крутить колесиком в таблице то вылезает эта ошибка

    System.InvalidOperationException HResult=0x80131509 Сообщение = Объект ItemsControl не соответствует своему источнику элементов.\n Дополнительные сведения см. в описании внутреннего исключения. Источник = PresentationFramework Трассировка стека: в System.Windows.Controls.ItemContainerGenerator.Verify() в System.Windows.Controls\ItemContainerGenerator.cs:строка 1518 в System.Windows.Controls.VirtualizingStackPanel.MeasureChild(IItemContainerGenerator& generator, IContainItemStorage& itemStorageProvider, IContainItemStorage& parentItemStorageProvider, Object& parentItem, Boolean& hasUniformOrAverageContainerSizeBeenSet, Double& computedUniformOrAverageContainerSize, Double& computedUniformOrAverageContainerPixelSize, Boolean& computedAreContainersUniformlySized, Boolean& hasAnyContainerSpanChanged, IList& items, Object& item, IList& children, Int32& childIndex, Boolean& visualOrderChanged, Boolean& isHorizontal, Size& childConstraint, Rect& viewport, VirtualizationCacheLength& cacheSize, VirtualizationCacheLengthUnit& cacheUnit, Int64& scrollGeneration, Boolean& foundFirstItemInViewport, Double& firstItemInViewportOffset, Size& stackPixelSize, Size& stackPixelSizeInViewport, Size& stackPixelSizeInCacheBeforeViewport, Size& stackPixelSizeInCacheAfterViewport, Size& stackLogicalSize, Size& stackLogicalSizeInViewport, Size& stackLogicalSizeInCacheBeforeViewport, Size& stackLogicalSizeInCacheAfterViewport, Boolean& mustDisableVirtualization, Boolean isBeforeFirstItem, Boolean isAfterFirstItem, Boolean isAfterLastItem, Boolean skipActualMeasure, Boolean skipGeneration, Boolean& hasBringIntoViewContainerBeenMeasured, Boolean& hasVirtualizingChildren) в System.Windows.Controls\VirtualizingStackPanel.cs:строка 6182 в System.Windows.Controls.VirtualizingStackPanel.MeasureOverrideImpl(Size constraint, Nullable1& lastPageSafeOffset, List1& previouslyMeasuredOffsets, Nullable`1& lastPagePixelSize, Boolean remeasure) в System.Windows.Controls\VirtualizingStackPanel.cs:строка 3037 в System.Windows.Controls.VirtualizingStackPanel.MeasureOverride(Size constraint) в System.Windows.Controls\VirtualizingStackPanel.cs:строка 2861 в System.Windows.FrameworkElement.MeasureCore(Size availableSize) в System.Windows\FrameworkElement.cs:строка 4124 в System.Windows.UIElement.Measure(Size availableSize) в System.Windows.ContextLayoutManager.UpdateLayout() в System.Windows.Controls.VirtualizingStackPanel.<>c__DisplayClass94_0.b__0() в System.Windows.Controls\VirtualizingStackPanel.cs:строка 4005 в System.Windows.Threading.ExceptionWrapper.InternalRealCall(Delegate callback, Object args, Int32 numArgs) в System.Windows.Threading.ExceptionWrapper.TryCatchWhen(Object source, Delegate callback, Object args, Int32 numArgs, Delegate catchHandler) в System.Windows.Threading.DispatcherOperation.InvokeImpl() в MS.Internal.CulturePreservingExecutionContext.CallbackWrapper(Object obj) в System.Threading.ExecutionContext.RunInternal(ExecutionContext executionContext, ContextCallback callback, Object state) --- Конец трассировки стека из предыдущего расположения --- в System.Threading.ExecutionContext.RunInternal(ExecutionContext executionContext, ContextCallback callback, Object state) в MS.Internal.CulturePreservingExecutionContext.Run(CulturePreservingExecutionContext executionContext, ContextCallback callback, Object state) в System.Windows.Threading.DispatcherOperation.Invoke() в System.Windows.Threading.Dispatcher.ProcessQueue() в System.Windows.Threading.Dispatcher.WndProcHook(IntPtr hwnd, Int32 msg, IntPtr wParam, IntPtr lParam, Boolean& handled) в MS.Win32.HwndWrapper.WndProc(IntPtr hwnd, Int32 msg, IntPtr wParam, IntPtr lParam, Boolean& handled) в System.Windows.Threading.ExceptionWrapper.InternalRealCall(Delegate callback, Object args, Int32 numArgs) в System.Windows.Threading.ExceptionWrapper.TryCatchWhen(Object source, Delegate callback, Object args, Int32 numArgs, Delegate catchHandler) в System.Windows.Threading.Dispatcher.LegacyInvokeImpl(DispatcherPriority priority, TimeSpan timeout, Delegate method, Object args, Int32 numArgs) в MS.Win32.HwndSubclass.SubclassWndProc(IntPtr hwnd, Int32 msg, IntPtr wParam, IntPtr lParam) в MS.Win32.UnsafeNativeMethods.DispatchMessage(MSG& msg) в System.Windows.Threading.Dispatcher.PushFrameImpl(DispatcherFrame frame) в System.Windows.Application.RunDispatcher(Object ignore) в System.Windows\Application.cs:строка 1780 в System.Windows.Application.RunInternal(Window window) в System.Windows\Application.cs:строка 1455 в magn.App.Main()

    Внутреннее исключение 1: Exception: Информация для разработчиков (для чтения используйте средство визуализации текста): Это исключение возникло, так как генератор для элемента управления "System.Windows.Controls.DataGrid Items.Count:0" с именем "CombinedMagneteDataGrid" получил последовательность событий CollectionChanged, которые не согласуются с текущим состоянием коллекции Items. Обнаружены следующие отличия: Накопленное количество 0 отличается от фактического количества 872. [Накопленное количество вычисляется по формуле (число при последнем сбросе + количество добавлений – количество удалений после последнего сброса).]

    Один или несколько следующих источников могли создать неверные события: System.Windows.Controls.ItemContainerGenerator System.Windows.Controls.ItemCollection System.Windows.Data.BindingListCollectionView

    • System.Data.DataView
      

    (Источники, которые считаются наиболее вероятной причиной проблемы, помечены звездочкой.)

    Наиболее распространенные причины: (а) изменение коллекции или ее свойства Count без создания соответствующего события и (б) создание события с неверным параметром индекса или элемента.

    В трассировке стека исключения описан процесс обнаружения несоответствий, а не процесс их возникновения. Для своевременного получения исключения задайте значение"High" для присоединенного свойства "PresentationTraceSources.TraceLevel" генератора и перезапустите сценарий. Один из способов решения этой задачи состоит в выполнении команды, аналогичной следующей\n System.Diagnostics.PresentationTraceSources.SetTraceLevel(myItemsControl.ItemContainerGenerator, System.Diagnostics.PresentationTraceLevel.High) из окна интерпретации. Это приведет к запуску логики обнаружения после каждого события CollectionChanged, что замедлит работу приложения.

        <!-- Верхнее меню -->
        <Menu DockPanel.Dock="Top">
            <!-- Пункт меню "Проект" -->
            <MenuItem Header="_Проект">
                <MenuItem Header="_Сохранить проект" Click="SaveProject_Click" />
                <MenuItem Header="_Загрузить проект" Click="LoadProject_Click" />
            </MenuItem>
        </Menu>
    
        <!-- Верхняя панель инструментов (ToolBar) -->
        <ToolBar DockPanel.Dock="Top" Margin="0,30,0,0" Height="30">
            <!-- Добавлено отступ сверху, чтобы меню не перекрывало ToolBar -->
            <Button Content="Загрузить .txt файлы" Width="150" Click="LoadFiles_Click" Tag="txt" />
            <Button Content="Загрузить .magnete файлы" Width="180" Click="LoadFiles_Click" Tag="magnete" Margin="10,0,0,0"/>
            <!-- Удалена кнопка "Проект" из ToolBar -->
            <Button Content="Сформировать файл" Width="150" Click="CombineFiles_Click" Margin="10,0,0,0"/>
            <Button Content="Редактировать и Экспортировать" Width="220" Click="EditAndExport_Click" IsEnabled="False" x:Name="EditExportButton" Margin="10,0,0,0"/>
            <Button Content="Графики" Width="100" Click="ShowGraphs_Click" Margin="10,0,0,0"/>
        </ToolBar>
    
        <!-- Строка состояния -->
        <StatusBar DockPanel.Dock="Bottom">
            <StatusBarItem>
                <TextBlock x:Name="StatusTextBlock" Text="Готово"/>
            </StatusBarItem>
        </StatusBar>
    
        <!-- Основная область с данными -->
        <Grid>
            <Grid.RowDefinitions>
                <RowDefinition Height="3*"/>
                <RowDefinition Height="2*"/>
            </Grid.RowDefinitions>
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="*"/>
                <ColumnDefinition Width="5"/>
                <ColumnDefinition Width="*"/>
            </Grid.ColumnDefinitions>
    
            <!-- Левая область для файлов -->
            <GroupBox Header=".txt Файлы" Grid.Row="0" Grid.Column="0" Margin="0,10,5,10">
                <TabControl x:Name="FilesTabControl"/>
            </GroupBox>
    
            <!-- Разделитель -->
            <GridSplitter Grid.Row="0" Grid.Column="1" Width="5" HorizontalAlignment="Stretch" Background="Gray"/>
    
            <!-- Правая область для файлов -->
            <GroupBox Header=".magnete Файлы" Grid.Row="0" Grid.Column="2" Margin="5,10,0,10">
                <TabControl x:Name="MagneteFilesTabControl"/>
            </GroupBox>
    
            <!-- Нижняя область для объединённых данных -->
            <Grid Grid.Row="1" Grid.Column="0" Grid.ColumnSpan="3">
                <Grid.RowDefinitions>
                    <RowDefinition Height="*"/>
                    <RowDefinition Height="5"/>
                    <RowDefinition Height="*"/>
                </Grid.RowDefinitions>
                <Grid.ColumnDefinitions>
                    <ColumnDefinition Width="*"/>
                    <ColumnDefinition Width="5"/>
                    <ColumnDefinition Width="*"/>
                </Grid.ColumnDefinitions>
    
                <!-- Объединённые .txt данные -->
                <GroupBox Header="Объединённые .txt Файлы" Grid.Row="0" Grid.Column="0" Margin="0,10,5,10" Grid.RowSpan="3">
                    <DataGrid x:Name="CombinedTxtDataGrid" 
                              AutoGenerateColumns="True" 
                              IsReadOnly="True" 
                              ItemsSource="{Binding CombinedTxtDataTable.DefaultView}" 
                              FontFamily="Consolas" 
                              FontSize="12" 
                              Margin="5"/>
                </GroupBox>
    
                <!-- Разделитель -->
                <GridSplitter Grid.Row="0" Grid.Column="1" Width="5" HorizontalAlignment="Stretch" Background="Gray"/>
    
                <!-- Объединённые .magnete данные -->
                <GroupBox Header="Объединённые .magnete Файлы" Grid.Row="0" Grid.Column="2" Margin="5,10,0,10" Grid.RowSpan="3">
                    <DataGrid x:Name="CombinedMagneteDataGrid" 
                              AutoGenerateColumns="True" 
                              IsReadOnly="True" 
                              ItemsSource="{Binding CombinedMagneteDataTable.DefaultView}" 
                              FontFamily="Consolas" 
                              FontSize="12" 
                              Margin="5"/>
                </GroupBox>
            </Grid>
        </Grid>
    </DockPanel>
    

    // MainWindow.xaml.cs using Microsoft.Win32; using Newtonsoft.Json; using ProjNet.CoordinateSystems; using ProjNet.CoordinateSystems.Transformations; using System; using System.Collections.Generic; using System.ComponentModel; // For INotifyPropertyChanged using System.Data; using System.Globalization; using System.IO; using System.Linq; using System.Threading.Tasks; using System.Windows; using System.Windows.Controls;

    namespace TxtProcessorApp { /// /// Класс MainWindow.xaml.cs для приложения TxtProcessorApp /// public partial class MainWindow : Window, INotifyPropertyChanged { // Реализация интерфейса INotifyPropertyChanged public event PropertyChangedEventHandler PropertyChanged;

        protected void OnPropertyChanged(string name)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));
        }
    
        // Словари для хранения данных из файлов
        private Dictionary<string, List<string[]>> txtFileData = new Dictionary<string, List<string[]>>();
        private Dictionary<string, List<string[]>> magneteFileData = new Dictionary<string, List<string[]>>();
    
        // Поля для объединенных DataTable
        private DataTable combinedTxtDataTable = new DataTable();
        private DataTable combinedMagneteDataTable = new DataTable();
    
        // Свойства для привязки
        public DataTable CombinedTxtDataTable
        {
            get => combinedTxtDataTable;
            set
            {
                combinedTxtDataTable = value;
                OnPropertyChanged(nameof(CombinedTxtDataTable));
            }
        }
    
        public DataTable CombinedMagneteDataTable
        {
            get => combinedMagneteDataTable;
            set
            {
                combinedMagneteDataTable = value;
                OnPropertyChanged(nameof(CombinedMagneteDataTable));
            }
        }
    
        /// <summary>
        /// Конструктор MainWindow
        /// </summary>
        public MainWindow()
        {
            InitializeComponent();
            this.DataContext = this; // Установка контекста данных
    
            // Инициализация столбцов для объединенных .txt данных
            InitializeCombinedTxtDataTable();
    
            // Инициализация столбцов для объединенных .magnete данных
            InitializeCombinedMagneteDataTable();
        }
    
        /// <summary>
        /// Инициализирует столбцы для объединенных .txt данных
        /// </summary>
        private void InitializeCombinedTxtDataTable()
        {
            CombinedTxtDataTable.Columns.Add("№", typeof(int));
            CombinedTxtDataTable.Columns.Add("BASE-1", typeof(string));
            CombinedTxtDataTable.Columns.Add("Noise", typeof(string));
            CombinedTxtDataTable.Columns.Add("Time", typeof(string));
            CombinedTxtDataTable.Columns.Add("Time UTC", typeof(string));
        }
    
        /// <summary>
        /// Инициализирует столбцы для объединенных .magnete данных
        /// </summary>
        private void InitializeCombinedMagneteDataTable()
        {
            CombinedMagneteDataTable.Columns.Add("DATA", typeof(string));
            CombinedMagneteDataTable.Columns.Add("DATA UTC", typeof(string));
            CombinedMagneteDataTable.Columns.Add("TIME", typeof(string));
            CombinedMagneteDataTable.Columns.Add("TIME UTC", typeof(string));
            CombinedMagneteDataTable.Columns.Add("Долгота WGS", typeof(string));
            CombinedMagneteDataTable.Columns.Add("Широта WGS", typeof(string));
            CombinedMagneteDataTable.Columns.Add("Долгота UTM", typeof(double));
            CombinedMagneteDataTable.Columns.Add("Широта UTM", typeof(double));
            CombinedMagneteDataTable.Columns.Add("№1", typeof(int));
            CombinedMagneteDataTable.Columns.Add("Альтитуда", typeof(string));
            CombinedMagneteDataTable.Columns.Add("№2", typeof(int));
            CombinedMagneteDataTable.Columns.Add("Shark", typeof(string));
        }
    
        #region Обработчики Загрузки Файлов
    
        /// <summary>
        /// Обработчик для загрузки .txt файлов через меню
        /// </summary>
        private async void LoadFiles_Click(object sender, RoutedEventArgs e)
        {
            if (sender is Button button && button.Tag is string fileType)
            {
                await LoadFilesAsync(fileType);
            }
        }
    
        /// <summary>
        /// Универсальный метод для загрузки файлов
        /// </summary>
        /// <param name="fileType">Тип файла: "txt" или "magnete"</param>
        private async Task LoadFilesAsync(string fileType)
        {
            string filter = fileType == "txt" ? "Текстовые файлы (*.txt)|*.txt" : "Magnete файлы (*.magnete)|*.magnete";
            OpenFileDialog ofd = new OpenFileDialog
            {
                Multiselect = true,
                Filter = filter
            };
    
            if (ofd.ShowDialog() == true)
            {
                foreach (var file in ofd.FileNames)
                {
                    await ProcessFileAsync(file, fileType);
                }
    
                // Обновление соответствующего TabControl
                if (fileType == "txt")
                {
                    PopulateTabControl(FilesTabControl, txtFileData, CreateTxtDataGrid);
                    CombinedTxtDataTable.Clear(); // Сброс объединенных данных
                }
                else
                {
                    PopulateTabControl(MagneteFilesTabControl, magneteFileData, CreateMagneteDataGrid);
                    CombinedMagneteDataTable.Clear(); // Сброс объединенных данных
                }
    
                // Обновление состояния кнопки "Редактировать и Экспортировать"
                EditExportButton.IsEnabled = false;
    
                // Обновление строки состояния
                StatusTextBlock.Text = $"Загружено {(fileType == "txt" ? txtFileData.Count : magneteFileData.Count)} {(fileType == "txt" ? ".txt" : ".magnete")} файлов.";
            }
        }
    
        /// <summary>
        /// Асинхронный метод для обработки загруженного файла
        /// </summary>
        private Task ProcessFileAsync(string filePath, string fileType)
        {
            return Task.Run(() =>
            {
                List<string[]> processedLines = new List<string[]>();
    
                try
                {
                    var lines = File.ReadAllLines(filePath);
                    if (fileType == "txt")
                    {
                        lines = lines.Skip(11).ToArray(); // Пропустить первые 11 строк
                    }
    
                    foreach (var line in lines)
                    {
                        if (string.IsNullOrWhiteSpace(line))
                            continue;
    
                        var columns = line.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
    
                        if (columns.Length == 0)
                            continue;
    
                        // Проверка первого столбца
                        if (columns[0].ToLower() == "nan" || string.IsNullOrWhiteSpace(columns[0]))
                            continue;
    
                        // Добавить столбцы в зависимости от типа файла
                        if (fileType == "txt")
                        {
                            // Для .txt пропустить первый столбец
                            processedLines.Add(columns.Skip(1).ToArray());
                        }
                        else
                        {
                            // Для .magnete добавить все столбцы
                            processedLines.Add(columns);
                        }
                    }
    
                    // Добавить обработанные данные в словарь
                    string fileName = Path.GetFileName(filePath);
                    string uniqueFileName = GetUniqueFileName(fileName, fileType == "txt" ? txtFileData : magneteFileData);
                    if (fileType == "txt")
                    {
                        lock (txtFileData)
                        {
                            txtFileData[uniqueFileName] = processedLines;
                        }
                    }
                    else
                    {
                        lock (magneteFileData)
                        {
                            magneteFileData[uniqueFileName] = processedLines;
                        }
                    }
                }
                catch (Exception ex)
                {
                    Dispatcher.Invoke(() =>
                        MessageBox.Show($"Ошибка при обработке файла {filePath}:\n{ex.Message}", "Ошибка", MessageBoxButton.OK, MessageBoxImage.Error));
                }
            });
        }
    
        /// <summary>
        /// Генерация уникального имени файла
        /// </summary>
        private string GetUniqueFileName(string fileName, Dictionary<string, List<string[]>> existingData)
        {
            string originalFileName = fileName;
            int duplicateCount = 1;
            while (existingData.ContainsKey(fileName))
            {
                fileName = $"{Path.GetFileNameWithoutExtension(originalFileName)}_{duplicateCount}{Path.GetExtension(originalFileName)}";
                duplicateCount++;
            }
            return fileName;
        }
    
        /// <summary>
        /// Метод для заполнения TabControl данными файлов
        /// </summary>
        private void PopulateTabControl(TabControl tabControl, Dictionary<string, List<string[]>> fileData, Func<List<string[]>, DataGrid> createGrid)
        {
            Dispatcher.Invoke(() =>
            {
                tabControl.Items.Clear();
                foreach (var kvp in fileData)
                {
                    TabItem tabItem = new TabItem
                    {
                        Header = kvp.Key,
                        Content = createGrid(kvp.Value)
                    };
                    tabControl.Items.Add(tabItem);
                }
            });
        }
    
        /// <summary>
        /// Создание DataGrid для .txt файлов
        /// </summary>
        private DataGrid CreateTxtDataGrid(List<string[]> data)
        {
            DataGrid dataGrid = new DataGrid
            {
                AutoGenerateColumns = true,
                ItemsSource = ConvertToDataTable(data, isTxt: true).DefaultView,
                IsReadOnly = true,
                FontFamily = new System.Windows.Media.FontFamily("Consolas"),
                FontSize = 12,
                Margin = new Thickness(5)
            };
            return dataGrid;
        }
    
        /// <summary>
        /// Создание DataGrid для .magnete файлов
        /// </summary>
        private DataGrid CreateMagneteDataGrid(List<string[]> data)
        {
            DataGrid dataGrid = new DataGrid
            {
                AutoGenerateColumns = true,
                ItemsSource = ConvertToDataTable(data, isTxt: false).DefaultView,
                IsReadOnly = true,
                FontFamily = new System.Windows.Media.FontFamily("Consolas"),
                FontSize = 12,
                Margin = new Thickness(5)
            };
            return dataGrid;
        }
    
        /// <summary>
        /// Универсальный метод для преобразования данных в DataTable
        /// </summary>
        private DataTable ConvertToDataTable(List<string[]> data, bool isTxt)
        {
            DataTable dt = new DataTable();
            if (data == null || data.Count == 0)
                return dt;
    
            if (isTxt)
            {
                dt.Columns.Add("№", typeof(int));
                dt.Columns.Add("BASE-1", typeof(string));
                dt.Columns.Add("Noise", typeof(string));
                dt.Columns.Add("Time", typeof(string));
                dt.Columns.Add("Time UTC", typeof(string));
            }
            else
            {
                // Определение столбцов для .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();
                if (isTxt)
                {
                    dr["№"] = int.TryParse(row[0], out int number) ? number : 0;
                    dr["BASE-1"] = row.Length > 1 ? row[1] : string.Empty;
                    dr["Noise"] = row.Length > 2 ? row[2] : string.Empty;
                    dr["Time"] = row.Length > 3 ? row[3] : string.Empty;
                    dr["Time UTC"] = row.Length > 4 ? row[4] : string.Empty;
                }
                else
                {
                    dr["Stan"] = row.Length > 0 ? row[0] : string.Empty;
                    dr["Zeit"] = row.Length > 1 ? row[1] : string.Empty;
                    dr["Noise"] = row.Length > 2 ? row[2] : string.Empty;
                    dr["Time"] = row.Length > 3 ? row[3] : string.Empty;
                    dr["TimeUTC"] = row.Length > 4 ? row[4] : string.Empty;
                }
                dt.Rows.Add(dr);
            }
    
            return dt;
        }
    
        #endregion
    
        #region Обработчики Объединения Файлов
    
        /// <summary>
        /// Обработчик для комбинирования файлов через меню
        /// </summary>
        private async void CombineFiles_Click(object sender, RoutedEventArgs e)
        {
            if (!txtFileData.Any() && !magneteFileData.Any())
            {
                MessageBox.Show("Нет загруженных файлов для объединения.", "Информация", MessageBoxButton.OK, MessageBoxImage.Information);
                return;
            }
    
            // Диалог для выбора типа файлов для объединения
            SelectEditTypeWindow selectWindow = new SelectEditTypeWindow("Выберите тип файлов для объединения:");
            selectWindow.Owner = this;
    
            if (selectWindow.ShowDialog() == true)
            {
                string selectedOption = selectWindow.SelectedOption;
    
                if (selectedOption == ".txt файлы" && txtFileData.Any())
                {
                    await CombineTxtFilesAsync();
                }
                else if (selectedOption == ".magnete файлы" && magneteFileData.Any())
                {
                    await CombineMagneteFilesAsync();
                }
                else
                {
                    MessageBox.Show("Выбранная опция недоступна или нет загруженных файлов данного типа.", "Ошибка", MessageBoxButton.OK, MessageBoxImage.Error);
                }
            }
        }
    
        /// <summary>
        /// Асинхронный метод для объединения .txt файлов
        /// </summary>
        private Task CombineTxtFilesAsync()
        {
            return Task.Run(() =>
            {
                List<string[]> combinedData = new List<string[]>();
                int lineNumber = 1;
    
                foreach (var file in txtFileData.Values)
                {
                    foreach (var row in file)
                    {
                        if (row.Length < 3)
                            continue;
    
                        string secondColumn = row[1];
                        string thirdColumn = row.Length > 2 ? row[2] : string.Empty;
                        string fourthColumn = row.Length > 3 ? row[3] : "0";
    
                        string timeString = "InvalidNumber";
                        if (double.TryParse(fourthColumn, NumberStyles.Any, CultureInfo.InvariantCulture, out double number))
                        {
                            double divided = number / 24;
                            TimeSpan time = TimeSpan.FromDays(divided);
                            timeString = time.ToString(@"hh\:mm\:ss");
                        }
    
                        combinedData.Add(new string[]
                        {
                            lineNumber.ToString(),
                            secondColumn,
                            thirdColumn,
                            fourthColumn,
                            timeString
                        });
    
                        lineNumber++;
                    }
                }
    
                // Преобразование списка в существующую DataTable
                Dispatcher.Invoke(() =>
                {
                    CombinedTxtDataTable.Clear(); // Очистка существующих данных
                    foreach (var row in combinedData)
                    {
                        CombinedTxtDataTable.Rows.Add(
                            int.Parse(row[0]),
                            row[1],
                            row[2],
                            row[3],
                            row[4]
                        );
                    }
    
                    // Включение кнопки "Редактировать и Экспортировать" при наличии данных
                    EditExportButton.IsEnabled = CombinedTxtDataTable.Rows.Count > 0 || CombinedMagneteDataTable.Rows.Count > 0;
    
                    // Обновление строки состояния
                    StatusTextBlock.Text = $"Объединены .txt файлы. Строк: {CombinedTxtDataTable.Rows.Count}.";
                });
            });
        }
    
        /// <summary>
        /// Асинхронный метод для объединения .magnete файлов
        /// </summary>
        private Task CombineMagneteFilesAsync()
        {
            return Task.Run(() =>
            {
                if (!magneteFileData.Any())
                {
                    Dispatcher.Invoke(() =>
                        MessageBox.Show("Нет загруженных .magnete файлов для объединения.", "Информация", MessageBoxButton.OK, MessageBoxImage.Information));
                    return;
                }
    
                DateTime fixedDate = new DateTime(1980, 1, 6, 0, 0, 0, DateTimeKind.Utc);
                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["DATA UTC"] = fixedDate.ToString("dd.MM.yyyy");
                        newRow["TIME"] = row.Length > 0 ? row[0].Trim() : string.Empty;
                        newRow["Широта WGS"] = row.Length > 1 ? row[1].Trim() : string.Empty;
                        newRow["Долгота WGS"] = row.Length > 2 ? row[2].Trim() : string.Empty;
                        newRow["№1"] = sequentialNumber;
                        newRow["№2"] = sequentialNumber;
                        newRow["Альтитуда"] = row.Length > 3 ? row[3].Trim() : string.Empty;
                        newRow["Shark"] = row.Length > 4 ? row[4].Trim() : string.Empty;
                        newRow["Долгота UTM"] = 0.0;
                        newRow["Широта UTM"] = 0.0;
    
                        string stanValue = row.Length > 0 ? row[0].Trim() : string.Empty;
                        string zeitValue = row.Length > 1 ? row[1].Trim() : string.Empty;
                        string noiseValue = row.Length > 2 ? row[2].Trim() : string.Empty;
    
                        double longitude, latitude;
                        bool validCoordinates = true;
    
                        if (!double.TryParse(noiseValue, NumberStyles.Any, CultureInfo.InvariantCulture, out longitude))
                        {
                            string error = $"Не удалось распарсить Долгота WGS='{noiseValue}' в строке: {string.Join("\t", row)}.";
                            errorMessages.Add(error);
                            LogCalculation(error);
                            validCoordinates = false;
                        }
    
                        if (!double.TryParse(zeitValue, NumberStyles.Any, CultureInfo.InvariantCulture, out latitude))
                        {
                            string error = $"Не удалось распарсить Широта WGS='{zeitValue}' в строке: {string.Join("\t", row)}.";
                            errorMessages.Add(error);
                            LogCalculation(error);
                            validCoordinates = false;
                        }
    
                        if (validCoordinates)
                        {
                            try
                            {
                                int utmZone = GetUTMZone(longitude);
                                var utmCoordinates = ConvertWGS84ToUTM(longitude, latitude, utmZone);
                                newRow["Долгота UTM"] = utmCoordinates.Easting;
                                newRow["Широта UTM"] = utmCoordinates.Northing;
                            }
                            catch (Exception ex)
                            {
                                string error = $"Ошибка при преобразовании координат (Долгота WGS='{noiseValue}', Широта WGS='{latitude}') в строке: {string.Join("\t", row)}. Текст ошибки: {ex.Message}.";
                                errorMessages.Add(error);
                                LogCalculation(error);
                            }
                        }
    
                        // Обработка столбца "Stan"
                        if (double.TryParse(stanValue, NumberStyles.Any, CultureInfo.InvariantCulture, out double stanSeconds))
                        {
                            if (stanSeconds < 0)
                            {
                                string warning = $"Отрицательное значение TIME='{stanSeconds}' в строке: {string.Join("\t", row)}. Установка даты как фиксированной.";
                                errorMessages.Add(warning);
                                LogCalculation(warning);
    
                                newRow["DATA"] = fixedDate.ToString("dd.MM.yyyy");
                                newRow["TIME UTC"] = fixedDate.ToString("HH:mm:ss.f");
                            }
                            else
                            {
                                try
                                {
                                    DateTime computedDate = fixedDate.AddSeconds(stanSeconds);
                                    newRow["DATA"] = computedDate.ToString("dd.MM.yyyy");
    
                                    TimeSpan offsetTime = TimeSpan.FromSeconds(18);
                                    TimeSpan computedTime = (computedDate.TimeOfDay >= offsetTime) ? computedDate.TimeOfDay - offsetTime : TimeSpan.Zero;
                                    double roundedSeconds = Math.Round(computedTime.TotalSeconds, 1, MidpointRounding.AwayFromZero);
                                    TimeSpan roundedTime = TimeSpan.FromSeconds(roundedSeconds);
                                    newRow["TIME UTC"] = roundedTime.ToString(@"hh\:mm\:ss\.f");
                                }
                                catch (Exception ex)
                                {
                                    string error = $"Ошибка при расчёте даты для TIME='{stanSeconds}' в строке: {string.Join("\t", row)}. Текст ошибки: {ex.Message}. Установка даты как фиксированной.";
                                    errorMessages.Add(error);
                                    LogCalculation(error);
    
                                    newRow["DATA"] = fixedDate.ToString("dd.MM.yyyy");
                                    newRow["TIME UTC"] = fixedDate.ToString("HH:mm:ss.f");
                                }
                            }
                        }
                        else
                        {
                            string error = $"Не удалось распарсить TIME='{stanValue}' в строке: {string.Join("\t", row)}. Установка даты как фиксированной.";
                            errorMessages.Add(error);
                            LogCalculation(error);
    
                            newRow["DATA"] = fixedDate.ToString("dd.MM.yyyy");
                            newRow["TIME UTC"] = fixedDate.ToString("HH:mm:ss.f");
                        }
    
                        CombinedMagneteDataTable.Rows.Add(newRow);
                        sequentialNumber++;
    
                        // Логирование расчетов для каждой строки
                        string logMessage = $"TIME: '{stanValue}', ComputedDate: '{newRow["DATA"]}', ComputedTime: '{newRow["TIME UTC"]}'";
                        LogCalculation(logMessage);
                    }
                }
    
                Dispatcher.Invoke(() =>
                {
                    // Включение кнопки "Редактировать и Экспортировать" при наличии данных
                    EditExportButton.IsEnabled = CombinedTxtDataTable.Rows.Count > 0 || CombinedMagneteDataTable.Rows.Count > 0;
    
                    // Обновление строки состояния
                    StatusTextBlock.Text = $"Объединены .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 успешно объединены без ошибок.", "Успех", MessageBoxButton.OK, MessageBoxImage.Information);
                    }
                });
            });
        }
    
        #endregion
    
        #region Обработчики Редактирования и Экспорта
    
        /// <summary>
        /// Обработчик для редактирования и экспорта через панель инструментов
        /// </summary>
        private void EditAndExport_Click(object sender, RoutedEventArgs e)
        {
            if ((CombinedTxtDataTable == null || CombinedTxtDataTable.Rows.Count == 0) &&
                (CombinedMagneteDataTable == null || CombinedMagneteDataTable.Rows.Count == 0))
            {
                MessageBox.Show("Нет объединённых данных для редактирования.", "Информация", MessageBoxButton.OK, MessageBoxImage.Information);
                return;
            }
    
            // Создание и открытие диалогового окна для выбора типа данных для редактирования
            SelectEditTypeWindow selectWindow = new SelectEditTypeWindow("Выберите данные для редактирования:");
            selectWindow.Owner = this;
    
            if (selectWindow.ShowDialog() == true)
            {
                string selectedOption = selectWindow.SelectedOption;
    
                if (selectedOption == ".txt файлы" && CombinedTxtDataTable != null && CombinedTxtDataTable.Rows.Count > 0)
                {
                    OpenEditWindow(CombinedTxtDataTable, "Редактирование .txt данных");
                }
                else if (selectedOption == ".magnete файлы" && CombinedMagneteDataTable != null && CombinedMagneteDataTable.Rows.Count > 0)
                {
                    OpenEditWindow(CombinedMagneteDataTable, "Редактирование .magnete данных");
                }
                else
                {
                    MessageBox.Show("Выбранная опция недоступна или данные отсутствуют.", "Ошибка", MessageBoxButton.OK, MessageBoxImage.Error);
                }
            }
        }
    
        /// <summary>
        /// Метод для открытия окна редактирования
        /// </summary>
        private void OpenEditWindow(DataTable dataTable, string windowTitle)
        {
            EditWindow editWindow = new EditWindow(dataTable)
            {
                Title = windowTitle,
                Owner = this
            };
            editWindow.ShowDialog();
    
            // После редактирования данные уже изменены в DataTable и отобразятся в DataGrid благодаря привязке
        }
    
        #endregion
    
        #region Обработчики Сохранения и Загрузки Проекта
    
        /// <summary>
        /// Обработчик для сохранения проекта через меню
        /// </summary>
        private async void SaveProject_Click(object sender, RoutedEventArgs e)
        {
            SaveFileDialog saveFileDialog = new SaveFileDialog
            {
                Filter = "Magnte Project Files (*.magn)|*.magn",
                DefaultExt = "magn",
                FileName = "project.magn"
            };
    
            if (saveFileDialog.ShowDialog() == true)
            {
                ProjectData project = new ProjectData
                {
                    TxtFileData = this.txtFileData,
                    MagneteFileData = this.magneteFileData,
                    CombinedTxtDataTable = this.CombinedTxtDataTable,
                    CombinedMagneteDataTable = this.CombinedMagneteDataTable
                };
    
                try
                {
                    // Асинхронная сериализация объекта в JSON
                    string json = await Task.Run(() => JsonConvert.SerializeObject(project, Formatting.Indented, new JsonSerializerSettings
                    {
                        PreserveReferencesHandling = PreserveReferencesHandling.Objects,
                        ReferenceLoopHandling = ReferenceLoopHandling.Ignore
                    }));
                    await File.WriteAllTextAsync(saveFileDialog.FileName, json, System.Text.Encoding.UTF8);
                    StatusTextBlock.Text = $"Проект сохранён: {saveFileDialog.FileName}";
                    MessageBox.Show("Проект успешно сохранён.", "Успех", MessageBoxButton.OK, MessageBoxImage.Information);
                }
                catch (Exception ex)
                {
                    MessageBox.Show($"Ошибка при сохранении проекта:\n{ex.Message}", "Ошибка", MessageBoxButton.OK, MessageBoxImage.Error);
                }
            }
        }
    
        /// <summary>
        /// Обработчик для загрузки проекта через меню
        /// </summary>
        private async void LoadProject_Click(object sender, RoutedEventArgs e)
        {
            OpenFileDialog openFileDialog = new OpenFileDialog
            {
                Filter = "Magnte Project Files (*.magn)|*.magn",
                DefaultExt = "magn"
            };
    
            if (openFileDialog.ShowDialog() == true)
            {
                try
                {
                    string json = await File.ReadAllTextAsync(openFileDialog.FileName, System.Text.Encoding.UTF8);
                    ProjectData project = JsonConvert.DeserializeObject<ProjectData>(json);
    
                    if (project != null)
                    {
                        // Загрузка данных .txt
                        this.txtFileData = project.TxtFileData ?? new Dictionary<string, List<string[]>>();
                        PopulateTabControl(FilesTabControl, txtFileData, CreateTxtDataGrid);
    
                        // Загрузка данных .magnete
                        this.magneteFileData = project.MagneteFileData ?? new Dictionary<string, List<string[]>>();
                        PopulateTabControl(MagneteFilesTabControl, magneteFileData, CreateMagneteDataGrid);
    
                        // Загрузка объединенных DataTable
                        CombinedTxtDataTable.Clear();
                        foreach (DataRow row in project.CombinedTxtDataTable.Rows)
                        {
                            CombinedTxtDataTable.ImportRow(row);
                        }
    
                        CombinedMagneteDataTable.Clear();
                        foreach (DataRow row in project.CombinedMagneteDataTable.Rows)
                        {
                            CombinedMagneteDataTable.ImportRow(row);
                        }
    
                        // Применяем AcceptChanges, чтобы очистить статус изменений
                        CombinedTxtDataTable.AcceptChanges();
                        CombinedMagneteDataTable.AcceptChanges();
    
                        // Обновляем состояние кнопки "Редактировать и Экспортировать"
                        EditExportButton.IsEnabled = CombinedTxtDataTable.Rows.Count > 0 || CombinedMagneteDataTable.Rows.Count > 0;
    
                        // Обновление строки состояния
                        StatusTextBlock.Text = $"Проект загружен: {openFileDialog.FileName}";
                        MessageBox.Show("Проект успешно загружен.", "Успех", MessageBoxButton.OK, MessageBoxImage.Information);
                    }
                    else
                    {
                        MessageBox.Show("Не удалось загрузить данные проекта.", "Ошибка", MessageBoxButton.OK, MessageBoxImage.Error);
                    }
                }
                catch (Exception ex)
                {
                    MessageBox.Show($"Ошибка при загрузке проекта:\n{ex.Message}", "Ошибка", MessageBoxButton.OK, MessageBoxImage.Error);
                }
            }
        }
    
        #endregion
    
        #region Обработчики Для Графиков
    
        /// <summary>
        /// Обработчик для отображения графиков через меню
        /// </summary>
        private void ShowGraphs_Click(object sender, RoutedEventArgs e)
        {
            if ((CombinedTxtDataTable == null || CombinedTxtDataTable.Rows.Count == 0) &&
                (CombinedMagneteDataTable == null || CombinedMagneteDataTable.Rows.Count == 0))
            {
                MessageBox.Show("Нет объединённых данных для построения графиков.", "Информация", MessageBoxButton.OK, MessageBoxImage.Information);
                return;
            }
    
            // Создаем копии DataTable для передачи в GraphWindow
            DataTable txtDataCopy = CombinedTxtDataTable.Copy();
            DataTable magneteDataCopy = CombinedMagneteDataTable.Copy();
    
            GraphWindow graphWindow = new GraphWindow(txtDataCopy, magneteDataCopy)
            {
                Owner = this
            };
            bool? dialogResult = graphWindow.ShowDialog();
    
            if (dialogResult == true)
            {
                // Пользователь нажал "Сохранить", применяем изменения
                // Обновляем Combined DataTables с копиями из GraphWindow
                CombinedTxtDataTable = graphWindow.TxtDataCopy;
                CombinedMagneteDataTable = graphWindow.MagneteDataCopy;
    
                // Применяем изменения
                CombinedTxtDataTable.AcceptChanges();
                CombinedMagneteDataTable.AcceptChanges();
    
                // Обновляем привязки
                OnPropertyChanged(nameof(CombinedTxtDataTable));
                OnPropertyChanged(nameof(CombinedMagneteDataTable));
    
                // Обновление строки состояния
                StatusTextBlock.Text = $"Данные графиков обновлены после сохранения изменений.";
            }
            else
            {
                // Пользователь отменил изменения
                StatusTextBlock.Text = $"Изменения на графиках были отменены.";
            }
        }
    
        #endregion
    
        #region Обработчики Меню
    
        /// <summary>
        /// Обработчик для выхода из приложения через меню
        /// </summary>
        private void Exit_Click(object sender, RoutedEventArgs e)
        {
            this.Close();
        }
    
        /// <summary>
        /// Обработчик для пункта "О программе" через меню
        /// </summary>
        private void About_Click(object sender, RoutedEventArgs e)
        {
            MessageBox.Show("Txt Processor App\nВерсия 1.0\n© 2023 Ваша Компания", "О программе", MessageBoxButton.OK, MessageBoxImage.Information);
        }
    
        #endregion
    
        #region Модели Данных
    
        /// <summary>
        /// Класс для хранения данных проекта
        /// </summary>
        public class ProjectData
        {
            public Dictionary<string, List<string[]>> TxtFileData { get; set; }
            public Dictionary<string, List<string[]>> MagneteFileData { get; set; }
            public DataTable CombinedTxtDataTable { get; set; }
            public DataTable CombinedMagneteDataTable { get; set; }
        }
    
        #endregion
    
        #region Helper Methods для Преобразований Координат
    
        /// <summary>
        /// Метод для логирования расчетов и ошибок
        /// </summary>
        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)
            {
                Dispatcher.Invoke(() =>
                    MessageBox.Show($"Не удалось записать лог: {ex.Message}", "Ошибка логирования", MessageBoxButton.OK, MessageBoxImage.Error));
            }
        }
    
        /// <summary>
        /// Метод для определения зоны UTM на основе долготы
        /// </summary>
        private int GetUTMZone(double longitude)
        {
            if (longitude < -180 || longitude > 180)
                throw new ArgumentOutOfRangeException("Долгота должна быть в диапазоне от -180 до 180 градусов.");
    
            int zone = (int)Math.Floor((longitude + 180) / 6) + 1;
            return zone;
        }
    
        /// <summary>
        /// Метод для преобразования координат WGS84 в UTM
        /// </summary>
        private (double Easting, double Northing) ConvertWGS84ToUTM(double longitude, double latitude, int utmZone)
        {
            var wgs84 = GeographicCoordinateSystem.WGS84;
            var utmCS = ProjectedCoordinateSystem.WGS84_UTM(utmZone, latitude >= 0);
            var transformFactory = new CoordinateTransformationFactory();
            var transformation = transformFactory.CreateFromCoordinateSystems(wgs84, utmCS);
            double[] fromPoint = new double[] { longitude, latitude };
            double[] toPoint = transformation.MathTransform.Transform(fromPoint);
            return (toPoint[0], toPoint[1]);
        }
    
        #endregion
    }
    

    }

    <Grid.RowDefinitions> </Grid.RowDefinitions>

        <TextBlock Text="Выберите данные:" Grid.Row="0" Margin="0,0,0,10" FontWeight="Bold" />
    
        <ListBox x:Name="OptionsListBox" Grid.Row="1">
            <ListBoxItem Content=".txt файлы" />
            <ListBoxItem Content=".magnete файлы" />
        </ListBox>
    
        <StackPanel Grid.Row="2" Orientation="Horizontal" HorizontalAlignment="Right" Margin="0,10,0,0">
            <Button Content="OK" Width="75" Margin="0,0,10,0" IsDefault="True" Click="OK_Click"/>
            <Button Content="Отмена" Width="75" IsCancel="True"/>
        </StackPanel>
    </Grid>
    

    // SelectEditTypeWindow.xaml.cs using System.Windows; using System.Windows.Controls;

    namespace TxtProcessorApp { public partial class SelectEditTypeWindow : Window { public string SelectedOption { get; private set; }

        public SelectEditTypeWindow(string prompt)
        {
            InitializeComponent();
            // Можно добавить дополнительную настройку окна при необходимости
        }
    
        private void OK_Click(object sender, RoutedEventArgs e)
        {
            if (OptionsListBox.SelectedItem is ListBoxItem selectedItem)
            {
                SelectedOption = selectedItem.Content.ToString();
                DialogResult = true;
            }
            else
            {
                MessageBox.Show("Пожалуйста, выберите опцию.", "Внимание", MessageBoxButton.OK, MessageBoxImage.Warning);
            }
        }
    }
    

    }

  2. Assistant

    Проблема, с которой вы столкнулись, связана с нарушением потокобезопасности при обновлении DataTable, которая привязана к DataGrid. Ваша ошибка System.InvalidOperationException указывает на то, что коллекция элементов контролла DataGrid не соответствует её источнику данных, что, скорее всего, происходит из-за одновременного изменения данных из фона (не UI-потока).

    Причина проблемы

    В методе CombineMagneteFilesAsync вы используете Task.Run для выполнения операций в фоновых потоках. Внутри этого метода вы добавляете строки в CombinedMagneteDataTable:

    CombinedMagneteDataTable.Rows.Add(newRow);
    

    Поскольку CombinedMagneteDataTable привязана к DataGrid, все изменения этой таблицы должны выполняться в UI-потоке. Попытка изменить DataTable из фонового потока приводит к несоответствию состояния коллекции, что и вызывает ошибку.

    Решение

    Необходимо гарантировать, что все изменения привязанного DataTable выполняются в UI-потоке. Это можно сделать, собирая все строки в списке в фоновом потоке, а затем добавляя их один раз в UI-потоке с помощью Dispatcher.Invoke. Это минимизирует количество переключений потоков и устраняет потенциальные ошибки.

    Ниже представлен обновленный код метода CombineMagneteFilesAsync с учетом этих изменений:

    private Task CombineMagneteFilesAsync()
    {
        return Task.Run(() =>
        {
            if (!magneteFileData.Any())
            {
                Dispatcher.Invoke(() =>
                    MessageBox.Show("Нет загруженных .magnete файлов для объединения.", "Информация", MessageBoxButton.OK, MessageBoxImage.Information));
                return;
            }
    
            DateTime fixedDate = new DateTime(1980, 1, 6, 0, 0, 0, DateTimeKind.Utc);
            int sequentialNumber = 1;
            List<string> errorMessages = new List<string>();
            List<DataRow> newRows = new List<DataRow>();
    
            foreach (var file in magneteFileData.Values)
            {
                foreach (var row in file)
                {
                    DataRow newRow = CombinedMagneteDataTable.NewRow();
                    newRow["DATA UTC"] = fixedDate.ToString("dd.MM.yyyy");
                    newRow["TIME"] = row.Length > 0 ? row[0].Trim() : string.Empty;
                    newRow["Широта WGS"] = row.Length > 1 ? row[1].Trim() : string.Empty;
                    newRow["Долгота WGS"] = row.Length > 2 ? row[2].Trim() : string.Empty;
                    newRow["№1"] = sequentialNumber;
                    newRow["№2"] = sequentialNumber;
                    newRow["Альтитуда"] = row.Length > 3 ? row[3].Trim() : string.Empty;
                    newRow["Shark"] = row.Length > 4 ? row[4].Trim() : string.Empty;
                    newRow["Долгота UTM"] = 0.0;
                    newRow["Широта UTM"] = 0.0;
    
                    string stanValue = row.Length > 0 ? row[0].Trim() : string.Empty;
                    string zeitValue = row.Length > 1 ? row[1].Trim() : string.Empty;
                    string noiseValue = row.Length > 2 ? row[2].Trim() : string.Empty;
    
                    double longitude, latitude;
                    bool validCoordinates = true;
    
                    if (!double.TryParse(noiseValue, NumberStyles.Any, CultureInfo.InvariantCulture, out longitude))
                    {
                        string error = $"Не удалось распарсить Долгота WGS='{noiseValue}' в строке: {string.Join("\t", row)}.";
                        errorMessages.Add(error);
                        LogCalculation(error);
                        validCoordinates = false;
                    }
    
                    if (!double.TryParse(zeitValue, NumberStyles.Any, CultureInfo.InvariantCulture, out latitude))
                    {
                        string error = $"Не удалось распарсить Широта WGS='{zeitValue}' в строке: {string.Join("\t", row)}.";
                        errorMessages.Add(error);
                        LogCalculation(error);
                        validCoordinates = false;
                    }
    
                    if (validCoordinates)
                    {
                        try
                        {
                            int utmZone = GetUTMZone(longitude);
                            var utmCoordinates = ConvertWGS84ToUTM(longitude, latitude, utmZone);
                            newRow["Долгота UTM"] = utmCoordinates.Easting;
                            newRow["Широта UTM"] = utmCoordinates.Northing;
                        }
                        catch (Exception ex)
                        {
                            string error = $"Ошибка при преобразовании координат (Долгота WGS='{noiseValue}', Широта WGS='{latitude}') в строке: {string.Join("\t", row)}. Текст ошибки: {ex.Message}.";
                            errorMessages.Add(error);
                            LogCalculation(error);
                        }
                    }
    
                    // Обработка столбца "Stan"
                    if (double.TryParse(stanValue, NumberStyles.Any, CultureInfo.InvariantCulture, out double stanSeconds))
                    {
                        if (stanSeconds < 0)
                        {
                            string warning = $"Отрицательное значение TIME='{stanSeconds}' в строке: {string.Join("\t", row)}. Установка даты как фиксированной.";
                            errorMessages.Add(warning);
                            LogCalculation(warning);
    
                            newRow["DATA"] = fixedDate.ToString("dd.MM.yyyy");
                            newRow["TIME UTC"] = fixedDate.ToString("HH:mm:ss.f");
                        }
                        else
                        {
                            try
                            {
                                DateTime computedDate = fixedDate.AddSeconds(stanSeconds);
                                newRow["DATA"] = computedDate.ToString("dd.MM.yyyy");
    
                                TimeSpan offsetTime = TimeSpan.FromSeconds(18);
                                TimeSpan computedTime = (computedDate.TimeOfDay >= offsetTime) ? computedDate.TimeOfDay - offsetTime : TimeSpan.Zero;
                                double roundedSeconds = Math.Round(computedTime.TotalSeconds, 1, MidpointRounding.AwayFromZero);
                                TimeSpan roundedTime = TimeSpan.FromSeconds(roundedSeconds);
                                newRow["TIME UTC"] = roundedTime.ToString(@"hh\:mm\:ss\.f");
                            }
                            catch (Exception ex)
                            {
                                string error = $"Ошибка при расчёте даты для TIME='{stanSeconds}' в строке: {string.Join("\t", row)}. Текст ошибки: {ex.Message}. Установка даты как фиксированной.";
                                errorMessages.Add(error);
                                LogCalculation(error);
    
                                newRow["DATA"] = fixedDate.ToString("dd.MM.yyyy");
                                newRow["TIME UTC"] = fixedDate.ToString("HH:mm:ss.f");
                            }
                        }
                    }
                    else
                    {
                        string error = $"Не удалось распарсить TIME='{stanValue}' в строке: {string.Join("\t", row)}. Установка даты как фиксированной.";
                        errorMessages.Add(error);
                        LogCalculation(error);
    
                        newRow["DATA"] = fixedDate.ToString("dd.MM.yyyy");
                        newRow["TIME UTC"] = fixedDate.ToString("HH:mm:ss.f");
                    }
    
                    newRows.Add(newRow);
                    sequentialNumber++;
    
                    // Логирование расчетов для каждой строки
                    string logMessage = $"TIME: '{stanValue}', ComputedDate: '{newRow["DATA"]}', ComputedTime: '{newRow["TIME UTC"]}'";
                    LogCalculation(logMessage);
                }
            }
    
            Dispatcher.Invoke(() =>
            {
                // Добавляем все новые строки в DataTable на UI-потоке
                foreach (var newRow in newRows)
                {
                    CombinedMagneteDataTable.Rows.Add(newRow);
                }
    
                // Включение кнопки "Редактировать и Экспортировать" при наличии данных
                EditExportButton.IsEnabled = CombinedTxtDataTable.Rows.Count > 0 || CombinedMagneteDataTable.Rows.Count > 0;
    
                // Обновление строки состояния
                StatusTextBlock.Text = $"Объединены .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 успешно объединены без ошибок.", "Успех", MessageBoxButton.OK, MessageBoxImage.Information);
                }
            });
        });
    }
    

    Объяснение изменений

    1. Сбор строк в фоновом потоке:

      • Вместо непосредственного добавления строк в CombinedMagneteDataTable.Rows.Add(newRow) из фонового потока, мы собираем все новые строки в список List<DataRow> newRows.
    2. Добавление строк в UI-потоке:

      • После обработки всех строк мы используем Dispatcher.Invoke для применения изменений в DataTable на UI-потоке. Это гарантирует, что привязка данных остаётся корректной и предотвращает ошибки коллекции.
    3. Улучшение производительности:

      • Добавление всех строк за один раз на UI-потоке снижает количество переключений между потоками и улучшает производительность.

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

    • Проверка на другие места с подобными изменениями: Убедитесь, что нигде в вашем коде другие привязанные коллекции или DataTable не изменяются из фоновых потоков.

    • Использование ObservableCollection: Если вы работаете с коллекциями, которые постоянно обновляются, рассмотрите использование ObservableCollection<T> вместе с правильной синхронизацией изменений.

    • Отладка с PresentationTraceSources.TraceLevel: В сообщении об ошибке указывается, что можно установить PresentationTraceSources.TraceLevel в High для получения дополнительной информации. Это может помочь в будущих отладках.

    Итог

    Основная проблема заключалась в попытке изменять привязанный DataTable из фонового потока, что приводило к несоответствию состояния коллекции и, как следствие, к выбросу исключения. Перемещая все изменения в UI-поток с помощью Dispatcher.Invoke, вы обеспечиваете корректное обновление UI и устраняете ошибку.

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


    Пример полного метода с учетом изменений:

    private Task CombineMagneteFilesAsync()
    {
        return Task.Run(() =>
        {
            if (!magneteFileData.Any())
            {
                Dispatcher.Invoke(() =>
                    MessageBox.Show("Нет загруженных .magnete файлов для объединения.", "Информация", MessageBoxButton.OK, MessageBoxImage.Information));
                return;
            }
    
            DateTime fixedDate = new DateTime(1980, 1, 6, 0, 0, 0, DateTimeKind.Utc);
            int sequentialNumber = 1;
            List<string> errorMessages = new List<string>();
            List<DataRow> newRows = new List<DataRow>();
    
            foreach (var file in magneteFileData.Values)
            {
                foreach (var row in file)
                {
                    DataRow newRow = CombinedMagneteDataTable.NewRow();
                    // ... заполняем newRow как раньше ...
    
                    newRows.Add(newRow);
                    sequentialNumber++;
    
                    // Логирование расчетов для каждой строки
                    string logMessage = $"TIME: '{stanValue}', ComputedDate: '{newRow["DATA"]}', ComputedTime: '{newRow["TIME UTC"]}'";
                    LogCalculation(logMessage);
                }
            }
    
            Dispatcher.Invoke(() =>
            {
                foreach (var newRow in newRows)
                {
                    CombinedMagneteDataTable.Rows.Add(newRow);
                }
    
                // Остальные обновления UI
                EditExportButton.IsEnabled = CombinedTxtDataTable.Rows.Count > 0 || CombinedMagneteDataTable.Rows.Count > 0;
                StatusTextBlock.Text = $"Объединены .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 успешно объединены без ошибок.", "Успех", MessageBoxButton.OK, MessageBoxImage.Information);
                }
            });
        });
    }
    

    Следуя этим рекомендациям, вы устраните проблему с ошибкой привязки и обеспечите стабильную работу вашего приложения при обработке .magnete файлов.