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

<Window x:Class="magnet.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:local="clr-namespace:magnet"
        Title="Magnet File Previewer" Height="800" Width="1000">
    <Grid>
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="200"/>
            <!-- Левая колонка для кнопок -->
            <ColumnDefinition Width="*"/>
            <!-- Правая колонка для списков и предпросмотра -->
        </Grid.ColumnDefinitions>
        <!-- Левая панель с кнопками -->
        <StackPanel Grid.Column="0" HorizontalAlignment="Center" VerticalAlignment="Top" Margin="10">
            <Button Name="LoadTxtFilesButton" Width="180" Height="40" Click="LoadTxtFilesButton_Click" Margin="0,10,0,15">Загрузить .txt файлы</Button>
            <Button Name="LoadMagnetFilesButton" Width="180" Height="40" Click="LoadMagnetFilesButton_Click" Margin="0,0,0,15">Загрузить .magnet файлы</Button>
            <Button Name="CreateCombinedFileButton" Width="180" Height="40" Click="CreateCombinedFileButton_Click" Margin="0,0,0,15">Создать объединённый файл</Button>
            <Button Name="SaveProjectButton" Width="180" Height="40" Click="SaveProjectButton_Click" Margin="0,0,0,15">Сохранить проект</Button>
            <Button Name="LoadProjectButton" Width="180" Height="40" Click="LoadProjectButton_Click">Загрузить проект</Button>
        </StackPanel>
        <!-- Правая панель с списками файлов и предпросмотром -->
        <Grid Grid.Column="1" Margin="10">
            <Grid.RowDefinitions>
                <RowDefinition Height="Auto"/>
                <!-- Группировка ListView -->
                <RowDefinition Height="Auto"/>
                <!-- Ввод пропуска строк -->
                <RowDefinition Height="*"/>
                <!-- Предпросмотр файла -->
                <RowDefinition Height="2*"/>
                <!-- Таблица с обработанными файлами -->
            </Grid.RowDefinitions>
            <!-- Списки загруженных файлов -->
            <Grid Grid.Row="0" Margin="0,0,0,10">
                <Grid.ColumnDefinitions>
                    <ColumnDefinition Width="*"/>
                    <ColumnDefinition Width="*"/>
                </Grid.ColumnDefinitions>
                <!-- Группа .txt файлов -->
                <GroupBox Header=".txt файлы" Grid.Column="0" Margin="0,0,5,0">
                    <ListView Name="TxtFilesListView" SelectionChanged="TxtFilesListView_SelectionChanged">
                        <ListView.View>
                            <GridView>
                                <GridViewColumn Header="Название файла" DisplayMemberBinding="{Binding FilePath}" Width="200"/>
                                <GridViewColumn Header="Строки для пропуска" DisplayMemberBinding="{Binding LinesToSkip}" Width="150"/>
                            </GridView>
                        </ListView.View>
                    </ListView>
                </GroupBox>
                <!-- Группа .magnet файлов -->
                <GroupBox Header=".magnet файлы" Grid.Column="1" Margin="5,0,0,0">
                    <ListView Name="MagnetFilesListView" SelectionChanged="MagnetFilesListView_SelectionChanged">
                        <ListView.View>
                            <GridView>
                                <GridViewColumn Header="Название файла" DisplayMemberBinding="{Binding FilePath}" Width="200"/>
                                <GridViewColumn Header="Строки для пропуска" DisplayMemberBinding="{Binding LinesToSkip}" Width="150"/>
                            </GridView>
                        </ListView.View>
                    </ListView>
                </GroupBox>
            </Grid>
            <!-- Поле ввода LinesToSkip и кнопка Обновить -->
            <StackPanel Grid.Row="1" Orientation="Horizontal" Margin="0,0,0,10">
                <Label Content="Пропустить строк:" VerticalAlignment="Center"/>
                <TextBox Name="LinesToSkipTextBox" Width="60" Margin="5,0,0,0" Text="0" />
                <Button Content="Обновить" Click="UpdateLinesToSkip_Click" Margin="10,0,0,0" Width="80" />
            </StackPanel>
            <!-- Область предпросмотра файла -->
            <ScrollViewer Grid.Row="2" VerticalScrollBarVisibility="Auto">
                <TextBox Name="PreviewTextBox" IsReadOnly="True" 
                         VerticalScrollBarVisibility="Auto" 
                         HorizontalScrollBarVisibility="Auto" 
                         TextWrapping="Wrap" 
                         FontFamily="Consolas" 
                         FontSize="12"/>
            </ScrollViewer>
            <!-- Таблица с обработанными файлами -->
            <GroupBox Grid.Row="3" Header="Обработанные файлы" Margin="0,10,0,0">
                <TabControl Name="ProcessedFilesTabControl" />
            </GroupBox>
        </Grid>
    </Grid>
</Window>

using Microsoft.Win32;
using Newtonsoft.Json;
using System;
using System.Collections.ObjectModel;
using System.IO;
using System.Linq;
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 void LoadTxtFilesButton_Click(object sender, RoutedEventArgs e)
        {
            LoadFiles(".txt", currentProject.TxtFiles, TxtFilesListView);
        }

        /// <summary>
        /// Обработчик нажатия кнопки "Загрузить .magnet файлы".
        /// </summary>
        private void LoadMagnetFilesButton_Click(object sender, RoutedEventArgs e)
        {
            LoadFiles(".magnet", currentProject.MagnetFiles, MagnetFilesListView);
        }

        /// <summary>
        /// Метод для загрузки файлов определенного типа.
        /// </summary>
        /// <param name="extension">Расширение файлов.</param>
        /// <param name="fileCollection">Коллекция для добавления файлов.</param>
        /// <param name="listView">ListView для GUI.</param>
        private void LoadFiles(string extension, ObservableCollection<FileSetting> fileCollection, ListView listView)
        {
            OpenFileDialog dlg = new OpenFileDialog
            {
                Multiselect = true,
                Filter = $"Файлы {extension}|*{extension}"
            };

            bool? result = dlg.ShowDialog();

            if (result == true)
            {
                foreach (string filename in dlg.FileNames)
                {
                    // Проверка на уже добавленные файлы в соответствующей коллекции
                    if (!fileCollection.Any(f => f.FilePath.Equals(filename, StringComparison.OrdinalIgnoreCase)))
                    {
                        // Добавляем файл в коллекцию
                        var fileSetting = new FileSetting { FilePath = filename, LinesToSkip = 0 };
                        fileCollection.Add(fileSetting);

                        // Автоматически выбрать добавленный файл и отобразить его содержимое
                        listView.SelectedItem = fileSetting;
                    }
                    else
                    {
                        MessageBox.Show($"Файл уже добавлен: {filename}", "Информация", MessageBoxButton.OK, MessageBoxImage.Information);
                    }
                }
            }
        }

        /// <summary>
        /// Обработчик изменения выбора в ListView .txt файлов.
        /// </summary>
        private void TxtFilesListView_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (TxtFilesListView.SelectedItem is FileSetting selected)
            {
                selectedFile = selected;
                LinesToSkipTextBox.Text = selected.LinesToSkip.ToString();
                PreviewFile(selected);
                MagnetFilesListView.SelectedItem = null; // Снять выделение из другого списка
            }
            else
            {
                selectedFile = null;
                PreviewTextBox.Clear();
                LinesToSkipTextBox.Clear();
            }
        }

        /// <summary>
        /// Обработчик изменения выбора в ListView .magnet файлов.
        /// </summary>
        private void MagnetFilesListView_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (MagnetFilesListView.SelectedItem is FileSetting selected)
            {
                selectedFile = selected;
                LinesToSkipTextBox.Text = selected.LinesToSkip.ToString();
                PreviewFile(selected);
                TxtFilesListView.SelectedItem = null; // Снять выделение из другого списка
            }
            else
            {
                selectedFile = null;
                PreviewTextBox.Clear();
                LinesToSkipTextBox.Clear();
            }
        }

        /// <summary>
        /// Метод для загрузки и отображения содержимого файла с нумерацией строк.
        /// </summary>
        /// <param name="fileSetting">Настройки выбранного файла.</param>
        private void PreviewFile(FileSetting fileSetting)
        {
            try
            {
                if (!File.Exists(fileSetting.FilePath))
                {
                    PreviewTextBox.Text = $"Файл не найден: {fileSetting.FilePath}";
                    return;
                }

                using (StreamReader reader = new StreamReader(fileSetting.FilePath))
                {
                    int currentLine = 0;
                    // Пропускаем указанные строки
                    for (int i = 0; i < fileSetting.LinesToSkip; i++)
                    {
                        if (reader.ReadLine() == null)
                            break;
                        currentLine++;
                    }

                    // Читаем оставшиеся строки и нумеруем
                    string content = "";
                    string line;
                    while ((line = reader.ReadLine()) != null)
                    {
                        currentLine++;
                        content += $"{currentLine}. {line}{Environment.NewLine}";
                    }

                    PreviewTextBox.Text = content;
                }

                this.Title = $"Magnet File Previewer - {System.IO.Path.GetFileName(fileSetting.FilePath)}";
            }
            catch (Exception ex)
            {
                PreviewTextBox.Text = $"Ошибка при чтении файла: {ex.Message}";
            }
        }

        /// <summary>
        /// Обработчик нажатия кнопки "Обновить".
        /// Обновляет количество строк для пропуска и предпросмотр.
        /// </summary>
        private void UpdateLinesToSkip_Click(object sender, RoutedEventArgs e)
        {
            if (selectedFile != null)
            {
                if (int.TryParse(LinesToSkipTextBox.Text, out int skip) && skip >= 0)
                {
                    selectedFile.LinesToSkip = skip;
                    PreviewFile(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 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 = File.ReadAllText(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
                        PreviewTextBox.Clear();
                        LinesToSkipTextBox.Clear();
                        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 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 = reader.ReadLine(); // Предполагается, что есть заголовок
                            if (!string.IsNullOrWhiteSpace(headerLine))
                            {
                                // Можно добавить проверку структуры заголовков или игнорировать заголовки
                            }

                            string line;
                            while ((line = reader.ReadLine()) != null)
                            {
                                if (string.IsNullOrWhiteSpace(line))
                                    continue;
                                // Предполагается, что разделитель - табуляция
                                string[] columns = line.Split('\t'); // Или ',' если CSV

                                // Проверка наличия минимального количества столбцов
                                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[1]; // Столбец 3 исходного файла
                                newRow[2] = columns[1]; // Столбец 4 исходного файла
                                newRow[3] = columns[1]; // Столбец 5 исходного файла

                                // Обработка столбца 5: деление на 24 и форматирование как время
                                if (double.TryParse(columns[1], 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>
        /// <param name="processedFile">Обработанный файл.</param>
        private void AddProcessedFileTab(ProcessedFile processedFile)
        {
            // Создание DataGrid
            DataGrid dataGrid = new DataGrid
            {
                AutoGenerateColumns = false,
                IsReadOnly = false,
                CanUserAddRows = false,
                ItemsSource = processedFile.Data,
                Margin = new Thickness(5)
            };

            // Добавление столбцов
            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>
        /// <param name="processedFile">Обработанный файл.</param>
        private 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))
                    {
                        // Запись заголовка (опционально)
                        writer.WriteLine("№\tСтолбец 2\tСтолбец 3\tСтолбец 4\tСтолбец 5");

                        foreach (var row in processedFile.Data)
                        {
                            writer.WriteLine($"{row.Number}\t{row.Column2}\t{row.Column3}\t{row.Column4}\t{row.Column5}");
                        }
                    }

                    MessageBox.Show("Файл успешно сохранён!", "Успех", MessageBoxButton.OK, MessageBoxImage.Information);
                }
                catch (Exception ex)
                {
                    MessageBox.Show($"Ошибка при сохранении файла: {ex.Message}", "Ошибка", MessageBoxButton.OK, MessageBoxImage.Error);
                }
            }
        }

        /// <summary>
        /// Обработчик нажатия кнопки "Создать объединённый файл".
        /// </summary>
        /// (Ранее описан в Создание Объединённого Файла)
    }

    /// <summary>
    /// Класс для содержимого вкладки с обработанным файлом.
    /// </summary>
    public class ProcessedFile
    {
        public string FileName { get; set; }
        public List<ProcessedRow> Data { get; set; } = new List<ProcessedRow>();
    }

    /// <summary>
    /// Класс для строки обработанного файла.
    /// </summary>
    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, формат времени)
    }
}

using System.Collections.Generic;
using System.Windows;

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

        /// <summary>
        /// Конструктор окна выбора файлов.
        /// </summary>
        /// <param name="availableFiles">Список доступных файлов для выбора.</param>
        /// <param name="maxSelection">Максимальное количество выбираемых файлов.</param>
        public SelectFilesWindow(List<FileSetting> availableFiles, int maxSelection)
        {
            InitializeComponent();
            FilesListBox.ItemsSource = availableFiles;
        }

        /// <summary>
        /// Обработчик нажатия кнопки "OK".
        /// Проверяет, что выбрано ровно два файла.
        /// </summary>
        private void OKButton_Click(object sender, RoutedEventArgs e)
        {
            if (FilesListBox.SelectedItems.Count != 2)
            {
                MessageBox.Show("Выберите ровно два файла для объединения.", "Ошибка", 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();
        }
    }
}

using System.Collections.ObjectModel;

namespace magnet
{
    public class FileSetting
    {
        public string FilePath { get; set; }
        public int LinesToSkip { get; set; } = 0;
    }

    public class ProjectModel
    {
        public ObservableCollection<FileSetting> TxtFiles { get; set; } = new ObservableCollection<FileSetting>();
        public ObservableCollection<FileSetting> MagnetFiles { get; set; } = new ObservableCollection<FileSetting>();
    }
}

<Window x:Class="magnet.SelectFilesWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="Выберите файлы для объединения" Height="400" Width="300">
    <Grid Margin="10">
        <Grid.RowDefinitions>
            <RowDefinition Height="*"/>
            <RowDefinition Height="Auto"/>
        </Grid.RowDefinitions>
        <ListBox Name="FilesListBox" SelectionMode="Extended">
            <!-- Элементы будут добавлены из кода -->
        </ListBox>
        <StackPanel Grid.Row="1" Orientation="Horizontal" HorizontalAlignment="Right" Margin="0,10,0,0">
            <Button Content="OK" Width="75" Click="OKButton_Click" Margin="0,0,10,0"/>
            <Button Content="Отмена" Width="75" Click="CancelButton_Click"/>
        </StackPanel>
    </Grid>
</Window>