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

Всички 90 термина от 12 модула на едно място, подредени по азбука. Не помниш какво беше „инкапсулация“ или „ламбда“? Намери го тук.

А Б В Г Д Е З И К Л М Н О П Р С Т У Ф A B C D E F K L P S T V

90 термина

А

Абсолютен път: Пълен път от корена на диска: @"C:\MyFolder\data.txt" — еднозначен, но непреносим между компютри.
Абстрактен клас: Клас-основа, който не може да се инстанцира; абстрактните му методи са без тяло и наследниците са длъжни да ги override-нат.
Агрегация: Свеждане на колекция до една стойност: Sum, Average, Min, Max, Count.
Акумулатор: Променлива, декларирана преди цикъла, която "натрупва" резултат по време на итерациите: sum += i;.
Аргумент: Конкретната стойност, подадена при извикването: AddNumbers(10, 15) → 10 и 15.

Б

Базов клас: Родителят в йерархията — общите данни и поведение живеят в него.
Безкраен цикъл: Цикъл, чието условие никога не става false — програмата "забива". Най-често от забравено обновяване на променливата в условието.
Брояч (итератор): Променливата, която следи докъде е стигнал цикълът — по конвенция i (после j, k за вложените).
Булев израз: Всеки израз с резултат от тип bool — сравнение (a > 5), логическа комбинация (a > 5 && b < 10) или булева променлива.

В

Верижност (chaining): Навързване на методи: list.Where(...).OrderBy(...).Select(...) — резултатът от единия е вход за следващия.
Вложени цикли: Цикъл вътре в цикъл. Вътрешният изминава всичките си итерации за всяка стъпка на външния.
Връщан тип: Типът на резултата (int, string, bool…) или void, ако методът само върши действие.

Г

Генеричен тип <T>: T в List<T> е "заместител" за типа на елементите: List<int>, List<string>, List<Student>.

Д

Декларация: Създаване на променлива с тип и име: int age;. Често се комбинира с инициализация — даване на първа стойност: int age = 20;.
Директория (папка): Контейнер за файлове и други директории. В C# се управлява с класа Directory.
Дословен низ (@): Низ с @ пред кавичките, в който \ не е специален символ — задължителен за Windows пътища.

Е

Елемент: Една стойност от колекцията: arr[2] е третият елемент.

З

Защитно програмиране: Предотвратяване вместо лекуване: проверки на входа, TryParse, File.Exists — изключенията остават за неочакваното.

И

Изключение (Exception): Обект-сигнал, че изпълнението не може да продължи нормално. Нехванато — срива програмата.
Индекс: Позицията на елемент в колекцията, броена от 0. Последният елемент е на индекс Length - 1.
Инициализатор: Съкратен запис за създаване с готови стойности: int[] a = { 1, 2, 3 }; или new List<int> { 1, 2, 3 }.
Инкапсулация: Скриване на вътрешните данни (private) и достъп само през контролиран интерфейс (свойства, методи).
Интерполация: Вграждане на стойности в низ чрез $"... {израз} ..." — изразите в скобите се заместват с резултата си.
Итерация: Едно изпълнение на тялото на цикъла. "Цикълът направи 5 итерации" = тялото се изпълни 5 пъти.

К

Клас: Чертеж/шаблон, който описва данните (полета, свойства) и поведението (методи) на бъдещите обекти.
Ключ (Key): "Адресът" на записа — уникален в рамките на речника. По него се чете и пише.
Компилация: Превод на изходния код в изпълнима програма. Компилационните грешки (липсваща ;, грешен тип) спират превода още преди програмата да тръгне.
Композиция: Влагане на обект като поле — правилният избор при връзка "има" (Колата ИМА двигател).
Конкатенация: Слепване на низове с + или интерполация. За много слепвания в цикъл — StringBuilder.
Константа (const): Стойност, която се задава веднъж и не може да се променя: const double Pi = 3.14159;.
Конструктор: Специален метод с името на класа и без връщан тип; извиква се автоматично при new и инициализира обекта.

Л

Ламбда израз: Малка анонимна функция: x => x > 5 — "вземи x, такова че x > 5". Лявата страна е параметърът, дясната — изразът.
Лог: Файл-дневник, в който програмата записва събития и грешки с дата и час — винаги с AppendAllText.
Логически оператор: && (И), || (ИЛИ), ! (НЕ) — комбинират или обръщат булеви стойности.

М

Масив (Array): Наредена редица от елементи от един тип с фиксирана дължина: int[] nums = new int[5];.
Материализация: Принудително изпълнение на заявката и запазване на резултата: .ToList(), .ToArray().
Метод: Именуван блок код, който може да се извиква многократно — с входни данни (параметри) и евентуален резултат (return).
Множество (HashSet): Колекция само от уникални стойности — дубликатите при Add тихо се игнорират.
Мързеливо оценяване: При a && b, ако a е false, b изобщо не се проверява (резултатът вече е ясен). Аналогично за || при true.

Н

Наследник (derived class): Класът, който наследява — получава всичко от базовия и добавя/променя своето.
Наследяване: Клас получава полетата, свойствата и методите на друг: class Student : Person. Връзка "е-вид" (is-a).
Неизменимост (immutability): Низът не може да се променя след създаване — всички методи връщат нов низ.
Низ (string): Последователност от символи. Достъп по индекс (name[0]), дължина чрез Length.

О

Обект (екземпляр): Конкретна реализация на класа в паметта, създадена с new, със собствени стойности.
Обхват (scope): Областта, в която едно име съществува. Променлива, декларирана в метод, живее само в него.
Опашка (Queue) / Стек (Stack): Колекции с ред на обработка: опашката е FIFO (пръв влязъл — пръв излязъл), стекът е LIFO (последен влязъл — пръв излязъл).
Оператор за сравнение: ==, !=, >, <, >=, <= — сравняват две стойности и връщат bool.
Отложено изпълнение: LINQ заявката се изпълнява чак при обхождане или при .ToList() — дотогава е само "рецепта".
Относителен път: Път спрямо работната папка на програмата: "data.txt" се търси в bin/Debug на проекта.

П

Параметър: Променлива в декларацията на метода: (int a, int b). Получава стойност при извикване.
Парсване (Parsing): Преобразуване на текст в друг тип, най-често число: int.Parse("20") → 20. При невалиден текст хвърля FormatException.
Поле: Променлива вътре в класа, обикновено private — "суровите" данни на обекта.
Полиморфизъм: "Много форми" — едно извикване изпълнява различен код според реалния тип на обекта.
Предефиниране (overloading): Няколко метода с едно име, но различни параметри — компилаторът избира по аргументите.
Предикат: Ламбда, която връща bool — условието, подавано на Where, Any, All, Count.
Променлива: Именувано място в паметта, което съхранява стойност от определен тип и може да се променя по време на изпълнение.

Р

Разклонение: Точка, в която програмата избира между два или повече пътя на изпълнение (if-else, switch).
Разпространение (bubbling): Нехванатото изключение се "качва" от метод към извикващия го, докато някой не го хване (или програмата не се срине).
Речник (Dictionary): Колекция от двойки ключ → стойност с мигновено търсене по ключ: Dictionary<string, int>.

С

Свойство (Property): Контролиран публичен достъп до данните с get и set — мястото за валидация.
Сигнатура: Името на метода + типовете и редът на параметрите — това, по което компилаторът го разпознава.
Символ (char): Един единствен знак в единични кавички: 'A'. Помощници: char.ToUpper, char.IsDigit.
Списък (List<T>): Динамична колекция с променлив размер — Add, Remove, Contains. Изисква using System.Collections.Generic;.
Стойност (Value): Данните, съхранени срещу ключа. Може да е всякакъв тип, включително списък или обект.

Т

Тернарен оператор: Съкратен if-else за избор на стойност: условие ? приTrue : приFalse.
Тип данни: Определя какви стойности може да съхранява променливата и какви операции са позволени (int, double, string, bool, char).
Търсене с флаг: Шаблон: bool found = false; преди цикъла, вдигане при намиране, проверка след цикъла — отговаря и на въпроса "а ако го няма?".
Тяло на цикъла: Кодът между { }, който се повтаря на всяка итерация.

У

Условие: Израз, който се изчислява до true или false и определя кой клон от кода ще се изпълни.

Ф

Файл: Именувана порция данни на диска, която оцелява след затварянето на програмата.

A

Auto-property: Съкратен запис public double Grade { get; set; } — компилаторът създава скритото поле сам.

B

base: Достъп до родителя: base(...) вика родителския конструктор, base.Method() — родителската версия на метода.
break / continue: break прекратява целия цикъл; continue прескача само текущата итерация.

C

camelCase / PascalCase: Конвенции за имена: camelCase за променливи (studentAge), PascalCase за класове и методи (CalculateArea).

D

DRY: "Don't Repeat Yourself" — повтарящ се код се изнася в метод, за да се променя на едно място.

E

Escape последователност: Специален запис в низ: \n нов ред, \t табулация, \\ черта, \" кавичка.
ex.Message: Човешкото описание на грешката — текстът, който показваме или записваме в лог.

F

Fall-through (пропадане): Празни case-ове в switch, които "пропадат" към следващия — така няколко стойности споделят един код.
finally: Блок, който се изпълнява винаги — при успех и при грешка. Място за почистване на ресурси.

K

KeyValuePair: Една двойка от речника при обхождане: pair.Key и pair.Value.

L

LINQ: Language-Integrated Query — методи за филтриране, сортиране и трансформиране на колекции направо в езика. Изисква using System.Linq;.

P

protected: Достъпно за класа и наследниците му, скрито за всички останали.

S

Stack trace: Списъкът от методи до мястото на грешката, с редове — картата за намиране на проблема.
StringBuilder: Клас от System.Text за ефективно сглобяване на дълъг текст: Append + накрая ToString().
System.IO: Именното пространство с класовете за вход/изход: File, Directory, Path.

T

this: Препратка към текущия обект — this.name = name; различава полето от параметъра.
throw: Хвърляне на изключение от наш код: throw new ArgumentException("..."); — начинът класът да защити правилата си.
try / catch: try огражда рисковия код; catch поема управлението при грешка от съответния тип.
TryGetValue: Безопасно четене: връща true/false и подава стойността през out — без изключения.

V

virtual / override: Двойката, която позволява замяна на метод: базовият разрешава с virtual, наследникът заменя с override.