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

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

211 термина

`

`checked` / `unchecked`
Контексти в C#, които определят дали аритметиката с цели числа проверява за препълване. Обикновеният код е unchecked, константните изрази – checked.
`null`
Специална стойност на референция, която не сочи към нищо. Стойностните типове не могат да са null, освен ако са обявени като нулируеми (int?).
`NullReferenceException`
Изключение, което се хвърля при опит за достъп до член (поле, метод, индекс) през референция със стойност null.
`TryParse`
Метод като int.TryParse(text, out int value), който връща true и попълва value при успешно преобразуване, а при грешка връща false, без да хвърля изключение.

А

Абсолютен път
Пълен път от корена на диска: @"C:\MyFolder\data.txt" — еднозначен, но непреносим между компютри.
Абстрактен клас
Клас-основа, който не може да се инстанцира; абстрактните му методи са без тяло и наследниците са длъжни да ги override-нат.
Агрегация
Свеждане на колекция до една стойност: Sum, Average, Min, Max, Count.
Акумулатор
Променлива, декларирана преди цикъла, която "натрупва" резултат по време на итерациите: sum += i;.
Алгоритъм (algorithm)
Крайна наредена последователност от точно определени стъпки, която превръща входни данни в резултат. Притежава свойствата дискретност, определеност, крайност, масовост и резултатност.
Алтернация (alternation)
Операторът |, който означава „или“: (cat|dog) съвпада с една от двете думи.
Алчен и мързелив квантификатор (greedy, lazy)
Алчният (.*) взема възможно най-много символи и отстъпва при нужда; мързеливият (.*?) взема възможно най-малко и разширява при нужда.
Амортизирана сложност (amortized complexity)
Средна цена на една операция в дълга поредица, когато повечето са евтини, а рядко някоя е скъпа. List<T>.Add е O(1) амортизирано, макар понякога да копира целия вътрешен масив.
Аргумент
Конкретната стойност, подадена при извикването: AddNumbers(10, 15) → 10 и 15.
Асоциативност (associativity)
Посоката на изчисление при оператори с еднакъв приоритет. Аритметичните са отляво надясно (10 - 4 - 3 е 3), присвояването — отдясно наляво (a = b = 0).

Б

Базов клас
Родителят в йерархията — общите данни и поведение живеят в него.
Байт (byte)
Група от 8 бита, която побира 256 стойности (от 0 до 255) и се записва с точно две шестнадесетични цифри.
Банково закръгляне (banker's rounding)
Правилото по подразбиране на Math.Round: стойност точно по средата (.5) се закръгля към четния съсед — 2.5 става 2, 3.5 става 4. Задава се с MidpointRounding.ToEven; алтернативата е MidpointRounding.AwayFromZero.
Безкраен цикъл
Цикъл, чието условие никога не става false — програмата "забива". Най-често от забравено обновяване на променливата в условието.
Бит (bit)
Една двоична цифра – 0 или 1; най-малката единица информация в компютъра.
Блок-схема (flowchart)
Графично описание на алгоритъм, в което стъпките са стандартни фигури (овал, успоредник, правоъгълник, ромб), а стрелките показват реда на изпълнение.
Бройна система (number system)
Правило за записване на числа с краен набор от цифри. В позиционните системи стойността на една цифра зависи от мястото ѝ в записа.
Брояч (итератор)
Променливата, която следи докъде е стигнал цикълът — по конвенция i (после j, k за вложените).
Булев израз
Всеки израз с резултат от тип bool — сравнение (a > 5), логическа комбинация (a > 5 && b < 10) или булева променлива.

В

Валидация на входа (input validation)
Проверка дали въведеното е от правилния тип и в допустимия диапазон, преди да се използва; при грешка програмата пита отново, вместо да спре.
Верижност (chaining)
Навързване на методи: list.Where(...).OrderBy(...).Select(...) — резултатът от единия е вход за следващия.
Вложени цикли
Цикъл вътре в цикъл. Вътрешният изминава всичките си итерации за всяка стъпка на външния.
Времева сложност (time complexity)
Броят операции, които алгоритъмът извършва като функция на n. Записва се с нотация O, например O(n log n).
Връщан тип
Типът на резултата (int, string, bool…) или void, ако методът само върши действие.
Вторичен диагонал (secondary diagonal)
Елементите от горния десен до долния ляв ъгъл, за които r + c == n - 1, където n е размерът на квадратната матрица.
Входна точка (entry point)
Методът static void Main, от който започва изпълнението на програмата. При top-level statements компилаторът го създава сам.

Г

Генеричен тип <T>
T в List<T> е "заместител" за типа на елементите: List<int>, List<string>, List<Student>.
Главен диагонал (main diagonal)
Елементите на квадратна матрица от горния ляв до долния десен ъгъл, за които r == c.
Граничен случай (edge case)
Вход на ръба на допустимото или извън него – нула елемента, най-малката стойност, отрицателно число, текст вместо число – с който се проверява устойчивостта на програмата.
Група (group)
Част от шаблона в кръгли скоби, която се третира като едно цяло и запомня съвпадналия текст. Достъпва се чрез Groups[1] или, при именувана група (?<име>...), чрез Groups["име"].

Д

Два индекса (two pointers)
Техника, при която два индекса се движат от двата края към средата; използва се за обръщане, проверка за палиндром и търсене на двойка с дадена сума в сортиран масив.
Двоично търсене (binary search)
Търсене в сортиран масив, което на всяка стъпка сравнява със средния елемент и отхвърля половината; работи за O(log n).
Двумерен масив (two-dimensional array)
Масив с два индекса — ред и колона, деклариран с int[,]. Всички редове са с еднаква дължина, а елементите се достъпват с m[r, c].
Дебъгер (debugger)
Инструмент, който изпълнява програмата под контрол: спира я на избрани места, показва стойностите на променливите и позволява изпълнение ред по ред. Вграден е във Visual Studio и Visual Studio Code.
Дебъгер и точка на прекъсване (debugger, breakpoint)
Инструмент, който изпълнява програмата ред по ред и показва стойностите на променливите. Точката на прекъсване (F9) казва на кой ред да спре.
Декларация
Създаване на променлива с тип и име: int age;. Често се комбинира с инициализация — даване на първа стойност: int age = 20;.
Динамична памет (heap)
Област, в която с new се създават обектите от референтни типове. Обектът живее, докато някой го сочи; след това го освобождава събирачът на боклук (garbage collector).
Директория (папка)
Контейнер за файлове и други директории. В C# се управлява с класа Directory.
Допълнителен код (two's complement)
Начин за запис на отрицателни цели числа: най-левият бит е знаков, а -x се получава, като се обърнат битовете на x и се прибави 1.
Дословен низ (@)
Низ с @ пред кавичките, в който \ не е специален символ — задължителен за Windows пътища.

Е

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

З

Заместващ символ (wildcard)
Символ в шаблон за LIKE: % замества произволен брой символи, а _ — точно един.
Защитно програмиране
Предотвратяване вместо лекуване: проверки на входа, TryParse, File.Exists — изключенията остават за неочакваното.
Заявка (query)
Команда към базата данни, написана на SQL. SELECT е заявка за четене — тя не променя данните, а само ги извлича и показва.

И

Изключение (Exception)
Обект-сигнал, че изпълнението не може да продължи нормално. Нехванато — срива програмата.
Изпълнител (executor)
Този, който изпълнява стъпките на алгоритъма — човек, устройство или компютър. Компютърът изпълнява само стъпки, записани на език за програмиране, който разбира.
Израз (expression)
Комбинация от стойности, променливи, оператори и извиквания на методи, която се изчислява до една стойност от определен тип, например Math.Sqrt(a * a + b * b).
Изходен код (source code)
Текстът на програмата, написан от човек на език за програмиране — при C# това са файловете .cs. Компютърът не може да го изпълни направо, нужен е преводач.
Изчислена колона
Колона в резултата, получена от израз (price * quantity) или функция (CONCAT), а не прочетена директно от таблицата.
Индекс
Позицията на елемент в колекцията, броена от 0. Последният елемент е на индекс Length - 1.
Индекс (index)
Номерът на елемент в масива. Първият е 0, последният е Length - 1.
Инициализатор
Съкратен запис за създаване с готови стойности: int[] a = { 1, 2, 3 }; или new List<int> { 1, 2, 3 }.
Инкапсулация
Скриване на вътрешните данни (private) и достъп само през контролиран интерфейс (свойства, методи).
Инкремент и декремент (increment, decrement)
Операторите ++ и --, които променят променлива с единица. Префиксната форма (++i) връща новата стойност, постфиксната (i++) — старата.
Инструкции от най-високо ниво (top-level statements)
Кратка форма на Program.cs, в която командите се пишат направо във файла без class и Main. Позволена е само в един файл на проекта.
Интерполация
Вграждане на стойности в низ чрез $"... {израз} ..." — изразите в скобите се заместват с резултата си.
Интерпретатор (interpreter)
Програма, която чете изходния код и го изпълнява ред по ред при всяко стартиране, без да създава отделен изпълним файл. Така работят Python и JavaScript.
Итерация
Едно изпълнение на тялото на цикъла. "Цикълът направи 5 итерации" = тялото се изпълни 5 пъти.

К

Квантификатор (quantifier)
Указва колко пъти се повтаря предходният елемент: *, +, ?, {n}, {n,}, {n,m}.
Клас
Чертеж/шаблон, който описва данните (полета, свойства) и поведението (методи) на бъдещите обекти.
Клас от символи (character class)
Описание на един символ от определен вид: \d, \w, \s или набор в квадратни скоби като [A-Za-z] и [^0-9].
Клауза (clause)
Отделна част на заявката, въведена с ключова дума, например WHERE или ORDER BY. Клаузите се подреждат в строго определен ред.
Ключ (Key)
"Адресът" на записа — уникален в рамките на речника. По него се чете и пише.
Коефициент на детерминация (R²)
Дял от разсейването на y, който моделът обяснява: 1 е идеално, 0 е колкото прогноза „средната стойност“, а отрицателен е по-лошо от нея.
Компилатор (compiler)
Програма, която превежда целия изходен код наведнъж в машинен или междинен код и докладва синтактичните грешки преди изпълнението. Компилаторът на C# създава междинен код (IL) във файл .dll.
Компилация
Превод на изходния код в изпълнима програма. Компилационните грешки (липсваща ;, грешен тип) спират превода още преди програмата да тръгне.
Композиция
Влагане на обект като поле — правилният избор при връзка "има" (Колата ИМА двигател).
Компромис отклонение–дисперсия (bias–variance tradeoff)
Твърде простият модел има голямо отклонение (не улавя формата – недообучение), твърде сложният – голяма дисперсия (следва шума – преобучение); целта е балансът между двете.
Конкатенация
Слепване на низове с + или интерполация. За много слепвания в цикъл — StringBuilder.
Константа (const)
Стойност, която се задава веднъж и не може да се променя: const double Pi = 3.14159;.
Конструктор
Специален метод с името на класа и без връщан тип; извиква се автоматично при new и инициализира обекта.
Котва (anchor)
Елемент, който съвпада с позиция, а не със символ: ^ начало на низа, $ край, \b граница на дума.
Крива на валидация (validation curve)
Графика на грешката на обучение и на валидация спрямо сложността на модела (например степента на полинома); степента се избира в минимума на валидационната крива.

Л

Ламбда израз
Малка анонимна функция: x => x > 5 — "вземи x, такова че x > 5". Лявата страна е параметърът, дясната — изразът.
Лог
Файл-дневник, в който програмата записва събития и грешки с дата и час — винаги с AppendAllText.
Логаритъм (logarithm, log₂ n)
Колко пъти трябва да разделим n на 2, за да стигнем до 1: log₂ 1024 = 10, log₂ 1 000 000 ≈ 20.
Логическа грешка (logic bug)
Грешка, при която програмата се компилира и работи без изключение, но дава грешен резултат. Открива се чрез сравняване на очакваните и реалните стойности в дебъгера.
Логически оператор
&& (И), || (ИЛИ), ! (НЕ) — комбинират или обръщат булеви стойности.

М

Масив (Array)
Наредена редица от елементи от един тип с фиксирана дължина: int[] nums = new int[5];.
Маска (bit mask)
Число, в което само определени битове са единици, например 1 << n. С &, |, ^ и ~ чрез нея проверяваме, вдигаме, сваляме или обръщаме точно тези битове.
Материализация
Принудително изпълнение на заявката и запазване на резултата: .ToList(), .ToArray().
Матрица (matrix)
Математическото име на правоъгълна таблица от стойности с редове и колони. В C# се представя най-често с двумерен масив.
Метод
Именуван блок код, който може да се извиква многократно — с входни данни (параметри) и евентуален резултат (return).
Метод (method)
Именувана част от програмата, която върши една работа; може да приема параметри и да връща стойност с return. В конзолното приложение се обявява извън Main със static.
Метод на мехурчето (bubble sort)
Сортиране чрез многократно сравняване и размяна на съседни елементи, при което най-големият „изплува“ в края след всяко преминаване.
Метод на най-малките квадрати (least squares)
Начин за намиране на параметрите на модела, при който сумата на квадратите на остатъците е минимална; за линейния модел има точно решение по формули или през нормалното уравнение.
Мини проект (mini project)
Малка, но завършена програма с няколко функционалности, която се планира, реализира, тества и представя пред други.
Множество (HashSet)
Колекция само от уникални стойности — дубликатите при Add тихо се игнорират.
Мързеливо оценяване
При a && b, ако a е false, b изобщо не се проверява (резултатът вече е ясен). Аналогично за || при true.

Н

Назъбен масив (jagged array)
Масив от масиви, деклариран с int[][]. Всеки ред е отделен едномерен масив със собствена дължина и трябва да бъде заделен поотделно.
Най-лош случай (worst case)
Входът, при който алгоритъмът върши най-много работа, например липсващ елемент при линейно търсене. Нотацията O по подразбиране описва именно него.
Най-старши и най-младши бит (MSB, LSB)
Най-левият бит с най-голямо тегло и най-десният бит с тегло 1. При деленето с остатък първият получен остатък е най-младшият бит.
Наследник (derived class)
Класът, който наследява — получава всичко от базовия и добавя/променя своето.
Наследяване
Клас получава полетата, свойствата и методите на друг: class Student : Person. Връзка "е-вид" (is-a).
Неизменимост (immutability)
Низът не може да се променя след създаване — всички методи връщат нов низ.
Неизменяем (immutable)
Обект, чието съдържание не може да се промени след създаването му. string е неизменяем: всяка „промяна“ създава нов низ.
Низ (string)
Последователност от символи. Достъп по индекс (name[0]), дължина чрез Length.
Нотация O (Big O notation)
Запис на класа на нарастване, в който се запазва само най-бързо растящият член и се изхвърлят константите: 3n² + 10n е O(n²).

О

Обект (екземпляр)
Конкретна реализация на класа в паметта, създадена с new, със собствени стойности.
Обръщане (reverse)
Пренареждане, при което първият елемент става последен, вторият – предпоследен и така нататък; на място се прави с два индекса или с Array.Reverse.
Обхват (scope)
Областта, в която едно име съществува. Променлива, декларирана в метод, живее само в него.
Онлайн съдия (online judge)
Система, която компилира изпратения код, пуска го върху тестове със скрит вход и сравнява изхода с очаквания. Присъдата е Accepted, Wrong Answer, Compilation Error, Runtime Error или Time Limit Exceeded.
Опашка (Queue) / Стек (Stack)
Колекции с ред на обработка: опашката е FIFO (пръв влязъл — пръв излязъл), стекът е LIFO (последен влязъл — пръв излязъл).
Оператор за сравнение
==, !=, >, <, >=, <= — сравняват две стойности и връщат bool.
Оператор и операнд (operator, operand)
Операторът е знак за действие (+, %, &&), а операндите са стойностите, върху които той действа. В a % b операторът е %, операндите са a и b.
Основа (base, radix)
Броят на различните цифри в системата и множителят между две съседни позиции: 2 за двоичната, 8 за осмичната, 10 за десетичната, 16 за шестнадесетичната.
Остатък (modulo, `%`)
Остатъкът от целочислено деление; знакът му съвпада със знака на делимото. 7 % 3 е 1, -7 % 3 е -1.
Остатък (residual)
Разликата y - y_pred между истинската и прогнозираната стойност за една точка; метриките MAE, MSE и RMSE се изчисляват от остатъците.
Остатък по модул (`%`)
Остатъкът от целочислено деление. Изразът (i + k) % n дава индекс, който винаги е в границите от 0 до n - 1.
Отложено изпълнение
LINQ заявката се изпълнява чак при обхождане или при .ToList() — дотогава е само "рецепта".
Относителен път
Път спрямо работната папка на програмата: "data.txt" се търси в bin/Debug на проекта.

П

Параметър
Променлива в декларацията на метода: (int a, int b). Получава стойност при извикване.
Парсване (Parsing)
Преобразуване на текст в друг тип, най-често число: int.Parse("20") → 20. При невалиден текст хвърля FormatException.
Плаваща запетая (floating point, IEEE 754)
Представяне на реални числа чрез знак, експонента и мантиса. Типовете float и double са приблизителни, затова не се сравняват с ==.
Побитов оператор (bitwise operator)
Оператор, който работи върху всеки бит на цяло число поотделно: &, |, ^, ~, <<, >>. Различен е от логическите &&, ||, !, които работят с bool.
Поле
Променлива вътре в класа, обикновено private — "суровите" данни на обекта.
Полиморфизъм
"Много форми" — едно извикване изпълнява различен код според реалния тип на обекта.
Полиномна регресия (polynomial regression)
Линейна регресия върху разширени признаци x, x², ..., x^d; кривата е нелинейна по x, но моделът остава линеен по параметрите и се решава с най-малките квадрати.
Правоъгълен масив (rectangular array)
Друго име на масива [,] (и [,,]): един непрекъснат блок памет, в който всеки ред има еднакъв брой колони.
Предефиниране (overloading)
Няколко метода с едно име, но различни параметри — компилаторът избира по аргументите.
Предикат
Ламбда, която връща bool — условието, подавано на Where, Any, All, Count.
Преобучение (overfitting)
Състояние, при което моделът следва шума в обучаващите данни: грешката на обучение е много ниска, а грешката върху нови данни – висока.
Препълване (overflow)
Резултат, който не се побира в диапазона на типа. В unchecked режим стойността превърта, в checked се хвърля OverflowException.
Префикс на литерал (0b, 0x)
Означение в C# кода за основата, в която е написан литералът: 0b1010 е двоичен, 0x1A – шестнадесетичен. За осмична система в C# няма префикс.
Приоритет (precedence)
Редът, по който се изпълняват операторите в израз без скоби: умножението и делението са преди събирането, сравненията — преди &&, а && — преди ||.
Променлива
Именувано място в паметта, което съхранява стойност от определен тип и може да се променя по време на изпълнение.
Пространствена сложност (space complexity)
Допълнителната памет, която алгоритъмът използва освен самия вход, като функция на n. Няколко променливи са O(1), копие на масива — O(n).
Пряка селекция (selection sort)
Сортиране, при което за всяка позиция се избира най-малкият от останалите елементи и се разменя с елемента на тази позиция.
Псевдокод (pseudocode)
Структуриран текстов запис на алгоритъм с малко ключови думи (ВХОД, АКО, ДОКАТО) и отместване навътре, който прилича на програма, но не зависи от конкретен език.
Псевдоним (alias)
Временно име на колона или израз, зададено с AS. Вижда се само в резултата на заявката, таблицата не се променя.

Р

Разклонение
Точка, в която програмата избира между два или повече пътя на изпълнение (if-else, switch).
Разклонение (branching)
Част от алгоритъм, в която според истинността на условие се изпълнява единият или другият клон. Пълно е, когато има действие и за „Да“, и за „Не“; в C# — if ... else.
Разпространение (bubbling)
Нехванатото изключение се "качва" от метод към извикващия го, докато някой не го хване (или програмата не се срине).
Ранг (rank)
Броят на измеренията на масив: int[] има ранг 1, int[,] — 2, int[,,] — 3. Назъбеният int[][] има ранг 1, защото е едномерен масив от масиви.
Регресия (regression)
Задача на машинното обучение, в която моделът предсказва числова стойност (цена, температура, точки) по един или повече признаци.
Регулярен израз (regular expression, regex)
Шаблон, описващ множество от низове чрез обикновени символи и специални метасимволи. В C# се прилага чрез класа Regex от System.Text.RegularExpressions.
Резултатен набор (result set)
Таблицата, която базата връща след изпълнение на SELECT. Съществува само докато гледаме резултата и не се записва в базата.
Референтен тип (reference type)
Тип, чиято променлива съдържа адрес към обект в heap-а — class, масиви, string. Присвояването споделя обекта, а не го копира.
Референция (reference)
Адресът, по който се намира един обект; „стрелката“ от променливата към обекта. Няколко референции могат да сочат към един и същ обект.
Речник (Dictionary)
Колекция от двойки ключ → стойност с мигновено търсене по ключ: Dictionary<string, int>.
Решение и проект (solution, project)
Проектът (.csproj) събира файловете и настройките на една програма; решението (.sln) обединява един или повече проекти. Виждат се в Solution Explorer.
Ротация (rotation)
Циклично изместване на елементите: при ротация наляво първият отива в края, при ротация надясно последният отива в началото.

С

Свойство (Property)
Контролиран публичен достъп до данните с get и set — мястото за валидация.
Сигнатура
Името на метода + типовете и редът на параметрите — това, по което компилаторът го разпознава.
Символ (char)
Един единствен знак в единични кавички: 'A'. Помощници: char.ToUpper, char.IsDigit.
Синтактична грешка (syntax error)
Нарушение на правилата на езика — липсваща ;, незатворена скоба, сгрешено име. Открива се от компилатора и спира създаването на програмата.
Сложност на алгоритъм (algorithmic complexity)
Зависимост между размера на входа n и ресурсите — време или памет — които алгоритъмът изразходва. Позволява алгоритмите да се сравняват независимо от конкретния компютър.
Сортиране (sorting)
Подреждане на елементите във възходящ или низходящ ред. В .NET се прави с Array.Sort, а за низходящ ред – последвано от Array.Reverse.
Списък (List<T>)
Динамична колекция с променлив размер — Add, Remove, Contains. Изисква using System.Collections.Generic;.
Среда за разработка (IDE)
Програма, която обединява редактор на код, компилатор, инструменти за стартиране и дебъгер. За C# най-често е Visual Studio.
Стандартен вход и изход (stdin, stdout)
Потокът, от който Console.ReadLine() чете, и потокът, в който Console.WriteLine() пише. Онлайн съдията подава тестовете на stdin и проверява stdout.
Стек (stack)
Област от паметта, в която живеят локалните променливи и параметрите на всеки изпълняващ се метод. Освобождава се автоматично, когато методът приключи.
Стек на извикванията (call stack)
Веригата от методи, които са започнали и още не са завършили; всеки от тях е рамка (frame). Прозорецът Call Stack показва кой кого е извикал, от текущия метод до Main.
Стойност (Value)
Данните, съхранени срещу ключа. Може да е всякакъв тип, включително списък или обект.
Стойностен тип (value type)
Тип, чиято променлива съдържа самата стойност — int, double, bool, enum, struct. Присвояването и подаването на метод правят копие.
Страниране (pagination)
Показване на дълъг резултат на части („страници“) — LIMIT задава размера на страницата, а OFFSET колко реда да се прескочат.
Стъпково изпълнение (stepping)
Изпълнение на програмата ред по ред с командите Step Over (F10), Step Into (F11) и Step Out (Shift+F11).
Схема на Хорнер (Horner's method)
Начин за пресмятане на стойността на число по цифрите му отляво надясно чрез result = result * основа + цифра, без основата да се повдига на степен.
Съвпадение (match)
Част от входния низ, която отговаря на шаблона. Обектът Match носи Success, Value, Index и Groups.
Съкратено изчисляване (short-circuit evaluation)
Поведение на && и ||, при което дясната страна не се изчислява, ако лявата вече определя резултата. Позволява защитни проверки като x != 0 && 10 / x > 1.
Състояние на програмата (state)
Променливите, чиито стойности се помнят между итерациите на менюто (сума, брой, баланс); декларират се извън цикъла или като static полета.

Т

Тегло на позицията (place value)
Степента на основата, съответстваща на дадена позиция, като се брои от нулева степен отдясно наляво: в двоична система 1, 2, 4, 8, 16 и така нататък.
Тернарен оператор
Съкратен if-else за избор на стойност: условие ? приTrue : приFalse.
Тестов случай (test case)
Конкретен вход заедно с очаквания резултат; редицата от тестови случаи е тестовата таблица, по която се проверява проектът преди представянето.
Тип данни
Определя какви стойности може да съхранява променливата и какви операции са позволени (int, double, string, bool, char).
Точка на прекъсване (breakpoint)
Маркер върху ред от кода, при който дебъгерът спира изпълнението, преди да изпълни реда. Поставя се с F9 или с щракване в полето вляво от кода.
Точка на проследяване (tracepoint)
Точка на прекъсване с действие: вместо да спира програмата, извежда съобщение със стойности на променливи в прозореца Output.
Транспониране (transpose)
Получаване на нова матрица, в която редовете на изходната са станали колони: t[c, r] = m[r, c]; матрица rows на cols става cols на rows.
Търсене с флаг
Шаблон: bool found = false; преди цикъла, вдигане при намиране, проверка след цикъла — отговаря и на въпроса "а ако го няма?".
Тяло на цикъла
Кодът между { }, който се повтаря на всяка итерация.

У

Условие
Израз, който се изчислява до true или false и определя кой клон от кода ще се изпълни.
Условна точка на прекъсване (conditional breakpoint)
Точка на прекъсване, която спира само когато зададен израз е истина, например i == 734, или при определен брой преминавания (Hit Count).

Ф

Файл
Именувана порция данни на диска, която оцелява след затварянето на програмата.
Флаг (flag)
Единичен бит, който означава състояние „включено/изключено“. В C# набор от флагове се описва с изброим тип с атрибут [Flags] и стойности степени на двойката.
Функционалност (feature)
Едно действие, което потребителят може да поиска от програмата, например „добави оценка“; обикновено отговаря на една точка от менюто и на един метод.

Ц

Целочислено деление (integer division)
Деление на две цели числа, при което дробната част се отрязва към нулата: 7 / 2 е 3, -7 / 2 е -3.
Цикъл (loop)
Повтаряне на група стъпки (тяло), докато условието е вярно. Има начална стойност, условие, тяло и промяна; в C# — while, do ... while и for.
Цикъл на менюто (menu loop)
do-while или while, който показва менюто, чете избора и го обработва със switch, докато не бъде избран изход.

Ш

Шаблон (pattern)
Самият текст на регулярния израз, например ^\d{4}$. В C# се записва като verbatim низ @"...", за да останат обратните наклонени черти непроменени.
Шестнадесетична цифра (hex digit)
Един от символите 0–9 и A–F, който представя стойност от 0 до 15, тоест точно 4 бита (половин байт).

A

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

B

base
Достъп до родителя: base(...) вика родителския конструктор, base.Method() — родителската версия на метода.
Boxing / unboxing
Опаковане на стойностен тип в обект от тип object в heap-а (object o = 5;) и обратното явно преобразуване ((int)o). Струва време и памет, затова се избягва в горещи цикли.
break / continue
break прекратява целия цикъл; continue прескача само текущата итерация.

C

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

D

DISTINCT
Модификатор на SELECT, който премахва повтарящите се редове от резултата, за да остане всяка стойност по веднъж.
DRY
"Don't Repeat Yourself" — повтарящ се код се изнася в метод, за да се променя на едно място.

E

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

F

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

G

GetLength(d)
Метод, който връща дължината на масива по измерение d: GetLength(0) е броят на редовете, GetLength(1) — броят на колоните.

K

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

L

LINQ
Language-Integrated Query — методи за филтриране, сортиране и трансформиране на колекции направо в езика. Изисква using System.Linq;.
Locals, Autos, Watch
Прозорци за наблюдение на променливи: Locals показва всички в текущия метод, Autos — само тези от текущия и предишния ред, Watch — изрази, които сами сте добавили.

N

NULL
Специален маркер за „няма стойност“. Не е равен на нищо, дори на друг NULL, и се проверява само с IS NULL / IS NOT NULL.

P

PolynomialFeatures
Трансформатор от sklearn.preprocessing, който от входните признаци създава всички степени и произведения до зададена степен degree; в конвейер се прилага автоматично и при fit, и при predict.
protected
Достъпно за класа и наследниците му, скрито за всички останали.

S

Stack trace
Списъкът от методи до мястото на грешката, с редове — картата за намиране на проблема.
Stopwatch
Клас от System.Diagnostics за точно измерване на време: StartNew(), Stop(), Restart(), ElapsedMilliseconds, Elapsed.TotalMilliseconds.
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.

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

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