Создание программы - ООП модель, MVP

    /// <summary>
    /// Опросник.
    /// Содержит список вопросов.
    /// </summary>
    [Serializable]
    public class Questionnaire : List<Quest>
    {
    }
 
    /// <summary>
    /// Вопрос.
    /// Содержит список альтернатив.
    /// </summary>
    [Serializable]
    public class Quest : List<Alternative>
    {
        /// <summary>
        /// Идентификатор вопроса
        /// </summary>
        public string Id { get; set; }
 
        /// <summary>
        /// Текст вопроса
        /// </summary>
        public string Title { get; set; }
    }
 
    /// <summary>
    /// Альтернатива вопроса
    /// </summary>
    [Serializable]
    public class Alternative
    {
        /// <summary>
        /// Код альтернативы
        /// </summary>
        public int Code { get; set; }
 
        /// <summary>
        /// Текст альтернативы
        /// </summary>
        public string Title { get; set; }
    }

    [Serializable]
    public class Questionnaire
    {
        public List<Quest> Questions { get; set; }
    }

    /// <summary>
    /// Сохранение и чтение объектов в/из файла
    /// </summary>
    public class SaverLoader
    {
        /// <summary>
        /// Сохранение объекта в файл
        /// </summary>
        public static void Save<T>(T obj, string filePath)
        {
            using (var fs = File.OpenWrite(filePath))
                new BinaryFormatter().Serialize(fs, obj);
        }
 
        /// <summary>
        /// Чтение объекта из файла
        /// </summary>
        public static T Load<T>(string filePath)
        {
            using (var fs = File.OpenRead(filePath))
                return (T)new BinaryFormatter().Deserialize(fs);
        }
    }

    [TestClass]
    public class UnitTest1
    {
        [TestMethod]
        public void TestMethod1()
        {
            //создаем опросник
            var questionnaire = new Questionnaire();
            //создаем вопрос
            var quest = new Quest { Title = "Заголовок вопроса" };
            //создаем альтернативу
            var alt = new Alternative {Code = 1, Title = "Вариант1"};
            //добавляем альтернативу в вопрос
            quest.Add(alt);
            //добавляем вопрос в опросник
            questionnaire.Add(quest);
 
            //сохраняем опросник в файл
            SaverLoader.Save(questionnaire, "c:\\temp.q");
 
            //читаем опросник из файла
            var loadedQuestionnaire = SaverLoader.Load<Questionnaire>("c:\\temp.q");
 
            //проверяем число вопросов и альтернатив в загруженном опроснике
            Assert.AreEqual(loadedQuestionnaire.Count, questionnaire.Count);
            Assert.AreEqual(loadedQuestionnaire[0].Count, questionnaire[0].Count);
        }
    }

    /// <summary>
    /// Заполненная анкета.
    /// Содержит список ответов.
    /// </summary>
    [Serializable]
    public class Anketa : List<Answer>
    {
    }
 
    /// <summary>
    /// Ответ респондента в конкретном вопросе
    /// </summary>
    [Serializable]
    public class Answer
    {
        /// <summary>
        /// Идентификатор вопроса
        /// </summary>
        public string QuestId { get; set; }
 
        /// <summary>
        /// Код выбранной альтернативы
        /// </summary>
        public int AlternativeCode { get; set; }
    }

        [TestMethod]
        public void TestMethod2()
        {
            //создаем анкету
            var anketa = new Anketa();
            //создаем ответ
            var answer = new Answer{ QuestId = "A1", AlternativeCode = 1 };
            //добавляем ответ в анкету
            anketa.Add(answer);
 
            //сохраняем анкету в файл
            SaverLoader.Save(anketa, "c:\\temp.a");
 
            //читаем анкету из файла
            var loadedAnketa = SaverLoader.Load<Anketa>("c:\\temp.a");
 
            //проверяем число ответов в загруженной анкете
            Assert.AreEqual(loadedAnketa.Count, anketa.Count);
        }

using System;
using System.Windows.Forms;
using WindowsFormsApplication396.Controls;
using WindowsFormsApplication396.Core;
 
namespace WindowsFormsApplication396
{
    public partial class MainForm : Form
    {
        // Текущий опросник
        private Questionnaire questionnaire = new Questionnaire();
 
        public MainForm()
        {
            InitializeComponent();
 
            //строим интерфейс
            Build();
        }
 
        private void Build()
        {
            //очищаем центральную панель
            pnMain.Controls.Clear();
            //создаем контролы для каждого вопроса
            foreach (var quest in questionnaire)
            {
                //создаем usercontrol для вопроса
                var pn = new QuestPanel();
                //строим его
                pn.Build(quest);
                //добавляем на главную панель
                pnMain.Controls.Add(pn);
            }
            //обновляем интерфейс
            UpdateInterface();
        }
 
        private void UpdateInterface()
        {
        }
 
        private void LoadQuestionnaireFromFile(string filePath)
        {
            //загружаем из файла
            questionnaire = SaverLoader.Load<Questionnaire>(filePath);
            //перестриваем интерфейс
            Build();
        }
 
        private void SaveQuestionnaireToFile(string filePath)
        {
            //сохраняем в файл
            SaverLoader.Save(questionnaire, filePath);
        }
 
        private void btOpen_Click(object sender, EventArgs e)
        {
            var ofd = new OpenFileDialog() {Filter = "Опросник|*.q"};
            if (ofd.ShowDialog() == DialogResult.OK)
                LoadQuestionnaireFromFile(ofd.FileName);
        }
 
        private void btSave_Click(object sender, EventArgs e)
        {
            var sfd = new SaveFileDialog() { Filter = "Опросник|*.q" };
            if (sfd.ShowDialog() == DialogResult.OK)
                SaveQuestionnaireToFile(sfd.FileName);
        }
 
        private void btAddQuest_Click(object sender, EventArgs e)
        {
            //добавляем новый вопрос в опросник
            new QuestionnaireManipulator().AddNewQuest(questionnaire);
            //перестраиваем интерфейс
            Build();
        }
    }
}

    /// <summary>
    /// Производит манипуляции с опросником
    /// </summary>
    class QuestionnaireManipulator
    {
        /// <summary>
        /// Добавить новый вопрос
        /// </summary>
        public Quest AddNewQuest(Questionnaire questionnaire)
        {
            var quest = new Quest() {Id = "A1", Title = "Текст вопроса"};
            questionnaire.Add(quest);
            return quest;
        }
 
        /// <summary>
        /// Удалить вопрос
        /// </summary>
        public void RemoveQuest(Questionnaire questionnaire, Quest quest)
        {
            questionnaire.Remove(quest);
        }
 
        /// <summary>
        /// Перемещение вопроса
        /// </summary>
        public void MoveQuest(Questionnaire questionnaire, Quest quest, int dir)
        {
            //получаем текущий индекс
            var i = questionnaire.IndexOf(quest);
            if (i < 0) return;//хм...
 
            if (i == 0 && dir < 0) return; //не можем переместить вверх, потому что вопрос и так первый
            if (i >= questionnaire.Count - 1 && dir > 0) return; //не можем переместить вниз, потому что вопрос и так последний
 
            //перемещаем вверх
            if (dir < 0)
            {
                questionnaire.RemoveAt(i);
                questionnaire.Insert(i - 1, quest);
            }
 
            //перемещаем вниз
            if (dir > 0)
            {
                questionnaire.RemoveAt(i);
                questionnaire.Insert(i + 1, quest);
            }
        }
    }

    public partial class QuestPanel : UserControl
    {
        private Questionnaire questionnaire;
        private Quest quest;
        private int updating;
 
        public event Action QuestionnaireListChanged = delegate { };
        public event Action Changed = delegate { };
 
        public QuestPanel()
        {
            InitializeComponent();
        }
 
        /// <summary>
        /// Строим интерфейс
        /// </summary>
        public void Build(Questionnaire questionnaire, Quest quest)
        {
            this.questionnaire = questionnaire;
            this.quest = quest;
 
            //выставляем флажок обновления
            updating++;
 
            //переносим данные из объекта в интерфейс
            tbId.Text = quest.Id;
            tbTitle.Text = quest.Title;
 
            //сбрасываем флажок обновления
            updating--;
        }
 
        /// <summary>
        /// Обновляем объект из интерфеса
        /// </summary>
        private void UpdateObject()
        {
            //если режим обновления интерфейса - не реагируем
            if (updating > 0) return;
 
            //переносим данные из интерфейса в объект
            quest.Id = tbId.Text;
            quest.Title = tbTitle.Text;
 
            //сигнализируем наверх о том, что объект изменился
            Changed();
        }
 
        private void btDelete_Click(object sender, EventArgs e)
        {
            if (MessageBox.Show("Удалить вопрос?", "Удаление вопроса", MessageBoxButtons.OKCancel) == DialogResult.OK)
            {
                //удаляем вопрос
                new QuestionnaireManipulator().RemoveQuest(questionnaire, quest);
                //сигнализируем наверх о том, что список вопросов поменялся
                QuestionnaireListChanged();
            }
        }
 
        private void btUp_Click(object sender, EventArgs e)
        {
            //передвигаем вопрос вверх по списку
            new QuestionnaireManipulator().MoveQuest(questionnaire, quest, -1);
            //сигнализируем наверх о том, что список вопросов поменялся
            QuestionnaireListChanged();
        }
 
        private void btDown_Click(object sender, EventArgs e)
        {
            //передвигаем вопрос вниз по списку
            new QuestionnaireManipulator().MoveQuest(questionnaire, quest, +1);
            //сигнализируем наверх о том, что список вопросов поменялся
            QuestionnaireListChanged();
        }
 
        private void tb_TextChanged(object sender, EventArgs e)
        {
            //обновляем объект
            UpdateObject();
        }
    }

    /// <summary>
    /// Производит манипуляции с вопросом
    /// </summary>
    class QuestManipulator
    {
        /// <summary>
        /// Добавить новую альтернативу
        /// </summary>
        public Alternative AddNewAlt(Quest quest)
        {
            var alt = new Alternative() { Code = 1, Title = "Вариант 1" };
            quest.Add(alt);
            return alt;
        }
 
        /// <summary>
        /// Удалить альтренативу
        /// </summary>
        public void RemoveAlt(Quest quest, Alternative alt)
        {
            quest.Remove(alt);
        }
 
        /// <summary>
        /// Перемещение альтернативы
        /// </summary>
        public void MoveAlt(Quest quest, Alternative alt, int dir)
        {
            //получаем текущий индекс
            var i = quest.IndexOf(alt);
            if (i < 0) return;//хм...
 
            if (i == 0 && dir < 0) return; //не можем переместить вверх, потому что альтернатива и так первая
            if (i >= quest.Count - 1 && dir > 0) return; //не можем переместить вниз, потому что альтернатива и так последняя
 
            //перемещаем вверх
            if (dir < 0)
            {
                quest.RemoveAt(i);
                quest.Insert(i - 1, alt);
            }
 
            //перемещаем вниз
            if (dir > 0)
            {
                quest.RemoveAt(i);
                quest.Insert(i + 1, alt);
            }
        }
    }

    public partial class AlternativePanel : UserControl
    {
        private Quest quest;
        private Alternative alt;
        private int updating;
 
        public event Action AlternativeListChanged = delegate { };
        public event Action Changed = delegate { };
 
        public AlternativePanel()
        {
            InitializeComponent();
        }
 
        /// <summary>
        /// Строим интерфейс
        /// </summary>
        public void Build(Quest quest, Alternative alt)
        {
            this.quest = quest;
            this.alt = alt;
 
            //выставляем флажок обновления
            updating++;
 
            //переносим данные из объекта в интерфейс
            tbId.Text = alt.Code.ToString();
            tbTitle.Text = alt.Title;
 
            //сбрасываем флажок обновления
            updating--;
        }
 
        /// <summary>
        /// Обновляем объект из интерфеса
        /// </summary>
        private void UpdateObject()
        {
            //если режим обновления интерфейса - не реагируем
            if (updating > 0) return;
 
            //переносим данные из интерфейса в объект
            alt.Code = int.Parse(tbId.Text);
            alt.Title = tbTitle.Text;
 
            //сигнализируем наверх о том, что объект изменился
            Changed();
        }
 
        private void btDelete_Click(object sender, EventArgs e)
        {
            if (MessageBox.Show("Удалить альтернативу?", "Удаление альтернативы", MessageBoxButtons.OKCancel) == DialogResult.OK)
            {
                //удаляем альтернативу
                new QuestManipulator().RemoveAlt(quest, alt);
                //сигнализируем наверх о том, что список поменялся
                AlternativeListChanged();
            }
        }
 
        private void btUp_Click(object sender, EventArgs e)
        {
            //передвигаем альтернативу вверх по списку
            new QuestManipulator().MoveAlt(quest, alt, -1);
            //сигнализируем наверх о том, что список поменялся
            AlternativeListChanged();
        }
 
        private void btDown_Click(object sender, EventArgs e)
        {
            //передвигаем альтернативу вниз по списку
            new QuestManipulator().MoveAlt(quest, alt, +1);
            //сигнализируем наверх о том, что список поменялся
            AlternativeListChanged();
        }
 
        private void tb_TextChanged(object sender, EventArgs e)
        {
            //обновляем объект
            UpdateObject();
        }
    }

    /// <summary>
    /// Производит манипуляции с опросником
    /// </summary>
    class QuestionnaireManipulator
    {
        private const string DefaultQuestPrefix = "A";
 
        /// <summary>
        /// Добавить новый вопрос
        /// </summary>
        public Quest AddNewQuest(Questionnaire questionnaire)
        {
            //подбираем уникальное имя вопроса
            var counter = 1;
            var name = DefaultQuestPrefix + counter;
 
            while (questionnaire.Any(q => q.Id == name))//увеличиваем счетчик, пока не найдем имени, которого еще нет в опроснике
            {
                counter++;
                name = DefaultQuestPrefix + counter;
            }
            //
            var quest = new Quest() {Id = name, Title = "Текст вопроса"};
            questionnaire.Add(quest);
            return quest;
        }
 
        //....
    }

    /// <summary>
    /// Производит манипуляции с вопросом
    /// </summary>
    class QuestManipulator
    {
        /// <summary>
        /// Добавить новую альтернативу
        /// </summary>
        public Alternative AddNewAlt(Quest quest)
        {
            //подбираем уникальный код альтернативы
            var code = 1;
 
            while (quest.Any(a => a.Code == code))//увеличиваем счетчик, пока не найдем кода, которого еще нет
                code++;
 
            //
            var alt = new Alternative() { Code = code, Title = "Вариант "  + code };
            quest.Add(alt);
            return alt;
        }
 
        //....
    }

    /// <summary>
    /// Проверяет корректность опросника.
    /// Генерирует исключение с текстом, описывающим суть проблемы.
    /// </summary>
    class QuestionnaireValidator
    {
        public void Validate(Questionnaire questionnaire)
        {
            //проверяем уникальность имен вопросов
            var names = new HashSet<string>();
            foreach(var q in questionnaire)
            if(!names.Add(q.Id))
                throw new Exception("Дублируется имя вопроса " + q.Id);
 
            //проверяем уникальность кодов альтернатив
            foreach (var quest in questionnaire)
            {
                var codes = new HashSet<int>();
                foreach (var a in quest)
                if (!codes.Add(a.Code))
                    throw new Exception("В вопросе " + quest.Id + " дублируется код альтернативы " + a.Code);
            }
        }
    }

        private void SaveQuestionnaireToFile(string filePath)
        {
            //проверяем опросник
            new QuestionnaireValidator().Validate(questionnaire);
            //сохраняем в файл
            SaverLoader.Save(questionnaire, filePath);
        }
 
        private void RunQuestionnaire()
        {
            //проверяем опросник
            new QuestionnaireValidator().Validate(questionnaire);
            //todo ...
        }

    public static class ExceptionHandler
    {
        public static void Init()
        {
            Application.SetUnhandledExceptionMode(UnhandledExceptionMode.CatchException);
            Application.ThreadException -= Handle;
            Application.ThreadException += Handle;
            AppDomain.CurrentDomain.UnhandledException -= CurrentDomain_UnhandledException;
            AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
        }
 
        static void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
        {
            //здесь обрабатываются исключения не UI потоков
            var ex = e.ExceptionObject as Exception;
            if (ex != null)
            {
                while (ex.InnerException != null)
                    ex = ex.InnerException;
                MessageBox.Show(ex.Message, "Thread exception");
            }
            else
                MessageBox.Show(e.ExceptionObject.ToString(), "Thread exception");
        }
 
        static void Handle(object sender, ThreadExceptionEventArgs e)
        {
            var ex = e.Exception;
            while (ex.InnerException != null)
                ex = ex.InnerException;
 
#if DEBUG
            using (var exceptionDlg = new ThreadExceptionDialog(ex))
            {
                var res = exceptionDlg.ShowDialog();
                if (res == DialogResult.Abort)
                    Application.Exit();
            }
#else
            MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
#endif
        }
    }

    static class ListHelper
    {        
        /// <summary>
        /// Перемещение элемента вверх/вниз по списку
        /// </summary>
        public static void MoveElement<T>(IList<T> list, T element, int dir)
        {
            //получаем текущий индекс
            var i = list.IndexOf(element);
            if (i < 0) return;//хм...
 
            if (i == 0 && dir < 0) return; //не можем переместить вверх, потому что вопрос и так первый
            if (i >= list.Count - 1 && dir > 0) return; //не можем переместить вниз, потому что вопрос и так последний
 
            //перемещаем
            list.RemoveAt(i);
            list.Insert(i + dir, element);
        }
    }

        /// <summary>
        /// Перемещение вопроса
        /// </summary>
        public void MoveQuest(Questionnaire questionnaire, Quest quest, int dir)
        {
            ListHelper.MoveElement(questionnaire, quest, dir);
        }
 
        //....
 
        /// <summary>
        /// Перемещение альтернативы
        /// </summary>
        public void MoveAlt(Quest quest, Alternative alt, int dir)
        {
            ListHelper.MoveElement(quest, alt, dir);
        }

        //проверка валидатора
        [TestMethod]
        public void TestMethod3()
        {
            //создаем опросник
            var questionnaire = new Questionnaire();
            //создаем вопросы с одинаковыми именами
            questionnaire.Add(new Quest { Id = "A1", Title = "Заголовок вопроса" });
            questionnaire.Add(new Quest { Id = "A1", Title = "Заголовок вопроса" });
 
            //запускаем валидатор
            try
            {
                new QuestionnaireValidator().Validate(questionnaire);
                Assert.Fail("Validator passes duplicates");
            }
            catch
            {
                //все ок
            }
        }

    /// <summary>
    /// Условие, которое может возвращать true или false в зависимости от ответов в Anketa
    /// </summary>
    public class Condition
    {
        /// <summary>
        /// Выполняется ли условие для данной анкеты?
        /// </summary>
        public bool Check(Anketa anketa)
        {
            //todo
            return true;//temp!
        }
    }

    /// <summary>
    /// Вопрос.
    /// Содержит список альтернатив.
    /// </summary>
    [Serializable]
    public class Quest : List<Alternative>
    {
        //....
 
        /// <summary>
        /// Условие показа
        /// </summary>
        public Condition Condition { get; set; }
    }
 
    /// <summary>
    /// Альтернатива вопроса
    /// </summary>
    [Serializable]
    public class Alternative
    {
        //....
 
        /// <summary>
        /// Условие показа
        /// </summary>
        public Condition Condition { get; set; }
    }

    /// <summary>
    /// Вопрос.
    /// Содержит список альтернатив.
    /// </summary>
    [Serializable]
    public class Quest : List<Alternative>
    {
        // ....
 
        /// <summary>
        /// Тип вопроса
        /// </summary>
        public QuestType QuestType { get; set; }
    }
 
    /// <summary>
    /// Тип вопроса
    /// </summary>
    [Serializable]
    public enum QuestType
    {
        /// <summary>
        /// Выбор одной альтернативы из фиксированного списка альтернатив
        /// </summary>
        SingleAnswer,
        /// <summary>
        /// Пользователь может вбить произвольный ответ в текстовое поле
        /// </summary>
        OpenQuestion
    }

    /// <summary>
    /// Процесс прохождения интервью
    /// </summary>
    public class Interview
    {
        internal Questionnaire questionnaire { get; private set; }
        internal Anketa anketa { get; private set; }
 
        /// <summary>
        /// Ответы, уже данные респондентом
        /// </summary>
        public List<Answer> PassedAnswers { get; set; } = new List<Answer>();
 
        /// <summary>
        /// Текущий вопрос, на который отвечает респондент в данный момент
        /// </summary>
        public Answer CurrentAnswer { get; set; }
 
        /// <summary>
        /// Интервью завершено?
        /// </summary>
        public bool IsFinished { get; internal set; }
 
        public Interview(Questionnaire questionnaire, Anketa anketa)
        {
            this.questionnaire = questionnaire;
            this.anketa = anketa;
        }
    }

    /// <summary>
    /// Функционал для Interview
    /// </summary>
    public class InterviewManipulator
    {
        private Interview interview;
 
        public InterviewManipulator(Interview interview)
        {
            this.interview = interview;
        }
 
        /// <summary>
        /// Переходим к следующему вопросу
        /// </summary>
        public void GoToNextQuestion()
        {
            if (interview.IsFinished) return;//интервью уже завершено
 
            //получаем индекс текущего вопроса
            var currentQuestIndex = interview.CurrentAnswer == null ? -1 : interview.questionnaire.FindIndex(q => q.Id == interview.CurrentAnswer.QuestId);
 
            //ищем следующий вопрос, у которого выполняется условие показа
            for (int i = currentQuestIndex + 1; i < interview.questionnaire.Count; i++)
            {
                //получаем условие отображения вопроса
                var condition = interview.questionnaire[i].Condition;
 
                //условие выполняется?
                if (condition == null || condition.Check(interview.anketa))
                {
                    //нашли
                    var quest = interview.questionnaire[i];
 
                    //добавляем текущий ответ в список отвеченных вопросов
                    if(interview.CurrentAnswer != null)
                        interview.PassedAnswers.Add(interview.CurrentAnswer);
 
                    //создаем новый Answer для нового вопроса
                    interview.CurrentAnswer = new Answer { QuestId = quest.Id };
                    interview.anketa.Add(interview.CurrentAnswer);
                    //
                    return;
                }
            }
 
            //нет следующего вопроса, анкета завершена
            if (interview.CurrentAnswer != null)
            {
                interview.PassedAnswers.Add(interview.CurrentAnswer);
                interview.CurrentAnswer = null;
            }
            interview.IsFinished = true;
        }
 
        /// <summary>
        /// Получение списка альтернатив, разрешенных к показу, для текущего вопроса
        /// </summary>
        public IEnumerable<Alternative> GetAllowedAlternatives()
        {
            if (interview.IsFinished) yield break;//интервью уже завершено
            if (interview.CurrentAnswer == null) yield break;//нет текущего вопроса
 
            //получаем текущий вопрос
            var quest = interview.questionnaire.First(q => q.Id == interview.CurrentAnswer.QuestId);
 
            //перебираем альтернативы, проверяем условие показа, возвращаем те, которые разрешены к показу
            foreach(var alt in quest)
            if (alt.Condition == null || alt.Condition.Check(interview.anketa))
                yield return alt;
        }
    }

    public partial class MainForm : Form
    {
        //интервью
        private Interview interview;
 
        //функционал интервью
        private InterviewManipulator interviewManipulator;
 
        //текущий опросник
        private Questionnaire questionnaire;
 
        //текущая анкета
        private Anketa anketa;
 
        public MainForm()
        {
            InitializeComponent();
        }
 
        protected override void OnLoad(EventArgs e)
        {
            base.OnLoad(e);
 
            //создаем новую анкету
            anketa = new Anketa();
 
            //запрашиваем опросник, если он не задан
            if (questionnaire == null)
            {
                var ofd = new OpenFileDialog() { Filter = "Опросник|*.q", Title = "Выберите опросник" };
                if (ofd.ShowDialog(this) == DialogResult.OK)
                {
                    questionnaire = SaverLoader.Load<Questionnaire>(ofd.FileName);
                }
                else
                {
                    //если пользователь не выбрал опросник - просто завершаем приложение
                    Close();
                    return;
                }
            }
 
            //создаем процесс опроса (интервью)
            interview = new Interview(questionnaire, anketa);
            //создаем манипулятор для интервью
            interviewManipulator = new InterviewManipulator(interview);
 
            //переходим к первому вопросу
            interviewManipulator.GoToNextQuestion();
 
            //строим интерфейс
            Build();
        }
 
        /// <summary>
        /// Построение интерфейса для опросника
        /// </summary>
        public void Build()
        {
            //очищаем панель ответов
            pnAnswers.Controls.Clear();
 
            //отображаем уже отвеченные вопросы
            foreach (var answer in interview.PassedAnswers)
            {
                //создаем панель ответа
                var pn = new AnswerPanel();
                //строим
                pn.Build(interviewManipulator, questionnaire.First(q => q.Id == answer.QuestId), answer, true);
                //добавляем на форму
                pn.Parent = pnAnswers;
            }
 
            //отображаем вопрос, на который нужно ответить
            if (interview.CurrentAnswer != null)
            {
                //создаем панель ответа
                var pn = new AnswerPanel();
                //строим
                pn.Build(interviewManipulator, questionnaire.First(q => q.Id == interview.CurrentAnswer.QuestId), interview.CurrentAnswer, false);
                //добавляем на форму
                pn.Parent = pnAnswers;
            }
 
            //добавляем кнопку "далее"
            btNext.Parent = interview.IsFinished ? null : pnAnswers;
            btFinish.Parent = interview.IsFinished ? pnAnswers : null;
        }
 
        private void btNext_Click(object sender, EventArgs e)
        {
            //переходим к следующему вопросу
            interviewManipulator.GoToNextQuestion();
            //строим интерфейс
            Build();
        }
 
        private void btFinish_Click(object sender, EventArgs e)
        {
            //предлагаем сохранить анкету
            if (MessageBox.Show("Сохранить анкету?", "Сохранение анкеты", MessageBoxButtons.OKCancel) == DialogResult.OK)
            {
                var sfd = new SaveFileDialog() { Filter = "Анкета|*.a", FileName = Guid.NewGuid().ToString() };
                if (sfd.ShowDialog(this) == DialogResult.OK)
                {
                    //сохраняем анкету
                    SaverLoader.Save(anketa, sfd.FileName);
                }
            }
            //выходим
            Close();
        }
    }

    /// <summary>
    /// Отображение вопроса и ответа
    /// </summary>
    public partial class AnswerPanel : UserControl
    {
        private Quest quest;
        private Answer answer;
        private InterviewManipulator interviewManipulator;
 
        /// <summary>
        /// Пользователь указал/изменил ответ
        /// </summary>
        public event Action Changed = delegate { };
 
        public AnswerPanel()
        {
            InitializeComponent();
        }
 
        /// <summary>
        /// Построение интерфейса
        /// </summary>
        public void Build(InterviewManipulator interviewManipulator, Quest quest, Answer answer, bool readOnly)
        {
            this.interviewManipulator = interviewManipulator;
            this.quest = quest;
            this.answer = answer;
 
            lbQuestTitle.Text = quest.Title;
 
            //очищаем панель альтернатив
            pnMain.Controls.Clear();
 
            if (readOnly)
            {
                //строим ответы в режиме readonly
                BuildReadOnlyAnswerInterface();
            }
            else
            { 
                //строим альтернативы, в зависимости от типа вопроса
                switch (quest.QuestType)
                {
                    case QuestType.SingleAnswer: BuildSingleAnswerInterface(); break;
                    case QuestType.OpenQuestion: BuildOpenAnswerInterface(); break;
                }
            }
        }
 
        private void BuildSingleAnswerInterface()
        {
            //создаем комбобокс
            var cb = new ComboBox();
            cb.DataSource = interviewManipulator.GetAllowedAlternatives().ToList();//отображаем список разрешенных к показу альтернатив
            cb.ValueMember = "Code";
            cb.DisplayMember = "Title";
            cb.DropDownStyle = ComboBoxStyle.DropDownList;
            cb.Parent = pnMain;
            cb.SelectedValueChanged += (o, O) => OnValueSelected((int)cb.SelectedValue);//обрабатываем выбор
        }
 
        private void BuildOpenAnswerInterface()
        {
            //создаем текстбокс
            var tb = new TextBox();
            tb.Parent = pnMain;
            tb.TextChanged += (o, O) => OnValueSelected(tb.Text);//обрабатываем выбор
        }
 
        private void BuildReadOnlyAnswerInterface()
        {
            //создаем лейбу
            var lb = new Label();
            //получаем альтернативу
            var alt = quest.FirstOrDefault(a => a.Code == answer.AlternativeCode);
            lb.Text = alt?.Title + " " + answer.Text;
            lb.Parent = pnMain;
        }
 
        private void OnValueSelected(int alternativeCode)
        {
            answer.AlternativeCode = alternativeCode; //отправляем выбранное значение в доменный объект
            Changed();//сигнализируем наверх, о том, что пользователь что-то выбрал
        }
 
        private void OnValueSelected(string text)
        {
            answer.Text = text; //отправляем выбранное значение в доменный объект
            Changed();//сигнализируем наверх, о том, что пользователь что-то выбрал
        }
    }

        private void RunQuestionnaire()
        {
            //проверяем опросник
            new QuestionnaireValidator().Validate(questionnaire);
            //запускаем интервью
            new QuestInterviewNS.MainForm(questionnaire).ShowDialog(this);
        }

    /// <summary>
    /// Вычисляет условия
    /// </summary>
    public class ConditionCalculator
    {
        private const string QuestNamePattern = @"\b[A-Z]\d+\b";
 
        public bool Calculate(Anketa anketa, Condition condition)
        {
            if (condition == null || string.IsNullOrEmpty(condition.Expression))
                return true;
 
            //заменяем имена вопросов на значения
            var expression = Regex.Replace(condition.Expression, QuestNamePattern,
                (m) =>
                {
                    var questId = m.Value;
                    //ищем ответ
                    var answer = anketa.FirstOrDefault(a => a.QuestId == questId);
                    if (answer != null)
                    {
                        //заменяем имя вопроса на ответ
                        if (string.IsNullOrEmpty(answer.Text))
                            return answer.AlternativeCode.ToString();
 
                        return "'" + answer.Text + "'";
                    }
                    return "0";//код отсутствия ответа
                });
 
            //вычислем выражение
            return (bool) new DataTable().Compute(expression, null);
        }
 
        public void Check(Questionnaire questionnaire, string expression)
        {
            if (string.IsNullOrEmpty(expression))
                return;
 
            //проверяем имена вопросов
            foreach(Match m in Regex.Matches(expression, QuestNamePattern))
                if (questionnaire.All(q => q.Id != m.Value))
                    throw new Exception("Вопрос " + m.Value + " не найден");
 
            //проверяем синтаксис
            Calculate(new Anketa(), new Condition {Expression = expression});
        }
    }

    public partial class ConditionForm : Form
    {
        private Condition condition;
        private Questionnaire questionnaire;
 
        public event Action Changed = delegate { };
 
        public ConditionForm()
        {
            InitializeComponent();
        }
 
        public void Build(Questionnaire questionnaire, Condition condition)
        {
            this.questionnaire = questionnaire;
            this.condition = condition;
 
            tbExpression.Text = condition.Expression;
        }
 
        private void btOk_Click(object sender, EventArgs e)
        {
            var expression = tbExpression.Text.Trim();
 
            //проверяем корректность выражения
            try
            {
                new ConditionCalculator().Check(questionnaire, expression);
            }
            catch(Exception ex)
            {
                MessageBox.Show(ex.Message);
                return;
            }
            //обновляем доменный объект
            condition.Expression = expression;
            //сигнализируем наверх о том, что объект поменялся
            Changed();
            //закрываем окно
            DialogResult = DialogResult.OK;
        }
    }

        //проверка калькулятора условий
        [TestMethod]
        public void TestMethod4()
        {
            //создаем опросник
            var questionnaire = new Questionnaire();
            //создаем вопросы
            questionnaire.Add(new Quest { Id = "A1"});
            questionnaire.Add(new Quest { Id = "A2"});
 
            //создакем калькулятор
            var calc = new ConditionCalculator();
 
            //проверка синтаксиса с ошибкой
            try
            {
                calc.Check(questionnaire, "A1 - 23");
                calc.Check(questionnaire, "A1 = 2 + ");
                Assert.Fail("Calculator.Check() false positive");
            }
            catch
            {
                //все ок
            }
 
            //проверка несуществующих вопросов
            try
            {
                calc.Check(questionnaire, "A23 = 1");
                Assert.Fail("Calculator.Check() false positive");
            }
            catch
            {
                //все ок
            }
 
            //проверка корректных выражений
            var anketa = new Anketa();
            anketa.Add(new Answer {QuestId = "A1", AlternativeCode = 1});
            anketa.Add(new Answer { QuestId = "A2", AlternativeCode = 1 });
            anketa.Add(new Answer { QuestId = "A3", Text = "YES" });
            Assert.IsTrue(calc.Calculate(anketa, new Condition {Expression = "A1 = 1"}));
            Assert.IsTrue(calc.Calculate(anketa, new Condition { Expression = "A1 = A2" }));
            Assert.IsTrue(calc.Calculate(anketa, new Condition { Expression = "A3 <> 'NO'" }));
            Assert.IsTrue(calc.Calculate(anketa, new Condition { Expression = "A1 + A2 = 2" }));
            Assert.IsTrue(calc.Calculate(anketa, new Condition { Expression = "(A1 = 1) and (A3 = 'YES')" }));
            Assert.IsTrue(calc.Calculate(anketa, new Condition { Expression = "(A1 = 5) or (A3 = 'YES')" }));
        }

    /// <summary>
    /// Экспорт анкет во внешние форматы
    /// </summary>
    public class Export
    {
        public string Separator { get; set; } = ";";
        public Encoding Encoding { get; set; } = Encoding.UTF8;
 
        /// <summary>
        /// Экспорт заполненых анкет в CSV
        /// </summary>
        public void ExportToCSV(IEnumerable<Anketa> anketas, string fileName)
        {
            //получаем имена всех вопросов
            var questNames = anketas.SelectMany(a => a).Select(a => a.QuestId).Distinct().ToArray();
            //открываем файл на запись
            using (var sw = new StreamWriter(fileName, false, Encoding))
            {
                //пишем шапку CSV
                sw.WriteLine(string.Join(Separator, questNames));
                //перебираем анкеты
                foreach (var anketa in anketas)
                {
                    var nameToAnswer = new Dictionary<string, string>();
                    //перебираем ответы
                    foreach (var answer in anketa)
                        nameToAnswer[answer.QuestId] = answer.ToString();
 
                    //пишем ответы
                    for (int i = 0; i < questNames.Length; i++)
                    {
                        if (i > 0) sw.Write(Separator);
                        if (nameToAnswer.ContainsKey(questNames[i]))
                            sw.Write(nameToAnswer[questNames[i]]);
                    }
 
                    sw.WriteLine();
                }
            }
        }
    }

        private void btExportCSV_Click(object sender, EventArgs e)
        {
            var ofd = new OpenFolderDialog();
            if (ofd.ShowDialog(this) == DialogResult.OK)
            {
                //получаем список анкет в выбранной папке
                var anketas = Directory.GetFiles(ofd.Folder, "*.a").Select(path => SaverLoader.Load<Anketa>(path)).ToList();
                if (anketas.Count == 0)
                {
                    MessageBox.Show("В этой папке не найдены анкеты");
                    return;
                }
 
                //запрашиваем имя выходного csv файла
                var sfd = new SaveFileDialog() {Filter = "CSV|*.csv"};
                if (sfd.ShowDialog() == DialogResult.OK)
                {
                    //экспортируем
                    new Export().ExportToCSV(anketas, sfd.FileName);
                    MessageBox.Show("Экспортировано " + anketas.Count + " анкет");
                }
            }
        }

    /// <summary>
    /// Проверяет корректность опросника.
    /// Генерирует исключение с текстом, описывающим суть проблемы.
    /// </summary>
    public class QuestionnaireValidator
    {
        public void Validate(Questionnaire questionnaire)
        {
            //проверяем уникальность имен вопросов
            var names = new HashSet<string>();
            foreach(var q in questionnaire)
            if(!names.Add(q.Id))
                throw new Exception("Дублируется имя вопроса " + q.Id);
 
            //проверяем уникальность кодов альтернатив и их число
            foreach (var quest in questionnaire)
            {
                var codes = new HashSet<int>();
                foreach (var a in quest)
                if (!codes.Add(a.Code))
                    throw new Exception("В вопросе " + quest.Id + " дублируется код альтернативы " + a.Code);
                if(quest.Count == 0)
                    throw new Exception("В вопросе " + quest.Id + " нет альтернатив");
            }
        }
    }

    public class ControlHelper
    {
        private int scrollValue;
        private ScrollableControl ctrl;
 
        [DllImport("user32.dll")]
        private static extern int SendMessage(IntPtr hWnd, Int32 wMsg, bool wParam, Int32 lParam);
        private const int WM_SETREDRAW = 11;
 
        public ControlHelper(ScrollableControl ctrl)
        {
            this.ctrl = ctrl;
            StopDrawing();
        }
 
        private void StopDrawing()
        {
            SendMessage(ctrl.Handle, WM_SETREDRAW, false, 0);
            scrollValue = ctrl.VerticalScroll.Value;
            ctrl.SuspendLayout();
        }
 
        public void ResumeDrawing()
        {
            ctrl.VerticalScroll.Value = Math.Min(ctrl.VerticalScroll.Maximum, scrollValue);
            ctrl.ResumeLayout();
            SendMessage(ctrl.Handle, WM_SETREDRAW, true, 0);
            ctrl.Refresh();
        }
    }