reklama - zainteresowany?

C# 7.0. Kompletny przewodnik dla praktyków. Wydanie VI - Helion


ebook
Autor: Mark Michaelis
Tytuł oryginału: Essential C# 7.0 (6th Edition)
Tłumaczenie: Tomasz Walczak
ISBN: 978-83-283-5781-5
stron: 961, Format: ebook
Data wydania: 2019-08-01
Księgarnia: Helion

Cena książki: 103,20 zł (poprzednio: 129,00 zł)
Oszczędzasz: 20% (-25,80 zł)

Dodaj do koszyka

Tagi: C# - Programowanie

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!

Dodaj do koszyka

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

Dodaj do koszyka

Code, Publish & WebDesing by CATALIST.com.pl



(c) 2005-2020 CATALIST agencja interaktywna, znaki firmowe należą do wydawnictwa Helion S.A.