C# jest jednym z lepiej dopracowanych języków programowania. Cechują go dojrzałość, prostota, nowoczesność i bezpieczeństwo. Został od podstaw zaprojektowany jako obiektowy. Stanowi integralną część platformy Microsoft .NET Framework. Jest ulubionym narzędziem profesjonalnych programistów, którym zależy na pisaniu kodu bezpiecznego, przejrzystego, wydajnego i prostego w konserwacji. W wersji 7.0 tego języka pojawiły się nowe usprawnienia, dzięki którym programowanie stało się jeszcze bardziej efektywne i satysfakcjonujące.

Ta książka jest szóstym, zaktualizowanym i uzupełnionym wydaniem jednego z najlepszych podręczników programowania. Poza znakomitym kompendium języka C# znalazły się tu informacje o poszczególnych metodykach programowania, od sekwencyjnego aż po podstawy programowania deklaratywnego z wykorzystaniem atrybutów. Szczegółowo przedstawiono funkcje wprowadzone do wersji 7.0 języka, a także w platformie .NET Framework 4.7/.NET Core 2.0. Książka jest też wygodnym źródłem wiedzy o pewnych rzadko stosowanych konstrukcjach składniowych, specyficznych szczegółach i subtelnościach języka C#. Jasny i przejrzysty sposób prezentowania treści pozwoli na szybkie zrozumienie nawet najbardziej zawiłych zagadnień.

W tej książce między innymi:

• przewodnik po C# oraz różne paradygmaty programowania
• interfejsy, dziedziczenie, typy bezpośrednie
• obsługa wyjątków
• delegaty, technologia LINQ i mechanizm refleksji
• zarządzanie wątkami i programowanie asynchroniczne

C#. Nowoczesny, elegancki, bezpieczny!

Osoby które kupowały "C# 7.0. Kompletny przewodnik dla praktyków. Wydanie VI", wybierały także:

• Domain-Driven Design dla .NET Core. Jak rozwiązywać złożone problemy podczas projektowania architektury aplikacji 96,45 zł, (29,90 zł -69%)
• Gray Hat C#. Język C# w kontroli i łamaniu zabezpieczeń 57,74 zł, (17,90 zł -69%)
• Platforma Xamarin. Kurs video. Poziom drugi. Zaawansowane techniki tworzenia aplikacji cross-platform 99,00 zł, (39,60 zł -60%)
• Wzorce projektowe dla programistów C#. Kurs video 99,00 zł, (39,60 zł -60%)
• WPF. Kurs video. Om 219,00 zł, (98,55 zł -55%)

Spis treści

C# 7.0. Kompletny przewodnik dla praktyków. Wydanie VI eBook -- spis treści

• Przedmowa
• Wprowadzenie
  • Dla kogo przeznaczona jest ta książka?
  • Cechy tej książki
    • Wskazówki dotyczące pisania kodu w języku C#
    • Przykładowy kod
    • Mapy myśli
    • Pomocne uwagi
  • Struktura książki
• Podziękowania
• O autorze
  • O redaktorze technicznym
• 1. Wprowadzenie do języka C#
  • Witaj, świecie
    • Tworzenie, edytowanie, kompilowanie i uruchamianie kodu źródłowego w języku C#
      • Używanie narzędzia Dotnet CLI
      • Używanie środowiska Visual Studio 2017
    • Tworzenie projektu
    • Kompilowanie i wykonywanie kodu
    • Kod źródłowy do książki C# 7.0
      • Używanie Dotnet CLI
      • Używanie Visual Studio
  • Podstawy składni języka C#
    • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
      • Słowa kluczowe
    • Słowa kluczowe języka C#
    • Identyfikatory
    • ZAGADNIENIE DLA ZAAWANSOWANYCH
      • Słowa kluczowe
    • Definicja typu
    • Metoda Main
      • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
        • Czym jest metoda
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Deklaracja metody Main
    • Instrukcje i ograniczniki instrukcji
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Instrukcje bez średników
      • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
        • Czym są odstępy?
    • Odstępy
      • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
        • Formatowanie kodu za pomocą odstępów
  • Korzystanie ze zmiennych
    • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
      • Zmienne lokalne
    • Typy danych
      • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
        • Czym jest typ danych?
    • Deklarowanie zmiennej
    • Przypisywanie wartości do zmiennej
    • Korzystanie ze zmiennej
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Wartość łańcuchów znaków jest niezmienna
  • Dane wejściowe i wyjściowe w konsoli
    • Pobieranie danych wejściowych z konsoli
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Metoda System.Console.Read()
    • Wyświetlanie danych wyjściowych w konsoli
    • Komentarze
      • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
        • XML
  • Wykonywanie kodu w środowisku zarządzanym i platforma CLI
    • Język CIL i narzędzie ILDASM
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Dane wyjściowe w języku CIL z programu HelloWorld.exe
  • Różne wersje platformy .NET
    • Interfejsy API
    • Wersje języka C# i platformy .NET
    • .NET Standard
  • Podsumowanie
• 2. Typy danych
  • Podstawowe typy liczbowe
    • Typy całkowitoliczbowe
    • Typy zmiennoprzecinkowe (float i double)
    • Typ decimal
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Analiza typów zmiennoprzecinkowych
    • Literały liczbowe
      • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
        • Zachowaj ostrożność, gdy zapisujesz wartości na sztywno
      • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
        • Notacja szesnastkowa
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Wyświetlanie liczb w formacie szesnastkowym
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Formatowanie dwustronne
  • Inne podstawowe typy
    • Typ logiczny (bool)
    • Typ znakowy (char)
      • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
        • Standard Unicode
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • 16 bitów nie wystarcza do przedstawienia wszystkich znaków Unicode
    • Łańcuchy znaków
      • Literały
      • Interpolacja łańcuchów znaków
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Wewnętrzne mechanizmy interpolacji łańcuchów znaków
      • Metody dla typu string
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Dyrektywy using i using static
      • Formatowanie łańcuchów znaków
      • Nowy wiersz
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Właściwości w języku C#
      • Długość łańcuchów znaków
      • Łańcuchy znaków są niezmienne
      • Typ System.Text.StringBuilder
  • Wartości null i void
    • Słowo kluczowe null
    • Typ void
  • Konwersje typów danych
    • Jawne rzutowanie
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Konwersje kontrolowane i niekontrolowane
      • Konwersja niejawna
    • Konwersja typów bez rzutowania
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Metoda TryParse()
  • Podsumowanie
• 3. Jeszcze o typach danych
  • Kategorie typów
    • Typy bezpośrednie
    • Typy referencyjne
  • Modyfikator umożliwiający stosowanie wartości null
    • Zmienne lokalne z niejawnie określanym typem danych
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Typy anonimowe
  • Krotki
    • ZAGADNIENIE DLA ZAAWANSOWANYCH
      • Typ System.ValueTuple<>
  • Tablice
    • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
      • Tablice
    • Deklarowanie tablicy
    • Tworzenie instancji tablic i przypisywanie do nich wartości
    • Korzystanie z tablicy
      • Długość
      • Inne metody dla tablic
      • Metody instancyjne tablicy
    • Łańcuchy znaków jako tablice
    • Typowe błędy związane z tablicami
  • Podsumowanie
• Operatory i przepływ sterowania
  • Operatory
    • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
      • Operatory
    • Operatory jednoargumentowe plus (+) i minus ()
    • Arytmetyczne operatory dwuargumentowe (+, , *, /, %)
      • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
        • Nawiasy, łączność, priorytety i określanie wartości
      • Używanie operatora dodawania dla łańcuchów znaków
      • Używanie znaków w operacjach arytmetycznych
      • Wyjątkowe cechy typów zmiennoprzecinkowych
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Nieoczekiwane nierówności wartości typów zmiennoprzecinkowych
    • Złożone operatory przypisania (+=, =, *=, /=, %=)
    • Operatory inkrementacji i dekrementacji (++, )
      • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
        • Przykładowa dekrementacja w pętli
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Inkrementacja i dekrementacja bezpieczna ze względu na wątki
    • Wyrażenia o stałej wartości i stałe lokalne
  • Zarządzanie przepływem sterowania
    • Instrukcja if
    • Zagnieżdżone instrukcje if
  • Bloki kodu ({})
  • Bloki kodu, zasięgi i przestrzenie deklaracji
  • Wyrażenia logiczne
    • Operatory relacyjne i równości
    • Operatory logiczne
      • Operator OR (||)
      • Operator AND (&&)
      • Operator XOR (^)
    • Logiczny operator negacji (!)
    • Operator warunkowy (?:)
    • Operator ??
    • Operator ?.
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Stosowanie operatora ?. razem z delegatami
  • Operatory bitowe (<<, >>, |, &, ^, ~)
    • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
      • Bity i bajty
    • Operatory przesunięcia (<<, >>, <<=, >>=)
    • Operatory bitowe (&, |, ^)
      • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
        • Objaśnienie operatorów logicznych
    • Bitowe złożone operatory przypisania (&=, |=, ^=)
    • Bitowy operator dopełnienia (~)
  • Instrukcje związane z przepływem sterowania ciąg dalszy
    • Pętle while i do/while
      • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
        • Kiedy należy stosować pętlę while?
    • Pętla for
    • Pętla foreach
      • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
        • W jakich sytuacjach sensowne jest stosowanie instrukcji switch?
    • Podstawowa postać instrukcji switch
  • Instrukcje skoku
    • Instrukcja break
      • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
        • Sprawdzanie pozycji za pomocą operatorów bitowych
    • Instrukcja continue
    • Instrukcja goto
  • Dyrektywy preprocesora języka C#
    • Wykluczanie i dołączanie kodu (#if, #elif, #else, #endif)
    • Definiowanie symboli preprocesora (#define, #undef)
    • Generowanie błędów i ostrzeżeń (#error, #warning)
    • Wyłączanie komunikatów z ostrzeżeniami (#pragma)
    • Opcja nowarn:<lista ostrzeżeń>
    • Określanie numerów wierszy (#line)
    • Wskazówki dla edytorów kodu z interfejsem graficznym (#region, #endregion)
  • Podsumowanie
• 5. Metody i parametry
  • Wywoływanie metody
    • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
      • Czym jest metoda?
    • Przestrzenie nazw
    • Nazwa typu
    • Zasięg
    • Nazwa metody
    • Parametry i argumenty
    • Wartości zwracane przez metody
    • Instrukcje a wywołania metod
  • Deklarowanie metody
    • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
      • Refaktoryzacja kodu przez umieszczanie go w metodach
    • Deklarowanie parametrów formalnych
    • Deklaracja typu wartości zwracanej przez metodę
    • Metody z ciałem w postaci wyrażenia
      • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
        • Przestrzenie nazw
  • Dyrektywa using
    • ZAGADNIENIE DLA ZAAWANSOWANYCH
      • Zagnieżdżone dyrektywy using
    • Dyrektywa using static
    • Tworzenie aliasów
  • Zwracane wartości i parametry metody Main()
    • ZAGADNIENIE DLA ZAAWANSOWANYCH
      • Odróżnianie od siebie różnych metod Main()
    • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
      • Stos wywołań i miejsce wywołania
  • Zaawansowane parametry metod
    • Parametry przekazywane przez wartość
      • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
        • Dopasowywanie zmiennych z jednostki wywołującej do nazw parametrów
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Typy referencyjne a typy bezpośrednie
    • Parametry przekazywane przez referencję (z modyfikatorem ref)
    • Parametry wyjściowe (z modyfikatorem out)
    • Przekazywanie przez referencję w trybie tylko do odczytu (in)
    • Zwracanie przez referencję
    • Tablice parametrów (params)
  • Rekurencja
    • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
      • Błąd nieskończonej rekurencji
  • Przeciążanie metod
  • Parametry opcjonalne
    • ZAGADNIENIE DLA ZAAWANSOWANYCH
      • Określanie wywoływanej metody
  • Podstawowa obsługa błędów z wykorzystaniem wyjątków
    • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
      • Wartość 42 jako łańcuch znaków i jako liczba całkowita
    • Przechwytywanie błędów
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Dziedziczenie klas wyjątków
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Ogólny blok catch
    • Zgłaszanie błędów za pomocą instrukcji throw
      • Unikaj stosowania obsługi wyjątków do radzenia sobie z oczekiwanymi sytuacjami
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Przekształcanie liczb za pomocą instrukcji TryParse()
  • Podsumowanie
• 6. Klasy
  • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
    • Programowanie obiektowe
    • Hermetyzacja
    • Dziedziczenie
    • Polimorfizm
  • Deklarowanie klasy i tworzenie jej instancji
    • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
      • Czym są obiekty, a czym klasy?
    • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
      • Hermetyzacja, część 1. Obiekty łączą dane z metodami
  • Pola instancji
    • Deklarowanie pola instancji
    • Dostęp do pól instancji
  • Metody instancji
  • Stosowanie słowa kluczowego this
    • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
      • Wykorzystywanie stylu programowania do unikania wieloznaczności
    • Zapisywanie i wczytywanie plików
  • Modyfikatory dostępu
    • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
      • Hermetyzacja, część 2. Ukrywanie informacji
  • Właściwości
    • Deklarowanie właściwości
    • Automatycznie implementowane wartości
    • Wskazówki dotyczące właściwości i pól
    • Używanie właściwości ze sprawdzaniem poprawności
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Operator nameof
    • Właściwości przeznaczone tylko do odczytu i tylko do zapisu
    • Właściwości jako pola wirtualne
    • Modyfikatory dostępu w getterach i setterach
    • Właściwości i wywołania metod nie są dozwolone jako wartości parametrów ref i out
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Wewnętrzne mechanizmy właściwości
  • Konstruktory
    • Deklarowanie konstruktora
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Szczegóły implementacji operatora new
    • Konstruktory domyślne
    • Inicjatory obiektów
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Inicjatory kolekcji
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Finalizatory
    • Przeciążanie konstruktorów
    • Łączenie konstruktorów w łańcuch wywoływanie innego konstruktora za pomocą słowa kluczowego this
      • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
        • Centralizowanie inicjowania
    • Dekonstruktory
  • Składowe statyczne
    • Pola statyczne
      • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
        • Dane można powiązać zarówno z klasą, jak i z obiektami
    • Metody statyczne
    • Konstruktory statyczne
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Preferuj statyczną inicjację w deklaracji
    • Właściwości statyczne
    • Klasy statyczne
  • Metody rozszerzające
  • Hermetyzacja danych
    • Modyfikator const
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Stałe publiczne powinny być niezmiennymi wartościami
    • Modyfikator readonly
  • Klasy zagnieżdżone
  • Klasy częściowe
    • Definiowanie klasy częściowej
    • Metody częściowe
  • Podsumowanie
• Dziedziczenie
  • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
    • Definicje z obszaru dziedziczenia
  • Tworzenie klas pochodnych
    • Rzutowanie między typami bazowymi i pochodnymi
      • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
        • Rzutowanie w łańcuchu dziedziczenia
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Definiowanie niestandardowych konwersji
    • Modyfikator dostępu private
    • Modyfikator dostępu protected
    • Metody rozszerzające
    • Dziedziczenie po jednym typie
    • Klasy zamknięte
  • Przesłanianie składowych z klas bazowych
    • Modyfikator virtual
    • Modyfikator new
    • Modyfikator sealed
    • Składowa base
    • Konstruktory
  • Klasy abstrakcyjne
    • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
      • Klasy abstrakcyjne
    • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
      • Polimorfizm
  • Wszystkie klasy są pochodne od System.Object
  • Sprawdzanie typu za pomocą operatora is
  • Dopasowanie do wzorca z użyciem operatora is
  • Dopasowanie do wzorca w instrukcji switch
  • Konwersja z wykorzystaniem operatora as
  • Podsumowanie
• 8. Interfejsy
  • Wprowadzenie do interfejsów
    • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
      • Po co stosować interfejsy?
  • Polimorfizm oparty na interfejsach
  • Implementacja interfejsu
    • Składowe z jawnie podawanym interfejsem
    • Składowe bez jawnie podawanego interfejsu
    • Porównanie implementacji z jawnie podawanym interfejsem i bez podawania interfejsu
  • Przekształcanie między klasą z implementacją i interfejsami
  • Dziedziczenie interfejsów
  • Dziedziczenie po wielu interfejsach
  • Metody rozszerzające i interfejsy
  • Implementowanie wielodziedziczenia za pomocą interfejsów
    • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
      • Diagramy interfejsów
  • Zarządzanie wersjami
  • Interfejsy a klasy
  • Interfejsy a atrybuty
  • Podsumowanie
• 9. Typy bezpośrednie
  • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
    • Kategorie typów
    • Typy bezpośrednie
    • Typy referencyjne
  • Struktury
    • Inicjowanie struktur
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Używanie operatora new do typów bezpośrednich
    • Używanie operatora default
    • Dziedziczenie i interfejsy a typy bezpośrednie
  • Opakowywanie
    • ZAGADNIENIE DLA ZAAWANSOWANYCH
      • Typy bezpośrednie w instrukcji lock
    • ZAGADNIENIE DLA ZAAWANSOWANYCH
      • Jak uniknąć opakowywania w wywołaniach metod?
  • Wyliczenia
    • Zgodność typów wyliczeniowych
    • Konwersja między wyliczeniami a łańcuchami znaków
    • Wyliczenia jako flagi
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Atrybut FlagsAttribute
  • Podsumowanie
• 10. Dobrze uformowane typy
  • Przesłanianie składowych z klasy object
    • Przesłanianie metody ToString()
    • Przesłanianie metody GetHashCode()
    • Przesłanianie metody Equals()
      • Tożsamość obiektów a równe wartości obiektów
      • Implementowanie metody Equals()
    • Przeciążanie funkcji GetHashCode() i Equals() z użyciem krotek
  • Przeciążanie operatorów
    • Operatory porównania (==, !=, <, >, <=, >=)
    • Operatory dwuargumentowe (+, , *, /, %, &, |, ^, <<, >>)
    • Łączenie przypisania z operatorami dwuargumentowymi (+=, =, *=, /=, %=, &=, )
    • Logiczne operatory warunkowe (&&, ||)
    • Operatory jednoargumentowe (+, , !, ~, ++, , true, false)
    • Operatory konwersji
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Operator rzutowania ()
    • Wytyczne dotyczące operatorów konwersji
  • Wskazywanie innych podzespołów
    • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
      • Biblioteki klas
    • Wskazywanie biblioteki
    • Wskazywanie projektu lub biblioteki w Dotnet CLI
    • Wskazywanie projektu lub biblioteki w Visual Studio 2017
    • Pakiety NuGet
    • Referencje do pakietów NuGet w Dotnet CLI
    • Dodawanie referencji do pakietów NuGet w Visual Studio 2017
    • Wywoływanie pakietu NuGet
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Hermetyzacja typów
        • Modyfikatory dostępu public i internal w deklaracjach typów
      • Modyfikator protected internal dla składowych w typach
      • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
        • Modyfikatory dostępu dla składowych w typach
  • Definiowanie przestrzeni nazw
  • Komentarze XML-owe
    • Wiązanie komentarzy XML-owych z konstrukcjami programistycznymi
    • Generowanie pliku z dokumentacją w formacie XML
  • Odzyskiwanie pamięci
    • ZAGADNIENIE DLA ZAAWANSOWANYCH
      • Odzyskiwanie pamięci w platformie .NET
    • Słabe referencje
  • Porządkowanie zasobów
    • Finalizatory
    • Deterministyczna finalizacja z wykorzystaniem instrukcji using
    • Odzyskiwanie pamięci, finalizacja i interfejs IDisposable
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Przekazywanie wyjątków z konstruktorów
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Ponowne tworzenie usuwanych obiektów
  • Leniwe inicjowanie
    • ZAGADNIENIE DLA ZAAWANSOWANYCH
      • Leniwe inicjowanie za pomocą typów generycznych i wyrażeń lambda
  • Podsumowanie
• 11. Obsługa wyjątków
  • Wiele typów wyjątków
  • Przechwytywanie wyjątków
    • Ponowne zgłaszanie przetwarzanego wyjątku
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Zgłaszanie istniejącego już wyjątku bez zastępowania informacji na stosie
  • Ogólny blok catch
    • ZAGADNIENIE DLA ZAAWANSOWANYCH
      • Ogólne bloki catch w języku C# 1.0
    • ZAGADNIENIE DLA ZAAWANSOWANYCH
      • Wewnętrzne mechanizmy pustego bloku catch
  • Wskazówki związane z obsługą wyjątków
  • Definiowanie niestandardowych wyjątków
    • ZAGADNIENIE DLA ZAAWANSOWANYCH
      • Wyjątki z obsługą serializacji
  • Ponowne zgłaszanie opakowanego wyjątku
    • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
      • Konwersje z kontrolą i bez kontroli
  • Podsumowanie
• 12. Typy generyczne
  • Język C# bez typów generycznych
    • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
      • Inny przykład typy bezpośrednie z możliwą wartością null
  • Wprowadzenie do typów generycznych
    • Używanie klasy generycznej
    • Definiowanie prostej klasy generycznej
    • Zalety typów generycznych
    • Wskazówki związane z tworzeniem nazw parametrów określających typy
    • Generyczne interfejsy i struktury
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Wielokrotne implementowanie jednego interfejsu w tej samej klasie
    • Definiowanie konstruktora i finalizatora
    • Określanie wartości domyślnej
    • Wiele parametrów określających typ
      • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
        • Krotki typy o różnej arności
    • Zagnieżdżone typy generyczne
  • Ograniczenia
    • Ograniczenia dotyczące interfejsu
    • Ograniczenia dotyczące klasy
    • Ograniczenia wymagające struktury lub klasy (struct i class)
    • Zestawy ograniczeń
    • Ograniczenia dotyczące konstruktora
    • Ograniczenia dotyczące dziedziczenia
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Wymogi związane z ograniczeniami
        • Ograniczenia dotyczące operatorów są niedozwolone
        • Relacja LUB między ograniczeniami nie jest obsługiwana
        • Ograniczenia dotyczące delegatów i wyliczeń są niedozwolone
        • W ograniczeniu dotyczącym konstruktora można podawać tylko konstruktory domyślne
  • Metody generyczne
    • Inferencja typów w metodach generycznych
    • Dodawanie ograniczeń
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Rzutowanie w metodach generycznych
  • Kowariancja i kontrawariancja
    • Umożliwianie kowariancji za pomocą modyfikatora out stosowanego do parametru określającego typ (od wersji C# 4.0)
    • Umożliwianie kontrawariancji z użyciem modyfikatora in dla parametru określającego typ (od wersji C# 4.0)
    • Obsługa niezabezpieczonej kowariancji w tablicach
  • Wewnętrzne mechanizmy typów generycznych
    • ZAGADNIENIE DLA ZAAWANSOWANYCH
      • Reprezentacja typów generycznych w kodzie CIL
    • ZAGADNIENIE DLA ZAAWANSOWANYCH
      • Tworzenie obiektów typów generycznych opartych na typach bezpośrednich
    • ZAGADNIENIE DLA ZAAWANSOWANYCH
      • Tworzenie obiektów typów generycznych opartych na typach referencyjnych
  • Podsumowanie
• 13. Delegaty i wyrażenia lambda
  • Wprowadzenie do delegatów
    • Opis scenariusza
    • Typ danych w postaci delegata
  • Deklarowanie typu delegata
    • Typy delegatów do ogólnego użytku System.Func i System.Action
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Deklarowanie typu delegata
    • Tworzenie instancji delegata
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Tworzenie instancji delegatów w wersji C# 1.0
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Wewnętrzne mechanizmy delegatów
  • Wyrażenia lambda
    • Lambdy w postaci instrukcji
    • Lambdy w postaci wyrażeń
  • Metody anonimowe
    • ZAGADNIENIE DLA ZAAWANSOWANYCH
      • Bezparametrowe metody anonimowe
    • ZAGADNIENIE DLA ZAAWANSOWANYCH
      • Skąd się wzięła nazwa lambda?
    • Delegaty nie zapewniają równości strukturalnej
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Wewnętrzne mechanizmy wyrażeń lambda i metod anonimowych
    • Zmienne zewnętrzne
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Implementacja zmiennych zewnętrznych w kodzie CIL
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Przypadkowe przechwytywanie zmiennych z pętli
    • Drzewo wyrażeń
      • Używanie wyrażeń lambda jako danych
      • Drzewa wyrażeń są grafami obiektów
      • Delegaty a drzewa wyrażeń
      • Badanie drzewa wyrażeń
  • Podsumowanie
• 14. Zdarzenia
  • Implementacja wzorca publikuj-subskrybuj za pomocą delegatów typu multicast
    • Definiowanie metod subskrybujących
    • Definiowanie klasy publikującej zdarzenia
    • Łączenie subskrybentów z nadawcą
    • Wywoływanie delegata
    • Sprawdzanie, czy wartość jest różna od null
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Operator = delegatów zwraca nową instancję
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Wywoływanie delegata z zachowaniem bezpieczeństwa ze względu na wątki
    • Operatory używane do delegatów
    • Wywołania sekwencyjne
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Wewnętrzne mechanizmy delegatów typu multicast
    • Obsługa błędów
    • Wartości zwracane przez metodę i przekazywanie danych przez referencję
  • Zdarzenia
    • Po co stosować zdarzenia?
      • Hermetyzacja subskrypcji
      • Hermetyzacja procesu publikacji
    • Deklarowanie zdarzeń
    • Konwencje programistyczne
    • Typy generyczne a delegaty
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Wewnętrzne mechanizmy zdarzeń
    • Modyfikowanie implementacji zdarzeń
  • Podsumowanie
• 15. Interfejsy kolekcji ze standardowymi operatorami kwerend
  • Inicjatory kolekcji
  • Interfejs IEnumerable<T> sprawia, że klasa staje się kolekcją
    • Instrukcja foreach dla tablic
    • Instrukcja foreach dla interfejsu IEnumerable<T>
      • Współdzielony stan
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Porządkowanie zasobów po iteracji
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Pętla foreach bez interfejsu IEnumerable
    • Nie modyfikuj kolekcji w trakcie iterowania z wykorzystaniem pętli foreach
  • Standardowe operatory kwerend
    • Filtrowanie danych za pomocą metody Where()
    • Projekcje z wykorzystaniem metody Select()
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Równoległe wykonywanie kwerend w technologii LINQ
    • Zliczanie elementów za pomocą metody Count()
    • Opóźnione wykonanie
    • Sortowanie z wykorzystaniem metod OrderBy() i ThenBy()
      • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
        • Złączanie
    • Przeprowadzanie złączania wewnętrznego za pomocą instrukcji Join()
    • Grupowanie wyników za pomocą metody GroupBy()
    • Implementowanie relacji jeden do wielu za pomocą metody GroupJoin()
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Implementowanie złączeń zewnętrznych za pomocą metody GroupJoin()
    • Wywoływanie metody SelectMany()
    • Inne standardowe operatory kwerend
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Klasa Queryable z metodami rozszerzającymi interfejs IQueryable<T>
  • Typy anonimowe w technologii LINQ
    • Typy anonimowe
      • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
        • Zmienne lokalne o niejawnie określanym typie (zmienne var)
    • Pobieranie danych do zmiennych typu anonimowego za pomocą technologii LINQ
    • Więcej o typach anonimowych i zmiennych lokalnych o niejawnie określanym typie
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Generowanie typów anonimowych
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Inicjatory kolekcji a typy anonimowe
  • Podsumowanie
• 16. Technologia LINQ i wyrażenia z kwerendami
  • Wprowadzenie do wyrażeń z kwerendami
    • Projekcja
      • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
        • Opóźnione wykonywanie wyrażeń z kwerendą
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Implementacja opóźnionego wykonywania
    • Filtrowanie
    • Sortowanie
    • Klauzula let
    • Grupowanie
    • Kontynuowanie kwerendy za pomocą klauzuli into
    • Spłaszczanie sekwencji składających się z sekwencji za pomocą kilku klauzul from
      • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
        • Niepowtarzalne elementy
  • Wyrażenia z kwerendą to tylko wywołania metod
  • Podsumowanie
• 17. Tworzenie niestandardowych kolekcji
  • Inne interfejsy implementowane w kolekcjach
    • Porównanie interfejsów IList<T> i IDictionary<TKey, TValue>
    • Interfejs ICollection<T>
  • Podstawowe klasy kolekcji
    • Kolekcje w postaci list List<T>
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Modyfikowanie procesu sortowania kolekcji
    • Porządkowanie całkowite
    • Przeszukiwanie kolekcji typu List<T>
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Wyszukiwanie wielu elementów za pomocą metody FindAll()
    • Kolekcje w postaci słownika Dictionary<TKey, TValue>
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Modyfikowanie sprawdzania równości w słowniku
      • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
        • Wymogi związane ze sprawdzaniem równości
    • Kolekcje posortowane SortedDictionary<TKey, TValue> i SortedList<T>
    • Kolekcje w postaci stosu Stack<T>
    • Kolekcje w postaci kolejek Queue<T>
    • Listy powiązane LinkedList<T>
  • Udostępnianie indeksera
    • ZAGADNIENIE DLA ZAAWANSOWANYCH
      • Określanie nazwy indeksera za pomocą atrybutu IndexerName
    • ZAGADNIENIE DLA ZAAWANSOWANYCH
      • Definiowanie operatora indeksowania przyjmującego różną liczbę parametrów
  • Zwracanie wartości null lub pustej kolekcji
  • Iteratory
    • ZAGADNIENIE DLA ZAAWANSOWANYCH
      • Początki iteratorów
    • Definiowanie iteratora
    • Składnia iteratora
    • Zwracanie wartości przez iterator
    • Iteratory i stan
    • Inne przykładowe iteratory
    • Umieszczanie instrukcji yield return w pętli
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Zagrożenia związane z iteratorami rekurencyjnymi
      • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
        • Struktury a klasy
    • Anulowanie dalszych iteracji za pomocą instrukcji yield break
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Jak działają iteratory
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Kontekstowe słowa kluczowe
    • Tworzenie wielu identyfikatorów w jednej klasie
    • Wymagania związane z instrukcją yield
  • Podsumowanie
• 18. Refleksja, atrybuty i programowanie dynamiczne
  • Mechanizm refleksji
    • Dostęp do metadanych za pomocą obiektu typu System.Type
      • Metoda GetType()
      • Operator typeof()
    • Wywoływanie składowych
    • Refleksja dotycząca typów generycznych
      • Ustalanie typów podanych w parametrach określających typ
      • Określanie, czy klasa lub metoda ma parametry generyczne
      • Pobieranie parametrów określających typ z klas lub metod generycznych
  • Operator nameof
  • Atrybuty
    • Niestandardowe atrybuty
    • Wyszukiwanie atrybutów
    • Inicjowanie atrybutu za pomocą konstruktora
    • Atrybut System.AttributeUsageAttribute
    • Parametry nazwane
      • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
        • Atrybut FlagsAttribute
      • Predefiniowane atrybuty
      • Atrybut System.ConditionalAttribute
      • Atrybut System.ObsoleteAttribute
      • Atrybuty związane z serializacją
      • Atrybut System.NonSerializable
        • Udostępnianie niestandardowej serializacji
        • Zarządzanie wersjami w trakcie serializacji
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Atrybut System.SerializableAttribute i kod CIL
  • Programowanie z wykorzystaniem obiektów dynamicznych
    • Korzystanie z refleksji za pomocą instrukcji dynamic
    • Zasady i operacje związane z typem dynamic
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Omówienie typu dynamic
    • Po co stosować wiązanie dynamiczne?
    • Statyczna kompilacja a programowanie dynamiczne
    • Tworzenie niestandardowych obiektów dynamicznych
  • Podsumowanie
• 19. Wielowątkowość
  • Podstawy wielowątkowości
    • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
      • Słownictwo związane z wielowątkowością
    • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
      • Co, jak i dlaczego w dziedzinie wielowątkowości
    • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
      • Uwagi dotyczące wydajności
    • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
      • Problemy z wątkami
        • Większość operacji nie jest atomowa
        • Niepewność spowodowana sytuacją wyścigu
        • Modele zarządzania pamięcią są skomplikowane
        • Blokady mogą skutkować zakleszczeniem
  • Używanie klasy System.Threading
    • Wykonywanie operacji asynchronicznych za pomocą klasy System.Threading.Thread
    • Zarządzanie wątkami
    • Nie usypiaj wątków w kodzie produkcyjnym
    • Nie usuwaj wątków w kodzie produkcyjnym
    • Pule wątków
  • Zadania asynchroniczne
    • Od wątków do zadań
    • Wprowadzenie do asynchronicznych zadań
    • Kontynuacja zadania
    • Używanie wyjątków AggregateException do obsługi nieobsłużonych wyjątków w zadaniach
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Radzenie sobie z nieobsłużonymi wyjątkami w wątku
  • Anulowanie zadania
    • Task.Run() skrócona i uproszczona wersja wywołania Task.Factory.StartNew()
    • Długotrwałe zadania
    • Zadania pozwalają zwalniać zasoby
  • Wzorzec obsługi asynchroniczności za pomocą zadań
    • Synchroniczne wywoływanie operacji o dużej latencji
    • Asynchroniczne wywoływanie operacji o dużej latencji za pomocą biblioteki TPL
    • Asynchroniczność oparta na zadaniach oraz instrukcjach async i await
    • Zwracanie wartości w metodach asynchronicznych
    • Dodanie możliwości zwracania typu ValueTask<T> w metodach asynchronicznych
    • Zwracanie wartości void w metodach asynchronicznych
    • Asynchroniczne lambdy i funkcje lokalne
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Tworzenie niestandardowej metody asynchronicznej
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Oczekiwanie na wartości inne niż obiekt typu Task<T>
    • Programy szeregujące zadania i kontekst synchronizacji
    • Modyfikatory async i await w programach z interfejsem użytkownika z systemu Windows
    • Operatory await
  • Równoległe wykonywanie iteracji pętli
    • ZAGADNIENIE DLA ZAAWANSOWANYCH
      • W jaki sposób biblioteka TPL dostraja wydajność
    • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
      • Używanie typu AggregateException do obsługi wyjątków w pętlach równoległych
    • Anulowanie wykonywania pętli równoległej
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Opcje pętli równoległych
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Wychodzenie z pętli równoległej
  • Równoległe wykonywanie kwerend LINQ
    • Anulowanie kwerendy PLINQ
  • Podsumowanie
• 20. Synchronizowanie wątków
  • Po co stosować synchronizację?
    • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
      • Wiele wątków i zmienne lokalne
    • Synchronizacja z wykorzystaniem klasy Monitor
    • Stosowanie słowa kluczowego lock
      • ZAGADNIENIE DLA POCZĄTKUJĄCYCH
        • Zwracanie obiektu typu Task bez operatora await
    • Wybieranie obiektu reprezentującego blokadę
    • Dlaczego należy unikać blokad opartych na słowie kluczowym this, wyrażeniu typeof(typ) lub typie string?
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Unikaj synchronizacji z wykorzystaniem atrybutu MethodImplAttribute
    • Deklarowanie pól jako zmiennych (volatile)
    • Stosowanie klasy System.Threading.Interlocked
    • Powiadomienia o zdarzeniach kierowane do wielu wątków
    • Najlepsze praktyki z obszaru projektowania synchronizacji
      • Unikanie zakleszczenia
      • Kiedy należy zapewniać synchronizację?
      • Unikanie zbędnych blokad
    • Inne typy związane z synchronizacją
      • Korzystanie z klasy System.Threading.Mutex
      • Klasa WaitHandle
      • Zdarzenia resetujące ManualResetEvent i ManualResetEventSlim
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Przedkładaj typ ManualResetEvent i semafory nad typ AutoResetEvent
      • Typy Semaphore, SemaphoreSlim i CountdownEvent
      • Klasy kolekcji przetwarzanych równolegle
    • Pamięć lokalna wątków
      • ThreadLocal<T>
      • Pamięć lokalna wątku tworzona za pomocą atrybutu ThreadStaticAttribute
  • Zegary
    • ZAGADNIENIE DLA ZAAWANSOWANYCH
      • Kontrolowanie modelu wątkowego w technologii COM za pomocą atrybutu STAThreadAttribute
  • Podsumowanie
• 21. Współdziałanie między platformami i niezabezpieczony kod
  • Mechanizm P/Invoke
    • Deklarowanie funkcji zewnętrznych
    • Typy danych parametrów
    • Stosowanie parametrów ref zamiast wskaźników
    • Używanie atrybutu StructLayoutAttribute do zapewniania układu sekwencyjnego
    • Obsługa błędów
    • Używanie typu SafeHandle
    • Wywoływanie funkcji zewnętrznych
    • Upraszczanie wywołań interfejsów API za pomocą nakładek
    • Odwzorowywanie wskaźników do funkcji na delegaty
    • Wskazówki
  • Wskaźniki i adresy
    • Kod niezabezpieczony
    • Deklarowanie wskaźników
    • Przypisywanie wartości do wskaźników
      • Zapewnianie stałej lokalizacji danych
      • Alokowanie danych na stosie
    • Dereferencja wskaźników
    • Dostęp do składowych typu docelowego
  • Wykonywanie niezabezpieczonego kodu za pomocą delegata
  • Podsumowanie
• 22. Standard CLI
  • Definiowanie standardu CLI
  • Implementacje standardu CLI
    • Microsoft .NET Framework
    • .NET Core
    • Xamarin
  • Specyfikacja .NET Standard
  • Biblioteka BCL
  • Kompilacja kodu w języku C# na kod maszynowy
  • Środowisko uruchomieniowe
    • Odzyskiwanie pamięci
    • Odzyskiwanie pamięci w platformie .NET
    • Bezpieczeństwo ze względu na typ
      • ZAGADNIENIE DLA ZAAWANSOWANYCH
        • Omijanie hermetyzacji i modyfikatorów dostępu
    • Przenośność między platformami
    • Wydajność
  • Podzespoły, manifesty i moduły
  • Język Common Intermediate Language
  • Common Type System
  • Common Language Specification
  • Metadane
  • Architektura .NET Native i kompilacja AOT
  • Podsumowanie