Теория
Когато програмата работи, паметта ѝ е разделена на две области с различни правила. Стекът (stack) е подредена купчина: всеки извикан метод слага отгоре своя „рамка“ с локалните си променливи и параметри, а когато методът приключи, рамката се маха и паметта се освобождава автоматично. Затова стекът е много бърз, но и строг: това, което живее в него, съществува само докато методът работи. Динамичната памет (heap) е голямо свободно пространство, в което с оператора new създаваме обекти, живеещи толкова дълго, колкото са нужни — независимо кой метод ги е създал. Когато вече никой не сочи към даден обект, събирачът на боклук (garbage collector, GC) го открива и освобождава мястото му; вие не изтривате нищо ръчно.
Стойностните типове (value types) пазят стойността направо в променливата: int, double, bool, char, decimal, изброяванията enum и всяка структура struct. Локална променлива от такъв тип живее в стека и съдържа самите данни, а не адрес. Присвояването int b = a; прави копие: след b = 10; променливата a остава непроменена, защото двете са отделни кутийки. Същото важи за структурите: Point p2 = p1; копира всички полета на p1 в p2 и оттам нататък двете точки са независими. Стойностните типове не могат да са null и имат стойност по подразбиране — 0 за числата, false за bool, а при struct всички полета са нулирани.
Референтните типове (reference types) — всеки class, всеки масив, string, интерфейсите и делегатите — работят по друг начин. Самият обект се създава с new в heap-а, а променливата пази само референция (reference): адреса, на който обектът се намира. Присвояването Student b = a; копира адреса, а не обекта — вече имате две променливи, сочещи към един и същ обект, и промяната b.Points = 100; се вижда и през a. Точно това изненадва при масивите: int[] copy = original; не прави копие; след copy[0] = 99; и original[0] е 99. Истинско копие се получава само ако изрично го поискате, например с (int[])original.Clone(), Array.Copy или с нов обект, чиито полета попълвате сами.
Подаването на аргумент на метод е по подразбиране по стойност (by value): параметърът е нова локална променлива, в която се копира това, което подавате. При int се копира числото, затова Change(n) с x = 10; в тялото оставя n непроменено. При клас или масив се копира референцията — методът получава втори адрес към същия обект, така че arr[0] = 0; вътре в него променя масива на извикващия. Но ако методът напише arr = new int[3];, той пренасочва само своята локална референция, а променливата отвън продължава да сочи към стария масив. Когато искате методът да променя самата променлива на извикващия, обявете параметъра с ref (или out за стойност, която методът задължително връща) и подайте аргумента също с ref: Swap(ref a, ref b).
Референтна променлива може да не сочи към нищо — тогава стойността ѝ е null. Такива са полетата от референтен тип, които не сте инициализирали, елементите на нов масив от обекти (new Student[5] съдържа пет null) и резултатът от метод, който „не намира“ нищо. Опитате ли да достъпите член през null — s.Name, arr.Length, list.Add(...) — програмата се срива с NullReferenceException: няма обект, от който да се вземе полето. Защитата е проста: проверете if (s != null) преди точката, използвайте оператора ?. (s?.Name връща null, вместо да гръмне) и ?? за стойност по подразбиране (name ?? "Непознат"). В .NET 8 проектите нулируемите референции са включени: string? name казва на компилатора, че null е допустим, и той ви предупреждава там, където забравяте проверката; стойностен тип става нулируем с ? — int? age = null;.
string е референтен тип, но се държи като стойностен и това често обърква. Низът е неизменяем (immutable): веднъж създаден, съдържанието му не може да се промени. Методите ToUpper(), Replace(), Trim() не пипат низа, а връщат нов — ако не запишете резултата (text = text.ToUpper();), промяната се губи. При string b = a; b += "!"; променливата a остава същата, защото += създава нов низ и пренасочва само b. Освен това за string операторът == е специално предефиниран да сравнява съдържанието, а не адресите, така че "abc" == "abc" е true, както очаквате.
За всеки друг клас обаче == по подразбиране означава „един и същ обект ли е“ (reference equality): два обекта new Point(1, 2) с еднакви полета не са равни чрез ==, защото живеят на различни адреси. Ако ви трябва сравнение по съдържание, сравнете полетата, предефинирайте Equals и GetHashCode или използвайте record, при който равенството е по стойност. При структурите == изобщо не е дефиниран без ваша намеса, но Equals сравнява поле по поле. Накрая, когато стойностен тип се запише в променлива от тип object (object o = 42;), стойността се опакова (boxing) в нов обект в heap-а; обратното разопаковане (unboxing) е явно преобразуване (int)o. Boxing е незабележим в малки програми, но в цикъл с милиони итерации струва време и памет — още една причина да предпочитате конкретни типове и генерични колекции като List<int> пред object.
Златни правила
Стойност се копира, референция се споделя
= при int и struct прави отделно копие; при class, масив и string копира само адреса. Преди да промените обект през втора променлива, попитайте се: един ли е обектът, или два?
`new` означава heap
Всичко, което създавате с new от клас или масив, живее в динамичната памет и остава там, докато някой го сочи. Локалните променливи и стойностите в тях са в стека и изчезват с края на метода.
Проверявай за `null` преди точката
Всяко нещо.Член, при което нещо може да е null, е потенциален NullReferenceException. Инициализирайте референциите или проверявайте с != null, ?. и ??.
Низът не се променя — презаписва се
ToUpper(), Replace(), Trim() връщат нов низ, а старият остава същият. Винаги записвайте резултата: text = text.Trim();.
`==` при клас пита „същият обект ли е“
Два различни обекта с еднакво съдържание не са равни чрез ==. За сравнение по съдържание използвайте Equals, сравнете полетата или направете типа record. Изключение е string, при който == сравнява текста.
Бърз справочник
Стойностни срещу референтни типове
| Характеристика | Стойностни типове | Референтни типове |
|---|---|---|
| Примери | int, double, bool, char, decimal, enum, struct | class, масиви (int[]), string, интерфейси, делегати |
| Какво пази променливата | Самата стойност | Референция (адрес) към обект в heap-а |
| Къде живеят данните | В стека (като локална променлива) или вътре в обекта, който ги съдържа | Обектът е в heap-а; референцията е в стека или в друг обект |
Присвояване b = a | Копира стойността; a и b са независими | Копира адреса; a и b сочат към един обект |
| Подаване на метод | Методът получава копие и не може да промени оригинала | Методът може да промени съдържанието на обекта, но не и накъде сочи променливата отвън |
Може ли да е null | Не (освен нулируем вариант като int?) | Да; полетата и елементите на нов масив са null по подразбиране |
| Стойност по подразбиране | 0, false, '\0', нулирани полета | null |
== по подразбиране | Сравнява стойностите (struct няма == без предефиниране) | Сравнява референциите (същият обект ли е); string е изключение |
| Освобождаване | Автоматично при излизане от метода | От garbage collector, когато никой вече не сочи към обекта |
Работа с референции и null
| Запис | Какво прави | Пример | Бележка |
|---|---|---|---|
new Тип(...) | Създава обект в heap-а и връща референция към него | Student s = new Student(); | Всяко new е нов, отделен обект |
null | Референция, която не сочи към нищо | Student? s = null; | Достъп до член през null хвърля NullReferenceException |
x != null / x is null | Проверка дали има обект | if (s != null) Console.WriteLine(s.Name); | is null работи дори ако == е предефиниран |
?. | Достъп до член само ако обектът не е null | int? len = s?.Name.Length; | Резултатът е null, когато s е null |
?? | Стойност по подразбиране при null | string n = s?.Name ?? "Непознат"; | Чете се „ако е null, вземи…“ |
ref | Параметърът е псевдоним на променливата на извикващия | Swap(ref a, ref b); | Пише се и в метода, и при извикването |
out | Като ref, но методът трябва да присвои стойност | int.TryParse(text, out int n); | Аргументът не трябва да е инициализиран предварително |
(int[])arr.Clone() | Плитко копие на масив | int[] copy = (int[])arr.Clone(); | Елементите, които са обекти, остават споделени |
object o = 5; / (int)o | Boxing / unboxing | object o = 42; int n = (int)o; | Unboxing към грешен тип хвърля InvalidCastException |
Код за анализ и пренаписване
struct, class и масив: копие или споделяне
using System;
struct PointStruct
{
public int X;
public int Y;
}
class PointClass
{
public int X;
public int Y;
}
class Program
{
static void Main()
{
// Стойностен тип: присвояването прави копие
PointStruct s1 = new PointStruct { X = 1, Y = 2 };
PointStruct s2 = s1;
s2.X = 100;
Console.WriteLine($"struct: s1.X = {s1.X}, s2.X = {s2.X}");
// Референтен тип: присвояването копира само адреса
PointClass c1 = new PointClass { X = 1, Y = 2 };
PointClass c2 = c1;
c2.X = 100;
Console.WriteLine($"class: c1.X = {c1.X}, c2.X = {c2.X}");
// Масивът също е референтен тип
int[] a = { 1, 2, 3 };
int[] b = a;
b[0] = 99;
Console.WriteLine($"array: a[0] = {a[0]}, b[0] = {b[0]}");
// Истинско копие на масив
int[] c = (int[])a.Clone();
c[0] = -1;
Console.WriteLine($"clone: a[0] = {a[0]}, c[0] = {c[0]}");
// == при референтни типове пита: същият обект ли е?
Console.WriteLine($"c1 == c2: {c1 == c2}, a == b: {a == b}, a == c: {a == c}");
}
}Какво се случва тук?
-
PointStructиPointClassимат еднакви полета, но едната еstruct(стойностен тип), а другата —class(референтен тип); цялата разлика в поведението идва от тази една дума. -
PointStruct s2 = s1;копира полетата:s1иs2са две отделни стойности в стека, затоваs2.X = 100;оставяs1.Xравно на1. -
PointClass c2 = c1;копира само референцията — обектът е един, в heap-а, и промяната презc2се вижда и презc1: двете отпечатват100. - Масивът
aе референтен тип като всеки клас:int[] b = a;не създава втори масив, затоваb[0] = 99;променя иa[0]. -
(int[])a.Clone()създава нов масив със същите елементи;cвече е независим иc[0] = -1;не засягаa. Преобразуването(int[])е нужно, защотоClone()връщаobject. - Последният ред показва какво сравнява
==при референтни типове:c1 == c2иa == bсаTrue, защото сочат към същия обект, аa == cеFalse, макар масивите да изглеждат подобни. - Очакван изход:
s1.X = 1, s2.X = 100, послеc1.X = 100, c2.X = 100,a[0] = 99, b[0] = 99,a[0] = 99, c[0] = -1и накраяTrue, True, False.
Параметри, ref, null, неизменяем string и boxing
using System;
class Student
{
public string Name = "";
public int Points;
}
class Program
{
static void AddTen(int points)
{
points += 10; // променя само копието
}
static void AddTen(ref int points)
{
points += 10; // променя самата променлива на извикващия
}
static void AddTen(Student s)
{
s.Points += 10; // променя споделения обект
}
static void Replace(Student s)
{
s = new Student { Name = "Нов", Points = 0 }; // сменя само локалната референция
}
static void Main()
{
int n = 5;
AddTen(n);
Console.WriteLine($"int по стойност: {n}");
AddTen(ref n);
Console.WriteLine($"int с ref: {n}");
Student ivan = new Student { Name = "Иван", Points = 5 };
AddTen(ivan);
Console.WriteLine($"обект: {ivan.Name} има {ivan.Points} точки");
Replace(ivan);
Console.WriteLine($"след Replace: {ivan.Name}");
string text = "здравей";
string upper = text.ToUpper();
Console.WriteLine($"string: {text} / {upper}");
Student? nobody = null;
if (nobody == null)
{
Console.WriteLine("nobody е null, няма да го пипаме");
}
Console.WriteLine(nobody?.Name ?? "(няма име)");
object boxed = n; // boxing: int отива в heap-а
int unboxed = (int)boxed; // unboxing: обратно в стека
Console.WriteLine($"boxing: {boxed}, unboxing: {unboxed}");
}
}Какво се случва тук?
- Трите метода
AddTenса претоварвания с различен вид параметър:intпо стойност,ref intи референтен типStudent; компилаторът избира кой да извика според аргумента. -
AddTen(n)получава копие на числото иpoints += 10променя само него —nостава5.AddTen(ref n)работи със самата променливаnи тя става15. -
AddTen(ivan)получава копие на референцията, но обектът е същият, затоваs.Points += 10увеличава точките на Иван до15. -
Replace(ivan)присвояваnew Studentна локалния параметърs; променливатаivanвMainпродължава да сочи към стария обект и след извикването името е все още „Иван“. -
text.ToUpper()не променяtext— низът е неизменяем; новият низ се връща и го записваме вupper. Отпечатва сездравей / ЗДРАВЕЙ. -
Student? nobody = null;обявява референция, която не сочи към нищо; проверката== nullи операторите?.и??ни пазят отNullReferenceException— отпечатва се(няма име). -
object boxed = n;опакова стойността15в нов обект в heap-а (boxing), а(int)boxedя разопакова обратно в стека (unboxing). Изходът еboxing: 15, unboxing: 15.
Внимавай! Чести грешки
Грешките, които почти всеки прави в тази тема — виж разликата между грешния и правилния код.
Масивът не се копира с `=`
Грешно
int[] scores = { 90, 80, 70 };
int[] backup = scores;
scores[0] = 0;
// backup[0] също е 0 - резервното копие е изгубеноПравилно
int[] scores = { 90, 80, 70 };
int[] backup = (int[])scores.Clone();
scores[0] = 0;
// backup[0] остава 90backup = scores копира само референцията — двете имена сочат към един масив. Копие на съдържанието се прави само изрично с Clone(), Array.Copy или нов масив.
Член през `null`
Грешно
string[] names = new string[3];
Console.WriteLine(names[0].Length); // NullReferenceExceptionПравилно
string[] names = new string[3];
int length = names[0]?.Length ?? 0;
Console.WriteLine(length); // 0 вместо сривНовият масив от референтен тип е пълен с null, а null няма Length. Проверете за null с if, или използвайте ?. и ??, за да дадете стойност по подразбиране.
Забравен резултат от `ToUpper()`
Грешно
string name = "иван";
name.ToUpper();
Console.WriteLine(name); // иванПравилно
string name = "иван";
name = name.ToUpper();
Console.WriteLine(name); // ИВАННизовете са неизменяеми: ToUpper() не променя name, а връща нов низ. Без присвояване новият низ веднага се губи.
Сравнение на обекти с `==`
Грешно
Point a = new Point { X = 1, Y = 2 };
Point b = new Point { X = 1, Y = 2 };
Console.WriteLine(a == b); // False - два различни обекта
class Point { public int X; public int Y; }Правилно
Point a = new Point(1, 2);
Point b = new Point(1, 2);
Console.WriteLine(a == b); // True - равенство по стойност
record Point(int X, int Y);За класове == проверява дали двете променливи сочат към един и същ обект. Ако ви трябва равенство по съдържание, сравнете полетата, предефинирайте Equals и GetHashCode, или обявете типа като record.
Задачи за самостоятелна работа
Опитай първо сам — подсказката е там само ако наистина закъсаш.
Структура или клас?
Дефинирайте структура RectStruct и клас RectClass, всеки с полета Width и Height. В Main създайте по един правоъгълник от всеки тип със страни 2 и 3, присвоете го на втора променлива, променете Width на копието на 10 и отпечатайте размерите на оригинала и на копието. Преди да пуснете програмата, запишете какво очаквате да видите, и после сравнете.
Какво може да промени методът
Напишете три метода: Swap(ref int a, ref int b), който разменя две променливи; FillZeros(int[] arr), който нулира всички елементи на масива; и TryReplace(int[] arr), който присвоява на параметъра нов масив { 7, 7, 7 }. В Main ги извикайте върху int x = 1, y = 2 и масив { 5, 6, 7 } и отпечатайте резултата след всяко извикване. Обяснете с коментар защо TryReplace не променя масива на извикващия, а FillZeros го променя.
Безопасно сравнение на книги
Създайте клас Book с полета Title и Author. Напишете метод static bool SameBook(Book? a, Book? b), който връща true, ако двете референции сочат към един и същ обект или ако заглавието и авторът съвпадат, и false в останалите случаи — без да хвърля изключение, когато една от двете (или и двете) е null. Проверете го с: обект и негов псевдоним, два отделни обекта с еднакво съдържание, различна книга и null. Отпечатайте и резултата от == за първите два случая, за да видите разликата.
Мини-тест за проверка
Отговори си наум (или на глас!) и чак тогава разкрий отговора.
1. След `int[] a = { 1, 2, 3 }; int[] b = a; b[1] = 0;` какво ще отпечата `Console.WriteLine(a[1]);` и защо?
2. Методът `static void Change(int x) { x = 10; }` е извикан с `int n = 3; Change(n);`. Каква е стойността на `n` след това и как да накарате метода наистина да я промени?
3. Какво ще се случи при `Student? s = null; Console.WriteLine(s.Name);` и как се предпазваме?
4. Защо `p1 == p2` връща `false` за два обекта `new Point { X = 1, Y = 1 }` от клас `Point`, а `"ab" == "ab"` връща `true`?
Речник на термините
Виж пълния речник на курсаnew се създават обектите от референтни типове. Обектът живее, докато някой го сочи; след това го освобождава събирачът на боклук (garbage collector).int, double, bool, enum, struct. Присвояването и подаването на метод правят копие.class, масиви, string. Присвояването споделя обекта, а не го копира.null, освен ако са обявени като нулируеми (int?).null.string е неизменяем: всяка „промяна“ създава нов низ.object в heap-а (object o = 5;) и обратното явно преобразуване ((int)o). Струва време и памет, затова се избягва в горещи цикли.Провери знанията
Бърз тест с избор от отговори върху термините на модула — с точки и моментална обратна връзка.
Провери знанията си
9 въпроса върху термините от модула. Показваме определение — ти избираш правилния термин.
Препоръки за този модул
- Рисувайте паметта на хартия: отляво стекът с променливите, отдясно heap-ът с обектите, а референциите — като стрелки. Щом две стрелки сочат към една кутия, промяната през едната се вижда и през другата.
- Когато получите неочаквана промяна на масив или обект, потърсете мястото, където сте написали
=между две променливи от референтен тип — почти винаги сте споделили, а не копирали. - Четете съобщението на
NullReferenceExceptionдокрай: дебъгерът спира точно на реда с грешката. Поставете breakpoint на този ред и вижте коя променлива еnull, вместо да гадаете. - Експериментирайте с малки програми: напишете един и същ тип веднъж като
structи веднъж катоclass, копирайте, променете и отпечатайте. Пет минути опит се помнят по-дълго от правило наизуст.