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

программа очень силльно нагружает память и тормозит, исправь это <!-- MainWindow.xaml…

  1. User

    программа очень силльно нагружает память и тормозит, исправь это

    <Grid.ColumnDefinitions> </Grid.ColumnDefinitions> Загрузить .txt файлы Загрузить .magnet файлы Создать объединённый файл Сохранить проект Загрузить проект <Grid.RowDefinitions> </Grid.RowDefinitions> <Grid.ColumnDefinitions> </Grid.ColumnDefinitions> <ListView.View> </ListView.View> <ListView.View> </ListView.View> <DataGrid.Columns> </DataGrid.Columns>

    // MainWindow.xaml.cs using Microsoft.Win32; using Newtonsoft.Json; using System; using System.Collections.ObjectModel; using System.IO; using System.Linq; using System.Threading.Tasks; using System.Windows; using System.Windows.Controls; using System.Collections.Generic;

    namespace magnet { public partial class MainWindow : Window { private ProjectModel currentProject = new ProjectModel(); private FileSetting selectedFile = null;

        public MainWindow()
        {
            InitializeComponent();
            TxtFilesListView.ItemsSource = currentProject.TxtFiles;
            MagnetFilesListView.ItemsSource = currentProject.MagnetFiles;
        }
    
        /// <summary>
        /// Обработчик нажатия кнопки "Загрузить .txt файлы".
        /// </summary>
        private async void LoadTxtFilesButton_Click(object sender, RoutedEventArgs e)
        {
            await LoadFilesAsync(".txt", currentProject.TxtFiles, TxtFilesListView);
        }
    
        /// <summary>
        /// Обработчик нажатия кнопки "Загрузить .magnet файлы".
        /// </summary>
        private async void LoadMagnetFilesButton_Click(object sender, RoutedEventArgs e)
        {
            await LoadFilesAsync(".magnet", currentProject.MagnetFiles, MagnetFilesListView);
        }
    
        /// <summary>
        /// Асинхронный метод для загрузки файлов определенного типа.
        /// </summary>
        private async Task LoadFilesAsync(string extension, ObservableCollection<FileSetting> fileCollection, ListView listView)
        {
            OpenFileDialog dlg = new OpenFileDialog
            {
                Multiselect = true,
                Filter = $"Файлы {extension}|*{extension}"
            };
    
            bool? result = dlg.ShowDialog();
    
            if (result == true)
            {
                var newFiles = dlg.FileNames.Where(filename => !fileCollection.Any(f => f.FilePath.Equals(filename, StringComparison.OrdinalIgnoreCase))).ToList();
    
                if (newFiles.Any())
                {
                    foreach (string filename in newFiles)
                    {
                        fileCollection.Add(new FileSetting { FilePath = filename, LinesToSkip = 0 });
                    }
    
                    // Автоматически выбрать последний добавленный файл
                    var lastFile = fileCollection.Last();
                    listView.SelectedItem = lastFile;
                }
                else
                {
                    MessageBox.Show("Все выбранные файлы уже добавлены.", "Информация", MessageBoxButton.OK, MessageBoxImage.Information);
                }
            }
        }
    
        /// <summary>
        /// Обработчик изменения выбора в ListView .txt файлов.
        /// </summary>
        private async void TxtFilesListView_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (TxtFilesListView.SelectedItem is FileSetting selected)
            {
                selectedFile = selected;
                LinesToSkipTextBox.Text = selected.LinesToSkip.ToString();
                MagnetFilesListView.SelectedItem = null; // Снять выделение из другого списка
                await PreviewFileAsync(selected);
            }
            else
            {
                selectedFile = null;
                PreviewDataGrid.ItemsSource = null;
                LinesToSkipTextBox.Text = "0";
            }
        }
    
        /// <summary>
        /// Обработчик изменения выбора в ListView .magnet файлов.
        /// </summary>
        private async void MagnetFilesListView_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (MagnetFilesListView.SelectedItem is FileSetting selected)
            {
                selectedFile = selected;
                LinesToSkipTextBox.Text = selected.LinesToSkip.ToString();
                TxtFilesListView.SelectedItem = null; // Снять выделение из другого списка
                await PreviewFileAsync(selected);
            }
            else
            {
                selectedFile = null;
                PreviewDataGrid.ItemsSource = null;
                LinesToSkipTextBox.Text = "0";
            }
        }
    
        /// <summary>
        /// Асинхронный метод для загрузки и отображения содержимого файла с нумерацией строк и столбцов.
        /// </summary>
        private async Task PreviewFileAsync(FileSetting fileSetting)
        {
            try
            {
                if (!File.Exists(fileSetting.FilePath))
                {
                    PreviewDataGrid.ItemsSource = null;
                    MessageBox.Show($"Файл не найден: {fileSetting.FilePath}", "Ошибка", MessageBoxButton.OK, MessageBoxImage.Error);
                    return;
                }
    
                var data = new List<PreviewRow>();
                int currentLine = 0;
                int maxColumns = 0;
    
                await Task.Run(() =>
                {
                    using (StreamReader reader = new StreamReader(fileSetting.FilePath))
                    {
                        // Пропускаем указанные строки
                        for (int i = 0; i < fileSetting.LinesToSkip; i++)
                        {
                            if (reader.ReadLine() == null)
                                break;
                            currentLine++;
                        }
    
                        string line;
                        while ((line = reader.ReadLine()) != null)
                        {
                            currentLine++;
                            var columns = line.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
                            lock (data)
                            {
                                if (columns.Length > maxColumns)
                                    maxColumns = columns.Length;
    
                                data.Add(new PreviewRow
                                {
                                    LineNumber = currentLine,
                                    Columns = columns.ToList()
                                });
                            }
                        }
                    }
                });
    
                // Создать колонки для DataGrid
                Dispatcher.Invoke(() =>
                {
                    PreviewDataGrid.Columns.Clear();
                    PreviewDataGrid.Columns.Add(new DataGridTextColumn
                    {
                        Header = "#",
                        Binding = new System.Windows.Data.Binding("LineNumber"),
                        Width = 50
                    });
    
                    for (int i = 0; i < maxColumns; i++)
                    {
                        PreviewDataGrid.Columns.Add(new DataGridTextColumn
                        {
                            Header = $"C{i + 1}",
                            Binding = new System.Windows.Data.Binding($"Columns[{i}]"),
                            Width = 100
                        });
                    }
    
                    PreviewDataGrid.ItemsSource = data;
                    this.Title = $"Magnet File Previewer - {System.IO.Path.GetFileName(fileSetting.FilePath)}";
                });
            }
            catch (Exception ex)
            {
                PreviewDataGrid.ItemsSource = null;
                MessageBox.Show($"Ошибка при чтении файла: {ex.Message}", "Ошибка", MessageBoxButton.OK, MessageBoxImage.Error);
            }
        }
    
        /// <summary>
        /// Обработчик нажатия кнопки "Обновить".
        /// Обновляет количество строк для пропуска и предпросмотр.
        /// </summary>
        private async void UpdateLinesToSkip_Click(object sender, RoutedEventArgs e)
        {
            if (selectedFile != null)
            {
                if (int.TryParse(LinesToSkipTextBox.Text, out int skip) && skip >= 0)
                {
                    selectedFile.LinesToSkip = skip;
                    await PreviewFileAsync(selectedFile);
                    // Обновить соответствующий ListView
                    if (selectedFile.FilePath.EndsWith(".txt", StringComparison.OrdinalIgnoreCase))
                    {
                        TxtFilesListView.Items.Refresh();
                    }
                    else if (selectedFile.FilePath.EndsWith(".magnet", StringComparison.OrdinalIgnoreCase))
                    {
                        MagnetFilesListView.Items.Refresh();
                    }
                }
                else
                {
                    MessageBox.Show("Введите корректное неотрицательное число строк для пропуска.", "Ошибка ввода", MessageBoxButton.OK, MessageBoxImage.Warning);
                }
            }
            else
            {
                MessageBox.Show("Выберите файл для обновления.", "Предупреждение", MessageBoxButton.OK, MessageBoxImage.Warning);
            }
        }
    
        /// <summary>
        /// Обработчик нажатия кнопки "Сохранить проект".
        /// Сохраняет текущий проект в файл с расширением .magn.
        /// </summary>
        private void SaveProjectButton_Click(object sender, RoutedEventArgs e)
        {
            if (currentProject.TxtFiles.Count == 0 && currentProject.MagnetFiles.Count == 0)
            {
                MessageBox.Show("Нет файлов для сохранения проекта.", "Предупреждение", MessageBoxButton.OK, MessageBoxImage.Warning);
                return;
            }
    
            SaveFileDialog dlg = new SaveFileDialog
            {
                Filter = "Magnet Project Files (*.magn)|*.magn",
                DefaultExt = "magn",
                FileName = "project.magn"
            };
    
            bool? result = dlg.ShowDialog();
    
            if (result == true)
            {
                try
                {
                    string json = JsonConvert.SerializeObject(currentProject, Formatting.Indented);
                    File.WriteAllText(dlg.FileName, json);
                    MessageBox.Show("Проект успешно сохранён!", "Успех", MessageBoxButton.OK, MessageBoxImage.Information);
                }
                catch (Exception ex)
                {
                    MessageBox.Show($"Ошибка при сохранении проекта: {ex.Message}", "Ошибка", MessageBoxButton.OK, MessageBoxImage.Error);
                }
            }
        }
    
        /// <summary>
        /// Обработчик нажатия кнопки "Загрузить проект".
        /// Загружает проект из файла с расширением .magn.
        /// </summary>
        private async void LoadProjectButton_Click(object sender, RoutedEventArgs e)
        {
            OpenFileDialog dlg = new OpenFileDialog
            {
                Filter = "Magnet Project Files (*.magn)|*.magn",
                DefaultExt = "magn"
            };
    
            bool? result = dlg.ShowDialog();
    
            if (result == true)
            {
                try
                {
                    string json = await File.ReadAllTextAsync(dlg.FileName);
                    ProjectModel loadedProject = JsonConvert.DeserializeObject<ProjectModel>(json);
    
                    if (loadedProject != null)
                    {
                        // Очистка текущих коллекций
                        currentProject.TxtFiles.Clear();
                        currentProject.MagnetFiles.Clear();
    
                        // Добавление загруженных файлов
                        foreach (var file in loadedProject.TxtFiles)
                        {
                            currentProject.TxtFiles.Add(file);
                        }
                        foreach (var file in loadedProject.MagnetFiles)
                        {
                            currentProject.MagnetFiles.Add(file);
                        }
    
                        // Обновить списки
                        TxtFilesListView.Items.Refresh();
                        MagnetFilesListView.Items.Refresh();
    
                        // Очистить предпросмотр и LinesToSkipTextBox
                        PreviewDataGrid.ItemsSource = null;
                        LinesToSkipTextBox.Text = "0";
                        selectedFile = null;
    
                        MessageBox.Show("Проект успешно загружен!", "Успех", MessageBoxButton.OK, MessageBoxImage.Information);
                    }
                    else
                    {
                        MessageBox.Show("Не удалось загрузить проект.", "Ошибка", MessageBoxButton.OK, MessageBoxImage.Error);
                    }
                }
                catch (Exception ex)
                {
                    MessageBox.Show($"Ошибка при загрузке проекта: {ex.Message}", "Ошибка", MessageBoxButton.OK, MessageBoxImage.Error);
                }
            }
        }
    
        /// <summary>
        /// Обработчик нажатия кнопки "Создать объединённый файл".
        /// Объединяет два выбранных .txt файла и отображает результат в новой вкладке.
        /// </summary>
        private async void CreateCombinedFileButton_Click(object sender, RoutedEventArgs e)
        {
            // Проверка наличия как минимум двух .txt файлов
            if (currentProject.TxtFiles.Count < 2)
            {
                MessageBox.Show("Необходимо загрузить минимум два .txt файла для объединения.", "Предупреждение", MessageBoxButton.OK, MessageBoxImage.Warning);
                return;
            }
    
            // Открытие окна выбора двух файлов
            SelectFilesWindow selectFilesWindow = new SelectFilesWindow(currentProject.TxtFiles.ToList(), 2);
            if (selectFilesWindow.ShowDialog() == true)
            {
                List<FileSetting> selectedTxtFiles = selectFilesWindow.SelectedFilesSettings;
    
                if (selectedTxtFiles.Count != 2)
                {
                    MessageBox.Show("Выберите ровно два файла для объединения.", "Ошибка", MessageBoxButton.OK, MessageBoxImage.Error);
                    return;
                }
    
                try
                {
                    // Чтение и объединение файлов асинхронно
                    List<string[]> combinedData = new List<string[]>();
                    int numbering = 1;
    
                    foreach (var file in selectedTxtFiles)
                    {
                        using (StreamReader reader = new StreamReader(file.FilePath))
                        {
                            string headerLine = await reader.ReadLineAsync(); // Предполагается, что есть заголовок
                            // Можно игнорировать заголовок или добавить проверку его структуры
    
                            string line;
                            while ((line = await reader.ReadLineAsync()) != null)
                            {
                                if (string.IsNullOrWhiteSpace(line))
                                    continue;
                                // Разделитель - пробел
                                string[] columns = line.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
    
                                // Проверка наличия минимального количества столбцов
                                if (columns.Length < 5)
                                {
                                    MessageBox.Show($"Файл {file.FilePath} содержит строку с недостаточным количеством столбцов: {line}", "Ошибка", MessageBoxButton.OK, MessageBoxImage.Error);
                                    return;
                                }
    
                                // Создание новой строки согласно требованиям
                                string[] newRow = new string[5];
                                newRow[0] = numbering.ToString(); // Нумерация
                                newRow[1] = columns[2]; // Столбец 3 исходного файла (индекс 2)
                                newRow[2] = columns[3]; // Столбец 4 исходного файла (индекс 3)
                                newRow[3] = columns[4]; // Столбец 5 исходного файла (индекс 4)
    
                                // Обработка столбца 5: деление на 24 и форматирование как время
                                if (double.TryParse(columns[4], out double originalValue))
                                {
                                    double divided = originalValue / 24.0;
                                    TimeSpan time = TimeSpan.FromHours(divided);
                                    newRow[4] = time.ToString(@"hh\:mm\:ss");
                                }
                                else
                                {
                                    newRow[4] = "00:00:00"; // Значение по умолчанию при ошибке парсинга
                                }
    
                                combinedData.Add(newRow);
                                numbering++;
                            }
                        }
                    }
    
                    if (combinedData.Count == 0)
                    {
                        MessageBox.Show("Объединённые файлы не содержат данных для объединения.", "Информация", MessageBoxButton.OK, MessageBoxImage.Information);
                        return;
                    }
    
                    // Создание объекта обработанного файла
                    ProcessedFile processedFile = new ProcessedFile
                    {
                        FileName = $"Combined_{DateTime.Now:yyyyMMdd_HHmmss}.magn",
                        Data = combinedData.Select(row => new ProcessedRow
                        {
                            Number = int.Parse(row[0]),
                            Column2 = row[1],
                            Column3 = row[2],
                            Column4 = row[3],
                            Column5 = row[4]
                        }).ToList()
                    };
    
                    // Добавление новой вкладки с результатом
                    AddProcessedFileTab(processedFile);
                }
                catch (Exception ex)
                {
                    MessageBox.Show($"Ошибка при объединении файлов: {ex.Message}", "Ошибка", MessageBoxButton.OK, MessageBoxImage.Error);
                }
            }
        }
    
        /// <summary>
        /// Метод для добавления новой вкладки с обработанным файлом.
        /// </summary>
        private void AddProcessedFileTab(ProcessedFile processedFile)
        {
            // Создание DataGrid
            DataGrid dataGrid = new DataGrid
            {
                AutoGenerateColumns = false,
                IsReadOnly = true,
                CanUserAddRows = false,
                ItemsSource = processedFile.Data,
                Margin = new Thickness(5),
                EnableRowVirtualization = true,
                EnableColumnVirtualization = true
            };
    
            // Добавление столбцов
            dataGrid.Columns.Add(new DataGridTextColumn { Header = "№", Binding = new System.Windows.Data.Binding("Number"), Width = 50 });
            dataGrid.Columns.Add(new DataGridTextColumn { Header = "Столбец 2", Binding = new System.Windows.Data.Binding("Column2"), Width = 150 });
            dataGrid.Columns.Add(new DataGridTextColumn { Header = "Столбец 3", Binding = new System.Windows.Data.Binding("Column3"), Width = 150 });
            dataGrid.Columns.Add(new DataGridTextColumn { Header = "Столбец 4", Binding = new System.Windows.Data.Binding("Column4"), Width = 150 });
            dataGrid.Columns.Add(new DataGridTextColumn { Header = "Столбец 5", Binding = new System.Windows.Data.Binding("Column5"), Width = 100 });
    
            // Создание кнопки для сохранения
            Button saveButton = new Button
            {
                Content = "Сохранить файл",
                Width = 120,
                Height = 30,
                Margin = new Thickness(5)
            };
            saveButton.Click += (s, e) => SaveProcessedFile(processedFile);
    
            // Создание StackPanel для DataGrid и кнопки
            StackPanel stackPanel = new StackPanel();
            stackPanel.Children.Add(dataGrid);
            stackPanel.Children.Add(saveButton);
    
            // Создание новой вкладки
            TabItem tabItem = new TabItem
            {
                Header = processedFile.FileName,
                Content = stackPanel
            };
    
            ProcessedFilesTabControl.Items.Add(tabItem);
            ProcessedFilesTabControl.SelectedItem = tabItem;
        }
    
        /// <summary>
        /// Метод для сохранения обработанного файла.
        /// </summary>
        private async void SaveProcessedFile(ProcessedFile processedFile)
        {
            SaveFileDialog dlg = new SaveFileDialog
            {
                Filter = "Magnet Files (*.magn)|*.magn",
                DefaultExt = "magn",
                FileName = processedFile.FileName
            };
    
            bool? result = dlg.ShowDialog();
    
            if (result == true)
            {
                try
                {
                    using (StreamWriter writer = new StreamWriter(dlg.FileName))
                    {
                        // Запись заголовка
                        await writer.WriteLineAsync("№\tСтолбец 2\tСтолбец 3\tСтолбец 4\tСтолбец 5");
    
                        foreach (var row in processedFile.Data)
                        {
                            string line = $"{row.Number}\t{row.Column2}\t{row.Column3}\t{row.Column4}\t{row.Column5}";
                            await writer.WriteLineAsync(line);
                        }
                    }
    
                    MessageBox.Show("Файл успешно сохранён!", "Успех", MessageBoxButton.OK, MessageBoxImage.Information);
                }
                catch (Exception ex)
                {
                    MessageBox.Show($"Ошибка при сохранении файла: {ex.Message}", "Ошибка", MessageBoxButton.OK, MessageBoxImage.Error);
                }
            }
        }
    }
    
    /// <summary>
    /// Класс для строки предпросмотра файла с нумерацией строк и столбцов.
    /// </summary>
    public class PreviewRow
    {
        public int LineNumber { get; set; }
        public List<string> Columns { get; set; }
    }
    

    }

    <Grid.RowDefinitions> </Grid.RowDefinitions>

    // SelectFilesWindow.xaml.cs using System.Collections.Generic; using System.Windows; using System.Windows.Controls;

    namespace magnet { /// /// Логика взаимодействия для SelectFilesWindow.xaml /// public partial class SelectFilesWindow : Window { /// /// Выбранные файлы после закрытия окна. /// public List SelectedFilesSettings { get; private set; } = new List();

        private int maxSelection;
    
        /// <summary>
        /// Конструктор окна выбора файлов.
        /// </summary>
        /// <param name="availableFiles">Список доступных файлов для выбора.</param>
        /// <param name="maxSelection">Максимальное количество выбираемых файлов.</param>
        public SelectFilesWindow(List<FileSetting> availableFiles, int maxSelection)
        {
            InitializeComponent();
            FilesListBox.ItemsSource = availableFiles;
            this.maxSelection = maxSelection;
        }
    
        /// <summary>
        /// Обработчик нажатия кнопки "OK".
        /// Проверяет, что выбрано ровно необходимое количество файлов.
        /// </summary>
        private void OKButton_Click(object sender, RoutedEventArgs e)
        {
            if (FilesListBox.SelectedItems.Count != maxSelection)
            {
                MessageBox.Show($"Выберите ровно {maxSelection} файла(ов) для объединения.", "Ошибка", MessageBoxButton.OK, MessageBoxImage.Error);
                return;
            }
    
            foreach (var item in FilesListBox.SelectedItems)
            {
                if (item is FileSetting fileSetting)
                {
                    SelectedFilesSettings.Add(fileSetting);
                }
            }
    
            this.DialogResult = true;
            this.Close();
        }
    
        /// <summary>
        /// Обработчик нажатия кнопки "Отмена".
        /// Закрывает окно без выбора файлов.
        /// </summary>
        private void CancelButton_Click(object sender, RoutedEventArgs e)
        {
            this.DialogResult = false;
            this.Close();
        }
    }
    

    }

    // ProjectModel.cs using System.Collections.ObjectModel; using System.Collections.Generic;

    namespace magnet { public class ProjectModel { public ObservableCollection TxtFiles { get; set; } = new ObservableCollection(); public ObservableCollection MagnetFiles { get; set; } = new ObservableCollection(); }

    public class FileSetting
    {
        public string FilePath { get; set; }
        public int LinesToSkip { get; set; } = 0;
    }
    
    public class ProcessedFile
    {
        public string FileName { get; set; }
        public List<ProcessedRow> Data { get; set; } = new List<ProcessedRow>();
    }
    
    public class ProcessedRow
    {
        public int Number { get; set; } // Новый столбец 1
        public string Column2 { get; set; } // Новый столбец 2 (столбец 3 из исходного файла)
        public string Column3 { get; set; } // Новый столбец 3 (столбец 4 из исходного файла)
        public string Column4 { get; set; } // Новый столбец 4 (столбец 5 из исходного файла)
        public string Column5 { get; set; } // Новый столбец 5 (столбец 5 из исходного файла / 24, формат времени)
    }
    

    }

  2. Assistant

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

    1. Ограничение количества загружаемых строк для предпросмотра

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

    Изменения в PreviewFileAsync:

    private async Task PreviewFileAsync(FileSetting fileSetting)
    {
        try
        {
            if (!File.Exists(fileSetting.FilePath))
            {
                PreviewDataGrid.ItemsSource = null;
                MessageBox.Show($"Файл не найден: {fileSetting.FilePath}", "Ошибка", MessageBoxButton.OK, MessageBoxImage.Error);
                return;
            }
    
            var data = new List<PreviewRow>();
            int currentLine = 0;
            int maxColumns = 0;
            int maxPreviewLines = 1000; // Максимальное количество строк для предпросмотра
    
            await Task.Run(() =>
            {
                using (StreamReader reader = new StreamReader(fileSetting.FilePath))
                {
                    // Пропускаем указанные строки
                    for (int i = 0; i < fileSetting.LinesToSkip; i++)
                    {
                        if (reader.ReadLine() == null)
                            break;
                        currentLine++;
                    }
    
                    string line;
                    while ((line = reader.ReadLine()) != null && data.Count < maxPreviewLines)
                    {
                        currentLine++;
                        var columns = line.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
                        lock (data)
                        {
                            if (columns.Length > maxColumns)
                                maxColumns = columns.Length;
    
                            data.Add(new PreviewRow
                            {
                                LineNumber = currentLine,
                                Columns = columns.ToList()
                            });
                        }
                    }
                }
            });
    
            // Создать колонки для DataGrid
            Dispatcher.Invoke(() =>
            {
                PreviewDataGrid.Columns.Clear();
                PreviewDataGrid.Columns.Add(new DataGridTextColumn
                {
                    Header = "#",
                    Binding = new System.Windows.Data.Binding("LineNumber"),
                    Width = 50
                });
    
                for (int i = 0; i < maxColumns; i++)
                {
                    PreviewDataGrid.Columns.Add(new DataGridTextColumn
                    {
                        Header = $"C{i + 1}",
                        Binding = new System.Windows.Data.Binding($"Columns[{i}]"),
                        Width = 100
                    });
                }
    
                PreviewDataGrid.ItemsSource = data;
                this.Title = $"Magnet File Previewer - {System.IO.Path.GetFileName(fileSetting.FilePath)} (Предпросмотр {data.Count} строк)";
            });
        }
        catch (Exception ex)
        {
            PreviewDataGrid.ItemsSource = null;
            MessageBox.Show($"Ошибка при чтении файла: {ex.Message}", "Ошибка", MessageBoxButton.OK, MessageBoxImage.Error);
        }
    }
    

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

    • Ограничение строк для предпросмотра: Добавлен параметр maxPreviewLines, который ограничивает количество загружаемых строк для предпросмотра.
    • Изменение заголовка окна: Теперь заголовок окна отображает количество загруженных строк для понимания пользователем, что это лишь ограниченная часть файла.

    2. Оптимизация DataGrid для больших объемов данных

    Даже при ограничении количества строк, важно убедиться, что DataGrid оптимизирован для производительности.

    Улучшения в XAML (MainWindow.xaml):

    <DataGrid Name="PreviewDataGrid" IsReadOnly="True" 
              AutoGenerateColumns="False" 
              HeadersVisibility="Column" 
              CanUserAddRows="False"
              CanUserDeleteRows="False"
              CanUserResizeColumns="True"
              CanUserSortColumns="False"
              FontFamily="Consolas"
              FontSize="12"
              EnableRowVirtualization="True"
              EnableColumnVirtualization="True"
              VirtualizingPanel.IsVirtualizing="True"
              VirtualizingPanel.VirtualizationMode="Recycling"
              ScrollViewer.IsDeferredScrollingEnabled="True"
              EnableRowVirtualization="True">
        <!-- Колонки остались без изменений -->
    </DataGrid>
    

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

    • Virtualization Mode: Установлен режим виртуализации Recycling, который повторно использует элементы UI при прокрутке, снижая нагрузку на память.
    • Deferred Scrolling: Включена отложенная прокрутка (IsDeferredScrollingEnabled="True"), что позволяет улучшить производительность при быстром прокручивании.

    3. Использование ObservableCollection и INotifyPropertyChanged

    Убедитесь, что ваши модели поддерживают уведомление об изменениях, что особенно важно для динамического обновления UI.

    Изменения в FileSetting:

    using System.ComponentModel;
    
    public class FileSetting : INotifyPropertyChanged
    {
        private string filePath;
        private int linesToSkip;
    
        public string FilePath
        {
            get => filePath;
            set
            {
                if (filePath != value)
                {
                    filePath = value;
                    OnPropertyChanged(nameof(FilePath));
                }
            }
        }
    
        public int LinesToSkip
        {
            get => linesToSkip;
            set
            {
                if (linesToSkip != value)
                {
                    linesToSkip = value;
                    OnPropertyChanged(nameof(LinesToSkip));
                }
            }
        }
    
        public event PropertyChangedEventHandler PropertyChanged;
    
        protected void OnPropertyChanged(string propertyName) =>
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
    

    Изменения в XAML для привязки ListView:

    <GridViewColumn Header="Строки для пропуска" Width="150">
        <GridViewColumn.CellTemplate>
            <DataTemplate>
                <TextBox Text="{Binding LinesToSkip, UpdateSourceTrigger=PropertyChanged}" Width="140"/>
            </DataTemplate>
        </GridViewColumn.CellTemplate>
    </GridViewColumn>
    

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

    • INotifyPropertyChanged: Реализация интерфейса INotifyPropertyChanged в классе FileSetting позволяет автоматически обновлять UI при изменении свойств.
    • Привязка в XAML: Использование TextBox внутри GridViewColumn с двухсторонней привязкой (UpdateSourceTrigger=PropertyChanged) позволяет непосредственно изменять значения LinesToSkip без дополнительной логики.

    4. Освобождение ресурсов и оптимизация чтения файлов

    Убедитесь, что все ресурсы, такие как StreamReader и StreamWriter, правильно освобождаются после использования. Это уже реализовано в вашем коде с использованием using, что хорошо.

    Однако, можно рассмотреть более эффективные методы чтения, особенно при объединении файлов.

    Изменения в CreateCombinedFileButton_Click:

    private async void CreateCombinedFileButton_Click(object sender, RoutedEventArgs e)
    {
        // Проверка наличия как минимум двух .txt файлов
        if (currentProject.TxtFiles.Count < 2)
        {
            MessageBox.Show("Необходимо загрузить минимум два .txt файла для объединения.", "Предупреждение", MessageBoxButton.OK, MessageBoxImage.Warning);
            return;
        }
    
        // Открытие окна выбора двух файлов
        SelectFilesWindow selectFilesWindow = new SelectFilesWindow(currentProject.TxtFiles.ToList(), 2);
        if (selectFilesWindow.ShowDialog() == true)
        {
            List<FileSetting> selectedTxtFiles = selectFilesWindow.SelectedFilesSettings;
    
            if (selectedTxtFiles.Count != 2)
            {
                MessageBox.Show("Выберите ровно два файла для объединения.", "Ошибка", MessageBoxButton.OK, MessageBoxImage.Error);
                return;
            }
    
            try
            {
                // Чтение и объединение файлов асинхронно
                List<ProcessedRow> combinedData = new List<ProcessedRow>();
                int numbering = 1;
    
                foreach (var file in selectedTxtFiles)
                {
                    using (StreamReader reader = new StreamReader(file.FilePath))
                    {
                        string headerLine = await reader.ReadLineAsync(); // Предполагается, что есть заголовок
    
                        string line;
                        while ((line = await reader.ReadLineAsync()) != null)
                        {
                            if (string.IsNullOrWhiteSpace(line))
                                continue;
    
                            // Разделитель - пробел
                            string[] columns = line.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
    
                            // Проверка наличия минимального количества столбцов
                            if (columns.Length < 5)
                            {
                                MessageBox.Show($"Файл {file.FilePath} содержит строку с недостаточным количеством столбцов: {line}", "Ошибка", MessageBoxButton.OK, MessageBoxImage.Error);
                                return;
                            }
    
                            // Обработка столбца 5
                            string formattedTime = "00:00:00";
                            if (double.TryParse(columns[4], out double originalValue))
                            {
                                double divided = originalValue / 24.0;
                                TimeSpan time = TimeSpan.FromHours(divided);
                                formattedTime = time.ToString(@"hh\:mm\:ss");
                            }
    
                            // Создание нового ProcessedRow
                            combinedData.Add(new ProcessedRow
                            {
                                Number = numbering++,
                                Column2 = columns[2],
                                Column3 = columns[3],
                                Column4 = columns[4],
                                Column5 = formattedTime
                            });
                        }
                    }
                }
    
                if (combinedData.Count == 0)
                {
                    MessageBox.Show("Объединённые файлы не содержат данных для объединения.", "Информация", MessageBoxButton.OK, MessageBoxImage.Information);
                    return;
                }
    
                // Создание объекта обработанного файла
                ProcessedFile processedFile = new ProcessedFile
                {
                    FileName = $"Combined_{DateTime.Now:yyyyMMdd_HHmmss}.magn",
                    Data = combinedData
                };
    
                // Добавление новой вкладки с результатом
                AddProcessedFileTab(processedFile);
            }
            catch (Exception ex)
            {
                MessageBox.Show($"Ошибка при объединении файлов: {ex.Message}", "Ошибка", MessageBoxButton.OK, MessageBoxImage.Error);
            }
        }
    }
    

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

    • Использование List<ProcessedRow> вместо List<string[]>: Это упрощает хранение и обработку данных.
    • Избежание лишних преобразований: Прямое добавление ProcessedRow объектов, что снижает накладные расходы на конвертацию данных.

    5. Улучшение обработки больших файлов

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

    Использование ObservableCollection с потоковой загрузкой:

    private async Task PreviewFileAsync(FileSetting fileSetting)
    {
        try
        {
            if (!File.Exists(fileSetting.FilePath))
            {
                PreviewDataGrid.ItemsSource = null;
                MessageBox.Show($"Файл не найден: {fileSetting.FilePath}", "Ошибка", MessageBoxButton.OK, MessageBoxImage.Error);
                return;
            }
    
            var data = new ObservableCollection<PreviewRow>();
            int currentLine = 0;
            int maxColumns = 0;
            int maxPreviewLines = 1000;
    
            await Task.Run(() =>
            {
                using (StreamReader reader = new StreamReader(fileSetting.FilePath))
                {
                    // Пропуск строк
                    for (int i = 0; i < fileSetting.LinesToSkip; i++)
                    {
                        if (reader.ReadLine() == null)
                            break;
                        currentLine++;
                    }
    
                    string line;
                    while ((line = reader.ReadLine()) != null && data.Count < maxPreviewLines)
                    {
                        currentLine++;
                        var columns = line.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
    
                        if (columns.Length > maxColumns)
                            maxColumns = columns.Length;
    
                        // Создание строки для предпросмотра
                        var previewRow = new PreviewRow
                        {
                            LineNumber = currentLine,
                            Columns = columns.ToList()
                        };
    
                        // Добавление строки в коллекцию
                        Dispatcher.Invoke(() => data.Add(previewRow));
                    }
                }
            });
    
            // Создание колонок
            Dispatcher.Invoke(() =>
            {
                PreviewDataGrid.Columns.Clear();
                PreviewDataGrid.Columns.Add(new DataGridTextColumn
                {
                    Header = "#",
                    Binding = new System.Windows.Data.Binding("LineNumber"),
                    Width = 50
                });
    
                for (int i = 0; i < maxColumns; i++)
                {
                    PreviewDataGrid.Columns.Add(new DataGridTextColumn
                    {
                        Header = $"C{i + 1}",
                        Binding = new System.Windows.Data.Binding($"Columns[{i}]"),
                        Width = 100
                    });
                }
    
                PreviewDataGrid.ItemsSource = data;
                this.Title = $"Magnet File Previewer - {System.IO.Path.GetFileName(fileSetting.FilePath)} (Предпросмотр {data.Count} строк)";
            });
        }
        catch (Exception ex)
        {
            PreviewDataGrid.ItemsSource = null;
            MessageBox.Show($"Ошибка при чтении файла: {ex.Message}", "Ошибка", MessageBoxButton.OK, MessageBoxImage.Error);
        }
    }
    

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

    • Использование ObservableCollection: Это позволяет динамически обновлять UI по мере добавления новых строк.
    • Добавление строк в UI по мере чтения: Использование Dispatcher.Invoke для добавления строк в коллекцию обеспечивает обновление UI в реальном времени и предотвращает блокировку интерфейса.

    6. Анализ производительности и профилирование

    Для более точного определения узких мест рекомендуется использовать инструменты профилирования, такие как Visual Studio Profiler или dotMemory. Они помогут понять, какие части кода потребляют больше всего памяти и времени.

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

    • Асинхронность: Убедитесь, что все операции ввода-вывода выполняются асинхронно, чтобы не блокировать UI-поток.
    • Кэширование: Если вы часто обращаетесь к одним и тем же файлам, рассмотрите возможность кэширования их содержимого с ограниченным количеством строк.
    • Управление ресурсами: Периодически освобождайте неиспользуемые ресурсы и убедитесь, что нет утечек памяти.

    Финальная модифицированная версия PreviewFileAsync с ограничением строк и использованием ObservableCollection

    private async Task PreviewFileAsync(FileSetting fileSetting)
    {
        try
        {
            if (!File.Exists(fileSetting.FilePath))
            {
                PreviewDataGrid.ItemsSource = null;
                MessageBox.Show($"Файл не найден: {fileSetting.FilePath}", "Ошибка", MessageBoxButton.OK, MessageBoxImage.Error);
                return;
            }
    
            var data = new ObservableCollection<PreviewRow>();
            int currentLine = 0;
            int maxColumns = 0;
            int maxPreviewLines = 1000; // Ограничение для предпросмотра
    
            await Task.Run(() =>
            {
                using (StreamReader reader = new StreamReader(fileSetting.FilePath))
                {
                    // Пропуск строк
                    for (int i = 0; i < fileSetting.LinesToSkip; i++)
                    {
                        if (reader.ReadLine() == null)
                            break;
                        currentLine++;
                    }
    
                    string line;
                    while ((line = reader.ReadLine()) != null && data.Count < maxPreviewLines)
                    {
                        currentLine++;
                        var columns = line.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
    
                        if (columns.Length > maxColumns)
                            maxColumns = columns.Length;
    
                        var previewRow = new PreviewRow
                        {
                            LineNumber = currentLine,
                            Columns = columns.ToList()
                        };
    
                        // Добавление строки в коллекцию
                        Dispatcher.Invoke(() => data.Add(previewRow));
                    }
                }
            });
    
            // Создание колонок
            Dispatcher.Invoke(() =>
            {
                PreviewDataGrid.Columns.Clear();
                PreviewDataGrid.Columns.Add(new DataGridTextColumn
                {
                    Header = "#",
                    Binding = new System.Windows.Data.Binding("LineNumber"),
                    Width = 50
                });
    
                for (int i = 0; i < maxColumns; i++)
                {
                    PreviewDataGrid.Columns.Add(new DataGridTextColumn
                    {
                        Header = $"C{i + 1}",
                        Binding = new System.Windows.Data.Binding($"Columns[{i}]"),
                        Width = 100
                    });
                }
    
                PreviewDataGrid.ItemsSource = data;
                this.Title = $"Magnet File Previewer - {System.IO.Path.GetFileName(fileSetting.FilePath)} (Предпросмотр {data.Count} строк)";
            });
        }
        catch (Exception ex)
        {
            PreviewDataGrid.ItemsSource = null;
            MessageBox.Show($"Ошибка при чтении файла: {ex.Message}", "Ошибка", MessageBoxButton.OK, MessageBoxImage.Error);
        }
    }
    

    Заключение

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

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