Używamy cookies, aby ułatwić korzystanie z Portalu. Możesz określić warunki przechowywania, dostępu do plików cookies w Twojej przeglądarce. Dowiedz się więcej.
strona główna Strona główna | Nowości | Promocje | Zapowiedzi Twoje konto | Zarejestruj | Schowek | Kontakt | Pomoc
mapa działów
Szukaj: szukanie zaawansowane
Koszyk
Książki \ Programowanie \ C#

C# 7.0. Kompletny przewodnik dla praktyków. Wydanie VI Język: 1

978-83-283-5780-8

Cena Brutto: 129.00

Cena netto: 122.86

Ilość:
Wersja: Drukowana
Autor Mark Michaelis
Liczba_stron 840
Wydawnictwo Helion
Oprawa twarda
Data_Wydania 2019-11-19

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


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!

    • 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
powrót
 
Produkty Podobne
C# 7.0. Kompletny przewodnik dla praktyków. Wydanie VI
TDD z wykorzystaniem C# 7. Programowanie sterowane testam
Uczenie maszynowe w C#. Szybkie, sprytne i solidne aplikacje
C# 7 i .NET Core 2.0. Programowanie wielowątkowych i współbieżnych aplikacji
Struktury danych i algorytmy w języku C#. Projektowanie efektywnych aplikacji
Agile. Programowanie zwinne: zasady, wzorce i praktyki zwinnego wytwarzania oprogramowania w C#
Projektowanie gier przy użyciu środowiska Unity i języka C#. Od pomysłu do gotowej gry. Wydanie II
C# 7.1 i .NET Core 2.0 dla programistów aplikacji wieloplatformowych
Visual Studio 2017. Tworzenie aplikacji Windows w języku C#
Bardziej efektywny C#. 50 sposobów ulepszenia języka C#
Więcej produktów