ksiazki24h.pl
wprowadź własne kryteria wyszukiwania książek: (jak szukać?)
Twój koszyk:   0 zł   zamówienie wysyłkowe >>>
Strona główna > opis książki

C# 6.0 W PIGUŁCE


ALBAHARI J. ALBAHARI B.

wydawnictwo: HELION , rok wydania 2016, wydanie VI

cena netto: 131.39 Twoja cena  124,82 zł + 5% vat - dodaj do koszyka

C# 6.0 w pigułce


C# jest jednym z najlepszych projektów firmy Microsoft. Język ten został od podstaw zaprojektowany jako obiektowy. Charakteryzuje się niezwykłą elastycznością i wszechstronnością. Udostępnia wysokopoziomowe abstrakcje, takie jak wyrażenia, zapytania i kontynuacje asynchroniczne, a równocześnie pozwala na korzystanie z niskopoziomowych mechanizmów, jak własne typy wartościowe programisty czy opcjonalne wskaźniki. C# w wersji 6.0 jest kolejną istotną aktualizacją języka. Programista piszący w C# powinien konsekwentnie poznawać te zmiany.

Niniejsza książka jest zwięzłym kompendium wiedzy o C#, CLR oraz o związanej z C# platformie.

Napisano ją z myślą o programistach na co najmniej średnim poziomie zaawansowania. W zrozumiały, a równocześnie dogłębny sposób wyjaśniono takie trudne kwestie, jak współbieżność, bezpieczeństwo i domeny aplikacji. Informacje o nowych składnikach języka C# 6.0 i związanej z nim platformy zostały oznaczone. Szczególnie istotny z punktu widzenia programisty może okazać się rozdział o nowym kompilatorze Roslyn, zwanym kompilatorem usługowym.

Najważniejsze zagadnienia ujęte w książce:

  • składnia, typy oraz zmienne C#

  • bezpieczeństwo kodu i dyrektywy preprocesora

  • rdzenne technologie i techniki platformy .NET Framework, w tym LINQ, XML, kolekcje, kontrakty kodu, zarządzanie pamięcią, refleksja, programowanie dynamiczne

  • kompilator Roslyn, w tym jego architektura, struktura drzewa składni i model semantyczny


    Wstęp (11)

    1. Wprowadzenie do C# i .NET Framework (17)

    • Obiektowość (17)
    • Bezpieczeństwo typów (18)
    • Zarządzanie pamięcią (19)
    • Platformy (19)
    • Powiązania C# z CLR (19)
    • CLR i .NET Framework (20)
    • C# i środowisko wykonawcze systemu Windows (21)
    • Co nowego w C# 6.0 (22)
    • Co było nowego w C# 5.0 (24)
    • Co było nowego w C# 4.0 (24)
    • Co było nowego w C# 3.0 (25)

    2. Podstawy języka C# (27)

    • Pierwszy program w języku C# (27)
    • Składnia (30)
    • Podstawy typów (33)
    • Typy liczbowe (42)
    • Typ logiczny i operatory (49)
    • Łańcuchy znaków i pojedyncze znaki (51)
    • Tablice (53)
    • Zmienne i parametry (57)
    • Wyrażenia i operatory (65)
    • Operatory null (70)
    • Instrukcje (71)
    • Przestrzenie nazw (79)

    3. Tworzenie typów w języku C# (87)

    • Klasy (87)
    • Dziedziczenie (101)
    • Typ object (109)
    • Struktury (113)
    • Modyfikatory dostępu (114)
    • Interfejsy (116)
    • Wyliczenia (121)
    • Typy zagnieżdżone (124)
    • Typy generyczne (125)

    4. Zaawansowane elementy języka C# (139)

    • Delegaty (139)
    • Zdarzenia (147)
    • Wyrażenia lambda (153)
    • Metody anonimowe (157)
    • Instrukcje try i wyjątki (158)
    • Wyliczanie i iteratory (166)
    • Typy wartościowe dopuszczające wartość null (171)
    • Przeciążanie operatorów (177)
    • Metody rozszerzające (180)
    • Typy anonimowe (182)
    • Wiązanie dynamiczne (183)
    • Atrybuty (191)
    • Atrybuty informacji wywołującego (193)
    • Niebezpieczny kod i wskaźniki (194)
    • Dyrektywy preprocesora (198)
    • Dokumentacja XML (200)

    5. Ogólny zarys platformy (205)

    • CLR i rdzeń platformy (207)
    • Technologie praktyczne (212)

    6. Podstawowe wiadomości o platformie (219)

    • Obsługa łańcuchów i tekstu (219)
    • Data i godzina (232)
    • Daty i strefy czasowe (239)
    • Formatowanie i parsowanie (244)
    • Standardowe łańcuchy formatu i flagi parsowania (250)
    • Inne mechanizmy konwersji (257)
    • Globalizacja (261)
    • Praca z liczbami (262)
    • Wyliczenia (266)
    • Krotki (269)
    • Struktura Guid (271)
    • Sprawdzanie równości (271)
    • Określanie kolejności (281)
    • Klasy pomocnicze (284)

    7. Kolekcje (289)

    • Przeliczalność (289)
    • Interfejsy ICollection i IList (296)
    • Klasa Array (300)
    • Listy, kolejki, stosy i zbiory (308)
    • Słowniki (316)
    • Kolekcje i pośredniki z możliwością dostosowywania (322)
    • Dołączanie protokołów równości i porządkowania (328)

    8. Zapytania LINQ (335)

    • Podstawy (335)
    • Składnia płynna (337)
    • Wyrażenia zapytań (343)
    • Wykonywanie opóźnione (347)
    • Podzapytania (353)
    • Tworzenie zapytań złożonych (356)
    • Strategie projekcji (360)
    • Zapytania interpretowane (362)
    • LINQ to SQL i Entity Framework (368)
    • Budowanie wyrażeń zapytań (381)

    9. Operatory LINQ (387)

    • Informacje ogólne (388)
    • Filtrowanie (391)
    • Projekcja (394)
    • Łączenie (406)
    • Porządkowanie (413)
    • Grupowanie (416)
    • Operatory zbiorów (419)
    • Metody konwersji (420)
    • Operatory elementów (423)
    • Metody agregacyjne (425)
    • Kwantyfikatory (429)
    • Metody generujące (430)

    10. LINQ to XML (433)

    • Przegląd architektury (433)
    • Informacje ogólne o X-DOM (434)
    • Tworzenie drzewa X-DOM (437)
    • Nawigowanie i wysyłanie zapytań (440)
    • Modyfikowanie drzewa X-DOM (444)
    • Praca z wartościami (447)
    • Dokumenty i deklaracje (450)
    • Nazwy i przestrzenie nazw (453)
    • Adnotacje (458)
    • Projekcja do X-DOM (459)

    11. Inne technologie XML (465)

    • Klasa XmlReader (465)
    • Klasa XmlWriter (474)
    • Typowe zastosowania klas XmlReader i XmlWriter (476)
    • XSD i sprawdzanie poprawności schematów (480)
    • XSLT (483)

    12. Zwalnianie zasobów i mechanizm usuwania nieużytków (485)

    • IDisposable, Dispose i Close (485)
    • Automatyczne usuwanie nieużytków (491)
    • Finalizatory (493)
    • Jak działa mechanizm usuwania nieużytków? (498)
    • Wycieki pamięci zarządzanej (503)
    • Słabe odwołania (507)

    13. Diagnostyka i kontrakty kodu (511)

    • Kompilacja warunkowa (511)
    • Debugowanie i klasy monitorowania (515)
    • Ogólne omówienie kontraktów kodu (518)
    • Warunki początkowe (523)
    • Warunki końcowe (527)
    • Asercje i metody inwariantów obiektu (529)
    • Kontrakty w interfejsach i metodach abstrakcyjnych (531)
    • Rozwiązywanie problemów z awariami podczas użycia kontraktów (532)
    • Selektywne egzekwowanie kontraktów (534)
    • Statyczne sprawdzenie kontraktu (536)
    • Integracja z debuggerem (538)
    • Procesy i wątki procesów (539)
    • Klasy StackTrace i StackFrame (540)
    • Dziennik zdarzeń Windows (542)
    • Liczniki wydajności (544)
    • Klasa Stopwatch (549)

    14. Współbieżność i asynchroniczność (551)

    • Wprowadzenie (551)
    • Wątkowanie (552)
    • Zadania (569)
    • Reguły asynchroniczności (577)
    • Funkcje asynchroniczne w języku C# (582)
    • Wzorce asynchroniczności (598)
    • Wzorce uznane za przestarzałe (606)

    15. Strumienie i wejście-wyjście (611)

    • Architektura strumienia (611)
    • Użycie strumieni (613)
    • Adapter strumienia (626)
    • Kompresja strumienia (634)
    • Praca z plikami w postaci archiwum ZIP (636)
    • Operacje na plikach i katalogach (637)
    • Plikowe operacje wejścia-wyjścia w środowisku uruchomieniowym Windows (648)
    • Mapowanie plików w pamięci (650)
    • Odizolowany magazyn danych (653)

    16. Sieć (661)

    • Architektura sieci (661)
    • Adresy i porty (664)
    • Adresy URI (665)
    • Klasy po stronie klienta (667)
    • Praca z HTTP (680)
    • Utworzenie serwera HTTP (685)
    • Użycie FTP (688)
    • Użycie DNS (690)
    • Wysyłanie poczty elektronicznej za pomocą SmtpClient (691)
    • Użycie TCP (692)
    • Otrzymywanie poczty elektronicznej POP3 za pomocą TCP (695)
    • TCP w środowisku uruchomieniowym Windows (697)

    17. Serializacja (699)

    • Koncepcje serializacji (699)
    • Serializacja kontraktu danych (703)
    • Kontrakty danych i kolekcje (713)
    • Rozszerzenie kontraktu danych (715)
    • Serializacja binarna (718)
    • Atrybuty serializacji binarnej (720)
    • Serializacja binarna za pomocą ISerializable (724)
    • Serializacja XML (727)

    18. Podzespoły (737)

    • Co znajduje się w podzespole? (737)
    • Silne nazwy i podpisywanie podzespołu (742)
    • Nazwy podzespołów (745)
    • Technologia Authenticode (748)
    • Global Assembly Cache (751)
    • Zasoby i podzespoły satelickie (754)
    • Wyszukiwanie i wczytywanie podzespołów (762)
    • Wdrażanie podzespołów poza katalogiem bazowym (768)
    • Umieszczenie w pojedynczym pliku wykonywalnym (769)
    • Praca z podzespołami, do których nie ma odwołań (771)

    19. Refleksje i metadane (773)

    • Refleksje i aktywacja typów (774)
    • Refleksje i wywoływanie składowych (780)
    • Refleksje dla podzespołów (792)
    • Praca z atrybutami (793)
    • Generowanie dynamicznego kodu (799)
    • Emitowanie podzespołów i typów (805)
    • Emitowanie składowych typów (809)
    • Emitowanie generycznych typów i klas (814)
    • Kłopotliwe cele emisji (816)
    • Parsowanie IL (819)

    20. Programowanie dynamiczne (825)

    • Dynamiczny system wykonawczy języka (825)
    • Unifikacja typów liczbowych (827)
    • Dynamiczne wybieranie przeciążonych składowych (828)
    • Implementowanie obiektów dynamicznych (833)
    • Współpraca z językami dynamicznymi (836)

    21. Bezpieczeństwo (839)

    • Uprawnienia (839)
    • Zabezpieczenia dostępu kodu (843)
    • Dopuszczanie częściowo zaufanych wywołujących (846)
    • Model transparentności (848)
    • Ograniczanie innego zestawu (856)
    • Zabezpieczenia systemu operacyjnego (860)
    • Tożsamości i role (862)
    • Kryptografia (864)
    • Windows Data Protection (864)
    • Obliczanie skrótów (865)
    • Szyfrowanie symetryczne (867)
    • Szyfrowanie kluczem publicznym i podpisywanie (871)

    22. Zaawansowane techniki wielowątkowości (877)

    • Przegląd technik synchronizacji (878)
    • Blokowanie wykluczające (878)
    • Blokady i bezpieczeństwo ze względu na wątki (886)
    • Blokowanie bez wykluczania (892)
    • Sygnalizacja przy użyciu uchwytów zdarzeń oczekiwania (897)
    • Klasa Barrier (905)
    • Leniwa inicjalizacja (906)
    • Pamięć lokalna wątku (909)
    • Metody Interrupt i Abort (911)
    • Metody Suspend i Resume (912)
    • Zegary (913)

    23. Programowanie równoległe (917)

    • Dlaczego PFX? (917)
    • PLINQ (920)
    • Klasa Parallel (933)
    • Równoległe wykonywanie zadań (939)
    • Klasa AggregateException (948)
    • Kolekcje współbieżne (951)
    • Klasa BlockingCollection<T> (954)

    24. Domeny aplikacji (959)

    • Architektura domeny aplikacji (959)
    • Tworzenie i likwidowanie domen aplikacji (961)
    • Posługiwanie się wieloma domenami aplikacji (962)
    • Metoda DoCallBack (964)
    • Monitorowanie domen aplikacji (965)
    • Domeny i wątki (965)
    • Dzielenie danych między domenami (967)

    25. Współpraca (973)

    • Odwołania do natywnych bibliotek DLL (973)
    • Szeregowanie (974)
    • Wywołania zwrotne z kodu niezarządzanego (977)
    • Symulowanie unii C (977)
    • Pamięć współdzielona (978)
    • Mapowanie struktury na pamięć niezarządzaną (981)
    • Współpraca COM (985)
    • Wywołanie komponentu COM z C# (986)
    • Osadzanie typów współpracujących (990)
    • Główne moduły współpracujące (990)
    • Udostępnianie obiektów C# dla COM (991)

    26. Wyrażenia regularne (993)

    • Podstawy wyrażeń regularnych (994)
    • Kwantyfikatory (998)
    • Asercje o zerowej wielkości (999)
    • Grupy (1002)
    • Zastępowanie i dzielenie tekstu (1003)
    • Receptury wyrażeń regularnych (1005)
    • Leksykon języka wyrażeń regularnych (1008)

    27. Kompilator Roslyn (1013)

    • Architektura Roslyn (1014)
    • Drzewa składni (1015)
    • Kompilacja i model semantyczny (1030)

    Skorowidz (1041)


1064 stron, Format: 16.0x24.0cm, oprawa twarda

Po otrzymaniu zamówienia poinformujemy,
czy wybrany tytuł polskojęzyczny lub anglojęzyczny jest aktualnie na półce księgarni.

 
Wszelkie prawa zastrzeżone PROPRESS sp. z o.o. 2012-2022