Сохранить повреждённый бекап в созданную директорию

using System;
using System.IO;
using System.Xml;
using System.Xml.Serialization;
 
namespace Program
{
    internal class XmlStorage<T> : IAppStorage<T> where T : new()
    {
        private readonly object _lock = new object();
        private readonly FileInfo _file;
        private readonly string _rootElementName;
        private T _data;
        private FileStream _fileStream;
        private TextWriter _writer;
        private TextReader _reader;
 
        public bool IsOpen { get; private set; }
 
        public T Data
        {
            get
            {
                lock (_lock)
                {
                    ThrowIfNotOpened();
                    return _data;
                }
            }
        }
 
        public XmlStorage(FileInfo file, string rootElementName = null)
        {
            if (file == null) throw new ArgumentNullException("file");
 
            _file = file;
            _rootElementName = rootElementName;
        }
 
        public void Open(bool doBackup)
        {
            lock (_lock)
            {
                ThrowIfOpened();
                _file.Refresh();
 
                bool newFile = !_file.Exists;
 
                if (newFile && !string.IsNullOrEmpty(_file.DirectoryName))
                {
                    Directory.CreateDirectory(_file.DirectoryName);
                }
 
                try
                {
                    _fileStream = _file.Open(FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.Read);
                }
                catch (Exception ex)
                {
                    throw new IOException("Не удалось открыть или создать файл хранилища.", ex);
                }
 
                _writer = new StreamWriter(_fileStream);
                _reader = new StreamReader(_fileStream);
 
                if (newFile)
                {
                    _data = new T();
                    InternalSave();
                }
                else
                {
                    try
                    {
                        var xmlSerializer =
                            _rootElementName == null
                            ? new XmlSerializer(typeof(T))
                            : new XmlSerializer(typeof(T), new XmlRootAttribute(_rootElementName));
 
                        _data = (T)xmlSerializer.Deserialize(_reader);
                    }
                    catch (Exception ex)
                    {
                        DirectoryInfo directory = new DirectoryInfo(@".");
                        if (directory.Exists)
                        {
                            directory.CreateSubdirectory(@"C:\Users\Mikhailov\Desktop\ar-30\Aggregation_AR30\bin\Debug\Data\Backup");
                        }
 
                        throw new IOException("Не удалось разобрать данные хранилища. Возможно, данные повреждены.", ex);
                    }
                }
 
                IsOpen = true;
            }
        }
 
        public void OpenNew()
        {
            lock (_lock)
            {
                ThrowIfOpened();
 
                try
                {
                    _fileStream = _file.Open(FileMode.Create, FileAccess.ReadWrite, FileShare.Read);
                }
                catch (Exception ex)
                {
                    throw new IOException("Не удалось создать или перезаписать файл хранилища.", ex);
                }
 
                _writer = new StreamWriter(_fileStream);
                _reader = new StreamReader(_fileStream);
                _data = new T();
 
                IsOpen = true;
            }
        }
 
        public void Close()
        {
            lock (_lock)
            {
                ThrowIfNotOpened();
 
                _fileStream.Dispose();
                IsOpen = false;
            }
        }
 
        public void Save()
        {
            lock (_lock)
            {
                ThrowIfNotOpened();
 
                _fileStream.SetLength(0);
                _fileStream.Flush();
 
                InternalSave();
            }
        }
 
        private void InternalSave()
        {
            var settings = new XmlWriterSettings
            {
                Indent = true,
                OmitXmlDeclaration = true
            };
 
            try
            {
                using (var xmlWriter = XmlWriter.Create(_writer, settings))
                {
                    var emptyNamepsaces = new XmlSerializerNamespaces(new[] { XmlQualifiedName.Empty });
 
                    var xmlSerializer =
                        _rootElementName == null
                        ? new XmlSerializer(typeof(T))
                        : new XmlSerializer(typeof(T), new XmlRootAttribute(_rootElementName));
 
                    xmlSerializer.Serialize(xmlWriter, _data, emptyNamepsaces);
                    xmlWriter.Flush();
                }
            }
            catch (Exception ex)
            {
                throw new IOException("Не удалось сериализовать данные в хранилище.", ex);
            }
        }
 
        private void ThrowIfOpened()
        {
            if (IsOpen) throw new InvalidOperationException("Доступ к хранилищу уже открыт.");
        }
 
        private void ThrowIfNotOpened()
        {
            if (!IsOpen) throw new InvalidOperationException("Необходимо открыть доступ к хранилищу.");
        }
    }
}