Программное заполнение коллекции и отображение в DataGrid с использованием MVVM

namespace MVVMTest.Model
{
    public class Person : INotifyPropertyChanged
    {
        #region INotifyPropertyChanged Impl
        public event PropertyChangedEventHandler PropertyChanged;
        protected virtual void OnPropertyChanged([CallerMemberName]string propertyName = null)
        {
            PropertyChangedEventHandler handler = PropertyChanged;
            if (handler != null)
                handler(this, new PropertyChangedEventArgs(propertyName));
        }
        #endregion
 
        private string m_firstName;
        public string FirstName
        {
            get { return m_firstName; }
            set
            {
                if (value == m_firstName)
                    return;
 
                m_firstName = value;
                OnPropertyChanged();
            }
        }
 
        private string m_lastName;
        public string LastName
        {
            get { return m_lastName; }
            set
            {
                if (value == m_lastName)
                    return;
 
                m_lastName = value;
                OnPropertyChanged();
            }
        }
 
        private int m_age;
        public int Age
        {
            get { return m_age; }
            set
            {
                if (value == m_age)
                    return;
 
                m_age = value;
                OnPropertyChanged();
            }
        }
    }
 
 
}

namespace MVVMTest.ViewModel
{
        public class MyViewModel : INotifyPropertyChanged
        {
            #region INotifyPropertyChanged Impl
            public event PropertyChangedEventHandler PropertyChanged;
            protected virtual void OnPropertyChanged([CallerMemberName]string propertyName = null)
            {
                PropertyChangedEventHandler handler = PropertyChanged;
                if (handler != null)
                    handler(this, new PropertyChangedEventArgs(propertyName));
            }
            #endregion
 
            public ObservableCollection<Person> m_people = new ObservableCollection<Person>();
        public ObservableCollection<Person> test = new ObservableCollection<Person>();
            public ObservableCollection<Person> People
            {
                get { return m_people; }
                private set
                {
                    if (value == m_people)
                        return;
 
                    m_people = value;
                    OnPropertyChanged();
                }
            }
 
        public MyViewModel()
        {
            m_people.CollectionChanged += m_people_CollectionChanged;
            m_people.Add(new Person() { FirstName = "Bob", LastName = "Brown", Age = 45 });
            m_people.Add(new Person() { FirstName = "Sarah", LastName = "Smith", Age = 25 });
        }
 
            private void m_people_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
            {
                if (e.NewItems != null && e.NewItems.Count > 0)
                {
                    foreach (INotifyPropertyChanged item in e.NewItems.OfType<INotifyPropertyChanged>())
                    {
                        item.PropertyChanged += person_PropertyChanged;
                    }
                }
                if (e.OldItems != null && e.OldItems.Count > 0)
                {
                    foreach (INotifyPropertyChanged item in e.OldItems.OfType<INotifyPropertyChanged>())
                    {
                        item.PropertyChanged -= person_PropertyChanged;
                    }
                }
            }
            //Property Changed will be called whenever a property of one of the 'Person'
            //objects is changed.
            private void person_PropertyChanged(object sender, PropertyChangedEventArgs e)
            {
                var row = sender as Person;
                SaveData(row);
            }
 
            private void SaveData(Person row)
            {
                //Save the row to the database here.
            }
 
        }
}

using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Runtime.CompilerServices;
 
namespace CommLibrary
{
    /// <summary>Базовый класс с реализацией INPC </summary>
    public abstract class OnPropertyChangedClass : INotifyPropertyChanged
    {
        #region Событие PropertyChanged
        /// <summary>Событие для извещения об изменения свойства</summary>
        public event PropertyChangedEventHandler PropertyChanged;
        #endregion
 
        #region Методы вызова события PropertyChanged
        /// <summary>Метод для вызова события извещения об изменении свойства</summary>
        /// <param name="propertyName">Изменившееся свойство</param>
        public void OnPropertyChanged([CallerMemberName]string propertyName = "")
            => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
 
        /// <summary>Метод для вызова события извещения об изменении списка свойств</summary>
        /// <param name="propList">Список имён свойств</param>
        public void OnPropertyChanged(IEnumerable<string> propList)
        {
            foreach (string propertyName in propList.Where(name => !string.IsNullOrWhiteSpace(name)))
                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }
        /// <summary>Метод для вызова события извещения об изменении перечня свойств</summary>
        /// <param name="propList">Список имён свойств</param>
        public void OnPropertyChanged(params string[] propList)
        {
            foreach (string propertyName in propList.Where(name => !string.IsNullOrWhiteSpace(name)))
                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }
 
        /// <summary>Метод для вызова события извещения об изменении всех свойств</summary>
        /// <param name="propList">Список свойств</param>
        public void OnAllPropertyChanged()
            => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(null));
 
        #endregion
 
        #region Виртуальные защищённые методы для изменения значений свойств
        /// <summary>Виртуальный метод определяющий изменения в значении поля значения свойства</summary>
        /// <param name="fieldProperty">Ссылка на поле значения свойства</param>
        /// <param name="newValue">Новое значение</param>
        /// <param name="propertyName">Название свойства</param>
        protected virtual void SetProperty<T>(ref T fieldProperty, T newValue, [CallerMemberName]string propertyName = "")
        {
            if ((fieldProperty != null && !fieldProperty.Equals(newValue)) || (fieldProperty == null && newValue != null))
                PropertyNewValue(ref fieldProperty, newValue, propertyName);
        }
 
        /// <summary>Виртуальный метод изменяющий значение поля значения свойства</summary>
        /// <param name="fieldProperty">Ссылка на поле значения свойства</param>
        /// <param name="newValue">Новое значение</param>
        /// <param name="propertyName">Название свойства</param>
        protected virtual void PropertyNewValue<T>(ref T fieldProperty, T newValue, string propertyName)
        {
            fieldProperty = newValue;
            OnPropertyChanged(propertyName);
        }
        #endregion
    }
}

using System;
using System.Windows;
using System.Windows.Input;
 
namespace CommLibrary
{
    #region Делегаты для методов WPF команд
    public delegate void ExecuteHandler(object parameter);
    public delegate bool CanExecuteHandler(object parameter);
    #endregion
 
    #region Класс команд - RelayCommand
    /// <summary>Класс реализующий интерфейс ICommand для создания WPF команд</summary>
    public class RelayCommand : ICommand
    {
        private readonly CanExecuteHandler _canExecute;
        private readonly ExecuteHandler _onExecute;
        private readonly EventHandler _requerySuggested;
 
        /// <summary>Событие извещающее об изменении состояния команды</summary>
        public event EventHandler CanExecuteChanged;
 
        /// <summary>Конструктор команды</summary>
        /// <param name="execute">Выполняемый метод команды</param>
        /// <param name="canExecute">Метод разрешающий выполнение команды</param>
        public RelayCommand(ExecuteHandler execute, CanExecuteHandler canExecute = null)
        {
            _onExecute = execute;
            _canExecute = canExecute;
 
            _requerySuggested = (o, e) => Invalidate();
            CommandManager.RequerySuggested += _requerySuggested;
        }
 
        public void Invalidate()
            => Application.Current.Dispatcher.BeginInvoke(new Action(() =>
            {
                CanExecuteChanged?.Invoke(this, EventArgs.Empty);
            }), null);
 
        /// <summary>Вызов разрешающего метода команды</summary>
        /// <param name="parameter">Параметр команды</param>
        /// <returns>True - если выполнение команды разрешено</returns>
        public bool CanExecute(object parameter) => _canExecute == null ? true : _canExecute.Invoke(parameter);
 
        /// <summary>Вызов выполняющего метода команды</summary>
        /// <param name="parameter">Параметр команды</param>
        public void Execute(object parameter) => _onExecute?.Invoke(parameter);
    }
    #endregion
}

using System;
 
namespace CommLibrary
{
    /// <summary>Интерфейс для создания копии экземпляра того же типа
    /// и копирования значений в другой или из другого экземпляра</summary>
    /// <typeparam name="T"></typeparam>
    public interface ICopy<T> : ICloneable
    {
        /// <summary>Создание копии экземпляра</summary>
        /// <returns>Новый экземпляр в том же типе</returns>
        T Copy();
        /// <summary>Копирование значений экземпляра в другой экземпляр</summary>
        /// <param name="other">Другой экземпляр в который надо скопировать значения</param>
        void CopyTo(T other);
        /// <summary>Копирование значений экземпляра из другого экземпляра</summary>
        /// <param name="other">Другой экземпляр из которого надо скопировать значения</param>
        void CopyFrom(T other);
    }
}

using CommLibrary;
using System;
 
namespace ModelLibrary
{
    public class Person : OnPropertyChangedClass, ICopy<Person>, IComparable<Person>, IComparable
    {
        #region Поля для хранения значений свойств
        private string m_firstName;
        private string m_lastName;
        private int m_age;
        #endregion
 
        #region Свойства с INPC
        public string FirstName { get => m_firstName; set => SetProperty(ref m_firstName, value); }
        public string LastName { get => m_lastName; set => SetProperty(ref m_lastName, value); }
        public int Age { get => m_age; set => SetProperty(ref m_age, value); }
        #endregion
 
        #region Конструкторы
        public Person() { }
        public Person(string firstName, string lastName, int age)
        {
            FirstName = firstName;
            LastName = lastName;
            Age = age;
        }
        #endregion
 
        #region Реализация интерфейса ICopy<Person>
        /// <summary>Создание копии экземпляра Person</summary>
        /// <returns>Новый экземпляр в типе Person</returns>
        public Person Copy() => new Person(FirstName, LastName, Age);
 
        /// <summary>Копирование значений экземпляра Person в другой экземпляр Person</summary>
        /// <param name="other">Другой экземпляр Person в который надо скопировать значения</param>
        public void CopyTo(Person other)
        {
            other.FirstName = FirstName;
            other.LastName = LastName;
            other.Age = Age;
        }
 
        /// <summary>Копирование значений в экземпляр Person из другого экземпляра Person</summary>
        /// <param name="other">Другой экземпляр Person из которого надо скопировать значения</param>
        public void CopyFrom(Person other)
        {
            FirstName = other.FirstName;
            LastName = other.LastName;
            Age = other.Age;
        }
 
        /// <summary>Создание копии экземпляра Person</summary>
        /// <returns>Новый экземпляр в типе Object</returns>
        public object Clone() => Copy();
        #endregion
 
        #region Реализация интерфейсов IComparable<Person> и IComparable
        /// <summary>Компаратор с другим экземпляром Person</summary>
        /// <param name="other">Другой экземпляр Person</param>
        /// <returns>0 - экземпляры равны, 1 - экземпляр больше другого, -1 - экземпляр меньше</returns>
        public int CompareTo(Person other)
        {
            int ret;
            if ((ret = LastName.CompareTo(other.LastName)) != 0)
                return ret;
            if ((ret = FirstName.CompareTo(other.FirstName)) != 0)
                return ret;
            return Age.CompareTo(other.Age);
        }
 
        /// <summary>Компаратор с другим экземпляром любого типа</summary>
        /// <param name="other">Другой экземпляр Person</param>
        /// <returns>0 - экземпляры равны, 1 - экземпляр больше другого, -1 - экземпляр меньше</returns>
        public int CompareTo(object obj)
        {
            if (obj == null) return 1;
            if (obj is Person person)
                return CompareTo(person);
            throw new ArgumentException("Object is not a Person");
        }
        #endregion
    }
}

    [Serializable]
    public class Person : OnPropertyChangedClass, ICopy<Person>, IComparable<Person>, IComparable

using ModelLibrary;
using System;
using System.Collections.Generic;
 
namespace Model
{
    [Serializable]
    public class DataSerializable
    {
        public List<Person> People { get; set; }
    }
}

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml.Serialization;
 
namespace Model
{
    public class ModelMVVMTest
    {
        /// <summary>Сериализатор типа DataSerializable</summary>
        public static XmlSerializer DataSerializer { get; } = new XmlSerializer(typeof(DataSerializable));
 
        /// <summary>Десериализация DataSerializable из заданного файла</summary>
        /// <param name="fileName">Имя файла</param>
        /// <returns>Десериализованный DataSerializable</returns>
        /// <remarks>При ошибках выбрасывается исключение</remarks>
        public static DataSerializable LoadData(string fileName)
        {
            using (FileStream file = File.OpenRead(fileName))
            {
                return (DataSerializable)DataSerializer.Deserialize(file);
            }
        }
 
        /// <summary>Десериализация DataSerializable из заданного файла</summary>
        /// <param name="fileName">Имя файла</param>
        /// <param name="data">Десериализованный DataSerializable</param>
        /// <returns><see langword="true"/> если десериализация успешна, иначе - <see langword="false"/></returns>
        /// <remarks>При ошибках исключение не возникает</remarks>
        public static bool TryLoadData(string fileName, out DataSerializable data)
        {
            try
            {
                data = LoadData(fileName);
                return true;
            }
            catch (Exception)
            {
                data = null;
                return false;
            }
        }
 
        /// <summary>Поле для хранения данных</summary>
        private DataSerializable dataSerializable;
 
        /// <summary>Загрузка данных в экземпляр Модели</summary>
        /// <param name="fileName">Имя файла данных</param>
        public void Load(string fileName)
        {
            if (TryLoadData(fileName, out DataSerializable data))
                dataSerializable = data;
            else
                throw new Exception("Ошибка загрузки данных!");
        }
 
        /// <summary>Загрузка данных в экземпляр Модели из файла
        /// данных по умолчанию "dataMVVM.xml"</summary>
        public void Load() => Load("dataMVVM.xml");
 
 
        /// <summary>Сериализация DataSerializable в заданный файл</summary>
        /// <param name="fileName">Имя файла</param>
        /// <param name="data">Сериализуемый экземпляр</param>
        public static void SaveData(string fileName, DataSerializable data)
        {
            using (FileStream file = File.Create(fileName))
            {
                DataSerializer.Serialize(file, data);
            }
        }
 
        /// <summary>Сериализация данных Модели в заданном файле</summary>
        /// <param name="fileName">Имя файла</param>
        public void Save(string fileName) => SaveData(fileName, dataSerializable);
        /// <summary>Сериализация данных Модели в файле по умолчанию "dataMVVM.xml"</summary>
        public void Save() => SaveData("dataMVVM.xml", dataSerializable);
    }
}

    public partial class ModelMVVMTest
    {
        /// <summary>Получения последовательности Person</summary>
        /// <returns>Последовательность "отвязанную" от исходной коллекции</returns>
        public IEnumerable<Person> GetPeople() => dataSerializable?.People;
 
        /// <summary>Добавление Person в исходную коллекцию</summary>
        /// <param name="person">Добавляемый Person</param>
        public void AddPerson(Person person)
        {
            if (dataSerializable != null)
                dataSerializable.People.Add(person);
        }
 
        /// <summary>Удаление Person из исходной коллекции</summary>
        /// <param name="person">Удаляемый Person</param>
        public void RemovePerson(Person person)
        {
            if (dataSerializable != null)
                dataSerializable.People.Remove(person);
        }
    }

        public override string ToString() => $"Person: {FirstName} {LastName} - {Age};";

    class Program
    {
        static ModelMVVMTest modelMVVM;
 
        static void Main(string[] args)
        {
            modelMVVM = new ModelMVVMTest();
            modelMVVM.Load();
 
            ConsolePeople();
 
            string input;
            do
            {
                Console.WriteLine("Введите имя, фамилию и возраст через пробел:");
                input = Console.ReadLine();
                if (string.IsNullOrWhiteSpace(input))
                    continue;
 
                string[] values = input.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
                if (values.Length == 3 && uint.TryParse(values[2], out uint age))
                {
                    modelMVVM.AddPerson(new Person() { FirstName = values[0], LastName = values[1], Age = (int)age });
                    modelMVVM.Save();
                }
                else
                    input = null;
            } while (string.IsNullOrWhiteSpace(input));
 
            ConsolePeople();
 
            do
            {
                Console.WriteLine("Введите имя:");
                input = Console.ReadLine().Trim();
                if (string.IsNullOrWhiteSpace(input))
                    continue;
 
                Person person = modelMVVM.GetPeople().FirstOrDefault(p => p.FirstName == input);
                if (person != null)
                {
                    modelMVVM.RemovePerson(person);
                    modelMVVM.Save();
                }
                else
                    input = null;
            } while (string.IsNullOrWhiteSpace(input));
 
            ConsolePeople();
 
        }
 
        static void ConsolePeople()
            => Console.WriteLine(string.Join("\r\n", modelMVVM.GetPeople()));
    }

        /// <summary>Загрузка данных в экземпляр Модели</summary>
        /// <param name="fileName">Имя файла данных</param>
        public void Load(string fileName)
        {
            if (TryLoadData(fileName, out DataSerializable data))
                dataSerializable = data;
            else
            {
                dataSerializable = new DataSerializable() { People = new List<Person>() };
                throw new Exception("Ошибка загрузки данных!");
            }
        }

        static void Main(string[] args)
        {
            modelMVVM = new ModelMVVMTest();
            try
            {
                modelMVVM.Load();
            }
            catch (Exception ex)
            {
 
                Console.WriteLine(ex.Message);
                Console.WriteLine("Создана новая пустая коллекция!");
            }

public class Person
    {
        public static List<Person> list = new List<Person>();
        public string FirstName { get; set; }
        public string LastName { get; set; }
 
        public static List<Person> GetPersons()
        {
            list.Add(new Person() { FirstName = "test", LastName = "test" });
            return list;
        }
 
        public static List<Person> SetPersons(Person item)
        {
            list.Add(item);
            return list;
        }
    }

Person.SetPersons(new Person { FirstName = "123" , LastName = "321" });