Пример реализации WPF+MVVM приложения

    public class RelayCommand : ICommand
    {
        public event EventHandler CanExecuteChanged;
        private readonly Func<object, bool> _canExecute;
        private readonly Action<object> _onExecute;
 
        /// <summary>Конструктор команды</summary>
        /// <param name="execute">Выполняемый метод команды</param>
        /// <param name="canExecute">Метод разрешающий выполнение команды</param>
        public RelayCommand(Action<object> execute, Func<object, bool> canExecute = null)
        {
            _onExecute = execute;
            _canExecute = canExecute;
        }
 
        /// <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);
    }

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

    /// <summary>Статический класс модели данных</summary>
    public static class FuzzySearch_Model
    {
        static ObservableCollection<string> _listWords;
        /// <summary>Список слов</summary>
        public static ObservableCollection<string> ListWords
        {
            get => _listWords ?? (_listWords = new ObservableCollection<string>());
            private set => _listWords = value;
        }
 
        /// <summary>Сохранение списка слов в файле</summary>
        /// <param name="NameFile">Имя файла</param>
        public static void Save(string NameFile = null)
        {
            if (string.IsNullOrWhiteSpace(NameFile))
                NameFile = "ListWords.txt";
            StreamWriter file = null;
            try
            {
                file = new StreamWriter(NameFile, false, Encoding.Default);
                foreach (string word in ListWords)
                    file.WriteLine(word.ToLower());
            }
            catch (Exception)
            {
                MessageBox.Show("Ошибка записи в файл!");
            }
            if (file != null)
                file.Close();
        }
 
        /// <summary>Чтение списка слов из файла</summary>
        /// <param name="NameFile">Имя файла</param>
        public static void Load(string NameFile = null)
        {
            if (string.IsNullOrWhiteSpace(NameFile))
            {
                NameFile = "ListWords.txt";
                if (!File.Exists(NameFile))
                    File.Create(NameFile).Close();
            }
            StreamReader file = null;
            try
            {
                file = new StreamReader(NameFile, Encoding.Default);
                ListWords = new ObservableCollection<string>(file.ReadToEnd().Split("\r\n ".ToCharArray(), StringSplitOptions.RemoveEmptyEntries).Select(wrd => wrd.ToLower()));
            }
            catch (Exception)
            {
                MessageBox.Show("Ошибка чтения из файла!");
            }
            if (file != null)
                file.Close();
        }
 
        /// <summary>Добавление слова в список</summary>
        /// <param name="Words">Слово или список слов разделённых переносом строки или пробелом</param>
        public static void AddWord(string Words)
        {
            foreach (string word in Words.Split("\r\n ".ToCharArray(), StringSplitOptions.RemoveEmptyEntries))
                ListWords.Add(word);
        }
 
        /// <summary>Поиск слова в списке</summary>
        /// <param name="Word">Одно слово</param>
        /// <returns>Результат поиска</returns>
        public static string SearchWord(string Word)
        {
            string[] wordArr = Word.ToLower().Split("\r\n ".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
            if (wordArr.Length != 1) return "Ошибка ввода";
            Word = wordArr[0];
            int index = ListWords.IndexOf(Word);
            if (index >= 0) return "Tочное совпадение со словом по индексу " + index;
            /// *************************
            /// Нечёткий поиск
            /// *************************
            return "Результат нечёткого поиска";
        }
    }

    /// <summary>Класс ViewModel for DesignData</summary>
    public class FuzzySearch_VM_DataDesigner : OnPropertyChangedClass
    {
        #region Свойства для привязки элементов отображения
        /// <summary>Свойство для слова поиска</summary>
        public string TextSearch { get => _textSearch; set { _textSearch = value; OnAllPropertyChanged(); } }
        /// <summary>Свойство для слова добавления</summary>
        public string TextAdd { get => _textAdd; set { _textAdd = value; OnAllPropertyChanged(); } }
        /// <summary>Свойство для списка слова</summary>
        public ObservableCollection<string> ListWords { get => _listWords; set { _listWords = value; OnAllPropertyChanged(); } }
        /// <summary>Свойство для сообщения с результатами поиска</summary>
        public string TextMessage { get => _textMessage; set { _textMessage = value; OnAllPropertyChanged(); } }
        #endregion
 
        #region Приватные поля
        // Поля для хранения значения свойства
        private string _textSearch;
        private string _textAdd;
        private ObservableCollection<string> _listWords;
        private string _textMessage;
        // Поля для хранения значения команд
        private ICommand _searchComm;
        private ICommand _clearComm;
        private ICommand _addComm;
        private ICommand _saveComm;
        private ICommand _loadComm;
        #endregion
 
        #region Свойства для привязки команд
        /// <summary>Свойство для привязки команды</summary>
        public ICommand SearchComm => _searchComm ?? (_searchComm = new RelayCommand(OnSearch));
        /// <summary>Свойство для привязки команды</summary>
        public ICommand ClearComm => _clearComm ?? (_clearComm = new RelayCommand(OnClear));
        /// <summary>Свойство для привязки команды</summary>
        public ICommand AddComm => _addComm ?? (_addComm = new RelayCommand(OnAdd));
        /// <summary>Свойство для привязки команды</summary>
        public ICommand SaveComm => _saveComm ?? (_saveComm = new RelayCommand(OnSave));
        /// <summary>Свойство для привязки команды</summary>
        public ICommand LoadComm => _loadComm ?? (_loadComm = new RelayCommand(OnLoad));
        #endregion
 
        #region Методы для команд
        /// <summary>Метод для вызова из команды</summary>
        /// <param name="Value">Значение привязанного параметра</param>
        public virtual void OnSearch(object Value = null) { }
        /// <summary>Метод для вызова из команды</summary>
        /// <param name="Value">Значение привязанного параметра</param>
        public virtual void OnClear(object Value = null)
        { TextSearch = ""; TextMessage = ""; TextAdd = ""; }
        /// <summary>Метод для вызова из команды</summary>
        /// <param name="Value">Значение привязанного параметра</param>
        public virtual void OnAdd(object Value = null) { }
        /// <summary>Метод для вызова из команды</summary>
        /// <param name="Value">Значение привязанного параметра</param>
        public virtual void OnSave(object Value = null) { }
        /// <summary>Метод для вызова из команды</summary>
        /// <param name="Value">Значение привязанного параметра</param>
        public virtual void OnLoad(object Value = null) { }
        #endregion
    }

    /// <summary>Класс реальной ViewModel</summary>
    public class FuzzySearch_VM : FuzzySearch_VM_DataDesigner
    {
        public FuzzySearch_VM()
        {
            FuzzySearch_Model.Load();
            ListWords = FuzzySearch_Model.ListWords;
        }
 
        public override void OnAdd(object Value = null) => FuzzySearch_Model.AddWord(TextAdd);
        public override void OnLoad(object Value = null) => FuzzySearch_Model.Load();
        public override void OnSave(object Value = null) => FuzzySearch_Model.Save();
        public override void OnSearch(object Value = null) => TextMessage = FuzzySearch_Model.SearchWord(TextSearch);
    }