Загрузка данных из XML в DataGrid

public Visibility Visible { get; set; } = Visibility.Visible;
public Visibility VisibleSave { get; set; } = Visibility.Hidden;

public virtual void ChangeMode()
        {
            if (Visible == Visibility.Visible)
            {
                Visible = Visibility.Hidden;
                VisibleSave = Visibility.Visible;
            }
            else
            {
                Visible = Visibility.Visible;
                VisibleSave = Visibility.Hidden;
            }
        }
        private ICommand _saveChangeCommand { get; set; }
        public ICommand SaveChangeCommand => _saveChangeCommand ?? (_saveChangeCommand = new RelayCommand(OnSaveChange));
        protected virtual void OnSaveChange(object value)
        {
            //Сохранение данных
 
            //Метод смены режима
            ChangeMode();
        }
 
        private ICommand _exitModeCommand { get; set; }
        public ICommand ExitModeCommand => _exitModeCommand ?? (_exitModeCommand = new RelayCommand(OnExitMode));
        protected virtual void OnExitMode(object value)
        {
            ChangeMode();
        }

public Mode IsChange { get; set; };
        public enum Mode
        {
            Нормальный = 1,
            Добавление = 2,
            Редактирование = 3
        }

    /// <summary>Базовый класс с реализацией INPC </summary>
    public class OnPropertyChangedClass : INotifyPropertyChanged
    {
        #region Событие PropertyChanged и метод для его вызова
        /// <summary>Событие для извещения об изменения свойства</summary>
        public event PropertyChangedEventHandler PropertyChanged;
        /// <summary>Метод для вызова события извещения об изменении свойства</summary>
        /// <param name="prop">Изменившееся свойство</param>
        public void OnPropertyChanged([CallerMemberName]string prop = "")
        {
            string[] names = prop.Split("\\/\r \n()\"\'-".ToArray(), StringSplitOptions.RemoveEmptyEntries);
            switch (names.Length)
            {
                case 0: break;
                case 1:
                    PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(prop));
                    break;
                default:
                    OnPropertyChanged(names);
                    break;
            }
 
        }
 
        /// <summary>Метод для вызова события извещения об изменении списка свойств</summary>
        /// <param name="propList">Список имён свойств</param>
        public void OnPropertyChanged(IEnumerable<string> propList)
        {
            foreach (string prop in propList.Where(name => !string.IsNullOrWhiteSpace(name)))
                OnPropertyChanged(prop);
        }
 
        /// <summary>Метод для вызова события извещения об изменении списка свойств</summary>
        /// <param name="propList">Список свойств</param>
        public void OnPropertyChanged(IEnumerable<PropertyInfo> propList)
        {
            foreach (PropertyInfo prop in propList)
                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(prop.Name));
        }
 
        /// <summary>Метод для вызова события извещения об изменении всех свойств</summary>
        /// <param name="propList">Список свойств</param>
        public void OnAllPropertyChanged()
            => OnPropertyChanged(GetType().GetProperties());
        #endregion
    }
}

    /// <summary>Класс ViewModel времени разработки</summary>
    public class ViewModelDesigned : OnPropertyChangedClass
    {
        #region Приватные поля для хранения значений свойсвт
        private Client _currentClient = new Client();
        private Client _selectedClient = new Client();
        private List<Client> _clients = new List<Client>();
        private bool _isEdit;
        private bool _isAddNew;
        private bool _isModified;
        #endregion
 
        #region Свойства для привязки
        /// <summary>Клиент чьи свойства редактируются</summary>
        public Client CurrentClient { get => _currentClient; set { _currentClient = value; OnPropertyChanged(); } }
        /// <summary>Клиент выделенный в DataGrid</summary>
        public Client SelectedClient { get => _selectedClient; set { _selectedClient = value; if (!IsEdit) CurrentClient = SelectedClient; OnPropertyChanged(); } }
        /// <summary>Список клиентов</summary>
        public virtual List<Client> Clients { get => _clients; set { _clients = value; OnPropertyChanged(); } }
 
        /// <summary>Флаг режима редактирования</summary>
        public bool IsEdit { get => _isEdit; set { _isEdit = value; OnPropertyChanged(); } }
        /// <summary>Флаг режима вдобавления нового клиета</summary>
        public bool IsAddNew { get => _isAddNew; set { _isAddNew = value; OnPropertyChanged(); } }
        /// <summary>Флаг наличия несохранённых изменений</summary>
        public bool IsModified { get => _isModified; set { _isModified = value; OnPropertyChanged(); } }
        #endregion
 
        #region Свойства, поля и методы для привязки команд
        /// <summary>Поле для хранения значения свойства OpenFileCommand</summary>
        private ICommand _openFileCommand { get; set; }
        /// <summary>Свойство для привязки команды Открыть Файл</summary>
        public ICommand OpenFileCommand => _openFileCommand ?? (_openFileCommand = new RelayCommand(OnOpenFile));
        /// <summary>Метод для команды OpenFileCommand</summary>
        protected virtual void OnOpenFile(object value) { }
 
        /// <summary>Поле для хранения значения свойства SaveCommand</summary>
        private ICommand _saveCommand { get; set; }
        /// <summary>Свойство для привязки команды Сохранить</summary>
        public ICommand SaveCommand => _saveCommand ?? (_saveCommand = new RelayCommand(OnSave));
        /// <summary>Метод для команды SaveCommand</summary>
        protected virtual void OnSave(object value) { }
 
        /// <summary>Поле для хранения значения свойства SaveAsCommand</summary>
        private ICommand _saveAsCommand { get; set; }
        /// <summary>Свойство для привязки команды Сохранить в....</summary>
        public ICommand SaveAsCommand => _saveAsCommand ?? (_saveAsCommand = new RelayCommand(OnSaveAs));
        /// <summary>Метод для команды SaveAsCommand</summary>
        protected virtual void OnSaveAs(object value) { }
 
        /// <summary>Поле для хранения значения свойства AddCommand</summary>
        private ICommand _addCommand { get; set; }
        /// <summary>Свойство для привязки команды Добавить</summary>
        public ICommand AddCommand => _addCommand ?? (_addCommand = new RelayCommand(OnAdd));
        /// <summary>Метод для команды AddCommand</summary>
        protected virtual void OnAdd(object value) { IsEdit = true; IsAddNew = true; CurrentClient = new Client(); }
 
        /// <summary>Поле для хранения значения свойства RemoveCommand</summary>
        private ICommand _removeCommand { get; set; }
        /// <summary>Свойство для привязки команды Удалить</summary>
        public ICommand RemoveCommand => _removeCommand ?? (_removeCommand = new RelayCommand(OnRemove));
        /// <summary>Метод для команды RemoveCommand</summary>
        protected virtual void OnRemove(object value) { }
 
        /// <summary>Поле для хранения значения свойства EditCommand</summary>
        private ICommand _editCommand { get; set; }
        /// <summary>Свойство для привязки команды Редактировать</summary>
        public ICommand EditCommand => _editCommand ?? (_editCommand = new RelayCommand(OnEdit));
        /// <summary>Метод для команды EditCommand</summary>
        protected virtual void OnEdit(object value) { IsEdit = true; CurrentClient = SelectedClient.Copy(); }
 
        /// <summary>Поле для хранения значения свойства RemoveCommand</summary>
        private ICommand _saveChangeCommand { get; set; }
        /// <summary>Свойство для привязки команды Удалить</summary>
        public ICommand SaveChangeCommand => _saveChangeCommand ?? (_saveChangeCommand = new RelayCommand(OnSaveChange));
        /// <summary>Метод для команды RemoveCommand</summary>
        protected virtual void OnSaveChange(object value) { }
 
        /// <summary>Поле для хранения значения свойства EditCommand</summary>
        private ICommand _exitCommand { get; set; }
        /// <summary>Свойство для привязки команды Редактировать</summary>
        public ICommand ExitCommand => _exitCommand ?? (_exitCommand = new RelayCommand(OnExit));
        /// <summary>Метод для команды EditCommand</summary>
        protected virtual void OnExit(object value)
        {
            // Проверка были изменения или нет
            if
            (
                IsEdit
                && ((IsAddNew && !CurrentClient.Equals(new Client()))
                    || (!IsAddNew && !CurrentClient.Equals(SelectedClient)))
            ) // Если были изменения, то вывод предупреждения
                if (MessageBox.Show("Данные не были сохранены!\nПри выходе изменения будут утеряны\nВсё равно выйти?", "Предупреждение!", MessageBoxButton.YesNo)
                     == MessageBoxResult.No)
                    return;
            IsEdit = false;
            IsAddNew = false;
            CurrentClient = SelectedClient;
        }
        #endregion
    }

    /// <summary>Конвертер преобразующий bool в Visibility</summary>
    [ValueConversion(typeof(Boolean), typeof(Visibility))]
    public class BooleanToVisibilityConverter : IValueConverter
    {
        /// <summary>Прямая конвертация bool в Visibility</summary>
        /// <param name="value">Значение для конвертации</param>
        /// <param name="targetType">Целевой тип</param>
        /// <param name="parameter">Параметр. Если в нём "not", "no", "false" или "нет", то инвертируем видимость</param>
        /// <param name="culture">Не используется</param>
        /// <returns>Видимость</returns>
        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
        {
            Visibility ret = Visibility.Visible;
 
            // Если проверяемое значение не null и равно false, то коллапс
            if (value != null && ((value.GetType() == typeof(bool) && (bool)value == false)
                                    || (value.GetType() == typeof(string) && ((string)value).ToLower().Contains("false"))
                                  )
               )
                ret = Visibility.Collapsed;
 
            // Если параметр не null, то проверяем его тип
            if (parameter != null)
            {
                // Если тип параметра bool и он равен false, то инвертируем видимость
                if (parameter.GetType() == typeof(bool) && (bool)parameter == false)
                    if (ret == Visibility.Collapsed)
                        ret = Visibility.Visible;
                    else ret = Visibility.Collapsed;
 
                // Если тип параметра string и он содержит "not", "no", "false" или "нет", то инвертируем видимость
 
                if (parameter.GetType() == typeof(string)
                    && !string.IsNullOrWhiteSpace("not no false нет".Split().FirstOrDefault(str => ((string)parameter).ToLower().Contains(str))))
                    if (ret == Visibility.Collapsed)
                        ret = Visibility.Visible;
                    else ret = Visibility.Collapsed;
            }
 
            return ret;
        }
        /// <summary>Обратная конвертация не реализована</summary>
        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
        {
            return value;
        }
 
    }

    /// <summary>Конвертер инвертирующий bool</summary>
    [ValueConversion(typeof(Boolean), typeof(Boolean))]
    public class BooleanNotConverter : IValueConverter
    {
        /// <summary>Ивертация bool</summary>
        /// <param name="value">Инвертируемое значение</param>
        /// <param name="targetType">Не используется</param>
        /// <param name="parameter">Не используется</param>
        /// <param name="culture">Не используется</param>
        /// <returns>Инвертированное значение</returns>
        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
        {
            if (value.GetType() == typeof(bool))
                return !(bool)value;
            else
                return value;
        }
 
        /// <summary>Обратный конвертер</summary>
        /// <param name="value">Инвертируемое значение</param>
        /// <param name="targetType">Не используется</param>
        /// <param name="parameter">Не используется</param>
        /// <param name="culture">Не используется</param>
        /// <returns>Инвертированное значение</returns>
        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
        {
            if (value.GetType() == typeof(bool))
                return !(bool)value;
            else
                return value;
        }
    }

    /// <summary>Класс представляющий клиента</summary>
    public class Client
    {
        /// <summary>Неизменяемый уникальный идентификатор</summary>
        public string ID { get; private set; }
        /// <summary>Имя, фамилия и отчество</summary>
        public string Name { get; set; }
        /// <summary>Дата рождения</summary>
        public DateTime DateOfBirth { get; set; }
        /// <summary>Пол: мужской, женский</summary>
        public SexEnum Sex { get; set; }
        /// <summary>Место работы</summary>
        public string Job { get; set; }
        /// <summary>Доход (рублей в месяц)/summary>
        public string Salary { get; set; }
        /// <summary>Контактные телефоны</summary>
        public string Telephone { get; set; }
 
        /// <summary>Статический конструктор создания экземпляра из XML</summary>
        /// <param name="ClientXML">XElement с данными</param>
        /// <returns>Новый экземпляр если данные корректны, иначе - null</returns>
        public static Client CreateFromXML(XElement ClientXML)
        {
            if (ClientXML.Name != "Client") // Проверка имени корневого элемента
                return null;
            if // Проверка наличия всех необходимых данных
            (
                ClientXML.Attribute("ID") == null
                || ClientXML.Element("Name") == null
                || ClientXML.Element("DateOfBirth") == null
                || ClientXML.Element("Sex") == null
                || ClientXML.Element("Job") == null
                || ClientXML.Element("Salary") == null
                || ClientXML.Element("Telephone") == null
                || !DateTime.TryParse(ClientXML.Element("DateOfBirth").Value, out DateTime dateOfBirth)
                || !Enum.TryParse(ClientXML.Element("Sex").Value, true, out SexEnum sex)
             ) return null;
 
            return new Client()
            {
                ID = ClientXML.Attribute("ID").Value,
                Name = ClientXML.Element("Name").Value,
                DateOfBirth = dateOfBirth,
                Sex = sex,
                Job = ClientXML.Element("Job").Value,
                Salary = ClientXML.Element("Salary").Value,
                Telephone = ClientXML.Element("Telephone").Value
            };
        }
 
        /// <summary>Преобразует в XML</summary>
        /// <returns>XElement нужной структуры с нужными данными</returns>
        public XElement ToXML() => XElement.Parse
            (
                $"<Client ID=\"{ID?.Trim()}\">" +
                    $"<Name>{Name?.Trim()}</Name>" +
                    $"<DateOfBirth>{DateOfBirth.ToString()}</DateOfBirth>" +
                    $"<Sex>{Sex.ToString().Trim()}</Sex>" +
                    $"<Job>{Job?.Trim()}</Job>" +
                    $"<Salary>{Salary?.Trim()}</Salary>" +
                    $"<Telephone>{Telephone?.Trim()}</Telephone>" +
                $"</Client>"
             );
 
        /// <summary>Метод создания нового уникального ID</summary>
        /// <param name="Clients">Список существующих Client</param>
        /// <returns>Случайный ID которого нет в списке переданных Client</returns>
        public static string NewID(IEnumerable<Client> Clients)
        {
 
            Random rnd = new Random();
            string id;
            do
            {
                // Создаём в цикле новые ID до тех пор пока не найдём
                // несуществующий в переданном списке
                id = "Cl" + rnd.Next(1000000).ToString().PadLeft(6, '0');
            } while (Clients.FirstOrDefault(client => client.ID == id) != null);
            return id;
        }
 
        /// <summary>Возвращает список допустимых полов</summary>
        public SexEnum[] ListSex => (SexEnum[])Enum.GetValues(typeof(SexEnum));
 
        /// <summary>Перечисление допустимых полов</summary>
        public enum SexEnum
        {
            Мужской = 1,
            Женский = 2
        }
 
        /// <summary>Копирует объект</summary>
        /// <returns>Возвращает новый объект копию</returns>
        public Client Copy() => new Client()
        {
            ID = ID,
            Name = Name,
            DateOfBirth = DateOfBirth,
            Sex = Sex,
            Job = Job,
            Salary = Salary,
            Telephone = Telephone
        };
 
        public override bool Equals(object obj)
        {
            var client = obj as Client;
            return client != null &&
                   ID == client.ID &&
                   Name == client.Name &&
                   DateOfBirth == client.DateOfBirth &&
                   Sex == client.Sex &&
                   Job == client.Job &&
                   Salary == client.Salary &&
                   Telephone == client.Telephone;
        }
 
        public override int GetHashCode()
        {
            var hashCode = -1522303320;
            hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(ID);
            hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(Name);
            hashCode = hashCode * -1521134295 + DateOfBirth.GetHashCode();
            hashCode = hashCode * -1521134295 + Sex.GetHashCode();
            hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(Job);
            hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(Salary);
            hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(Telephone);
            return hashCode;
        }
    }