Модул 1

Основи на езика, Променливи и Типове Данни

Всичко, с което започва един C# програмист — структура на програмата, деклариране на променливи, основните типове данни, четене от конзолата и парсване на текст в число.

Теория

Всяка C# програма е изградена от класове, събрани в именни пространства (namespace). Изпълнението винаги започва от метода Main — той е "входната врата" на програмата. Всичко, което искаме компютърът да направи, описваме като последователност от команди в тялото на Main (а по-късно — и в собствени методи).

Променливата е именувано място в паметта, в което съхраняваме стойност. В C# всяка променлива има строго определен тип — той казва на компилатора колко памет да задели и какви операции са позволени. Затова казваме, че C# е статично типизиран език: типът се знае още при компилация и не може да се променя в движение.

Конзолата е най-простият начин за общуване с потребителя: Console.WriteLine() извежда текст, а Console.ReadLine() чете въведеното. Важно: ReadLine() винаги връща текст (string). Ако ни трябва число, трябва да го преобразуваме (парснем) с int.Parse(), double.Parse() или по-безопасното int.TryParse().

За съединяване на текст и стойности най-удобна е интерполацията на низове: поставяме $ пред кавичките и пишем променливите в къдрави скоби — $"Здравей, {name}!". Това е по-четимо от слепване с +.

С числата смятаме чрез аритметичните оператори: +, -, *, / и % (остатък от делене). Голям капан: когато двете страни са цели числа, / прави целочислено делене5 / 2 дава 2, а не 2.5! За дробен резултат поне едната страна трябва да е дробна: 5.0 / 2 или (double)a / b. Остатъкът % е изненадващо полезен: n % 2 == 0 проверява четност, n % 10 дава последната цифра.

Две удобни ключови думи: var оставя компилаторът сам да определи типа от стойността (var age = 20; е същото като int age = 20; — променливата пак е строго типизирана!), а const прави стойността константа, която не може да се променя: const double EuroRate = 1.95583;.

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

Case Sensitivity

C# прави разлика между главни и малки букви. myVariable и myvariable са две напълно различни неща!

Точка и запетая (;)

Всеки край на команда (оператор) задължително завършва с ;. Липсваща точка и запетая е една от най-честите грешки при компилация.

Конвенции за имена

Променливите се пишат в camelCase — малка буква в началото, всяка следваща дума с главна (напр. studentAge). Класовете и методите използват PascalCase (Program, Main, CalculateArea).

Смислени имена

Името на променливата трябва да описва какво съхранява: averageGrade е добре, x1 и temp — не. Кодът се чете много по-често, отколкото се пише.

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

Основни типове данни

Тип данниКакво съхранява?Пример за декларация
intЦели числа (от около -2.1 млрд. до +2.1 млрд.)int count = 10;
doubleДробни числа (с плаваща запетая)double price = 19.99;
charЕдин единствен символ (в единични кавички)char grade = 'A';
stringТекст (в двойни кавички)string name = "Иван";
boolИстина или лъжа (true / false)bool isPassed = true;

Вход, изход и преобразуване

КомандаКакво прави?Пример
Console.WriteLine()Извежда текст и минава на нов редConsole.WriteLine("Здравей!");
Console.Write()Извежда текст, без да минава на нов редConsole.Write("Въведи име: ");
Console.ReadLine()Чете един ред текст от потребителя (винаги string)string input = Console.ReadLine();
int.Parse()Превръща текст в цяло числоint n = int.Parse(input);
double.Parse()Превръща текст в дробно числоdouble d = double.Parse(input);
int.TryParse()Опитва да парсне, без да гърми при грешкаbool ok = int.TryParse(input, out int n);

Аритметични оператори

ОператорКакво прави?Пример (резултат)
+ - *Събиране, изваждане, умножение3 * 412
/Делене — целочислено, ако двете страни са int!7 / 23, но 7.0 / 23.5
%Остатък от делене7 % 21 (7 е нечетно)
++ / --Увеличава / намалява с 1count++;
+= -= *= /=Операция + присвояване накраткоsum += 5; е sum = sum + 5;
Math.Round()Закръгляне на дробно числоMath.Round(3.456, 2)3.46

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

Деклариране, интерполация и вход от потребителя

Program.cs
namespace ModuleOne
{
    class Program
    {
        static void Main(string[] args)
        {
            // Деклариране на променливи
            string studentName = "Алекс";
            int age = 20;
            double averageGrade = 5.75;
            bool isExcellent = true;

            // Интерполация на низове (String Interpolation)
            Console.WriteLine($"Студент: {studentName}");
            Console.WriteLine($"Възраст: {age} години");
            Console.WriteLine($"Среден успех: {averageGrade}");

            // Вход от потребителя
            Console.Write("Въведи нов успех: ");
            string input = Console.ReadLine();

            // Преобразуване на текст в число (Parsing)
            averageGrade = double.Parse(input);
            Console.WriteLine($"Обновен успех: {averageGrade}");
        }
    }
}

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

  • Декларираме четири променливи от различни типове — обърнете внимание, че всяка получава стойност от правилния си тип: текстът е в двойни кавички, дробното число използва точка (не запетая!), а bool приема само true или false.
  • Знакът $ пред кавичките включва интерполация — изразите в { } се заместват с реалните стойности на променливите.
  • Console.Write (без Line) оставя курсора на същия ред — така потребителят пише веднага след въпроса.
  • Console.ReadLine() връща string, дори потребителят да е въвел число. Затова на следващия ред използваме double.Parse(input), за да получим число, с което можем да смятаме.
  • Ако потребителят въведе нещо, което не е число (напр. "пет"), double.Parse ще хвърли FormatException и програмата ще гръмне — затова в реални програми се ползва TryParse.

Целочислено делене, остатък и константи

Program.cs
using System;

namespace ModuleOneExtra
{
    class Program
    {
        static void Main(string[] args)
        {
            int candies = 17;
            int kids = 5;

            int perKid = candies / kids;     // 3  (целочислено делене!)
            int left = candies % kids;       // 2  (остатък)
            double exact = (double)candies / kids; // 3.4

            Console.WriteLine($"Всяко дете получава {perKid} бонбона.");
            Console.WriteLine($"Остават {left} бонбона.");
            Console.WriteLine($"Точно по равно би било: {exact:F2}");

            // Константа - стойност, която не може да се променя
            const double EuroRate = 1.95583;

            Console.Write("Сума в лева: ");
            var leva = double.Parse(Console.ReadLine()); // var = компилаторът избира типа

            double euro = Math.Round(leva / EuroRate, 2);
            Console.WriteLine($"{leva} лв. = {euro} евро");
        }
    }
}

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

  • 17 / 5 дава 3, а не 3.4 — двете страни са int, затова деленето е целочислено и дробната част просто се отрязва (не се закръгля!).
  • 17 % 5 дава 2 — остатъкът след като 5 се "побере" 3 пъти в 17. Помнете двойката: / отговаря "по колко?", % — "колко остава?".
  • (double)candies е изрично преобразуване (cast) — превръщаме едната страна в дробно число и деленето вече е истинско: 3.4.
  • {exact:F2} във форматиращия израз показва стойността с точно 2 знака след запетаята.
  • const double EuroRate е константа — опит да ѝ присвоим нова стойност по-късно е грешка при компилация. Ползвайте константи за фиксирани величини (курсове, лимити, π).
  • var leva = double.Parse(...)var не значи "без тип"! Компилаторът вижда, че double.Parse връща double, и leva става double завинаги.

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

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

Десетична запетая вместо точка

Грешно

double price = 19,99;

Правилно

double price = 19.99;

В кода десетичният знак е винаги точка. Запетаята превръща записа в нещо съвсем друго и компилацията гърми. (На клавиатурата с български подреждане това е честа неволна грешка.)

Забравен $ при интерполация

Грешно

Console.WriteLine("Здравей, {name}!");
// печата: Здравей, {name}!

Правилно

Console.WriteLine($"Здравей, {name}!");
// печата: Здравей, Иван!

Без знака $ пред кавичките къдравите скоби са просто текст и се отпечатват буквално. $ включва интерполацията — изразите в { } се заместват със стойностите си.

Целочислено делене при средна стойност

Грешно

double avg = (5 + 6) / 2;
// avg e 5, а не 5.5!

Правилно

double avg = (5 + 6) / 2.0;
// avg e 5.5

Деленето се изпълнява преди присвояването: 11 / 2 е целочислено и дава 5, и чак после 5 става 5.0. Направете една от страните дробна още при делението.

ReadLine директно в число

Грешно

int age = Console.ReadLine();

Правилно

int age = int.Parse(Console.ReadLine());

Console.ReadLine() винаги връща string — дори потребителят да е написал цифри. Компилаторът отказва с грешка CS0029 (не може string да стане int). Преобразувайте с int.Parse или по-безопасното int.TryParse.

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

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

Задача 1: Лице на правоъгълник

Създайте програма, която пресмята лице на правоъгълник. Потребителят въвежда страните a и b (цели числа), а програмата отпечатва лицето.

Задача 2: Обмяна на валута

Напишете програма за обмяна на валута. Потребителят въвежда сума в лева, а програмата я пресмята в евро (курс: 1.95583) и закръгля до втория знак след запетаята.

Задача 3: Цифрите на трицифрено число

Потребителят въвежда трицифрено число (напр. 374). Отпечатайте отделно цифрата на стотиците, десетиците и единиците (3, 7 и 4).

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

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

1. Каква е разликата между float, double и decimal?

2. Какво ще се случи, ако се опитаме да парснем текста "пет" с int.Parse("пет")?

3. Кой символ се използва за коментар на един ред в C#?

4. Какво ще отпечата Console.WriteLine(7 / 2); и защо?

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

Виж пълния речник на курса
Променлива
Именувано място в паметта, което съхранява стойност от определен тип и може да се променя по време на изпълнение.
Тип данни
Определя какви стойности може да съхранява променливата и какви операции са позволени (int, double, string, bool, char).
Декларация
Създаване на променлива с тип и име: int age;. Често се комбинира с инициализация — даване на първа стойност: int age = 20;.
Парсване (Parsing)
Преобразуване на текст в друг тип, най-често число: int.Parse("20")20. При невалиден текст хвърля FormatException.
Интерполация
Вграждане на стойности в низ чрез $"... {израз} ..." — изразите в скобите се заместват с резултата си.
Константа (const)
Стойност, която се задава веднъж и не може да се променя: const double Pi = 3.14159;.
Компилация
Превод на изходния код в изпълнима програма. Компилационните грешки (липсваща ;, грешен тип) спират превода още преди програмата да тръгне.
camelCase / PascalCase
Конвенции за имена: camelCase за променливи (studentAge), PascalCase за класове и методи (CalculateArea).

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

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

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

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

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

  • Пишете кода на ръка, не го копирайте — синтаксисът се запомня с пръстите.
  • Експериментирайте: променете стойност, пуснете програмата отново и наблюдавайте разликата.
  • Четете съобщенията за грешки отдолу нагоре и внимателно — компилаторът почти винаги казва точно къде е проблемът.
  • Когато не сте сигурни какъв тип ви трябва: цели бройки → int, пари и измервания → double/decimal, да/не → bool, текст → string.

Начален курс по C# — учебен наръчник и бърз справочник за студенти.

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