księgarnia informatyczna aton.pl

C# 5.0. Programowanie Tworzenie aplikacji Windows 8, internetowych oraz biurowych w .NET 4.5 Framework

Wydawnictwo HELION

Cena:    129.00zł

C# 5.0. Programowanie Tworzenie aplikacji Windows 8, internetowych oraz biurowych w .NET 4.5 Framework


Autor: Ian Griffiths
ISBN: 978-83-246-6984-4
Ilość stron: 840
Data wydania: 08/2013
Format: 168x237
Wydawnictwo: HELION


Najlepszy podręcznik poświęcony C#!

W dzisiejszych czasach szczególną popularnością cieszą się języki programowania pozwalające na pisanie kodu łatwego do przenoszenia między platformami. Nikt nie ma czasu na pisanie kilku wersji jednej aplikacji. C# to uniwersalny język, w którym bez trudu dokonasz tego dzieła. Dzięki swej elastyczności, wydajności oraz mocnemu wsparciu społeczności zdobył on uznanie programistów. Taki wybór to strzał w dziesiątkę!

Ten rewelacyjny podręcznik jest Twoim kluczem do poznania wszystkich niuansów języka C# 5.0. Kolejne wydanie zostało zaktualizowane o wszystkie nowości w C#. Znajdziesz tu kompletny opis języka i platformy .NET. W trakcie lektury oprócz standardowych zagadnień będziesz mógł sprawdzić, jak tworzyć aplikacje dla systemu Windows 8 i interfejsu Metro. Ponadto błyskawicznie opanujesz detale związane z programowaniem obiektowym, dynamicznym i statycznym określaniem typów oraz językiem XAML. Książka ta jest uznanym kompendium wiedzy na temat języka C#. Musisz ją mieć!

Dzięki tej książce:

  • przygotujesz interfejs użytkownika zgodny z duchem Windows 8
  • wykorzystasz wielowątkowość w platformie .NET
  • poznasz podstawy programowania obiektowego
  • przekonasz się, jak LINQ może ułatwić Ci życie
  • opanujesz język C#

Wykorzystaj potencjał języka C#.

Spis treści:

1. Prezentacja C# (21)

  • Dlaczego C#? (21)
  • Dlaczego nie C#? (23)
  • Najważniejsze cechy C# (25)
    • Kod zarządzany i CLR (27)
    • Ogólność jest ważniejsza od specjalizacji (29)
    • Programowanie asynchroniczne (30)
  • Visual Studio (31)
  • Anatomia prostego programu (33)
    • Dodawanie projektów do istniejącej solucji (35)
    • Odwołania do innych projektów (35)
    • Pisanie testu jednostkowego (37)
    • Przestrzenie nazw (40)
    • Klasy (44)
    • Punkt wejścia do programu (44)
    • Testy jednostkowe (45)
  • Podsumowanie (47)

2. Podstawy stosowania języka C# (49)

  • Zmienne lokalne (50)
    • Zakres (55)
  • Instrukcje i wyrażenia (58)
    • Instrukcje (59)
    • Wyrażenia (60)
  • Komentarze i białe znaki (65)
  • Dyrektywy preprocesora (67)
    • Symbole kompilacji (67)
    • Dyrektywy #error oraz #warning (68)
    • Dyrektywa #line (69)
    • Dyrektywa #pragma (69)
    • Dyrektywy #region i #endregion (70)
  • Wbudowane typy danych (70)
    • Typy liczbowe (71)
    • Wartości logiczne (80)
    • Znaki i łańcuchy znaków (80)
    • Object (81)
  • Operatory (81)
  • Sterowanie przepływem (87)
    • Decyzje logiczne przy użyciu instrukcji if (87)
    • Wielokrotny wybór przy użyciu instrukcji switch (89)
    • Pętle: while oraz do (91)
    • Pętle znane z języka C (92)
    • Przeglądanie kolekcji przy użyciu pętli foreach (93)
  • Podsumowanie (94)

3. Typy (95)

  • Klasy (95)
    • Składowe statyczne (98)
    • Klasy statyczne (100)
    • Typy referencyjne (101)
  • Struktury (106)
    • Kiedy tworzyć typy wartościowe? (110)
  • Składowe (115)
    • Pola (115)
    • Konstruktory (117)
    • Metody (125)
    • Właściwości (130)
    • Indeksatory (134)
    • Operatory (135)
    • Zdarzenia (138)
    • Typy zagnieżdżone (138)
  • Interfejsy (140)
  • Typy wyliczeniowe (141)
  • Inne typy (144)
    • Typy anonimowe (145)
  • Typy i metody częściowe (146)
  • Podsumowanie (147)

4. Typy ogólne (149)

  • Typy ogólne (150)
  • Ograniczenia (152)
    • Ograniczenia typu (153)
    • Ograniczenia typu referencyjnego (155)
    • Ograniczenia typu wartościowego (157)
    • Stosowanie wielu ograniczeń (158)
  • Wartości przypominające zero (158)
  • Metody ogólne (160)
    • Wnioskowanie typu (160)
  • Tajniki typów ogólnych (161)
  • Podsumowanie (163)

5. Kolekcje (165)

  • Tablice (165)
    • Inicjalizacja tablic (168)
    • Użycie słowa kluczowego params do przekazywania zmiennej liczby argumentów (169)
    • Przeszukiwanie i sortowanie (171)
    • Tablice wielowymiarowe (178)
    • Kopiowanie i zmiana wielkości (181)
  • List (182)
  • Interfejsy list i sekwencji (185)
  • Implementacja list i sekwencji (189)
    • Iteratory (190)
    • Klasa Collection (194)
    • Klasa ReadOnlyCollection (195)
  • Słowniki (196)
    • Słowniki posortowane (198)
  • Zbiory (200)
  • Kolejki i stosy (201)
  • Listy połączone (202)
  • Kolekcje współbieżne (203)
  • Krotki (204)
  • Podsumowanie (205)

6. Dziedziczenie (207)

  • Dziedziczenie i konwersje (208)
  • Dziedziczenie interfejsów (210)
  • Typy ogólne (211)
    • Kowariancja i kontrawariancja (212)
  • System.Object (217)
    • Wszechobecne metody typu object (217)
  • Dostępność i dziedziczenie (218)
  • Metody wirtualne (220)
    • Metody abstrakcyjne (222)
  • Metody i klasy ostateczne (228)
  • Dostęp do składowych klas bazowych (229)
  • Dziedziczenie i tworzenie obiektów (230)
  • Specjalne typy bazowe (234)
  • Podsumowanie (235)

7. Cykl życia obiektów (237)

  • Mechanizm odzyskiwania pamięci (238)
    • Określanie osiągalności danych (239)
    • Przypadkowe problemy mechanizmu odzyskiwania pamięci (242)
    • Słabe referencje (244)
    • Odzyskiwanie pamięci (248)
    • Tryby odzyskiwania pamięci (254)
    • Przypadkowe utrudnianie scalania (256)
    • Wymuszanie odzyskiwania pamięci (260)
  • Destruktory i finalizacja (261)
    • Finalizatory krytyczne (264)
  • Interfejs IDisposable (265)
    • Zwalnianie opcjonalne (271)
  • Pakowanie (272)
    • Pakowanie danych typu Nullable (276)
  • Podsumowanie (277)

8. Wyjątki (279)

  • Źródła wyjątków (281)
    • Wyjątki zgłaszane przez API (282)
    • Wyjątki w naszym kodzie (284)
    • Błędy wykrywane przez środowisko uruchomieniowe (284)
  • Obsługa wyjątków (285)
    • Obiekty wyjątków (286)
    • Wiele bloków catch (287)
    • Zagnieżdżone bloki try (289)
    • Bloki finally (290)
  • Zgłaszanie wyjątków (292)
    • Powtórne zgłaszanie wyjątków (292)
    • Sposób na szybkie zakończenie aplikacji (295)
  • Typy wyjątków (296)
    • Wyjątki niestandardowe (298)
  • Wyjątki nieobsługiwane (301)
    • Debugowanie i wyjątki (303)
  • Wyjątki asynchroniczne (305)
  • Podsumowanie (308)

9. Delegaty, wyrażenia lambda i zdarzenia (309)

  • Typy delegatów (310)
    • Tworzenie delegatów (311)
    • MulticastDelegate - delegaty zbiorowe (314)
    • Wywoływanie delegatów (316)
    • Popularne typy delegatów (318)
    • Zgodność typów (319)
    • Więcej niż składnia (323)
  • Metody inline (326)
    • Przechwytywane zmienne (328)
    • Wyrażenia lambda oraz drzewa wyrażeń (335)
  • Zdarzenia (336)
    • Standardowy wzorzec delegatów zdarzeń (338)
    • Niestandardowe metody dodające i usuwające zdarzenia (339)
    • Zdarzenia i mechanizm odzyskiwania pamięci (342)
    • Zdarzenia a delegaty (344)
  • Delegaty a interfejsy (345)
  • Podsumowanie (345)

10. LINQ (347)

  • Wyrażenia zapytań (348)
    • Jak są rozwijane wyrażenia zapytań (351)
    • Obsługa wyrażeń zapytań (353)
  • Przetwarzanie opóźnione (357)
  • LINQ, typy ogólne oraz interfejs IQueryable (359)
  • Standardowe operatory LINQ (361)
    • Filtrowanie (364)
    • Selekcja (366)
    • Operator SelectMany (369)
    • Określanie porządku (371)
    • Testy zawierania (373)
    • Konkretne elementy i podzakresy (375)
    • Agregacja (379)
    • Operacje na zbiorach (384)
    • Operatory działające na całych sekwencjach z zachowaniem kolejności (384)
    • Grupowanie (386)
    • Złączenia (390)
    • Konwersje (392)
  • Generowanie sekwencji (396)
  • Inne implementacje LINQ (397)
    • Entity Framework (397)
    • LINQ to SQL (398)
    • Klient WCF Data Services (398)
    • Parallel LINQ (PLINQ) (399)
    • LINQ to XML (399)
    • Reactive Extensions (399)
  • Podsumowanie (400)

11. Reactive Extensions (401)

  • Rx oraz różne wersje .NET Framework (403)
  • Podstawowe interfejsy (405)
    • Interfejs IObserver (406)
    • Interfejs IObservable (407)
  • Publikowanie i subskrypcja z wykorzystaniem delegatów (413)
    • Tworzenie źródła przy wykorzystaniu delegatów (413)
    • Subskrybowanie obserwowalnych źródeł przy użyciu delegatów (417)
  • Generator sekwencji (418)
    • Empty (418)
    • Never (418)
    • Return (419)
    • Throw (419)
    • Range (419)
    • Repeat (419)
    • Generate (420)
  • Zapytania LINQ (421)
    • Operatory grupowania (423)
    • Operatory Join (424)
    • Operator SelectMany (429)
    • Agregacja oraz inne operatory zwracające jedną wartość (430)
    • Operator Concat (431)
  • Operatory biblioteki Rx (431)
    • Merge (432)
    • Operatory Buffer i Window (433)
    • Operator Scan (440)
    • Operator Amb (441)
    • DistinctUntilChanged (442)
  • Mechanizmy szeregujące (442)
    • Określanie mechanizmów szeregujących (443)
    • Wbudowane mechanizmy szeregujące (445)
  • Tematy (447)
    • Subject (447)
    • BehaviorSubject (448)
    • ReplaySubject (449)
    • AsyncSubject (449)
  • Dostosowanie (450)
    • IEnumerable (450)
    • Zdarzenia .NET (452)
    • API asynchroniczne (454)
  • Operacje z uzależnieniami czasowymi (456)
    • Interval (456)
    • Timer (457)
    • Timestamp (458)
    • TimeInterval (459)
    • Throttle (459)
    • Sample (460)
    • Timeout (460)
    • Operatory okien czasowych (460)
    • Delay (461)
    • DelaySubscription (461)
  • Podsumowanie (462)

12. Podzespoły (463)

  • Visual Studio i podzespoły (463)
  • Anatomia podzespołu (464)
    • Metadane .NET (465)
    • Zasoby (465)
    • Podzespoły składające się z wielu plików (466)
    • Inne możliwości formatu PE (467)
  • Tożsamość typu (468)
  • Wczytywanie podzespołów (471)
    • Jawne wczytywanie podzespołów (473)
    • Global Assembly Cache (474)
  • Nazwy podzespołów (476)
    • Silne nazwy (476)
    • Numer wersji (480)
    • Identyfikator kulturowy (484)
    • Architektura procesora (487)
  • Przenośne biblioteki klas (488)
  • Wdrażanie pakietów (490)
    • Aplikacje dla systemu Windows 8 (490)
    • ClickOnce oraz XBAP (491)
    • Aplikacje Silverlight oraz Windows Phone (492)
  • Zabezpieczenia (493)
  • Podsumowanie (494)

13. Odzwierciedlanie (495)

  • Typy odzwierciedlania (495)
    • Assembly (498)
    • Module (502)
    • MemberInfo (503)
    • Type oraz TypeInfo (506)
    • MethodBase, ConstructorInfo oraz MethodInfo (510)
    • ParameterInfo (512)
    • FieldInfo (513)
    • PropertyInfo (513)
    • EventInfo (514)
  • Konteksty odzwierciedlania (514)
  • Podsumowanie (516)

14. Dynamiczne określanie typów (517)

  • Typ dynamic (519)
  • Słowo kluczowe dynamic i mechanizmy współdziałania (521)
    • Silverlight i obiekty skryptowe (524)
    • Dynamiczne języki .NET (525)
  • Tajniki typu dynamic (526)
    • Ograniczenia typu dynamic (526)
    • Niestandardowe obiekty dynamiczne (528)
    • Klasa ExpandoObject (531)
  • Ograniczenia typu dynamic (531)
  • Podsumowanie (534)

15. Atrybuty (535)

  • Stosowanie atrybutów (535)
    • Cele atrybutów (537)
    • Atrybuty obsługiwane przez kompilator (539)
    • Atrybuty obsługiwane przez CLR (543)
  • Definiowanie i stosowanie atrybutów niestandardowych (551)
    • Typ atrybutu (551)
    • Pobieranie atrybutów (553)
  • Podsumowanie (556)

16. Pliki i strumienie (557)

  • Klasa Stream (558)
    • Położenie i poruszanie się w strumieniu (560)
    • Opróżnianie strumienia (561)
    • Kopiowanie (562)
    • Length (562)
    • Zwalnianie strumieni (564)
    • Operacje asynchroniczne (565)
    • Konkretne typy strumieni (565)
  • Windows 8 oraz interfejs IRandomAccessStream (566)
  • Typy operujące na tekstach (569)
    • TextReader oraz TextWriter (570)
    • Konkretne typy do odczytu i zapisu łańcuchów znaków (572)
    • Kodowanie (574)
  • Pliki i katalogi (578)
    • Klasa FileStream (578)
    • Klasa File (581)
    • Klasa Directory (585)
    • Klasa Path (586)
    • Klasy FileInfo, DirectoryInfo oraz FileSystemInfo (588)
    • Znane katalogi (589)
  • Serializacja (590)
    • Klasy BinaryReader oraz BinaryWriter (590)
    • Serializacja CLR (591)
    • Serializacja kontraktu danych (594)
    • Klasa XmlSerializer (597)
  • Podsumowanie (598)

17. Wielowątkowość (599)

  • Wątki (599)
    • Wątki, zmienne i wspólny stan (601)
    • Klasa Thread (607)
    • Pula wątków (609)
    • Powinowactwo do wątku oraz klasa SynchronizationContext (614)
  • Synchronizacja (618)
    • Monitory oraz słowo kluczowe lock (619)
    • Klasa SpinLock (625)
    • Blokady odczytu i zapisu (627)
    • Obiekty zdarzeń (628)
    • Klasa Barrier (631)
    • Klasa CountdownEvent (632)
    • Semafory (632)
    • Muteksy (633)
    • Klasa Interlocked (634)
    • Leniwa inicjalizacja (637)
    • Pozostałe klasy obsługujące działania współbieżne (639)
  • Zadania (640)
    • Klasy Task oraz Task (640)
    • Kontynuacje (643)
    • Mechanizmy szeregujące (645)
    • Obsługa błędów (647)
    • Niestandardowe zadania bezwątkowe (648)
    • Związki zadanie nadrzędne - zadanie podrzędne (649)
    • Zadania złożone (650)
  • Inne wzorce asynchroniczne (651)
  • Anulowanie (652)
  • Równoległość (653)
    • Klasa Parallel (653)
    • Parallel LINQ (654)
    • TPL Dataflow (654)
  • Podsumowanie (655)

18. Asynchroniczne cechy języka (657)

  • Nowe słowa kluczowe: async oraz await (658)
    • Konteksty wykonania i synchronizacji (662)
    • Wykonywanie wielu operacji i pętli (663)
    • Zwracanie obiektu Task (666)
    • Stosowanie async w metodach zagnieżdżonych (667)
  • Wzorzec słowa kluczowego await (668)
  • Obsługa błędów (672)
    • Weryfikacja poprawności argumentów (674)
    • Wyjątki pojedyncze oraz grupy wyjątków (675)
    • Operacje równoległe i nieobsłużone wyjątki (677)
  • Podsumowanie (678)

19. XAML (681)

  • Platformy XAML (682)
    • WPF (683)
    • Silverlight (684)
    • Windows Phone 7 (686)
    • Windows Runtime oraz aplikacje dostosowane do interfejsu użytkownika Windows 8 (687)
  • Podstawy XAML (688)
    • Przestrzenie nazw XAML oraz XML (689)
    • Generowane klasy i kod ukryty (690)
    • Elementy podrzędne (692)
    • Elementy właściwości (692)
    • Obsługa zdarzeń (694)
    • Wykorzystanie wątków (695)
  • Układ (696)
    • Właściwości (696)
    • Panele (702)
    • ScrollViewer (712)
    • Zdarzenia związane z układem (712)
  • Kontrolki (713)
    • Kontrolki z zawartością (714)
    • Kontrolki Slider oraz ScrollBar (717)
    • Kontrolki postępów (718)
    • Listy (719)
    • Szablony kontrolek (721)
    • Kontrolki użytkownika (724)
  • Tekst (725)
    • Wyświetlanie tekstów (725)
    • Edycja tekstów (727)
  • Wiązanie danych (729)
    • Szablony danych (732)
  • Grafika (735)
    • Kształty (735)
    • Bitmapy (736)
    • Media (737)
  • Style (738)
  • Podsumowanie (739)

20. ASP.NET (741)

  • Razor (742)
    • Wyrażenia (743)
    • Sterowanie przepływem (745)
    • Bloki kodu (746)
    • Jawne wskazywanie treści (747)
    • Klasy i obiekty stron (748)
    • Stosowanie innych komponentów (749)
    • Strony układu (749)
    • Strony początkowe (751)
  • Web Forms (752)
    • Kontrolki serwerowe (752)
    • Wyrażenia (758)
    • Bloki kodu (758)
    • Standardowe obiekty stron (759)
    • Klasy i obiekty stron (759)
    • Stosowanie innych komponentów (760)
    • Strony nadrzędne (760)
  • MVC (762)
    • Typowy układ projektu MVC (763)
    • Pisanie modeli (769)
    • Pisanie widoków (771)
    • Pisanie kontrolerów (772)
    • Obsługa dodatkowych danych wejściowych (774)
    • Generowanie łączy do akcji (776)
  • Trasowanie (777)
  • Podsumowanie (781)

21. Współdziałanie (783)

  • Wywoływanie kodu rodzimego (783)
    • Szeregowanie (784)
    • Procesy 32- i 64-bitowe (792)
    • Bezpieczne uchwyty (793)
    • Bezpieczeństwo (794)
  • Mechanizm Platform Invoke (795)
    • Konwencje wywołań (796)
    • Obsługa łańcuchów znaków (797)
    • Nazwa punktu wejścia (797)
    • Wartości wynikowe technologii COM (798)
    • Obsługa błędów Win32 (802)
  • Technologia COM (802)
    • Czas życia obiektów RCW (803)
    • Metadane (805)
    • Skrypty (811)
  • Windows Runtime (814)
    • Metadane (815)
    • Typy Windows Runtime (815)
    • Bufory (816)
  • Niebezpieczny kod (818)
  • C++/CLI i Component Extensions (819)
  • Podsumowanie (820)
Cena:    129.00zł


C# 5.0. Programowanie Tworzenie aplikacji Windows 8, internetowych oraz biurowych w .NET 4.5 FrameworkKsiążka informatyczna: C# 5.0. Programowanie Tworzenie aplikacji Windows 8, internetowych oraz biurowych w .NET 4.5 Framework
Księgarnia informatyczna aton.pl

Tutaj możesz kupić tę książkę w dobrej cenie. Zapraszamy na zakupy do naszej księgarni internetowej.