TOP 50 Pytań Rekrutacyjnych
Junior .NET Developer

class to typ referencyjny — obiekt żyje na stercie (heap), zmienna przechowuje referencję. struct to typ wartościowy — dane leżą na stosie (stack) lub inline w obiekcie-rodzicu, kopiowane przez wartość przy przypisaniu.

// class — kopiujemy referencję
Point a = new Point(1, 2);  // Point to class
Point b = a;
b.X = 99;
Console.WriteLine(a.X); // 99 — ten sam obiekt

// struct — kopiujemy wartość
PointS c = new PointS(1, 2);  // PointS to struct
PointS d = c;
d.X = 99;
Console.WriteLine(c.X); // 1 — niezależna kopia

Od C# 8 typy referencyjne są domyślnie non-nullable. Kompilator ostrzega, gdy możliwy jest NullReferenceException. Dodanie ? jawnie oznacza, że zmienna może być null.

#nullable enable
string  name = null;   // ⚠️ warning CS8600
string? name = null;   // OK — świadomie nullable

void Greet(string? name)
{
    // null-forgiving operator — "wiem co robię"
    Console.WriteLine(name!.Length);

    // lepiej — null check
    if (name is not null)
        Console.WriteLine(name.Length);
}

async/await to syntactic sugar na state machine generowaną przez kompilator. Przy pierwszym await, który nie jest jeszcze gotowy, metoda zwraca kontrolę do wywołującego. Gdy operacja I/O się kończy, kontynuacja uruchamia się (domyślnie) na tym samym SynchronizationContext.

// Złe — blokuje wątek
string json = httpClient.GetStringAsync(url).Result; // deadlock ryzyko!

// Dobre
string json = await httpClient.GetStringAsync(url);

// Bez potrzeby powrotu do kontekstu (np. w library code)
string json = await httpClient.GetStringAsync(url)
                              .ConfigureAwait(false);

IEnumerable<T> — tylko do odczytu, leniwa iteracja, brak informacji o Count. ICollection<T> dodaje Count, Add, Remove. IList<T> dodaje dostęp indeksowany i Insert/RemoveAt.

// Zasada: używaj najwęższego interfejsu wystarczającego do celu
void Process(IEnumerable<Order> orders)  { /* tylko iteracja */ }
void Fill(ICollection<Order> orders)     { orders.Add(new Order()); }
void Swap(IList<Order> orders, int i, int j) { (orders[i], orders[j]) = (orders[j], orders[i]); }

LINQ to deklaratywny mechanizm zapytań do dowolnych źródeł danych (kolekcje, bazy, XML). Operatory są leniwe — wykonują się przy pierwszej iteracji.

var orders = new List<Order> { ... };

// Where — filtruje, zwraca IEnumerable
var active = orders.Where(o => o.IsActive);

// Select — projekcja/transformacja każdego elementu
var ids = orders.Select(o => o.Id);

// FirstOrDefault — zwraca pierwszy lub null (nie rzuca wyjątku)
var order = orders.FirstOrDefault(o => o.Id == 5);
// vs First() — rzuca InvalidOperationException gdy brak elementu

record to typ referencyjny z wbudowaną semantyką wartości: auto-generowane Equals, GetHashCode, ToString oparte na właściwościach, nie referencji. Kompilator generuje też with-expression dla niemutowalnych kopii.

record Person(string FirstName, string LastName);

var p1 = new Person("Jan", "Kowalski");
var p2 = new Person("Jan", "Kowalski");

Console.WriteLine(p1 == p2);  // true — porównanie wg wartości

var p3 = p1 with { LastName = "Nowak" }; // niemutowalna kopia

// record struct (C# 10) — value type + value semantics
record struct Point(double X, double Y);

delegate to typowany wskaźnik na metodę. Action<T>, Func<T,TResult>, Predicate<T> to gotowe delegaty z .NET — nie trzeba deklarować własnych.

// Func — zwraca wartość, ostatni param to typ zwracany
Func<int, int, int> add = (a, b) => a + b;
Console.WriteLine(add(2, 3)); // 5

// Action — nie zwraca wartości (void)
Action<string> log = msg => Console.WriteLine(msg);

// Predicate — przyjmuje T, zwraca bool
Predicate<int> isEven = n => n % 2 == 0;

// Closures — lambda "zamyka" zmienną z zewnętrznego scope
int threshold = 10;
Func<int, bool> aboveThreshold = n => n > threshold;
threshold = 20; // zmiana wpływa na closure!

GC w .NET jest generacyjny — obiekty podzielone na Gen0, Gen1, Gen2 + Large Object Heap (LOH, ≥85KB). Gen0 jest zbierana najczęściej i najszybciej (krótko żyjące obiekty). Przeżałe trafiają do Gen1, a potem Gen2 (długo żyjące).

// Obiekty NIGDY nie powinny implementować finalizer bez IDisposable
// Finalizer opóźnia zwolnienie o przynajmniej jeden GC cycle

class Resource : IDisposable
{
    private bool _disposed;

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this); // bez tego finalizer i tak się odpali
    }

    protected virtual void Dispose(bool disposing) { /* cleanup */ }
    ~Resource() => Dispose(false); // finalizer — ostatnia deska ratunku
}

string jest niemutowalny — każda konkatenacja tworzy nowy obiekt na stercie. W pętlach prowadzi to do O(n²) alokacji. StringBuilder mutuje wewnętrzny bufor — alokacja O(n).

// Złe — tworzy n nowych stringów
string result = "";
foreach (var item in items)
    result += item + ", "; // 100 iteracji = ~100 alokacji

// Dobre
var sb = new StringBuilder();
foreach (var item in items)
    sb.Append(item).Append(", ");
string result = sb.ToString();

// Jeszcze lepiej (C# 10+) — interpolacja ze string.Create lub Span
// Dla małej liczby konkatenacji (2-3) += jest w porządku

Pattern matching pozwala testować kształt danych w is, switch i switch expression. C# 9/10 dodał relational, logical i property patterns.

object obj = new Order { Status = "Active", Amount = 150 };

// Type pattern + property pattern
if (obj is Order { Status: "Active", Amount: > 100 } order)
    Console.WriteLine($"Duże zamówienie: {order.Amount}");

// Switch expression (C# 8+)
string label = order.Amount switch
{
    < 50         => "małe",
    >= 50 and < 200 => "średnie",
    >= 200       => "duże",
    _            => "nieznane"
};

Enkapsulacja — ukrywanie stanu, dostęp przez publiczne API. Dziedziczenie — współdzielenie kodu przez hierarchię klas. Polimorfizm — ten sam interfejs, różne zachowanie. Abstrakcja — modelowanie esencji, ukrywanie szczegółów.

// Polimorfizm — kluczowy na rozmowie
abstract class Shape
{
    public abstract double Area();
}

class Circle(double radius) : Shape
{
    public override double Area() => Math.PI * radius * radius;
}

class Rectangle(double w, double h) : Shape
{
    public override double Area() => w * h;
}

// Polimorficzne wywołanie — nie obchodzi nas konkretny typ
List<Shape> shapes = [new Circle(5), new Rectangle(3, 4)];
double totalArea = shapes.Sum(s => s.Area()); // 98.54...

Klasa powinna mieć jeden powód do zmiany — jeden obszar odpowiedzialności. “Jeden powód” to jeden aktor biznesowy, który może zażądać zmiany logiki.

// Naruszenie SRP — OrderService robi za dużo
class OrderService
{
    public void PlaceOrder(Order order) { /* logika zamówień */ }
    public void SendEmail(Order order)  { /* wysyłka maila */ } // ← osobna odpowiedzialność
    public void SaveToCsv(Order order)  { /* eksport danych */ } // ← osobna odpowiedzialność
}

// Po SRP
class OrderService    { public void PlaceOrder(Order order) { ... } }
class EmailService    { public void SendConfirmation(Order order) { ... } }
class OrderExporter   { public void ExportToCsv(IEnumerable<Order> orders) { ... } }

Kod powinien być otwarty na rozszerzenie, zamknięty na modyfikację. Nowe zachowania dodajemy przez nowe klasy/implementacje, a nie przez zmienianie istniejącego kodu.

// Naruszenie — każdy nowy discount wymaga zmiany metody
decimal Calculate(Order o, string discountType)
{
    if (discountType == "vip") return o.Total * 0.9m;
    if (discountType == "promo") return o.Total * 0.85m;
    // ... kolejne if'y przy każdej nowej promocji
    return o.Total;
}

// Po OCP — nowy discount = nowa klasa, stary kod niezmieniony
interface IDiscountPolicy
{
    decimal Apply(decimal total);
}

class VipDiscount : IDiscountPolicy
    { public decimal Apply(decimal t) => t * 0.9m; }

class PromoDiscount : IDiscountPolicy
    { public decimal Apply(decimal t) => t * 0.85m; }

class OrderService(IDiscountPolicy discount)
{
    public decimal Calculate(Order o) => discount.Apply(o.Total);
}

DIP (zasada) — moduły wysokiego poziomu nie zależą od modułów niskiego poziomu; obie strony zależą od abstrakcji. DI (technika) — mechanizm dostarczania zależności z zewnątrz zamiast tworzenia ich wewnątrz klasy. DI to sposób realizacji DIP.

// Naruszenie DIP — OrderService tworzy konkretną zależność
class OrderService
{
    private readonly SqlOrderRepository _repo = new SqlOrderRepository(); // tight coupling!
}

// DIP + DI — zależność od interfejsu, wstrzykiwana z zewnątrz
class OrderService(IOrderRepository repo)  // constructor injection
{
    public async Task<Order> GetOrder(int id) => await repo.GetByIdAsync(id);
}

// Rejestracja w IoC container (ASP.NET Core)
builder.Services.AddScoped<IOrderRepository, SqlOrderRepository>();

Klasa abstrakcyjna może mieć stan, konstruktory i konkretne metody — wyraża relację “jest”. Interfejs definiuje kontrakt zachowania — wyraża relację “potrafi”. Klasa może implementować wiele interfejsów, ale dziedziczyć tylko z jednej klasy.

// Abstract class — wspólna baza + shared behavior
abstract class Animal
{
    public string Name { get; }
    protected Animal(string name) { Name = name; }
    public abstract void Speak();          // musi być nadpisana
    public void Breathe() { /* wspólna */ } // dziedziczona
}

// Interface — zdolność/kontrakt (C# 8+ pozwala na default implementations)
interface ISerializable
{
    string Serialize();
}

// Klasa psa: jest zwierzęciem ORAZ potrafi być serializowana
class Dog : Animal, ISerializable
{
    public Dog(string name) : base(name) { }
    public override void Speak() => Console.WriteLine("Woof!");
    public string Serialize() => JsonSerializer.Serialize(this);
}

Obiekt podklasy powinien być w stanie zastąpić obiekt klasy bazowej bez zmiany poprawności programu. Naruszenie objawia się rzucaniem wyjątków w nadpisanych metodach lub zawężaniem kontraktu.

// Klasyczne naruszenie LSP — Rectangle/Square
class Rectangle
{
    public virtual int Width  { get; set; }
    public virtual int Height { get; set; }
    public int Area => Width * Height;
}

class Square : Rectangle
{
    public override int Width  { set { base.Width = base.Height = value; } }
    public override int Height { set { base.Width = base.Height = value; } }
}

// Test ujawniający naruszenie
void TestArea(Rectangle r)
{
    r.Width  = 4;
    r.Height = 5;
    Debug.Assert(r.Area == 20); // ✅ dla Rectangle, ❌ dla Square (25)
}

// Rozwiązanie: nie dziedzicz Square z Rectangle — różne kontrakty

Klient nie powinien być zmuszony do zależności od metod, których nie używa. Duże interfejsy rozbijamy na mniejsze, specyficzne.

// Naruszenie ISP — "fat interface"
interface IWorker
{
    void Work();
    void Eat();
    void Sleep();
}

// Robot implementuje interfejs, ale nie je i nie śpi
class Robot : IWorker
{
    public void Work() { /* OK */ }
    public void Eat()  => throw new NotImplementedException(); // zapach kodu!
    public void Sleep()=> throw new NotImplementedException();
}

// Po ISP — segregacja interfejsów
interface IWorkable  { void Work(); }
interface IEatable   { void Eat(); }
interface ISleepable { void Sleep(); }

class Human : IWorkable, IEatable, ISleepable { /* implementuje wszystkie */ }
class Robot : IWorkable                        { /* implementuje tylko Work */ }

Dziedziczenie (is-a) tworzy silne powiązanie hierarchiczne. Kompozycja (has-a) składa obiekt z mniejszych, wymiennych części. Zasada GoF: “favor composition over inheritance”.

// Dziedziczenie — OK gdy relacja "jest" jest prawdziwa i stabilna
class ElectricCar : Car { /* ElectricCar "jest" Car */ }

// Kompozycja — elastyczność, łatwość testowania
class OrderProcessor
{
    private readonly IPaymentGateway _payment;
    private readonly IInventoryService _inventory;
    private readonly IEmailService _email;

    // Wstrzykiwane przez konstruktor — łatwo podmienić w testach
    public OrderProcessor(IPaymentGateway p, IInventoryService i, IEmailService e)
        => (_payment, _inventory, _email) = (p, i, e);
}

sealed blokuje dziedziczenie z klasy (lub nadpisywanie metody wirtualnej). Daje kompilatorowi i JIT więcej możliwości optymalizacji (devirtualization), dokumentuje intencję projektową i chroni przed nieoczekiwanym rozszerzaniem.

sealed class SqlOrderRepository : IOrderRepository
{
    // Nikt nie może dziedziczyć z tej klasy
    // JIT może wywołać metody bezpośrednio (devirtualization)
}

// Sealed override — blokuje dalsze nadpisywanie
class Base    { public virtual void Do() { } }
class Derived : Base { public sealed override void Do() { } }
// class Further : Derived { public override void Do() { } } // błąd kompilacji

// Wzorzec: domain exceptions często sealed
sealed class OrderNotFoundException(int orderId)
    : Exception($"Order {orderId} not found.");

override — nadpisuje wirtualną metodę klasy bazowej. Wywołanie przez referencję bazową uruchamia wersję z klasy pochodnej (polimorfizm runtime). new — ukrywa metodę bazową. Wywołanie przez referencję bazową uruchamia wersję bazową.

class Animal   { public virtual void Speak()  => Console.Write("..."); }
class DogA : Animal { public override void Speak() => Console.Write("Woof!"); }
class DogB : Animal { public new     void Speak() => Console.Write("Woof!"); }

Animal a1 = new DogA();
Animal a2 = new DogB();

a1.Speak(); // "Woof!" — override: polimorfizm działa
a2.Speak(); // "..."   — new: metoda bazowa ukryta, nie nadpisana

DogB d = new DogB();
d.Speak();  // "Woof!" — przez konkretny typ działa wersja z DogB

Żądanie przechodzi przez pipeline middleware — łańcuch komponentów, z których każdy może przetworzyć żądanie i/lub odpowiedź, albo przekazać dalej (next()).

// Kolejność middleware ma krytyczne znaczenie
app.UseExceptionHandler("/error"); // musi być pierwszy — łapie błędy z dalszych
app.UseHttpsRedirection();
app.UseAuthentication();            // kim jesteś?
app.UseAuthorization();             // czy masz dostęp?
app.UseRateLimiter();
app.MapControllers();               // routing + akcje

// Własny middleware
public class TimingMiddleware(RequestDelegate next)
{
    public async Task InvokeAsync(HttpContext ctx)
    {
        var sw = Stopwatch.StartNew();
        await next(ctx);             // wywołanie reszty pipeline
        sw.Stop();
        ctx.Response.Headers["X-Elapsed-Ms"] = sw.ElapsedMilliseconds.ToString();
    }
}

Transient — nowa instancja za każdym razem. Scoped — jedna instancja na żądanie HTTP. Singleton — jedna instancja przez całe życie aplikacji.

// Rejestracja
builder.Services.AddTransient<IEmailSender, SmtpEmailSender>();  // bezstanowe usługi
builder.Services.AddScoped<IOrderRepository, SqlOrderRepository>(); // DbContext, Unit of Work
builder.Services.AddSingleton<IConfiguration>(config);            // cache, konfiguracja

// PUŁAPKA: Captive Dependency
// Singleton NIGDY nie powinien zależeć od Scoped/Transient
// IoC container rzuci InvalidOperationException lub będzie leak
class BadSingleton(IScopedService scoped) { } // ❌ scoped "uwięziony" w singleton

Używamy IActionResult / ActionResult<T> i pomocniczych metod bazowego ControllerBase.

[ApiController]
[Route("api/[controller]")]
public class OrdersController(IOrderService service) : ControllerBase
{
    [HttpGet("{id}")]
    public async Task<ActionResult<OrderDto>> Get(int id)
    {
        var order = await service.GetByIdAsync(id);
        if (order is null)
            return NotFound(new { message = $"Order {id} not found." }); // 404

        return Ok(order); // 200 + JSON
    }

    [HttpPost]
    public async Task<ActionResult<OrderDto>> Create(CreateOrderRequest req)
    {
        var order = await service.CreateAsync(req);
        return CreatedAtAction(nameof(Get), new { id = order.Id }, order); // 201
    }

    [HttpDelete("{id}")]
    public async Task<IActionResult> Delete(int id)
    {
        await service.DeleteAsync(id);
        return NoContent(); // 204
    }
}

[ApiController] automatycznie zwraca 400 z detalami gdy ModelState.IsValid == false. Data Annotations to proste dekoratory — dla złożonej walidacji używamy FluentValidation.

JWT (JSON Web Token) składa się z header.payload.signature. Serwer generuje token po logowaniu; klient wysyła go w nagłówku Authorization: Bearer <token>. ASP.NET Core weryfikuje podpis i claims automatycznie.

IHostedService to interfejs dla usług startujących razem z aplikacją. BackgroundService to klasa bazowa upraszczająca implementację long-running workerów.

public class OrderCleanupWorker(IServiceScopeFactory scopeFactory, ILogger<OrderCleanupWorker> logger)
    : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            using var scope = scopeFactory.CreateScope(); // Scoped service w Singleton!
            var repo = scope.ServiceProvider.GetRequiredService<IOrderRepository>();

            await repo.DeleteExpiredAsync();
            logger.LogInformation("Cleanup completed at {time}", DateTimeOffset.UtcNow);

            await Task.Delay(TimeSpan.FromHours(1), stoppingToken);
        }
    }
}

// Rejestracja
builder.Services.AddHostedService<OrderCleanupWorker>();

Options Pattern silnie typuje konfigurację, umożliwia walidację przy starcie i ułatwia testowanie — nie przekazujemy surowego IConfiguration w głąb kodu.

RFC 9457 (Problem Details) to standard odpowiedzi błędów API. ASP.NET Core 8 wbudował globalny exception handler zastępując middleware z try/catch.

// Program.cs (ASP.NET Core 8+)
builder.Services.AddProblemDetails();
app.UseExceptionHandler();  // globalny handler

// Własny handler
app.UseExceptionHandler(x => x.Run(async ctx =>
{
    var ex = ctx.Features.Get<IExceptionHandlerFeature>()?.Error;
    var pd = ex switch
    {
        NotFoundException e => new ProblemDetails { Status = 404, Title = e.Message },
        ValidationException e => new ProblemDetails { Status = 422, Title = "Validation failed" },
        _ => new ProblemDetails { Status = 500, Title = "Internal server error" }
    };
    ctx.Response.StatusCode = pd.Status ?? 500;
    await ctx.Response.WriteAsJsonAsync(pd);
}));

// Odpowiedź zgodna z RFC 9457:
// { "type": "...", "title": "...", "status": 404, "detail": "..." }

Minimal APIs (ASP.NET 6+) rejestrują endpointy bezpośrednio w Program.cs bez kontrolerów. Mniej boilerplate, lepsza wydajność, świetne dla microservices i małych API.

CORS (Cross-Origin Resource Sharing) — przeglądarka blokuje żądania JS do innej domeny. Serwer musi jawnie zezwolić w nagłówkach odpowiedzi. Konfiguracja zbyt restrykcyjna = błędy frontendu. Zbyt luźna = ryzyko bezpieczeństwa.

// Rejestracja polityk
builder.Services.AddCors(opt =>
{
    opt.AddPolicy("Frontend", policy =>
        policy.WithOrigins("https://app.dev-hobby.pl", "http://localhost:4200")
              .AllowAnyMethod()
              .AllowAnyHeader()
              .AllowCredentials()); // wymagane gdy używasz cookies/Authorization

    opt.AddPolicy("Public", policy =>
        policy.AllowAnyOrigin().AllowAnyMethod().AllowAnyHeader());
});

// Middleware — MUSI być przed UseRouting/MapControllers
app.UseCors("Frontend");

// Na poziomie endpointu
app.MapGet("/public", handler).RequireCors("Public");

N+1 — zamiast jednego zapytania z JOIN, wykonujemy 1 zapytanie na listę + N zapytań dla każdego elementu. Demoluje wydajność przy dużych danych.

// Problem — N+1: 1 query na Orders + 1 query PER order
var orders = await ctx.Orders.ToListAsync();
foreach (var order in orders)
    Console.WriteLine(order.Customer.Name); // lazy load → dodatkowy SELECT!

// Fix 1 — Eager Loading (Include)
var orders = await ctx.Orders
    .Include(o => o.Customer)
    .Include(o => o.Items)
    .ToListAsync(); // JEDEN SQL z JOIN

// Fix 2 — Select (projekcja) — pobierz tylko to co potrzebne
var dtos = await ctx.Orders
    .Select(o => new OrderDto(o.Id, o.Customer.Name, o.Items.Count))
    .ToListAsync();

// Fix 3 — Split query (dla złożonych Include'ów)
var orders = await ctx.Orders
    .Include(o => o.Items).ThenInclude(i => i.Product)
    .AsSplitQuery()  // osobne SQL zamiast kartezjańskiego JOIN
    .ToListAsync();

Migracje to kod C# opisujący zmiany schematu DB. Generowane automatycznie z modelu, wykonywane przez EF lub ręcznie jako skrypt SQL.

Domyślnie EF Core śledzi zmiany w załadowanych encjach (Change Tracker). AsNoTracking() wyłącza śledzenie — szybsze zapytania, mniejsze zużycie pamięci. Używaj dla read-only operacji.

DbContext nie jest thread-safe i reprezentuje Unit of Work — śledzenie zmian w ramach jednej operacji biznesowej. Scoped = jeden kontekst na żądanie HTTP.

Repository abstrakcjonizuje dostęp do danych. Ułatwia testowanie (mock repository), pozwala zmienić ORM bez dotykania logiki biznesowej. Kontrowersja: DbContext sam w sobie jest już Unit of Work + Repository pattern.

LINQ jest pierwszym wyborem. Raw SQL stosujemy gdy: LINQ generuje nieefektywny zapytanie, potrzebujemy zaawansowanych feature’ów SQL (CTE, window functions), lub optymalizacji wydajności krytycznej ścieżki.

Optimistic Locking — zakładamy brak konfliktu, sprawdzamy przy zapisie przez RowVersion/ETag. Pessimistic Locking — blokujemy rekord na czas transakcji (SELECT FOR UPDATE). EF Core wspiera optimistic przez [Timestamp].

Repository izoluje dostęp do danych. Unit of Work grupuje wiele operacji w jedną atomową transakcję — albo wszystkie się udają, albo wszystkie się cofają.

Mediator oddziela nadawców od odbiorców — żądania/zdarzenia przechodzą przez centralny bus. MediatR + CQRS to fundament Clean Architecture w .NET.

Clean Architecture (Uncle Bob) organizuje kod w koncentryczne warstwy z Dependency Rule: zależności wskazują tylko do środka. Wewnętrzne warstwy nie wiedzą o zewnętrznych.

Factory enkapsuluje logikę tworzenia obiektów. Używamy gdy: tworzenie jest złożone, musimy wybrać konkretny typ w runtime, lub chcemy ukryć szczegóły konstruktora.

Decorator owija istniejący obiekt dodając nowe zachowanie bez modyfikowania klasy. Cross-cutting concerns: caching, logowanie, retry, timing.

Result Pattern jawnie komunikuje sukces/błąd przez typ zwracany, zamiast rzucać wyjątki dla oczekiwanych scenariuszy. Wyjątki są kosztowne i utrudniają śledzenie flow.

Unit test — testuje izolowaną jednostkę kodu, zależności mockowane. Szybki, deterministyczny. Integration test — testuje współpracę komponentów (np. kod + DB). E2E — symuluje użytkownika przez cały system (Playwright, Selenium).

Stub — zwraca predefiniowane dane, nie weryfikuje wywołań. Mock — weryfikuje, że metoda została wywołana z właściwymi argumentami. Fake — działająca uproszczona implementacja (np. in-memory DB).

WebApplicationFactory<T> uruchamia in-process prawdziwy serwer ASP.NET Core — pełny pipeline middleware, DI, routing. Bez mockowania HTTP. Baza danych wymieniona na in-memory lub Testcontainers.

AAA to struktura testu: przygotuj dane → wykonaj akcję → zweryfikuj wynik. Czytelny test = dokumentacja zachowania kodu.

merge łączy gałęzie zachowując historię (merge commit). rebase przepisuje historię tak, jakby branch był stworzony z aktualnego HEAD — linearna, czysta historia.

CI (Continuous Integration) — automatyczna weryfikacja kodu przy każdym push (build + testy). CD (Continuous Delivery/Deployment) — automatyczne wdrożenie do środowisk po przejściu CI.

Code review to nie poszukiwanie błędów — to dzielenie się wiedzą i podnoszenie jakości zespołu. Dobry review patrzy na czytelność, testy, bezpieczeństwo i zgodność z architekturą.