Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

Opanuj C# — Zaawansowany

Projektuj modele danych i przetwarzaj je w pamięci w C#. Korzystaj z rekordów, widoków Span, potoków asynchronicznych i kanałów; kontroluj zasoby, formatowanie oraz serializację JSON.

PODSUMOWANIE KURSUGOTOWE
Lekcje: 58
Quizy: 10
Wszystkie etapy: 68
$Gotowy do rozpoczęcia
Baza wiedzy tej technologii

Czego się nauczysz

  • Dobierać rekordy, klasy i struktury zgodnie z równością danych, kontrolować zmiany przez readonly, init i with oraz opisywać kontrakty nullowalności.
  • Przetwarzać tekst i kolekcje przez Span, ReadOnlySpan, LINQ i dopasowanie wzorców, ograniczać zbędne kopie oraz rozróżniać umowne liczniki od pomiarów wydajności.
  • Budować potoki async i kanały z kontrolą anulowania i domknięcia, zarządzać zasobami oraz oddzielać konfigurację, logikę domeny i prezentację wyników.
  • Tworzyć własne konwertery JSON, egzekwować format identyfikatorów, sprawdzać zakres obiegu zapis–odczyt i przygotowywać powtarzalne raporty niezależne od ustawień kultury.

Program kursu

Przechodź program krok po kroku. Ukończone etapy są oznaczone, a kolejny dostępny etap możesz otworzyć.

58 lekcji10 quizów68 kroków łącznie
  1. 01LEKCJA
    LEKCJA 1: Przegląd nowoczesnego C# (C# 9–12): co i po coDostępne
  2. 02LEKCJA
    LEKCJA 2: Records (zaawansowane): pozycje, dziedziczenie, with, required, równośćZablokowane
  3. 03LEKCJA
    LEKCJA 3: Zaawansowane dopasowanie do wzorca: wzorce relacyjne, logiczne i pozycyjne oraz strażnik whenZablokowane
  4. 04LEKCJA
    LEKCJA 4: switch expression — idiomy i eliminacja if/elseZablokowane
  5. 05LEKCJA
    LEKCJA 5: Obliczenia generyczne w C#: INumber<T> i operatoryZablokowane
  6. 06LEKCJA
    LEKCJA 6: Statyczne składowe abstrakcyjne w interfejsach (C# 11+)Zablokowane
  7. 01QUIZ
    Quiz 1: zastosowanie wiedzy z lekcji 1–6Zablokowane
  8. 07LEKCJA
    LEKCJA 7: Domyślne metody w interfejsach — ewolucja APIZablokowane
  9. 08LEKCJA
    LEKCJA 8: Semantyka wartości: readonly struct, ref struct, scopedZablokowane
  10. 09LEKCJA
    LEKCJA 9: Span<T> i ReadOnlySpan<T> — przetwarzanie bez alokacjiZablokowane
  11. 10LEKCJA
    LEKCJA 10: Memory<T> i właściciele pamięci (IMemoryOwner<T>)Zablokowane
  12. 11LEKCJA
    LEKCJA 11: stackalloc i buforowanie na stosie (bez unsafe)Zablokowane
  13. 12LEKCJA
    LEKCJA 12: Minimalizacja alokacji i kopii — praktyczne technikiZablokowane
  14. 02QUIZ
    Quiz 2: zastosowanie wiedzy z lekcji 7–12Zablokowane
  15. 13LEKCJA
    LEKCJA 13: ArrayPool<T> i pule obiektów — zarządzanie pamięciąZablokowane
  16. 14LEKCJA
    LEKCJA 14: ValueTask i asynchroniczność o niskim narzucieZablokowane
  17. 15LEKCJA
    LEKCJA 15: IAsyncEnumerable<T> — strumienie asynchroniczne i przetwarzanie potokoweZablokowane
  18. 16LEKCJA
    LEKCJA 16: Kanały (System.Threading.Channels) — kolejki producent-konsumentZablokowane
  19. 17LEKCJA
    LEKCJA 17: Synchronizacja: lock, Monitor i sekcje krytyczneZablokowane
  20. 18LEKCJA
    LEKCJA 18: Operacje atomowe: Interlocked i wzorce bezpiecznych licznikówZablokowane
  21. 03QUIZ
    Quiz 3: zastosowanie wiedzy z lekcji 13–18Zablokowane
  22. 19LEKCJA
    LEKCJA 19: Kolekcje współbieżne: ConcurrentDictionary, ConcurrentQueue, ConcurrentBagZablokowane
  23. 20LEKCJA
    LEKCJA 20: Kolekcje niezmienne (Immutable*) — bezpieczeństwo współbieżne przez designZablokowane
  24. 21LEKCJA
    LEKCJA 21: Zaawansowane anulowanie i timeouts — kompozycja tokenówZablokowane
  25. 22LEKCJA
    LEKCJA 22: Obsługa wyjątków (advanced): filtry wyjątków, rethrow, polityki błędówZablokowane
  26. 23LEKCJA
    LEKCJA 23: Refleksja (reflection) — inspekcja typów i metadanychZablokowane
  27. 24LEKCJA
    LEKCJA 24: Atrybuty — projektowanie własnych atrybutów i walidacjiZablokowane
  28. 04QUIZ
    Quiz 4: zastosowanie wiedzy z lekcji 19–24Zablokowane
  29. 25LEKCJA
    LEKCJA 25: Drzewa wyrażeń (Expression<TDelegate>) — generowanie logiki podczas działania programuZablokowane
  30. 26LEKCJA
    LEKCJA 26: dynamic i DLR — gdzie ma sens, gdzie unikaćZablokowane
  31. 27LEKCJA
    LEKCJA 27: Iterator pattern (advanced): niestandardowe enumeratory wydajne pamięciowoZablokowane
  32. 28LEKCJA
    LEKCJA 28: Projektowanie równości i porównywania pod wydajność (sort, hash)Zablokowane
  33. 29LEKCJA
    LEKCJA 29: LINQ (advanced): operatory niestandardowe i przepływy potokoweZablokowane
  34. 30LEKCJA
    LEKCJA 30: LINQ a wydajność: unikanie pułapek alokacji i wielokrotnej enumeracjiZablokowane
  35. 05QUIZ
    Quiz 5: zastosowanie wiedzy z lekcji 25–30Zablokowane
  36. 31LEKCJA
    LEKCJA 31: Projektowanie API: kontrakty, IDisposable, IAsyncDisposableZablokowane
  37. 32LEKCJA
    LEKCJA 32: using i deterministyczne zwalnianie zasobów bez I/OZablokowane
  38. 33LEKCJA
    LEKCJA 33: Formatowanie zaawansowane: IFormatProvider, niestandardowe formatyZablokowane
  39. 34LEKCJA
    LEKCJA 34: Globalizacja i kultura — testowalne formatowanie w pamięciZablokowane
  40. 35LEKCJA
    LEKCJA 35: Modele czasu: wstrzykiwany zegar (IClock) i testowalnośćZablokowane
  41. 36LEKCJA
    LEKCJA 36: Modelowanie domeny: wartości niezmienne, typy rzeczowe (Value Objects)Zablokowane
  42. 06QUIZ
    Quiz 6: zastosowanie wiedzy z lekcji 31–36Zablokowane
  43. 37LEKCJA
    LEKCJA 37: Bezpieczne typowo identyfikatory jako readonly record structZablokowane
  44. 38LEKCJA
    LEKCJA 38: Mapowanie danych bez bibliotek: ręczne projekcje i adapteryZablokowane
  45. 39LEKCJA
    LEKCJA 39: Serializacja w pamięci (System.Text.Json): opcje i konwertery własneZablokowane
  46. 40LEKCJA
    LEKCJA 40: Deserializacja bezpieczna — walidacja i kontraktyZablokowane
  47. 41LEKCJA
    LEKCJA 41: Projektowanie błędów bez wyjątków: Result<T> i warianty OneOf-likeZablokowane
  48. 42LEKCJA
    LEKCJA 42: FSM (finite state machine) z pattern matchingiemZablokowane
  49. 07QUIZ
    Quiz 7: zastosowanie wiedzy z lekcji 37–42Zablokowane
  50. 43LEKCJA
    LEKCJA 43: Modułowość i granice: interfejsy, rekordy, wydarzenia domenoweZablokowane
  51. 44LEKCJA
    LEKCJA 44: DI (advanced): composition root i konfiguracja modułówZablokowane
  52. 45LEKCJA
    LEKCJA 45: Wydajne potoki: łączenie LINQ + Channels + IAsyncEnumerableZablokowane
  53. 46LEKCJA
    LEKCJA 46: Równoległość z kontrolą presji: back-pressure na kanałachZablokowane
  54. 47LEKCJA
    LEKCJA 47: Analiza kosztów: alokacje vs kopie vs blokady — decyzje projektoweZablokowane
  55. 48LEKCJA
    LEKCJA 48: Projektowanie API pod testowalność i deterministyczne scenariuszeZablokowane
  56. 08QUIZ
    Quiz 8: zastosowanie wiedzy z lekcji 43–48Zablokowane
  57. 49LEKCJA
    LEKCJA 49: Potoki, filtrowanie, mapowanie i częściowa aplikacja funkcjiZablokowane
  58. 50LEKCJA
    LEKCJA 50: Przeciążanie operatorów — obliczenia pieniężne i rekordyZablokowane
  59. 51LEKCJA
    LEKCJA 51: Index i Range w wydajnych wycinkach danychZablokowane
  60. 52LEKCJA
    LEKCJA 52: readonly i init — spójność i niezmienność w modeluZablokowane
  61. 53LEKCJA
    LEKCJA 53: Nullability (advanced): adnotacje, kontrakty, analiza przepływuZablokowane
  62. 09QUIZ
    Quiz 9: zastosowanie wiedzy z lekcji 49–53Zablokowane
  63. 54LEKCJA
    LEKCJA 54: Records vs classes — wybór pod semantykę i wydajnośćZablokowane
  64. 55LEKCJA
    LEKCJA 55: Projekt: szybkie przetwarzanie tekstu na Span<T>/ReadOnlySpan<T>Zablokowane
  65. 56LEKCJA
    LEKCJA 56: Projekt: potok zdarzeń na Channels z anulowaniemZablokowane
  66. 57LEKCJA
    LEKCJA 57: Projekt: mini-DSL z records + pattern matchingZablokowane
  67. 58LEKCJA
    LEKCJA 58: Serializacja w pamięci z własnym JsonConverterZablokowane
  68. 10QUIZ
    Quiz 10: zastosowanie wiedzy z lekcji 54–58Zablokowane
  69. +EGZAMIN
    Potwierdź swoje umiejętności egzaminemPrzygotowanie w tym kursie jest dobrowolne. Egzamin certyfikacyjny dla tego języka i poziomu możesz wybrać bez ukończenia kursu i quizów. Sprawdź dostęp konta i potwierdź autoryzację egzaminu.Inny stan