Модул 21

Мини проект – конзолно приложение

Как се прави първият собствен проект на C#: избор на малка идея (калкулатор, дневник с оценки, викторина), план на функционалностите, меню с `do-while` и `switch`, безопасно четене с `TryParse`, разделяне на методи, тестване с гранични случаи и представяне пред класа. Плюс стратегия за решаване на изпитни задачи за цикли, когато часовникът тече.

Теория

Изпитната задача за цикли се различава от домашната по едно: има часовник. Затова не започвайте с кода, а с условието – прочетете го два пъти и си отговорете на три въпроса: какво се въвежда, какво трябва да се изведе и какъв е примерът в условието. Почти всяка задача за цикли се свежда до познат шаблон: брояч, акумулатор (сума или произведение), търсене на максимум или минимум, флаг „намерено ли е“ или вложени цикли за фигура. Разпознаете ли шаблона, вече знаете какво ще стои в тялото на цикъла. Правилото под напрежение е първо работещо, после красиво – грозна програма, която дава верен отговор, носи точки, а красива, която не се компилира, не носи нищо.

След като програмата тръгне, проверете я с примера от условието, и то символ по символ, а не „на око“. После нарочно се опитайте да я счупите с граничните случаи (edge cases): нула елемента, един елемент, отрицателни числа, текст вместо число. Най-честите изпитни грешки са добре известни: <= вместо < в условието на for, целочислено деление (sum / n при две int променливи реже дробната част – пишете (double)sum / n), деление на нула при празен вход и int.Parse, който гърми на буква. Държите ли този списък в главата си, ще откривате грешката за секунди. Ако времето свършва, предайте това, което работи – частично решение с ясен изход е по-добро от недовършена „пълна“ версия.

Мини проектът – конзолно приложение (console application) – е първата ви програма, която прави повече от едно нещо и която някой друг ще използва. Планът започва с избор на малка идея, която можете да завършите за два учебни часа: калкулатор, дневник с оценки, викторина, личен бюджет, конвертор на единици. После напишете на лист списък с функционалности (features) – 3 до 5 действия, които потребителят може да избира, например „добави оценка“, „покажи среден успех“, „изход“. Разделете ги на „задължителни“ и „ако остане време“, за да не започнете с най-трудното. От този списък се ражда и менюто: всяка функционалност получава номер, а номер 0 винаги е изходът. Планът е готов, когато можете да разкажете на съученик какво прави програмата, без да сте написали ред код.

Сърцето на реализацията е цикълът на менюто. Менюто трябва да се покаже поне веднъж и после да се повтаря, докато потребителят не избере изход – точно работата на do { ... } while (choice != 0);. В тялото показваме списъка с действия, четем избора и го подаваме на switch: всеки case отговаря на един номер и извиква един метод, default хваща невалиден избор, а всеки case задължително завършва с break. Променливата choice се декларира преди do, защото условието след while е извън блока и не вижда променливите, декларирани вътре. Алтернативата е while (running) с булева променлива, която case 0 обръща на false – изберете едното и го ползвайте навсякъде.

Валидацията на входа (input validation) е това, което отличава проект от упражнение: потребителят ще натисне грешен клавиш, ще въведе буква вместо число и ще поиска да изтегли повече пари, отколкото има. int.Parse и double.Parse при такъв вход хвърлят FormatException и програмата умира по средата на демонстрацията. Затова четете с int.TryParse(text, out int value) – методът връща true при успех и false при грешка, а стойността отива във value. Увийте проверката в while, който пита отново, докато не получи валидно число, и добавете проверка за диапазон: оценката е от 2 до 6, изборът в менюто – от 0 до броя на точките. Понеже тази проверка се повтаря навсякъде, тя е първият кандидат за отделен метод.

Когато всичко е в Main, програмата от 150 реда става нечетима и всяка промяна чупи нещо друго. Решението е разделяне на методи: static void ShowMenu() показва менюто, static int ReadInt(string prompt, int min, int max) връща проверено число, static void AddGrade() изпълнява една точка от менюто. Правилото е един метод – една работа, с име-глагол, което казва какво прави. Методите, които трябва да върнат резултат, го правят с return и обявен тип (int, double, bool), а тези, които само извеждат, са void. Данните, които трябва да се помнят между итерациите на менюто (сума на оценките, баланс, най-добър резултат), се пазят извън цикъла – в променливи, декларирани преди do, или в static полета на класа над Main, за да ги виждат всички методи. Така Main остава кратък: меню, избор, извикване.

Завършването и представянето са отделен урок, защото „работи на моя компютър“ не е край на проекта. Първо съставете тестова таблица: за всяка функционалност по един нормален вход и по един граничен или грешен (празен дневник, разход над баланса, буква вместо число) с колони „вход – очакван резултат – получен резултат“. Поправете каквото не съвпада, после почистете кода: ясни имена, еднакви отстъпи, кратък коментар над всеки метод, премахнати опити и забравени Console.WriteLine("test"). Представянето пред класа е 3–5 минути и следва прост ред: каква е идеята и за кого е, демонстрация на всяка точка от менюто с подготвен вход, показване на един метод и обяснение защо е отделен, какво ви затрудни и какво бихте добавили. Репетирайте демонстрацията веднъж предварително, защото на живо грешният вход се появява сам.

Златни правила

Първо работещо, после красиво

На изпит и в проект целта номер едно е програма, която се компилира и дава верен изход. Чак след това подреждайте, преименувайте и украсявайте – недовършената „идеална“ версия не носи точки.

Менюто е `do-while` със `switch`

Менюто се показва поне веднъж и се повтаря до избор за изход, затова do { ... } while (choice != 0);. Всеки case извиква един метод и завършва с break, а choice се декларира преди цикъла.

Никога не вярвайте на входа

Всяко четене от клавиатурата минава през TryParse и проверка за диапазон, увити в цикъл, който пита отново. Програма, която гърми на буква, не е завършена.

Един метод – една работа

Всяка точка от менюто е отделен метод с име-глагол; повтарящото се четене с проверка е метод, който връща стойност. Main съдържа само менюто и извикванията.

Тествайте с граничните случаи, преди да представите

Празен списък, нула, отрицателно число, текст вместо число, разход над баланса – ако програмата оцелее тях, ще оцелее и демонстрацията пред класа.

Бърз справочник

Стратегия за изпитна задача за цикли (около 20 минути)

СтъпкаКакво правитеВремеТипична грешка
Прочетете условието два пътиПодчертайте вход, изход, ограничения и примера2 минЗапочва се да се пише, преди да е ясно какво се иска
Изберете шаблонаБрояч, акумулатор (сума), максимум/минимум, флаг, вложени цикли за фигура1 минОпит за „оригинално“ решение вместо познат шаблон
Напишете скелетаusing System;, Main, четене на входа, празен цикъл, извеждане3 минЗабравен using, грешно име на метод
Напълнете цикълаТялото на цикъла и условието за край6 мин<= вместо <; брояч, започващ от грешно число
Проверете с примера от условиетоПуснете програмата точно с този вход3 минСравняване „на око“ вместо символ по символ
Гранични случаи0, 1, отрицателно число, текст вместо число3 минДеление на нула при празен вход, int.Parse на текст
Подредете кодаИмена, отстъпи, кратък коментар2 минГубене на време за красота, преди програмата да работи

Строителни блокове на конзолното приложение

ЕлементКодЗа какво служи
Цикъл на менютоdo { ... } while (choice != 0);Показва менюто поне веднъж и го повтаря до избор за изход
Разклонение по изборswitch (choice) { case 1: ...; break; default: ...; break; }Всеки избор извиква своя метод; default хваща невалидния
Безопасно четене на цяло числоint.TryParse(input, out int value)Връща false при текст, не хвърля изключение
Безопасно четене на реално числоdouble.TryParse(input, out double value)Същото за дробни числа; десетичният разделител зависи от регионалните настройки
Метод без резултатstatic void ShowMenu() { ... }Изнася повтарящи се действия на едно място
Метод с резултатstatic int ReadInt(string prompt, int min, int max)Връща проверена стойност с return
Състояние на програматаstatic double sum = 0; над MainСтойности, които живеят между итерациите на менюто и се виждат от всички методи
Форматиран изход$"Средно: {average:F2}"Два знака след десетичния разделител
Пауза и изчистване на екранаConsole.ReadKey(); Console.Clear();Потребителят вижда резултата, после менюто се показва на чист екран

Код за анализ и пренаписване

Калкулатор с меню, валидация и методи

Program.cs
using System;

namespace Calculator
{
    class Program
    {
        static void Main(string[] args)
        {
            int choice;
            do
            {
                ShowMenu();
                choice = ReadInt("Избор: ", 0, 4);

                switch (choice)
                {
                    case 1:
                        Calculate('+');
                        break;
                    case 2:
                        Calculate('-');
                        break;
                    case 3:
                        Calculate('*');
                        break;
                    case 4:
                        Calculate('/');
                        break;
                    case 0:
                        Console.WriteLine("Довиждане!");
                        break;
                }
                Console.WriteLine();
            } while (choice != 0);
        }

        static void ShowMenu()
        {
            Console.WriteLine("=== КАЛКУЛАТОР ===");
            Console.WriteLine("1. Събиране");
            Console.WriteLine("2. Изваждане");
            Console.WriteLine("3. Умножение");
            Console.WriteLine("4. Деление");
            Console.WriteLine("0. Изход");
        }

        // Чете цяло число от min до max; при грешен вход пита отново
        static int ReadInt(string prompt, int min, int max)
        {
            while (true)
            {
                Console.Write(prompt);
                if (int.TryParse(Console.ReadLine(), out int value) && value >= min && value <= max)
                {
                    return value;
                }
                Console.WriteLine($"Грешка: въведете цяло число от {min} до {max}.");
            }
        }

        // Чете реално число; при грешен вход пита отново
        static double ReadDouble(string prompt)
        {
            while (true)
            {
                Console.Write(prompt);
                if (double.TryParse(Console.ReadLine(), out double value))
                {
                    return value;
                }
                Console.WriteLine("Грешка: това не е число. Опитайте пак.");
            }
        }

        static void Calculate(char operation)
        {
            double a = ReadDouble("Първо число: ");
            double b = ReadDouble("Второ число: ");
            double result = 0;

            switch (operation)
            {
                case '+':
                    result = a + b;
                    break;
                case '-':
                    result = a - b;
                    break;
                case '*':
                    result = a * b;
                    break;
                case '/':
                    if (b == 0)
                    {
                        Console.WriteLine("Грешка: деление на нула не е възможно.");
                        return;
                    }
                    result = a / b;
                    break;
            }

            Console.WriteLine($"{a} {operation} {b} = {result}");
        }
    }
}

Какво се случва тук?

  • Main съдържа само цикъла на менюто: ShowMenu() показва точките, ReadInt чете избора, а switch насочва към нужното действие.
  • choice е декларирана преди do, защото условието while (choice != 0) е извън блока и иначе няма да я вижда.
  • ReadInt връща само число от min до max: int.TryParse отхвърля текста, а допълнителните сравнения – числата извън диапазона; while (true) се напуска единствено с return.
  • Благодарение на тази проверка switch в Main няма нужда от default – невалиден избор просто не може да стигне до него.
  • ReadDouble прилага същата идея за реални числа; на компютър с български регионални настройки десетичният разделител е запетая (3,5), а не точка.
  • Calculate получава операцията като char и я използва в собствен switch; при деление проверява b == 0 и излиза с return, преди да се стигне до грешен резултат.
  • Всяка точка от менюто е един ред в Main и един метод отдолу – ако добавите „5. Степенуване“, промените са само на две места.

Дневник с оценки: състояние между итерациите на менюто

Program.cs
using System;

namespace GradeBook
{
    class Program
    {
        // Състоянието на дневника: живее между итерациите на менюто
        static double sum = 0;
        static int count = 0;
        static int best = 0;

        static void Main(string[] args)
        {
            bool running = true;
            while (running)
            {
                Console.WriteLine();
                Console.WriteLine("=== ДНЕВНИК С ОЦЕНКИ ===");
                Console.WriteLine("1. Добави оценка");
                Console.WriteLine("2. Покажи статистика");
                Console.WriteLine("0. Изход");
                Console.Write("Избор: ");
                string input = Console.ReadLine();

                switch (input)
                {
                    case "1":
                        AddGrade();
                        break;
                    case "2":
                        ShowStatistics();
                        break;
                    case "0":
                        running = false;
                        break;
                    default:
                        Console.WriteLine("Невалиден избор, опитайте пак.");
                        break;
                }
            }
            Console.WriteLine("Довиждане!");
        }

        static void AddGrade()
        {
            int grade = ReadInt("Оценка (2-6): ", 2, 6);
            sum += grade;
            count++;
            if (grade > best)
            {
                best = grade;
            }
            Console.WriteLine($"Записана оценка {grade}. Общо оценки: {count}.");
        }

        static void ShowStatistics()
        {
            if (count == 0)
            {
                Console.WriteLine("Още няма въведени оценки.");
                return;
            }
            double average = sum / count;
            Console.WriteLine($"Брой оценки: {count}");
            Console.WriteLine($"Среден успех: {average:F2}");
            Console.WriteLine($"Най-висока оценка: {best}");
        }

        static int ReadInt(string prompt, int min, int max)
        {
            while (true)
            {
                Console.Write(prompt);
                if (int.TryParse(Console.ReadLine(), out int value) && value >= min && value <= max)
                {
                    return value;
                }
                Console.WriteLine($"Грешка: въведете цяло число от {min} до {max}.");
            }
        }
    }
}

Какво се случва тук?

  • Трите static полета над Main (sum, count, best) са състоянието на дневника – живеят през цялото изпълнение и са видими от всички методи.
  • Менюто тук е while (running) с булев флаг: case "0" го обръща на false и цикълът спира при следващата проверка.
  • Изборът се чете като текст и switch сравнява низове – така буква или празен ред попадат в default, без да е нужен TryParse за самото меню.
  • AddGrade използва ReadInt с диапазон 2–6, после обновява сумата, брояча и най-високата оценка – един метод, една точка от менюто.
  • ShowStatistics първо проверява count == 0 и излиза с return; без тази проверка sum / count би дало NaN вместо среден успех.
  • sum е double, за да е sum / count реално деление, а {average:F2} показва резултата с два знака след десетичния разделител.
  • Опитайте да счупите програмата: изберете 2, преди да сте въвели оценка, въведете 7, въведете abc – тя трябва да отговори учтиво и на трите.

Внимавай! Чести грешки

Грешките, които почти всеки прави в тази тема — виж разликата между грешния и правилния код.

Липсващ `break` в `case`

Грешно

switch (choice)
{
    case 1:
        AddGrade();
    case 2:
        ShowStatistics();
        break;
}

Правилно

switch (choice)
{
    case 1:
        AddGrade();
        break;
    case 2:
        ShowStatistics();
        break;
}

C# не позволява „пропадане“ от един case в следващия – компилаторът спира с грешка CS0163 „Control cannot fall through from one case label to another“. Всеки case завършва с break, return или друг изход от switch.

`int.Parse` гърми на буква

Грешно

Console.Write("Избор: ");
int choice = int.Parse(Console.ReadLine());

Правилно

Console.Write("Избор: ");
int choice;
while (!int.TryParse(Console.ReadLine(), out choice))
{
    Console.Write("Въведете число: ");
}

int.Parse("abc") хвърля FormatException и програмата спира точно по време на демонстрацията. TryParse връща false вместо да хвърля изключение, а цикълът пита отново, докато не получи число.

Състоянието е декларирано вътре в цикъла

Грешно

int choice;
do
{
    double sum = 0;   // нулира се на всяко завъртане!
    int count = 0;
    choice = ReadInt("Избор: ", 0, 2);
    if (choice == 1)
    {
        sum += ReadInt("Оценка: ", 2, 6);
        count++;
    }
} while (choice != 0);

Правилно

double sum = 0;   // състоянието живее извън цикъла
int count = 0;
int choice;
do
{
    choice = ReadInt("Избор: ", 0, 2);
    if (choice == 1)
    {
        sum += ReadInt("Оценка: ", 2, 6);
        count++;
    }
} while (choice != 0);

Променлива, декларирана в тялото на цикъла, се създава наново при всяко завъртане и старата стойност се губи. Всичко, което трябва да се помни между две избирания от менюто, се декларира преди do (или като static поле на класа).

`choice` е декларирана вътре в `do`, а се ползва след `while`

Грешно

do
{
    ShowMenu();
    int choice = ReadInt("Избор: ", 0, 4);
    // ...
} while (choice != 0);   // грешка: choice не съществува тук

Правилно

int choice;
do
{
    ShowMenu();
    choice = ReadInt("Избор: ", 0, 4);
    // ...
} while (choice != 0);

Променлива, декларирана в блока на do, е видима само в него; условието след while е извън блока и компилаторът спира с CS0103 „The name 'choice' does not exist in the current context“. Декларирайте я преди цикъла и само ѝ присвоявайте вътре.

Задачи за самостоятелна работа

Опитай първо сам — подсказката е там само ако наистина закъсаш.

Изпитна задача: статистика на N числа (15 минути)

Решете като на изпит, с часовник. Програмата чете цяло число N и след това N цели числа. Извежда сумата, средното аритметично с два знака след десетичния разделител и най-голямото число. Ако N не е число или е по-малко от 1, програмата пита отново; същото важи за всяко от N-те числа. Преди да пишете, определете кои шаблони за цикли ви трябват.

Викторина с меню и рекорд

Направете викторина с меню: 1 започва игра с три въпроса с текстов отговор, 2 показва най-добрия резултат досега, 0 излиза. Напишете метод static bool AskQuestion(string question, string correctAnswer), който задава въпроса, чете отговора и връща дали е верен, като не прави разлика между главни и малки букви и не брои излишните интервали в началото и края. Най-добрият резултат трябва да се помни между игрите, докато програмата работи.

Личен бюджет с тестова таблица

Направете приложение „Личен бюджет“ с меню: 1 приход, 2 разход, 3 справка, 0 изход. Сумите са положителни реални числа в евро и се четат с метод ReadAmount, който пита отново при грешен вход. Разход, по-голям от наличния баланс, се отказва със съобщение и не се записва. Справката показва баланс, брой записани операции и най-голям разход, а при нула операции – съобщение, че още няма такива. Разделете кода на методи AddIncome, AddExpense, ShowReport, ReadAmount и ReadInt. Преди представянето напишете като коментар в началото на файла поне пет тестови случая (вход – очакван резултат) и ги проверете един по един.

Мини-тест за проверка

Отговори си наум (или на глас!) и чак тогава разкрий отговора.

1. Защо за менюто на конзолно приложение предпочитаме `do-while` пред `while`?

2. Потребителят въвежда `abc`, когато програмата очаква число. Какво става при `int.Parse` и какво – при `int.TryParse`?

3. Програмата работи и когато целият код е в `Main`. Защо все пак го разделяме на методи?

4. На изпит имате 40 минути и три задачи за цикли. Как разпределяте времето?

Речник на термините

Виж пълния речник на курса
Мини проект (mini project)
Малка, но завършена програма с няколко функционалности, която се планира, реализира, тества и представя пред други.
Функционалност (feature)
Едно действие, което потребителят може да поиска от програмата, например „добави оценка“; обикновено отговаря на една точка от менюто и на един метод.
Цикъл на менюто (menu loop)
do-while или while, който показва менюто, чете избора и го обработва със switch, докато не бъде избран изход.
Валидация на входа (input validation)
Проверка дали въведеното е от правилния тип и в допустимия диапазон, преди да се използва; при грешка програмата пита отново, вместо да спре.
`TryParse`
Метод като int.TryParse(text, out int value), който връща true и попълва value при успешно преобразуване, а при грешка връща false, без да хвърля изключение.
Метод (method)
Именувана част от програмата, която върши една работа; може да приема параметри и да връща стойност с return. В конзолното приложение се обявява извън Main със static.
Състояние на програмата (state)
Променливите, чиито стойности се помнят между итерациите на менюто (сума, брой, баланс); декларират се извън цикъла или като static полета.
Тестов случай (test case)
Конкретен вход заедно с очаквания резултат; редицата от тестови случаи е тестовата таблица, по която се проверява проектът преди представянето.
Граничен случай (edge case)
Вход на ръба на допустимото или извън него – нула елемента, най-малката стойност, отрицателно число, текст вместо число – с който се проверява устойчивостта на програмата.

Провери знанията

Бърз тест с избор от отговори върху термините на модула — с точки и моментална обратна връзка.

Провери знанията си

9 въпроса върху термините от модула. Показваме определение — ти избираш правилния термин.

Материали от часовете

Задачи и тестове, давани в клас по тази тема.

Препоръки за този модул

  • Преди да отворите средата за програмиране, напишете менюто на лист: номер, име на действието, какво въвежда потребителят и какво вижда. Този лист е планът на проекта и по него се проверява дали сте готови.
  • Компилирайте и пускайте програмата след всеки нов метод, а не в края. Грешка в 15 нови реда се намира за минута; грешка в 150 – за час.
  • Водете тестова таблица в тетрадката: вход, очакван резултат, получен резултат. Същата таблица е и репетиция за представянето – тя е готовият сценарий за демонстрацията.
  • На изпит с няколко задачи първо прочетете всички условия и започнете от най-лесната. Дайте си лимит за всяка задача; ако сте заседнали над 5 минути на едно място, напишете коментар какво остава и преминете нататък – връщате се с остатъка от времето.

Учебен наръчник — теория, примери, задачи и тестове по предметите от учебния план.

Натисни Ctrl K или / отвсякъде, за да търсиш.