Модул 14

Първа програма и среда за разработка

Инсталиране на Visual Studio Community и създаване на първия конзолен проект, структурата на `Program.cs` (using, namespace, class, Main и top-level statements), извеждане на текст с `Console.WriteLine` и писане на коментари. Как се четат съобщенията на компилатора с CS кодове, каква е разликата между Build и Run, как се ползва дебъгерът и как се изпраща решение в онлайн съдия, който чете от stdin и сравнява stdout.

Теория

Преди да напишем и един ред код, ни трябва среда за разработка (IDE, Integrated Development Environment) — програма, която събира на едно място редактор на код, компилатор (compiler), инструменти за стартиране и дебъгер (debugger) за търсене на грешки. За C# стандартната среда е Visual Studio; изданието Community е безплатно за ученици и се тегли от visualstudio.microsoft.com (Visual Studio 2022 или по-новата версия, която училището използва). Инсталацията минава през Visual Studio Installer: в раздела Workloads отмятате „.NET desktop development“, който инсталира и .NET SDK — комплекта с компилатора и библиотеките, без които C# код не може да се превърне в работеща програма. Изберете английски език на интерфейса, за да съвпадат менютата и съобщенията с документацията и с помощта в интернет. Ако компютърът е по-слаб, алтернатива е Visual Studio Code с отделно инсталиран .NET SDK и разширението C# Dev Kit; командите dotnet new console, dotnet build и dotnet run в терминала правят същото, което Visual Studio прави с бутони. В началото на учебната практика се прави и инструктаж за кабинета — безопасна работа с техниката, собствена папка за проектите и редовно записване — а първите настройки на средата (тема, размер на шрифта, номера на редовете) са в Tools > Options.

Първата програма се създава с File > New > Project и шаблона Console App за C# (внимавайте да не изберете Console App (.NET Framework) — това е старата платформа). Давате име в PascalCase без интервали и кирилица, например HelloWorld, избирате папка и рамка .NET 8.0 (Long Term Support) или по-новата LTS версия, която средата предлага. Visual Studio създава решение (solution, файл .sln), което съдържа проект (.csproj), а в него — файла Program.cs с кода; цялата тази йерархия се вижда в прозореца Solution Explorer. Средата изпълнява два различни процеса: компилиране (Build, Ctrl+Shift+B) превежда изходния код в изпълним файл в папката bin\Debug\net8.0, а стартиране (Run, F5 или Ctrl+F5) пуска този файл; при F5 програмата върви под дебъгера, при Ctrl+F5 — без него, но и в двата случая Visual Studio първо компилира автоматично. Ако компилацията е неуспешна, средата пита дали да пусне последната успешна версия — отговорът винаги е No, иначе ще гледате резултат от стар код. Диалогът се появява само ако вече има успешно компилирана версия; никога не отмятайте „Do not show this dialog again“ с отговор Yes, иначе Visual Studio ще пуска тихо стария код след всяка неуспешна компилация (настройката се връща от Tools > Options > Projects and Solutions > Build and Run > On Run, when build or deployment errors occur).

Отворете Program.cs и ще видите само един коментар и един-единствен ред код: Console.WriteLine("Hello, World!");. Това са инструкции от най-високо ниво (top-level statements) — от C# 9 насам компилаторът сам построява около тях невидимия клас Program и метода Main. Класическата, пълна структура се вижда, ако при създаване на проекта отметнете „Do not use top-level statements“: директивата using System; казва, че ще ползваме пространството от имена (namespace) System, в което е класът Console, без да пишем всеки път System.Console (в новите проекти тя е включена автоматично чрез implicit usings, но не е грешка да я напишете), namespace HelloWorld групира класовете на програмата, class Program е контейнерът на кода, а static void Main(string[] args) е входната точка (entry point) — методът, от който започва изпълнението. Тялото на всеки блок се огражда с фигурни скоби { и }, а всяка команда завършва с точка и запетая ;. Пълната форма ще ви трябва в някои системи за онлайн оценяване и в по-големи проекти, където всеки клас е в отделен файл и входната точка е изписана явно, затова я научете наизуст още сега.

Извеждането на текст става чрез класа Console: Console.WriteLine("...") отпечатва текста и минава на нов ред, а Console.Write("...") остава на същия ред, така че следващото извеждане продължава след него. Текстът (низ, string) се пише в двойни кавички; специалните символи се вмъкват с escape последователности — \n е нов ред, \t табулация, \" кавичка вътре в текста, \\ обратна наклонена черта. С $ пред кавичките получавате интерполиран низ, в който стойности се вмъкват в къдрави скоби: $"Здравей, {name}!", а @ пред кавичките прави дословен низ (verbatim), в който \ е просто символ — удобно за пътища като @"C:\Projects". Ако кирилицата в конзолата излиза като въпросителни, добавете в началото на Main реда Console.OutputEncoding = System.Text.Encoding.UTF8;. Запомнете и че Console.WriteLine() без аргумент просто завършва реда или оставя празен ред.

Коментарите са текст в кода, който компилаторът пропуска изцяло — те са за хората, които четат програмата, включително за вас след месец. Едноредовият коментар започва с // и продължава до края на реда; многоредовият е ограден с /* и */ и може да обхваща няколко реда, но не може да се влага в друг такъв. Третият вид, ///, е документационен коментар над метод или клас — Visual Studio го показва като подсказка, когато някой използва вашия метод. Добрият коментар обяснява защо се прави нещо, а не повтаря какво прави кодът: // проверяваме дали има свободни места е полезно, а // увеличаваме i с 1 над i++ — не. Коментарите са и практичен инструмент за откриване на грешки: с Ctrl+K, Ctrl+C изключвате временно маркираните редове, а с Ctrl+K, Ctrl+U ги връщате.

Компилаторът е строг коректор: при синтактична грешка (syntax error) — липсваща ;, незатворена скоба или кавичка, сгрешено име — той отказва да създаде програма и описва проблема. Visual Studio подчертава мястото с червена вълнообразна линия още докато пишете, а след Build всички проблеми се събират в прозореца Error List: всеки има код (например CS1002), описание на английски, файл, ред и колона, а двойно щракване върху реда ви води до мястото. Четете съобщението буквално — CS1002: ; expected означава „тук очаквах точка и запетая“ и компилаторът посочва края на командата, на която тя липсва. Винаги поправяйте първата грешка и компилирайте отново: една незатворена скоба често поражда десет последващи съобщения, които изчезват сами. Жълтите предупреждения (warnings), като CS0168 за неизползвана променлива или CS8600 за възможна null стойност от Console.ReadLine(), не спират компилацията, но си струва да ги прочетете. Отделен вид са грешките по време на изпълнение (runtime errors, exceptions) — кодът се компилира, но гърми при работа, например int.Parse("abc"); за тях служи дебъгерът: поставяте точка на прекъсване (breakpoint, F9) на ред, пускате с F5, а после с F10 изпълнявате ред по ред и следите стойностите на променливите в прозореца Locals.

В учебната практика решенията се проверяват от система за онлайн оценяване (online judge) — например SoftUni Judge, Codeforces или HackerRank. Вие качвате изходния код (съдържанието на Program.cs, не .exe файла), системата го компилира и го пуска върху скрити тестове: подава вход на стандартния вход (stdin — това, което Console.ReadLine() чете) и сравнява стандартния изход (stdout — това, което Console.WriteLine() печата) с очаквания резултат, обикновено символ по символ. Затова в решението няма подкани като „Въведете число:“ — те стават част от изхода и го правят грешен; четете входа точно в реда, описан в условието, и печатайте точно описания формат, без излишни интервали или редове. Присъдата (verdict) е Accepted при пълно съвпадение, Wrong Answer при различен изход, Compilation Error при синтактична грешка, Runtime Error при изключение и Time Limit Exceeded при твърде бавна програма; при частично решение някои системи дават точки за всеки преминат тест. Преди да изпратите, тествайте локално с примерния вход от условието, изберете правилния език (C# / .NET) и проверете дали системата иска пълната форма с клас и Main.

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

Първо Build, после Run

Програма с макар и една червена грешка изобщо не се създава. Компилирайте често с Ctrl+Shift+B — след всеки няколко реда, а не в края на часа, за да е ясно кой ред е счупил компилацията.

Всяка команда с `;`, всяка скоба по двойки

Командата завършва с точка и запетая, а всяка отваряща {, ( и " има затваряща. Пишете чифта веднага и после попълвайте съдържанието между тях.

Главните и малките букви имат значение

Console.WriteLine е единственият верен запис: console, Writeline и writeLine са различни имена и компилаторът ги отхвърля с CS0103 или CS0117.

Чети първата грешка, не последната

Поправете най-горното съобщение в Error List и компилирайте отново. Голяма част от останалите грешки са последствие от първата и изчезват сами.

Съдията чете само изхода

Онлайн системата сравнява отпечатаното с очакваното символ по символ. Без подкани, без излишни интервали, точно във формата от условието.

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

Visual Studio: най-важните действия

ДействиеКлавишиМенюБележка
Нов проектCtrl+Shift+NFile > New > ProjectШаблон Console App (C#), не Console App (.NET Framework)
Компилиране (Build Solution)Ctrl+Shift+BBuild > Build SolutionСъздава .dll/.exe в bin\Debug\net8.0, но не стартира програмата
Стартиране с дебъгерF5Debug > Start DebuggingСпира на точките на прекъсване
Стартиране без дебъгерCtrl+F5Debug > Start Without DebuggingБез точки на прекъсване; в VS 2022 прозорецът остава отворен и при двата начина (освен ако е включена опцията Automatically close the console when debugging stops)
Точка на прекъсванеF9Debug > Toggle BreakpointИли щракване в сивата лента вляво от реда
Стъпка през / стъпка въвF10 / F11Debug > Step Over / Step IntoПо един ред; стойностите се виждат в прозореца Locals
Списък с грешки (Error List)Ctrl+\, EView > Error ListДвойно щракване върху грешка отваря реда
Solution ExplorerCtrl+Alt+LView > Solution ExplorerПоказва решение, проект и файлове
Коментиране / разкоментиранеCtrl+K, Ctrl+C / Ctrl+K, Ctrl+UEdit > AdvancedРаботи върху маркираните редове

Чести съобщения на компилатора

КодСъобщение (англ.)Какво означаваКак се поправя
CS1002; expectedЛипсва точка и запетая в края на командаДобавете ; в края на посочената команда
CS0103The name 'x' does not exist in the current contextИмето не е декларирано или е с други главни/малки буквиПроверете правописа; декларирайте променливата преди употреба
CS0117'Console' does not contain a definition for 'Writeline'Грешно изписан метод на класWriteLine с главно L
CS1010Newline in constantНезатворен низ — липсва затваряща кавичка "Затворете низа на същия ред
CS1513} expectedЛипсва затваряща фигурна скобаПребройте { и }; Ctrl+K, Ctrl+D подравнява кода и показва къде е дупката
CS0029Cannot implicitly convert type 'string' to 'int'Присвоявате текст на числова променливаint n = int.Parse(Console.ReadLine());
CS0165Use of unassigned local variable 'x'Променливата е декларирана, но няма стойностПрисвоете стойност: int x = 0;
CS0246The type or namespace name 'Strng' could not be foundГрешно име на тип или липсващ usingПоправете името или добавете нужния using
CS5001Program does not contain a static 'Main' method suitable for an entry pointНяма входна точкаДобавете static void Main(string[] args) или top-level statements

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

Пълна структура, извеждане на текст и коментари

Program.cs
using System;
using System.Text;

namespace FirstProgram
{
    // Класът Program е контейнерът на нашия код
    internal class Program
    {
        /* Main е входната точка: изпълнението започва оттук.
           args съдържа аргументите от командния ред (засега са празни). */
        static void Main(string[] args)
        {
            // Без този ред кирилицата може да излезе като ???? в някои конзоли
            Console.OutputEncoding = Encoding.UTF8;

            Console.WriteLine("Здравей, свят!");   // текст + нов ред
            Console.Write("Този текст ");          // без нов ред...
            Console.Write("остава на същия ред.");
            Console.WriteLine();                   // само завършва реда
            Console.WriteLine();                   // празен ред за разделяне

            string school = "ПГ по информатика";
            int year = 2026;
            Console.WriteLine("Училище: " + school);                 // слепване с +
            Console.WriteLine($"Учебна година: {year}/{year + 1}"); // интерполация

            Console.WriteLine("Колона 1\tКолона 2");            // \t е табулация
            Console.WriteLine("Първи ред\nВтори ред");          // \n е нов ред
            Console.WriteLine("Той каза: \"Здравей!\"");         // \" е кавичка в текста
            Console.WriteLine(@"Път: C:\Projects\FirstProgram"); // @ прави дословен низ
        }
    }
}

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

  • using System; дава достъп до класа Console, а using System.Text; — до Encoding; в проект на .NET 8 първото може да се пропусне заради implicit usings, но е добре да го виждате написано.
  • namespace FirstProgram и internal class Program са „опаковката“, а static void Main(string[] args) е входната точка — компилаторът търси точно такъв метод, за да знае откъде да започне.
  • Коментарите с // и /* */ не влияят на програмата; те обясняват намерението на кода и остават в него, когато го копирате в онлайн съдия.
  • Console.Write не добавя нов ред, затова двата текста излизат един до друг; първият празен Console.WriteLine() завършва този ред, а вторият оставя празен ред.
  • "Училище: " + school слепва текст и променлива, а интерполацията $"...{year + 1}" изчислява израза направо в къдравите скоби — на екрана излиза 2026/2027.
  • \t, \n и \" са escape последователности — на екрана излизат табулация, нов ред и кавичка; при @"..." обратната наклонена черта остава буквална и пътят се печата непроменен.
  • Когато пуснете програмата (F5 или Ctrl+F5), прозорецът остава отворен с „Press any key to close this window“ и виждате целия изход — общо десет реда, един от които празен.

Решение във формата на онлайн съдия

Program.cs
using System;

// Примерен вход:        Примерен изход:
// Maria                 Customer: Maria
// 3                     Tickets: 3
// 12                    Total: 36 lv.

namespace JudgeSolution
{
    internal class Program
    {
        static void Main(string[] args)
        {
            // Входът идва от стандартния вход (stdin) ред по ред,
            // точно в реда от условието: 1) име, 2) брой билети, 3) цена на билет
            string name = Console.ReadLine();
            int tickets = int.Parse(Console.ReadLine());
            int price = int.Parse(Console.ReadLine());

            int total = tickets * price;

            // Изходът отива на стандартния изход (stdout) и се сравнява с очаквания.
            // Няма подкани като "Въведете име:" - те биха развалили изхода.
            Console.WriteLine($"Customer: {name}");
            Console.WriteLine($"Tickets: {tickets}");
            Console.WriteLine($"Total: {total} lv.");
        }
    }
}

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

  • Всеки Console.ReadLine() взима следващия ред от стандартния вход; съдията ги подава от файл с тест, затова програмата не пита нищо и не чака жив човек.
  • int.Parse превръща прочетения текст в число; условието гарантира, че входът е цяло число, иначе при текст като abc би се получила грешка по време на изпълнение — в съдията това е Runtime Error.
  • Редът на четене е точно като в условието: първо името, после броят, после цената — разменени редове означават Wrong Answer, въпреки че кодът „работи“.
  • Изходът е три реда в точния формат — дума, двоеточие, интервал, стойност; дори lv. е част от очаквания текст и също се сравнява.
  • Няма Console.Write("Въведете име: ") — такава подкана би се отпечатала на stdout и би развалила първия ред от изхода.
  • Локално тествайте с примерния вход: пуснете с Ctrl+F5, въведете трите реда и сравнете изхода с примера; след това копирайте целия файл в полето на съдията и изберете език C#.
  • Ако системата приема само пълната форма, именно този вид файл с namespace, class Program и Main е сигурният избор; при top-level statements тялото на Main би стояло само, без обвивката.

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

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

Липсваща точка и запетая

Грешно

static void Main(string[] args)
{
    Console.WriteLine("Здравей")
    Console.WriteLine("Свят");
}

Правилно

static void Main(string[] args)
{
    Console.WriteLine("Здравей");
    Console.WriteLine("Свят");
}

Компилаторът дава CS1002: ; expected и посочва края на реда с първия WriteLine — мястото, където е очаквал ;. Ако посоченият ред ви изглежда наред, проверете дали командата на него наистина е затворена.

Грешни главни и малки букви

Грешно

console.writeline("Здравей");
Console.Writeline("Свят");

Правилно

Console.WriteLine("Здравей");
Console.WriteLine("Свят");

console не съществува — CS0103: The name 'console' does not exist in the current context; Writeline не е метод на Console — CS0117. C# различава главни от малки букви навсякъде, затова името се пише точно както в документацията.

Незатворен низ или скоба

Грешно

static void Main(string[] args)
{
    Console.WriteLine("Здравей, свят!);
    Console.WriteLine("Край");

Правилно

static void Main(string[] args)
{
    Console.WriteLine("Здравей, свят!");
    Console.WriteLine("Край");
}

Липсващата кавичка дава CS1010: Newline in constant, а липсващата } — CS1513: } expected; и двете пораждат още няколко последващи грешки. Поправете първата и компилирайте отново — останалите най-често изчезват.

Подкани в решение за онлайн съдия

Грешно

Console.Write("Въведете число: ");
int n = int.Parse(Console.ReadLine());
Console.WriteLine("Резултатът е: " + n * 2);

Правилно

int n = int.Parse(Console.ReadLine());
Console.WriteLine(n * 2);

Съдията не вижда екран — всичко отпечатано е изход и се сравнява с очакваното, тоест само числото n * 2. Текстовете „Въведете число: “ и „Резултатът е: “ го правят различен и присъдата е Wrong Answer, въпреки че сметката е вярна.

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

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

Визитка в конзолата

Създайте нов конзолен проект BusinessCard в Visual Studio (шаблон Console App, .NET 8, с отметка „Do not use top-level statements“). Програмата трябва да изведе „визитка“ от поне шест реда: име и фамилия, клас, училище, любим предмет, любима игра или програма и едно мото, оградено в кавички. Използвайте и Console.Write, и Console.WriteLine, поне една escape последователност (\t или \n), кавичка вътре в текста чрез \" и един дословен низ с @ за пътя до папката на проекта. Над всяка логическа част поставете едноредов коментар, а в началото на файла — многоредов коментар с автор и дата. Компилирайте с Ctrl+Shift+B и стартирайте с Ctrl+F5.

Лов на грешки

Създайте проект ErrorHunt и напишете програма, която декларира string name = "Мария"; и int age = 15; и извежда с интерполация два реда: Име: Мария и Възраст: 15. Уверете се, че се компилира. След това внесете умишлено и една по една следните грешки, като след всяка компилирате с Ctrl+Shift+B, записвате кода и текста на съобщението от Error List и после я поправяте: а) изтрийте ; след първия WriteLine; б) напишете console.WriteLine с малка буква; в) изтрийте затварящата кавичка на низа "Мария"; г) изтрийте последната } на файла; д) заменете age във втория WriteLine с years, без да декларирате такава променлива; е) напишете int age = "15";. Накрая върнете програмата в работещ вид и добавете под Main многоредов коментар с таблица „грешка, код, поправка“.

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

Напишете програма във формата, който приемат системите за онлайн оценяване. От стандартния вход се четат три реда: име на ученик (на латиница), получени точки (цяло число) и максимален брой точки (цяло число, по-голямо от 0). На изхода се печатат точно два реда: първият е <име>: <точки>/<максимум> points, вторият е процентът на успеваемост като цяло число, последван от знака % (дробната част се отрязва). Пример: вход Ivan, 45, 60 дава изход Ivan: 45/60 points и 75%. Няма подкани към потребителя. Тествайте с примера, с вход Maria, 17, 20 (очакван изход Maria: 17/20 points и 85%) и с вход Petar, 2, 3 (очакван изход Petar: 2/3 points и 66%), след което копирайте целия Program.cs в системата за оценяване, която използвате в училище.

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

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

1. Каква е разликата между Build (`Ctrl+Shift+B`) и Run (`F5` / `Ctrl+F5`) и защо Visual Studio понякога пита „Would you like to continue and run the last successful build?“

2. Какво е предназначението на `using`, `namespace`, `class` и `Main` в класическата структура на `Program.cs` и кои от тях „изчезват“ при top-level statements?

3. Error List показва `CS1002: ; expected` с номер на ред и колона. Какво точно казва това съобщение и какво правите, ако заедно с него има още пет грешки?

4. Програмата печата `Console.Write("Въведете число: ")`, чете число и извежда `Резултат: 10`. Локално работи вярно, но онлайн съдията дава Wrong Answer. Защо и как се поправя?

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

Виж пълния речник на курса
Среда за разработка (IDE)
Програма, която обединява редактор на код, компилатор, инструменти за стартиране и дебъгер. За C# най-често е Visual Studio.
Компилатор (compiler)
Програма, която превежда изходния код на C# в изпълним файл. Ако открие синтактична грешка, спира и описва проблема с код като CS1002.
Решение и проект (solution, project)
Проектът (.csproj) събира файловете и настройките на една програма; решението (.sln) обединява един или повече проекти. Виждат се в Solution Explorer.
Входна точка (entry point)
Методът static void Main, от който започва изпълнението на програмата. При top-level statements компилаторът го създава сам.
Инструкции от най-високо ниво (top-level statements)
Кратка форма на Program.cs, в която командите се пишат направо във файла без class и Main. Позволена е само в един файл на проекта.
Синтактична грешка (syntax error)
Нарушение на правилата на езика — липсваща ;, незатворена скоба, сгрешено име. Открива се от компилатора и спира създаването на програмата.
Дебъгер и точка на прекъсване (debugger, breakpoint)
Инструмент, който изпълнява програмата ред по ред и показва стойностите на променливите. Точката на прекъсване (F9) казва на кой ред да спре.
Стандартен вход и изход (stdin, stdout)
Потокът, от който Console.ReadLine() чете, и потокът, в който Console.WriteLine() пише. Онлайн съдията подава тестовете на stdin и проверява stdout.
Онлайн съдия (online judge)
Система, която компилира изпратения код, пуска го върху тестове със скрит вход и сравнява изхода с очаквания. Присъдата е Accepted, Wrong Answer, Compilation Error, Runtime Error или Time Limit Exceeded.

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

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

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

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

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

  • Настройте средата веднъж: Tools > Options > Environment > General за светла или тъмна тема, Fonts and Colors за по-едър шрифт и Text Editor > All Languages > General > Line numbers, ако номерата на редовете не се виждат — грешките се цитират по номер на ред. Пазете всички проекти в една папка с латинско име без интервали, например D:\Projects\CSharp, по един проект на задача.
  • Задръжте мишката върху червената вълнообразна линия, за да видите съобщението, или натиснете Ctrl+. — Visual Studio често предлага готова поправка (Quick Actions). Не приемайте предложението на сляпо: прочетете какво променя.
  • Когато не разбирате съобщение, потърсете кода му (например CS1002) в документацията на learn.microsoft.com — всеки код има страница с обяснение и пример. Запишете си кодовете, които срещате най-често, със свои думи — след няколко седмици ще ги разпознавате от пръв поглед.
  • Преди всяко изпращане към онлайн съдия пуснете програмата с примерния вход от условието: въведете го точно, сравнете изхода с очаквания знак по знак и чак тогава копирайте целия Program.cs в системата. Пазете локално копие на всяко изпратено решение.

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

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