Добавьте файлы проекта.

QWERTYkez.WordProcessor/WordReader.cs

@@ -0,0 +1,285 @@
+namespace QWERTYkez.WordProcessor;
+
+/// <summary>
+/// Предоставляет потокобезопасный процессор только для чтения документов Word (DOCX) формата.
+/// <para>Не поддерживает операции изменения документа.</para>
+/// </summary>
+internal class WordReader : IDisposable, IWordReader
+{
+    protected MemoryStream _ms = null!;
+    protected WordprocessingDocument _doc = null!;
+    protected Body _body = null!;
+    protected bool _disposed;
+    protected readonly object _syncLock = new();
+    protected string? _originalSourcePath;
+
+    public Body Body => _body;
+
+    internal WordReader() { }
+
+    #region Factory Methods
+
+    internal static WordReader? CreateInternal(FileInfo sourceFile)
+    {
+        if (sourceFile is null || !sourceFile.Exists)
+        {
+#if DEBUG
+            Debug.WriteLine($"[DEBUG] Source file is null or does not exist: {sourceFile?.FullName}");
+#endif
+            return null;
+        }
+
+        MemoryStream? ms = null;
+        WordprocessingDocument? doc = null;
+
+        try
+        {
+            ms = new MemoryStream();
+            using (var file = new FileStream(sourceFile.FullName,
+                FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete))
+            {
+                file.CopyTo(ms);
+            }
+            ms.Position = 0;
+
+            doc = WordprocessingDocument.Open(ms, isEditable: false,
+                new OpenSettings { AutoSave = false });
+
+            if (doc.MainDocumentPart?.Document?.Body is not { } body)
+            {
+#if DEBUG
+                Debug.WriteLine("[DEBUG] Document body is null or empty");
+#endif
+                doc.Dispose();
+                ms.Dispose();
+                return null;
+            }
+
+            var processor = new WordReader
+            {
+                _ms = ms,
+                _doc = doc,
+                _body = body,
+                _originalSourcePath = sourceFile.FullName,
+                FilePath = sourceFile.FullName
+            };
+
+            return processor;
+        }
+        catch (Exception ex)
+        {
+#if DEBUG
+            Debug.WriteLine($"[DEBUG] Error creating read-only processor: {ex.GetType().Name}: {ex.Message}");
+#endif
+            doc?.Dispose();
+            ms?.Dispose();
+            return null;
+        }
+    }
+
+    internal static WordReader? CreateFromData(ReadOnlyMemory<byte> data)
+    {
+        if (data.IsEmpty)
+            return null;
+
+        var ms = new MemoryStream();
+        try
+        {
+            ms.Write(data.ToArray(), 0, data.Length);
+            ms.Position = 0;
+
+            var doc = WordprocessingDocument.Open(ms, false, new OpenSettings { AutoSave = false });
+            if (doc.MainDocumentPart?.Document?.Body is not { } body)
+            {
+                doc.Dispose();
+                ms.Dispose();
+                return null;
+            }
+
+            return new WordReader
+            {
+                _ms = ms,
+                _doc = doc,
+                _body = body,
+                FilePath = null // из памяти – нет файла
+            };
+        }
+        catch
+        {
+            ms?.Dispose();
+            return null;
+        }
+    }
+
+    #endregion
+
+    #region Writers
+
+    public bool TryWrite(string destinationPath, Action<IWordWriter> action)
+    {
+        ThrowIfDisposed();
+
+        if (string.IsNullOrEmpty(destinationPath))
+            throw new ArgumentException("Destination path cannot be null or empty", nameof(destinationPath));
+        if (action is null)
+            throw new ArgumentNullException(nameof(action));
+
+        // Копируем данные из текущего потока
+        byte[] data;
+        lock (_syncLock)
+        {
+            _ms.Position = 0;
+            data = _ms.ToArray();
+        }
+
+        using var writable = WordWriter.CreateFromData(new ReadOnlyMemory<byte>(data), destinationPath);
+        if (writable is null)
+            return false;
+
+        try
+        {
+            action(writable);
+            return true;
+        }
+        catch (Exception ex)
+        {
+#if DEBUG
+            Debug.WriteLine($"[DEBUG] Error in TryWrite action: {ex.Message}");
+#endif
+            return false;
+        }
+    }
+
+    public bool TryWrite(Action<IWordWriter> write, Action<IWordReader> read)
+    {
+        ThrowIfDisposed();
+        if (write is null) throw new ArgumentNullException(nameof(write));
+        if (read is null) throw new ArgumentNullException(nameof(read));
+
+        // Копируем текущие данные
+        byte[] data;
+        lock (_syncLock)
+        {
+            _ms.Position = 0;
+            data = _ms.ToArray();
+        }
+
+        WordWriter? writable = null;
+        WordReader? resultReader = null;
+        try
+        {
+            // Создаём редактируемую копию (без привязки к файлу)
+            writable = WordWriter.CreateFromData(data);
+            if (writable is null)
+                return false;
+
+            // Применяем изменения
+            write(writable);
+
+            // Сохраняем изменения в поток и создаём read-only процессор
+            resultReader = writable.ToReader();
+
+            if (resultReader is null)
+                return false;
+
+            // Работаем с изменённой копией
+            read(resultReader);
+            return true;
+        }
+        catch (Exception ex)
+        {
+#if DEBUG
+            Debug.WriteLine($"[DEBUG] Error in TryWrite(write, read): {ex.Message}");
+#endif
+            return false;
+        }
+        finally
+        {
+            // Гарантированно освобождаем созданные процессоры
+            resultReader?.Dispose();
+            writable?.Dispose();
+        }
+    }
+
+    #endregion
+
+    #region Properties
+
+    /// <summary>
+    /// Получает путь к исходному файлу.
+    /// </summary>
+    public string? FilePath { get; protected set; }
+
+    /// <summary>
+    /// Получает значение, указывающее, находится ли процессор в допустимом состоянии для операций.
+    /// </summary>
+    public bool IsValid => !_disposed && _doc is not null && _body is not null && _ms is not null;
+
+    /// <summary>
+    /// Получает текущий размер документа в байтах.
+    /// </summary>
+    public long DocumentSize => _ms.Length;
+
+    #endregion
+
+    #region Read Operations
+
+    /// <summary>
+    /// Находит все уникальные плейсхолдеры в формате $...$ в документе.
+    /// <para>Ищет только внутри параграфов. Игнорирует вхождения, которые пересекают границы параграфов.</para>
+    /// </summary>
+    /// <param name="comparisonType">Способ сравнения строк при поиске (по умолчанию: без учета регистра)</param>
+    /// <returns>Коллекция уникальных найденных плейсхолдеров</returns>
+    public ISet<string> FindPlaceholders()
+    {
+        ThrowIfDisposed();
+
+        lock (_syncLock)
+        {
+            return PlaceholderFinder.FindInDocument(_doc, _body);
+        }
+    }
+
+    #endregion
+
+    #region Dispose Pattern
+
+    protected void ThrowIfDisposed()
+    {
+        if (_disposed)
+            throw new ObjectDisposedException(GetType().Name);
+    }
+
+    protected virtual void Dispose(bool disposing)
+    {
+        if (_disposed)
+            return;
+
+        lock (_syncLock)
+        {
+            if (disposing)
+            {
+                _doc.Dispose();
+                _ms.Dispose();
+            }
+
+            _doc = null!;
+            _body = null!;
+            _ms = null!;
+            _disposed = true;
+        }
+    }
+
+    public void Dispose()
+    {
+        Dispose(disposing: true);
+        GC.SuppressFinalize(this);
+    }
+
+    ~WordReader()
+    {
+        Dispose(disposing: false);
+    }
+
+    #endregion
+}