Пример создания приложения для тестирования [WPF, Элд Хасп]

namespace TestWPF
{
    // Примечание. Для запуска созданного кода может потребоваться NET Framework версии 4.5 или более поздней версии и .NET Core или Standard версии 2.0 или более поздней.
    /// <summary>Класс теста Модели</summary>
    [Serializable()]
    [System.ComponentModel.DesignerCategory("code")]
    [XmlType(AnonymousType = true)]
    [XmlRoot(Namespace = "", IsNullable = false, ElementName ="Test")]
    public partial class TestClass
    {
 
        /// <summary>Название теста</summary>
        public string NameTest { get; set; }
 
        /// <summary>Вопросы теста</summary>
        [XmlArrayItem("Question", IsNullable = false)]
        public TestClassQuestion[] Questions { get; set; }
    }
 
    /// <summary>Класс вопроса Модели</summary>
    [Serializable()]
    [System.ComponentModel.DesignerCategory("code")]
    [XmlType(AnonymousType = true)]
    public partial class TestClassQuestion
    {
 
        /// <summary>Текст вопроса</summary>
        public string Text { get; set; }
 
        /// <summary>Тип вопроса: <see langword="true"/> - только один ответ правильный,
        /// <see langword="false"/> - несколько вопросов могут быть правильными</summary>
        [XmlAttribute()]
        public bool IsOnlyOne { get; set; }
 
        /// <summary>Варианты ответов на вопрос</summary>
        [XmlArrayItem("Answer", IsNullable = false)]
        public TestClassAnswer[] Answers { get; set; }
    }
 
    /// <summary>Класс ответа на вопрос Модели</summary>
    [Serializable()]
    [System.ComponentModel.DesignerCategory("code")]
    [XmlType(AnonymousType = true)]
    public partial class TestClassAnswer
    {
 
        /// <summary>Флаг верного ответа</summary>
        [XmlAttribute()]
        public bool IsRight { get; set; }
 
        /// <summary>Текст ответа</summary>
        [XmlText()]
        public string Text { get; set; }
    }
}

    public class Model
    {
        /// <summary>Загруженный тест</summary>
        public TestClass Test { get; }
 
        /// <summary>Имя файла из которого загружен тест</summary>
        public string NameFileTest { get; }
 
        /// <summary>Конструтор с заданием имени файла из которого нужно загрузить тест</summary>
        /// <param name="nameFileTest">Имя файла теста</param>
        public Model(string nameFileTest)
        {
            XmlSerializer ser = new XmlSerializer(typeof(TestClass));
            using (FileStream file = new FileStream(nameFileTest, FileMode.Open))
            {
                Test = (TestClass)ser.Deserialize(file);
            }
            NameFileTest = nameFileTest;
 
            foreach (TestClassQuestion question in Test.Questions)
            {
                int countRight = question.Answers.Count(ans => ans.IsRight);
                if (countRight == 0)
                    throw new TestException("Хоть один ответ должен быть правильным!", question, TestExceptionEnum.NoRight);
                if (countRight != 1 && question.IsOnlyOne)
                    throw new TestException("Для этого вопроса только один ответ должен быть правильным!", question, TestExceptionEnum.NotOnlyOne);
            }
        }
        /// <summary>Конструтор без параметров. Загружает тест из файла "Test.xml"</summary>
        public Model() : this("Test.xml") { }
    }

    public class TestException : Exception
    {
        /// <summary>Вопрос теста в котором ошибка</summary>
        public TestClassQuestion Question { get; }
 
        /// <summary>Тип ошибки</summary>
        public TestExceptionEnum Error { get; }
 
        #region Конструторы с различным набором параметров
        public TestException(TestClassQuestion question, TestExceptionEnum error)
        {
            Question = question;
            Error = error;
        }
        public TestException(string message, TestClassQuestion question, TestExceptionEnum error)
            : base(message)
        {
            Question = question;
            Error = error;
        }
        public TestException(string message, Exception innerException, TestClassQuestion question, TestExceptionEnum error)
            : base(message, innerException)
        {
            Question = question;
            Error = error;
        }
        #endregion
    }

    public enum TestExceptionEnum
    {
        /// <summary>Нет правильных ответов</summary>
        NoRight,
        /// <summary>Правильный должен быть только один ответ</summary>
        NotOnlyOne,
        /// <summary>Неверное значение свойства IsOnlyOne</summary>
        InvalidIsOnlyOne
    }

namespace TestWPF
{
    #region Делегаты для методов WPF команд
    public delegate void ExecuteHandler(object parameter);
    public delegate bool CanExecuteHandler(object parameter);
    #endregion
 
    /// <summary>Класс реализующий интерфейс ICommand для создания WPF команд</summary>
    public class RelayCommand : ICommand
    {
        private readonly CanExecuteHandler _canExecute;
        private readonly ExecuteHandler _onExecute;
 
        /// <summary>Событие извещающее об изменении состояния команды</summary>
        public event EventHandler CanExecuteChanged
        {
            add { CommandManager.RequerySuggested += value; }
            remove { CommandManager.RequerySuggested -= value; }
        }
 
        /// <summary>Конструктор команды</summary>
        /// <param name="execute">Выполняемый метод команды</param>
        /// <param name="canExecute">Метод разрешающий выполнение команды</param>
        public RelayCommand(ExecuteHandler execute, CanExecuteHandler canExecute = null)
        {
            this._onExecute = execute;
            this._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);
    }
}

namespace TestWPF
{
    /// <summary>Базовый класс с реализацией INPC </summary>
    public abstract class OnPropertyChangedClass : INotifyPropertyChanged
    {
        /// <summary>Событие для извещения об изменения свойства</summary>
        public event PropertyChangedEventHandler PropertyChanged;
 
        /// <summary>Метод для вызова события извещения об изменении свойства</summary>
        /// <param name="propertyName">Изменившееся свойство</param>
        public void OnPropertyChanged([CallerMemberName]string propertyName = "") =>
                    PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

    /// <summary>Класс ответа на вопрос для ViewModel</summary>
    public class AnswerVM : OnPropertyChangedClass
    {
        /// <summary>Базовый ответ типа Модели</summary>
        private readonly TestClassAnswer TestAnswer;
 
        /// <summary>Поле для хранения значения свойства</summary>
        private bool _isRightView;
 
        /// <summary>Конструктор из ответа типа Модели</summary>
        /// <param name="testAnswer">Базовый ответ типа Модели</param>
        public AnswerVM(TestClassAnswer testAnswer) => TestAnswer = testAnswer;
 
        /// <summary>Текст ответа</summary>
        public string Text => TestAnswer.Text;
 
        /// <summary>Свойство для выбора ответа</summary>
        public bool IsRightView { get => _isRightView; set { _isRightView = value; OnPropertyChanged(); } }
 
        /// <summary>Возвращает <see langword="true"/> при правильном выборе</summary>
        public bool Value => IsRightView == TestAnswer.IsRight;
    }

    /// <summary>Базовый класс вопроса для ViewModel</summary>
    public class QuestionVM : OnPropertyChangedClass
    {
        /// <summary>Статический ГСЧ</summary>
        protected static readonly Random rand = new Random();
 
        /// <summary>Базовый вопрос типа Модели</summary>
        protected readonly TestClassQuestion TestQuestion;
 
        /// <summary>Конструктор из базового вопроса типа Модели</summary>
        /// <param name="testQuestion">Базовый вопрос типа Модели</param>
        public QuestionVM(TestClassQuestion testQuestion)
        {
            TestQuestion = testQuestion;
            Answers = TestQuestion.Answers.Select(ans => new AnswerVM(ans))
                .OrderBy(x => rand.Next()).ToArray();
        }
 
        /// <summary>Тип вопроса: <see langword="true"/> - только один правильный ответ, 
        /// <see langword="false"/> - может быть несколько правильных ответов</summary>
        public bool IsOnleOne => TestQuestion.IsOnlyOne;
 
        /// <summary>Текст вопроса</summary>
        public string Text => TestQuestion.Text;
 
        /// <summary>Варианты ответов</summary>
        public AnswerVM[] Answers { get; }
 
        /// <summary><see langword="true"/> - если выбраны правильные ответы</summary>
        public bool Value => Answers.All(ans => ans.Value);
 
        /// <summary>Статический конструктор из вопроса типа Модели</summary>
        /// <param name="testQuestion">Базовый вопрос типа Модели</param>
        /// <returns>Тип QuestionRadioButtonVM для вопросов с одним правильным ответом,
        /// тип QuestionCheckBoxVM для вопросов с несколькими правильными ответами</returns>
        public static QuestionVM Create(TestClassQuestion testQuestion)
        {
            if (testQuestion.IsOnlyOne)
                return new QuestionRadioButtonVM(testQuestion);
            return new QuestionCheckBoxVM(testQuestion);
        }
    }

    /// <summary>Класс вопроса для ViewModel с только одним правильным ответом</summary>
    public class QuestionRadioButtonVM : QuestionVM
    {
        /// <summary>Конструктор из базового вопроса типа Модели</summary>
        /// <param name="testQuestion">Базовый вопрос типа Модели</param>
        public QuestionRadioButtonVM(TestClassQuestion testQuestion)
            : base(testQuestion)
        {
            if (!IsOnleOne)
                throw new TestException("Неверное значение свойства IsOnlyOne!", testQuestion, TestExceptionEnum.InvalidIsOnlyOne);
        }
    }
 
    /// <summary>Класс вопроса для ViewModel с несколькими правильными ответами</summary>
    public class QuestionCheckBoxVM : QuestionVM
    {
        /// <summary>Конструктор из базового вопроса типа Модели</summary>
        /// <param name="testQuestion">Базовый вопрос типа Модели</param>
        public QuestionCheckBoxVM(TestClassQuestion testQuestion)
            : base(testQuestion)
        {
            if (IsOnleOne)
                throw new TestException("Неверное значение свойства IsOnlyOne!", testQuestion, TestExceptionEnum.InvalidIsOnlyOne);
        }
    }

    /// <summary>Класс теста для ViewModel</summary>
    public class TestVM : OnPropertyChangedClass
    {
        /// <summary>Статический ГСЧ</summary>
        private static readonly Random rand = new Random();
        /// <summary>Базовый тест типа Модели</summary>
        private readonly TestClass Test;
 
        /// <summary>Конструктор из базового теста типа Модели</summary>
        /// <param name="test">Базовый тест типа Модели</param>
        public TestVM(TestClass test)
        {
            Test = test;
            Questions = Test.Questions.Select(qu => QuestionVM.Create(qu))
                .OrderBy(x => rand.Next()).ToArray();
        }
 
        /// <summary>Название теста</summary>
        public string NameTest => Test.NameTest;
 
        /// <summary>Вопросы теста</summary>
        public QuestionVM[] Questions { get; }
 
        /// <summary>Количество вопросов с правильными ответами</summary>
        public int CountRight() => Questions.Count(qu => qu.Value);
    }

    public class BaseContent : OnPropertyChangedClass
    {
        /// <summary>Команда перехода к следующему контенту</summary>
        public RelayCommand JumpCommand { get; }
 
        /// <summary>Конструктор с делегатами для команды</summary>
        /// <param name="execute">Делегат метода перехода к следующему контенту</param>
        /// <param name="canExecute">Делегат метода проверяющего переход к следующему контенту</param>
        public BaseContent(ExecuteHandler execute, CanExecuteHandler canExecute = null) 
            => JumpCommand = new RelayCommand(execute, canExecute);
    }

    /// <summary>Класс начала теста контента ViewModel</summary>
    public class TitleContent : BaseContent
    {
        private string _nameTest;
        /// <summary>Название теста</summary>
        public string NameTest { get => _nameTest; set { _nameTest = value; OnPropertyChanged(); } }
 
        /// <summary>Конструктор через базовый конструктор</summary>
        /// <param name="execute">Метод перехода к списку вопросов</param>
        /// <param name="canExecute">Метод проверяющий переход к списку вопросов</param>
        public TitleContent(ExecuteHandler execute, CanExecuteHandler canExecute = null) : base(execute, canExecute) { }
 
    }

    /// <summary>Класс окончания теста контента ViewModel</summary>
    public class TotalContent : BaseContent
    {
        private int _countRight;
        private int _countTotal;
 
        /// <summary>Количество правильных ответов</summary>
        public int CountRight { get => _countRight; set { _countRight = value; OnPropertyChanged(); } }
 
        /// <summary>Количество вопросов в тесте</summary>
        public int CountTotal { get => _countTotal; set { _countTotal = value; OnPropertyChanged(); } }
 
        /// <summary>Конструктор через базовый конструктор</summary>
        /// <param name="execute">Метод перехода к повтору теста</param>
        /// <param name="canExecute">Метод проверяющий переход к повтору теста</param>
        public TotalContent(ExecuteHandler execute, CanExecuteHandler canExecute = null) : base(execute, canExecute) { }
    }

    /// <summary>Класс для контента со списком вопросов</summary>
    public class QuestionsContent : BaseContent
    {
        #region Поля для хранения значений свойств
        private QuestionVM[] _questions;
        private QuestionVM _currentQuestion;
        private int _currQuestionIndex;
        private RelayCommand _jumpQuestionCommand;
        #endregion
 
        /// <summary>Вопросы</summary>
        public QuestionVM[] Questions { get => _questions; set { _questions = value; OnPropertyChanged(); CurrQuestionIndex = -1; JumpQuestionMetod(1); } }
 
        /// <summary>Текущий вопрос</summary>
        public QuestionVM CurrentQuestion { get => _currentQuestion; set { _currentQuestion = value; OnPropertyChanged(); } }
 
        /// <summary>Индекс текущего вопроса</summary>
        private int CurrQuestionIndex { get => _currQuestionIndex; set { _currQuestionIndex = value; OnPropertyChanged(); } }
 
        /// <summary>Конструктор наследующий от базового конструктора</summary>
        /// <param name="execute">Делегат метода исполняющего выход из контента</param>
        /// <param name="canExecute">Делегат метода проверяющего выход из контента</param>
        public QuestionsContent(ExecuteHandler execute, CanExecuteHandler canExecute = null)
            : base(execute, canExecute) { }
 
        /// <summary>Команда для перехода между вопросами</summary>
        public RelayCommand JumpQuestionCommand => _jumpQuestionCommand ?? (_jumpQuestionCommand = new RelayCommand(JumpQuestionMetod, JumpQuestionCanMetod));
 
        /// <summary>Метод проверяющий переход на вопрос с указанным смещением</summary>
        /// <param name="parameter">Смешение на следующий вопрос</param>
        /// <returns><see langword="true"/> если переход возможен</returns>
        private bool JumpQuestionCanMetod(object parameter)
        => parameter != null
            && int.TryParse(parameter.ToString(), out int parInt)
            && CurrQuestionIndex + parInt >= 0 && CurrQuestionIndex + parInt < Questions.Length;
 
        /// <summary>Метод перехода на вопрос с указанным смещением</summary>
        /// <param name="parameter">Смешение на следующий вопрос</param>
        private void JumpQuestionMetod(object parameter)
        {
            int newIndex = CurrQuestionIndex + int.Parse(parameter.ToString());
            if (newIndex != CurrQuestionIndex)
            {
                CurrQuestionIndex = newIndex;
                CurrentQuestion = Questions[CurrQuestionIndex];
            }
        }
 
    }

    /// <summary>Класс ViewModel</summary>
    public class ViewModel : OnPropertyChangedClass
    {
        /// <summary>Тест полученный от Модели</summary>
        private readonly TestClass Test;
 
        /// <summary>Тест созданный ViewModel для View</summary>
        public TestVM TestView { get; private set; }
 
        /// <summary>Поле для хранения значения контента</summary>
        private BaseContent _content;
        /// <summary>Контент ViewModel</summary>
        public BaseContent Content { get => _content; set { _content = value; OnPropertyChanged(); } }
        Model model;
 
        /// <summary>Конструктор создающий Модель и загружающий из неё тест</summary>
        public ViewModel()
        {
            model = new Model("Test.xml");
            Test = model.Test;
            TotalMetod(null);
        }
 
        /// <summary>Метод для контента начала теста</summary>
        /// <param name="parameter">Не используется</param>
        private void TitleMetod(object parameter)
        {
            Content = new QuestionsContent(QuestionsMetod) { Questions = TestView.Questions };
        }
 
        /// <summary>Метод для контента вопросов теста</summary>
        /// <param name="parameter">Не используется</param>
        private void QuestionsMetod(object parameter)
        {
            Content = new TotalContent(TotalMetod)
            {
                CountRight = TestView.CountRight(),
                CountTotal = TestView.Questions.Length
            };
        }
 
        /// <summary>Метод для контента окончания теста</summary>
        /// <param name="parameter">Не используется</param>
        private void TotalMetod(object parameter)
        {
            TestView = new TestVM(Test);
            Content = new TitleContent(TitleMetod) { NameTest = TestView.NameTest };
        }
    }

    /// <summary>Клас окончания теста контента ViewModel</summary>
    public class TotalContent : BaseContent
    {
        /// <summary>Количество правильных ответов</summary>
        public int CountRight => 5;
 
        /// <summary>Количество вопросов в тесте</summary>
        public int CountTotal => 10;
   }

    /// <summary>Класс ответа на вопрос для ViewModel</summary>
    public class AnswerVM
    {
        /// <summary>Текст ответа</summary>
        public string Text => "Ответ";
 
        /// <summary>Свойство для выбора ответа</summary>
        public bool IsRightView => true;
    }