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

namespace FuzzySearch
{
    /// <summary>Статический класс модели данных</summary>
    public class FuzzySearch_Model
    {
 
        /// <summary>Имя файла по умолчанию</summary>
        public string NameFile { get; private set; } = "ListWords.txt";
        ObservableCollection<string> _listWords;
        /// <summary>Список слов</summary>
        public ObservableCollection<string> ListWords
        {
            get => _listWords ?? (_listWords = new ObservableCollection<string>());
            private set => _listWords = value;
        }
 
        /// <summary>Сохранение списка слов в файле</summary>
        public void Save()
        {
            if (string.IsNullOrWhiteSpace(NameFile))
                throw new ArgumentException("File name is empty", nameof(NameFile));
 
            using (StreamWriter file = new StreamWriter(NameFile, false, Encoding.Default))
                file.Write(string.Join(Environment.NewLine, ListWords));
        }
 
        /// <summary>Сохранение списка слов в файле  сзаданным именем</summary>
        /// <param name="NameFile">Имя файла</param>
        public void SaveAs(string NameFile)
        {
            if (string.IsNullOrWhiteSpace(NameFile))
                throw new ArgumentException("File name is empty", nameof(NameFile));
 
            using (StreamWriter file = new StreamWriter(NameFile, false, Encoding.Default))
                file.Write(string.Join(Environment.NewLine, ListWords));
 
            this.NameFile = NameFile;
        }
 
        /// <summary>Чтение списка слов из файла</summary>
        /// <param name="NameFile">Имя файла</param>
        public void Load(string NameFile = null)
        {
            if (string.IsNullOrWhiteSpace(NameFile))
                NameFile = this.NameFile;
 
            if (!File.Exists(NameFile))
                throw new ArgumentException("file does not exist", NameFile);
 
            using (StreamReader file = new StreamReader(NameFile, Encoding.Default))
                ListWords = new ObservableCollection<string>(file.ReadToEnd().Split("\r\n ".ToCharArray(), StringSplitOptions.RemoveEmptyEntries).Select(wrd => wrd.ToLower()));
 
        }
 
        /// <summary>Добавление слова в список</summary>
        /// <param name="Words">Слово или список слов разделённых переносом строки или пробелом</param>
        public void AddWord(string Words)
        {
            foreach (string word in Words.ToLower().Split("\r\n ".ToCharArray(), StringSplitOptions.RemoveEmptyEntries))
                ListWords.Add(word);
        }
 
        /// <summary>Поиск слова в списке</summary>
        /// <param name="Word">Одно слово</param>
        /// <returns>Результат поиска</returns>
        public SearchResult SearchWord(string Word)
        {
            string[] wordArr = Word.ToLower().Split("\r\n ".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
            if (wordArr.Length != 1)
                throw new ArgumentException("You need to pass single, non empty word", nameof(Word));
 
            Word = wordArr[0];
            int index = ListWords.IndexOf(Word);
            if (index >= 0)
                return new SearchResult { Type = ResultType.ExactMatch, Index = index };
            /// *************************
            /// Нечёткий поиск
            /// *************************
            for (index = 0; index < ListWords.Count; index++)
                if (IsNotMoreOneDifferense(Word, ListWords[index]))
                    return new SearchResult { Type = ResultType.PartialMatch, Index = index };
            return new SearchResult { Type = ResultType.NoMatch, Index = -1 };
        }
 
        //   https://www.cyberforum.ru/csharp-beginners/thread2376045.html#post13174564
        /// <summary>Метод нечёткого сравнения двух строк</summary>
        static bool IsNotMoreOneDifferense(string key, string str)
        {
            int error = 0;
            int delta = key.Length - str.Length;
            if (Math.Abs(delta) > 1) return false;
            int count = Math.Min(key.Length, str.Length);
            // начинаем посимвольное сравнение
            for (int i = 0, j = 0; i < count; i++, j++)
            {
                if (key[i] != str[j])
                {
                    error++;
                    // предел ошибок
                    if (error > 1) return false;
                    // оставляем неподвижным ползунок у кого слова, которое короче
                    // если образец
                    if (delta > 0) j--;
                    // если проверочное слово
                    if (delta < 0) i--;
                    // если длины слов одинаковы, ничего не менять
                }
            }
            return true;
        }
 
        /// <summary>Класс для результатов поиска</summary>
        public class SearchResult
        {
            public ResultType Type;
            public int Index;
        }
 
        /// <summary>Перечисление результатов поиска</summary>
        public enum ResultType
        {
            ExactMatch,
            PartialMatch,
            NoMatch
        }
    }
}

namespace FuzzySearch
{
    /// <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 _saveAsComm;
        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 SaveAsComm => _saveAsComm ?? (_saveAsComm = new RelayCommand(OnSaveAs));
        /// <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 OnSaveAs(object Value = null) { }
        /// <summary>Метод для вызова из команды</summary>
        /// <param name="Value">Значение привязанного параметра</param>
        public virtual void OnLoad(object Value = null) { }
        #endregion
    }
}

namespace FuzzySearch
{
    /// <summary>Клас реальной ViewModel</summary>
    public class FuzzySearch_VM : FuzzySearch_VM_DataDesigner
    {
        FuzzySearch_Model model;
        public FuzzySearch_VM()
        {
            model = new FuzzySearch_Model();
            ListWords = model.ListWords;
        }
 
        public override void OnAdd(object Value = null) => model.AddWord(TextAdd);
        public override void OnLoad(object Value = null)
        {
            // https://docs.microsoft.com/ru-ru/dotnet/api/microsoft.win32.openfiledialog?view=netframework-4.7.2
            // Configure open file dialog box
            OpenFileDialog dlg = new OpenFileDialog();
            dlg.FileName = model.NameFile; // Default file name
            dlg.DefaultExt = ".txt"; // Default file extension
            dlg.Filter = "Text documents (.txt)|*.txt"; // Filter files by extension
 
            // Show open file dialog box
            bool? result = dlg.ShowDialog();
 
            // Process open file dialog box results
            if (result != true)
                return;
 
                // Open document
            try
            {
                model.Load(dlg.FileName);
                ListWords = model.ListWords;
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }
        public override void OnSave(object Value = null)
        {
            try
            {
                model.Save();
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }
        public override void OnSaveAs(object Value = null)
        {
            // https://docs.microsoft.com/ru-ru/dotnet/api/microsoft.win32.savefiledialog?view=netframework-4.7.2
            // Configure save file dialog box
            SaveFileDialog dlg = new SaveFileDialog();
            dlg.FileName = model.NameFile; // Default file name
            dlg.DefaultExt = ".txt"; // Default file extension
            dlg.Filter = "Text documents (.txt)|*.txt"; // Filter files by extension
 
            // Show save file dialog box
            bool? result = dlg.ShowDialog();
 
            // Process save file dialog box results
            if (result != true)
                return;
 
                // Save document
            try
            {
                model.SaveAs(dlg.FileName);
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }
 
        public override void OnSearch(object Value = null)
        {
 
            try
            {
                SearchResult res = model.SearchWord(TextSearch);
                switch (res.Type)
                {
                    case ResultType.ExactMatch: TextMessage = "Tочное совпадение со словом по индексу " + res.Index; break;
                    case ResultType.PartialMatch: TextMessage = "Частичное совпадение со словом по индексу " + res.Index; break;
                    default: TextMessage = "Нет совпадений со словами из списка"; break;
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }
    }
}