Referencje w C# – jak obiekty żyją w pamięci

public class Osoba
{
    public string Imie;
    public int Wiek;
}

// Tworzę osobę
Osoba osoba1 = new Osoba();
osoba1.Imie = "Jan";
osoba1.Wiek = 25;

// "Kopiuję" do osoba2
Osoba osoba2 = osoba1;

// Zmieniam TYLKO osoba2
osoba2.Imie = "Anna";
osoba2.Wiek = 30;

// Co się wyświetli?
Console.WriteLine(osoba1.Imie);  // 🤔 ???
Console.WriteLine(osoba1.Wiek);  // 🤔 ???

// Z liczbami działa "normalnie"
int liczba1 = 10;
int liczba2 = liczba1;  // Kopia

liczba2 = 99;  // Zmieniam tylko liczba2

Console.WriteLine(liczba1);  // 10 ✅ Bez zmian!
Console.WriteLine(liczba2);  // 99

// Typy wartościowe – kopiowanie WARTOŚCI

int a = 10;
int b = a;  // Kopiujemy WARTOŚĆ 10

b = 99;  // Zmieniamy tylko b

Console.WriteLine(a);  // 10 ✅ Bez zmian!
Console.WriteLine(b);  // 99

// To samo z innymi typami wartościowymi:
double x = 3.14;
double y = x;
y = 2.71;
Console.WriteLine(x);  // 3.14 ✅

bool flaga1 = true;
bool flaga2 = flaga1;
flaga2 = false;
Console.WriteLine(flaga1);  // True ✅

public class Osoba
{
    public string Imie;
    public int Wiek;
}

// Tworzymy obiekt
Osoba osoba1 = new Osoba();
osoba1.Imie = "Jan";
osoba1.Wiek = 25;

// "Kopiujemy" – ale tylko ADRES!
Osoba osoba2 = osoba1;  // Kopia REFERENCJI, nie obiektu!

// Zmieniamy przez osoba2
osoba2.Imie = "Anna";
osoba2.Wiek = 30;

// OBE zmienne wskazują na TEN SAM obiekt!
Console.WriteLine(osoba1.Imie);  // Anna 😱
Console.WriteLine(osoba1.Wiek);  // 30 😱
Console.WriteLine(osoba2.Imie);  // Anna
Console.WriteLine(osoba2.Wiek);  // 30

int a = 10;
int b = a;
b = 99;

PAMIĘĆ (STOS):
┌─────────────┐
│ a: 10       │  ← Osobna komórka
├─────────────┤
│ b: 99       │  ← Osobna komórka
└─────────────┘

Zmiana b NIE wpływa na a!

Osoba osoba1 = new Osoba();
osoba1.Imie = "Jan";
Osoba osoba2 = osoba1;
osoba2.Imie = "Anna";

PAMIĘĆ:

STOS (zmienne):              STERTA (obiekty):
┌─────────────────┐          ┌─────────────────┐
│ osoba1: 0x1A2B ─┼─────────→│ Obiekt Osoba    │
├─────────────────┤          │ Imie: "Anna"    │
│ osoba2: 0x1A2B ─┼─────────→│ Wiek: 25        │
└─────────────────┘          └─────────────────┘

Obie zmienne wskazują na TEN SAM obiekt!

// Każdy NEW tworzy NOWY obiekt!
Osoba osoba1 = new Osoba();  // Nowy obiekt (adres: 0x1A2B)
osoba1.Imie = "Jan";

Osoba osoba2 = new Osoba();  // INNY nowy obiekt (adres: 0x3C4D)
osoba2.Imie = "Anna";

// Teraz to SĄ RÓŻNE obiekty!
osoba2.Imie = "Maria";

Console.WriteLine(osoba1.Imie);  // Jan ✅ Bez zmian!
Console.WriteLine(osoba2.Imie);  // Maria

PAMIĘĆ:

STOS:                        STERTA:
┌─────────────────┐          ┌─────────────────┐
│ osoba1: 0x1A2B ─┼─────────→│ Obiekt Osoba    │
├─────────────────┤          │ Imie: "Jan"     │
│ osoba2: 0x3C4D ─┼───┐      └─────────────────┘
└─────────────────┘   │      
                      │      ┌─────────────────┐
                      └─────→│ Obiekt Osoba    │
                             │ Imie: "Maria"   │
                             └─────────────────┘

Różne adresy = różne obiekty!

// Deklaracja bez inicjalizacji – domyślnie null
Osoba osoba1;  // null (niezainicjalizowana)

// Jawne przypisanie null
Osoba osoba2 = null;  // Jawnie: "nie ma obiektu"

// Po użyciu obiektu – "zapominamy" o nim
Osoba osoba3 = new Osoba();
osoba3.Imie = "Jan";
osoba3 = null;  // Teraz osoba3 już nie wskazuje na obiekt

Osoba osoba = null;

// ❌ BŁĄD! Próba użycia null
osoba.Imie = "Jan";  // NullReferenceException!

// Komunikat błędu:
// System.NullReferenceException: Object reference not set to an instance of an object.

Osoba osoba = null;

// Sposób 1: Sprawdzenie != null
if (osoba != null)
{
    osoba.Imie = "Jan";  // Bezpieczne!
}
else
{
    Console.WriteLine("Brak osoby!");
}

// Sposób 2: Operator ?. (null-conditional)
string imie = osoba?.Imie;  // Zwróci null jeśli osoba jest null

// Sposób 3: Operator ?? (null-coalescing)
string imie2 = osoba?.Imie ?? "Nieznane";  // Domyślna wartość

// Sposób 4: Pattern matching (C# 7+)
if (osoba is not null)
{
    Console.WriteLine(osoba.Imie);
}

Osoba osoba1 = new Osoba();
osoba1.Imie = "Jan";

Osoba osoba2 = new Osoba();  // NOWY obiekt!
osoba2.Imie = "Jan";

Osoba osoba3 = osoba1;  // Kopia REFERENCJI

// Sprawdzanie czy to TEN SAM obiekt (ta sama referencja)
Console.WriteLine(osoba1 == osoba2);  // False – różne obiekty!
Console.WriteLine(osoba1 == osoba3);  // True – ten sam obiekt!

// ReferenceEquals – jawne sprawdzenie referencji
Console.WriteLine(ReferenceEquals(osoba1, osoba2));  // False
Console.WriteLine(ReferenceEquals(osoba1, osoba3));  // True

// Sprawdzenie czy obiekt istnieje
Console.WriteLine(osoba1 != null);  // True

int[] tablica1 = { 1, 2, 3 };

// "Kopiujemy" tablicę – ale to tylko kopia referencji!
int[] tablica2 = tablica1;

// Zmieniamy przez tablica2
tablica2[0] = 999;

// OBE tablice pokazują zmianę!
Console.WriteLine(tablica1[0]);  // 999 😱
Console.WriteLine(tablica2[0]);  // 999

// Czy to ten sam obiekt?
Console.WriteLine(tablica1 == tablica2);  // True

int[] original = { 1, 2, 3 };

// Sposób 1: Metoda Clone()
int[] kopia1 = (int[])original.Clone();

// Sposób 2: Array.Copy()
int[] kopia2 = new int[original.Length];
Array.Copy(original, kopia2, original.Length);

// Sposób 3: ToArray() z LINQ
int[] kopia3 = original.ToArray();

// Teraz zmiany w kopii nie wpływają na oryginał!
kopia1[0] = 999;
Console.WriteLine(original[0]);  // 1 ✅

string tekst1 = "Hello";
string tekst2 = tekst1;  // Kopia referencji

// Ale zmiana "tekst2" nie wpływa na tekst1!
tekst2 = "World";  // To tworzy NOWY obiekt string!

Console.WriteLine(tekst1);  // "Hello" ✅
Console.WriteLine(tekst2);  // "World"

// Porównanie == dla stringów porównuje ZAWARTOŚĆ
string a = "Test";
string b = "Test";
Console.WriteLine(a == b);  // True – ta sama zawartość!

public class Osoba
{
    public string Imie;
    public int Wiek;
}

// Metoda przyjmująca obiekt
static void ZmienWiek(Osoba osoba)
{
    osoba.Wiek = 100;  // Zmienia ORYGINALNY obiekt!
}

// Użycie
Osoba jan = new Osoba();
jan.Imie = "Jan";
jan.Wiek = 25;

ZmienWiek(jan);

Console.WriteLine(jan.Wiek);  // 100 😱 Zmienione!

// Typ wartościowy – kopia wartości
static void ZmienLiczbe(int x)
{
    x = 999;  // Zmienia tylko LOKALNĄ kopię
}

int liczba = 10;
ZmienLiczbe(liczba);
Console.WriteLine(liczba);  // 10 ✅ Bez zmian!

// Typ referencyjny – kopia referencji (ten sam obiekt)
static void ZmienTablice(int[] tab)
{
    tab[0] = 999;  // Zmienia ORYGINALNĄ tablicę!
}

int[] tablica = { 1, 2, 3 };
ZmienTablice(tablica);
Console.WriteLine(tablica[0]);  // 999 😱 Zmienione!

// 1. new tworzy NOWY obiekt
Osoba a = new Osoba();  // Nowy obiekt
Osoba b = new Osoba();  // INNY nowy obiekt

// 2. = kopiuje REFERENCJĘ, nie obiekt
Osoba c = a;  // c i a wskazują na TEN SAM obiekt

// 3. Zawsze sprawdzaj null przed użyciem
if (osoba != null) { /* bezpiecznie */ }

// 4. Tablice to typy referencyjne!
int[] kopia = (int[])original.Clone();  // Prawdziwa kopia