księgarnia informatyczna aton.pl

C# Programowanie Wydanie VI

Wydawnictwo HELION

Cena:    129.00   91.59zł

C# Programowanie Wydanie VI


Autor: Ian Griffiths, Matthew Adams, Jesse Liberty

ISBN: 978-83-246-3701-0

Ilość stron: 840

Data wydania: 07/2012 (wydanie 6)

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, ponieważ nikt nie ma czasu na pisanie kilku wersji jednej aplikacji. C# to uniwersalny język, który bez trudu spełnia ten wymóg. Dzięki swej elastyczności, wydajności oraz mocnemu wsparciu społeczności zdobył on uznanie programistów. Jego wybór to strzał w dziesiątkę!

Ten bestsellerowy podręcznik pozwoli Ci błyskawicznie poznać wszystkie niuanse języka C# 4.0. Najnowsze wydanie zostało zaktualizowane o nowości w C# oraz zawiera opis tego języka i platformy .NET. W trakcie lektury nauczysz się tworzyć skomplikowane programy przy użyciu technik programowania obiektowego i funkcjonalnego. Ponadto sprawdzisz, jaki potencjał kryje język zapytań LINQ oraz jak przesyłać komunikaty za pomocą Windows Communication Foundation (WCF). Dodatkowo poznasz możliwości C# w zakresie tworzenia aplikacji internetowych w technologii Silverlight. Nauka C# jeszcze nigdy nie była tak przyjemna!

  • Pisz złożone programy z użyciem technik programowania obiektowego oraz funkcjonalnego
  • Przetwarzaj duże kolekcje danych dzięki wbudowanym w język zapytaniom LINQ
  • Komunikuj się przez sieć za pomocą Windows Communication Foundation (WCF)
  • Poznaj zalety technik programowania dynamicznego, dostępnych w C# 4.0
  • Twórz interaktywne aplikacje Windows z Windows Presentation Foundation (WPF)
  • Twórz bogate aplikacje internetowe z wykorzystaniem możliwości Silverlight oraz ASP.NET

Wykorzystaj potencjał języka C#.

Rozdziały:

1. Prezentacja C# (19)

  • Dlaczego C#? Dlaczego .NET? (19)
  • Biblioteka klas platformy .NET (20)
  • Styl języka (21)
    • Łatwość konstruowania oprogramowania (22)
    • Kod zarządzany (23)
    • Ciągłość i "ekosystem" Windows (24)
  • C# 4.0, .NET 4.0 oraz Visual Studio 2010 (25)
  • Podsumowanie (27)

2. Podstawowe techniki programowania (29)

  • Początki (29)
  • Przestrzenie nazw i typy (32)
  • Projekty i solucje (37)
  • Komentarze, regiony oraz czytelność (42)
    • Nieprawidłowe komentarze (43)
    • Komentarze dokumentujące XML (44)
  • Zmienne (45)
    • Typy zmiennych (46)
  • Wyrażenia i instrukcje (52)
    • Instrukcje przypisania (55)
    • Operatory inkrementacji i dekrementacji (55)
  • Instrukcje sterowania przepływem i wyboru (56)
    • Instrukcje if (58)
    • Instrukcje switch oraz case (62)
  • Instrukcje iteracji (64)
    • Instrukcje foreach (65)
    • Instrukcje for (67)
    • Instrukcje while oraz do (69)
    • Przerywanie wykonywania pętli (70)
  • Metody (71)
  • Podsumowanie (74)

3. Wyodrębnianie idei przy wykorzystaniu klas i struktur (77)

  • Dziel i rządź (77)
    • Wyodrębnianie idei w formie metod (77)
    • Wyodrębnianie idei przy użyciu obiektów i klas (80)
  • Definiowanie klas (81)
    • Reprezentowanie stanu przy użyciu właściwości (82)
    • Poziomy ochrony (84)
    • Inicjalizacja przy użyciu konstruktora (86)
    • Pola: miejsca do zapisywania danych (90)
    • Pola mogą się zmieniać, lecz stałe nie (92)
    • Pola i właściwości tylko do odczytu (93)
  • Typ enum - powiązane ze sobą stałe (96)
  • Typy wartościowe i referencyjne (100)
  • Zbyt wiele konstruktorów, Panie Mozart (105)
  • Przeciążanie (105)
    • Metody przeciążone oraz domyślne parametry nazwane (106)
  • Inicjalizatory obiektów (108)
  • Definiowanie metod (112)
    • Deklarowanie metod statycznych (115)
  • Pola i właściwości statyczne (116)
    • Konstruktory statyczne (117)
  • Podsumowanie (119)

4. Rozszerzalność i polimorfizm (121)

  • Tworzenie asocjacji poprzez kompozycję i agregację (122)
  • Dziedziczenie i polimorfizm (124)
  • Zastępowanie metod w klasach pochodnych (126)
    • Ukrywanie składowych klasy bazowej przy użyciu new (127)
    • Zastępowanie metod przy użyciu modyfikatorów virtual i override (129)
  • Dziedziczenie i ochrona (132)
  • Wywoływanie metod klasy bazowej (134)
  • Dotąd i ani kroku dalej: modyfikator sealed (136)
  • Wymuszanie przesłaniania - metody abstrakcyjne (138)
  • Wszystkie typy dziedziczą po klasie Object (144)
    • Pakowanie i rozpakowywanie typów wartościowych (144)
  • C# nie obsługuje wielokrotnego dziedziczenia implementacji (149)
  • C# obsługuje wielokrotne dziedziczenie interfejsów (149)
  • Tworzenie jednych interfejsów na bazie innych (152)
    • Jawna implementacja interfejsów (153)
  • Ostateczne rozwiązanie: sprawdzanie typów podczas wykonywania programu (157)
  • Podsumowanie (158)

5. Delegacje - łatwość komponowania i rozszerzalność (159)

  • Kompozycja funkcyjna wykorzystująca delegacje (166)
  • Typ Action - akcje ogólne (172)
  • Predicate - predykaty ogólne (175)
  • Stosowanie metod anonimowych (177)
  • Tworzenie delegacji przy użyciu wyrażeń lambda (178)
  • Delegacje we właściwościach (180)
  • Ogólne delegacje do funkcji (182)
  • Informowanie klientów za pomocą zdarzeń (186)
    • Udostępnianie dużej liczby zdarzeń (194)
  • Podsumowanie (197)

6. Obsługa błędów (199)

  • Kiedy i jak uznać niepowodzenie (204)
  • Zwracanie kodu błędu (207)
    • Debugowanie wartości zwracanych (213)
  • Wyjątki (214)
    • Obsługa wyjątków (219)
    • Kiedy są wykonywane bloki finally? (226)
    • Określanie, jakie wyjątki będą przechwytywane (227)
    • Wyjątki niestandardowe (230)
  • Podsumowanie (232)

7. Tablice i listy (233)

  • Tablice (233)
    • Tworzenie i inicjalizacja (234)
    • Własne typy w tablicach (237)
    • Składowe tablic (242)
    • Wielkość tablic (247)
  • List (254)
    • Niestandardowe indeksatory (257)
    • Wyszukiwanie i sortowanie (264)
  • Kolekcje i polimorfizm (264)
    • Tworzenie własnych implementacji IEnumerable (268)
  • Podsumowanie (274)

8. LINQ (275)

  • Wyrażenia zapytań (275)
    • Wyrażenia zapytań a wywołania metod (277)
    • Metody rozszerzeń a LINQ (278)
    • Klauzule let (280)
  • Koncepcje i techniki LINQ (281)
    • Delegacje i wyrażenia lambda (281)
    • Styl funkcyjny i kompozycja (283)
    • Wykonywanie opóźnione (284)
  • Operatory LINQ (285)
    • Filtrowanie (285)
    • Porządkowanie (286)
    • Konkatenacja (289)
    • Grupowanie (289)
    • Projekcje (291)
    • Spinanie (298)
    • Robimy się wybredni (299)
    • Testowanie całej kolekcji (300)
    • Agregacja (302)
    • Operacje na zbiorach (304)
    • Łączenie (304)
    • Konwersje (305)
  • Podsumowanie (306)

9. Klasy kolekcji (307)

  • Słowniki (307)
    • Popularne zastosowania słowników (309)
    • IDictionary (315)
    • Słowniki i LINQ (317)
  • HashSet oraz SortedSet (318)
  • Kolejki (319)
  • Listy połączone (320)
  • Stosy (321)
  • Podsumowanie (322)

10. Łańcuchy znaków (323)

  • Czym są łańcuchy znaków? (324)
  • Typy String i Char (325)
  • Literały łańcuchowe i znakowe (326)
    • Oznaczanie znaków specjalnych (327)
  • Formatowanie wyświetlanych danych (330)
    • Standardowe łańcuchy formatowania liczb (331)
    • Niestandardowe łańcuchy formatujące (337)
    • Daty i godziny (340)
    • W drugą stronę - konwersja łańcuchów na dane innych typów (343)
    • Złożone formatowanie przy użyciu metody String.Format (345)
  • Wrażliwość na ustawienia kulturowe (346)
    • Poznawanie reguł formatowania (348)
  • Uzyskiwanie dostępu do znaków na podstawie indeksów (349)
  • Łańcuchy znaków są niezmienne (349)
  • Pobieranie ciągu znaków (351)
  • Składanie łańcuchów znaków (352)
    • Ponowne dzielenie łańcuchów (354)
    • Wielkie i małe litery (355)
  • Operacje na tekście (356)
    • StringBuilder - modyfikowalne łańcuchy znaków (357)
  • Odnajdywanie i zastępowanie łańcuchów (361)
  • Wszelkiego typu "puste" łańcuchy znaków (362)
  • Usuwanie białych znaków (365)
  • Sprawdzanie typu znaków (368)
  • Kodowanie znaków (368)
    • Dlaczego kodowanie ma znaczenie (370)
    • Kodowanie i dekodowanie (371)
    • Po co reprezentować łańcuchy w formie sekwencji bajtów? (378)
  • Podsumowanie (378)

11. Pliki i strumienie (379)

  • Sprawdzanie katalogów i plików (379)
  • Badanie katalogów (382)
  • Operacje na ścieżkach (383)
    • Ścieżka i aktualny katalog roboczy (384)
  • Zdobywanie informacji o pliku (385)
  • Tworzenie plików tymczasowych (388)
  • Usuwanie plików (389)
  • Powszechnie znane katalogi (390)
  • Bezpieczne łączenie elementów ścieżek (393)
  • Tworzenie i zabezpieczanie hierarchii katalogów (394)
  • Usuwanie katalogu (401)
  • Zapis plików tekstowych (402)
    • Zapis całego pliku tekstowego w jednym wywołaniu (402)
    • Zapis tekstu przy użyciu klasy StreamWriter (403)
  • Gdy pliki schodzą na złą drogę: obsługa wyjątków (406)
    • Określanie i modyfikacja uprawnień (410)
  • Wczytywanie plików do pamięci (414)
  • Strumienie (418)
    • Poruszanie się wewnątrz strumienia (424)
    • Zapis danych przy użyciu strumieni (425)
  • Odczyt, zapis i blokowanie plików (426)
  • Konstruktory klasy FileStream (428)
    • Bufory strumieni (428)
    • Określanie uprawnień podczas tworzenia strumieni (429)
    • Opcje zaawansowane (429)
  • Asynchroniczne operacje na plikach (430)
  • Mechanizm Isolated Storage (433)
    • Magazyny (434)
    • Zapis i odczyt tekstu (435)
    • Definicja izolowania (436)
    • Zarządzanie magazynami użytkownika przy użyciu limitów (440)
    • Zarządzanie magazynami (441)
  • Strumienie, które nie są plikami (444)
    • Strumień adaptujący - CryptoStream (447)
    • Wszystko w pamięci - MemoryStream (448)
    • Reprezentowanie danych binarnych jako tekstu przy użyciu kodowania Base64 (449)
  • Podsumowanie (452)

12. XML (453)

  • Podstawy XML (krótki przegląd) (453)
    • Elementy (453)
    • XHTML (455)
  • Litera "X" oznacza "rozszerzalny" (eXtensible) (456)
  • Tworzenie dokumentów XML (456)
    • Elementy XML (459)
    • Atrybuty XML (460)
    • Umieszczanie kodu LINQ w LINQ to XML (463)
  • Przeszukiwanie kodu XML za pomocą LINQ (464)
    • Wyszukiwanie pojedynczego węzła (467)
    • Osie wyszukiwania (468)
    • Klauzule where (469)
  • Serializacja XML (469)
    • Dostosowywanie serializacji XML za pomocą atrybutów (472)
  • Podsumowanie (473)

13. Sieci (475)

  • Wybór technologii sieciowej (475)
    • Aplikacja WWW z kodem klienta (476)
    • Klient .NET i serwer .NET (480)
    • Klient .NET i usługa WWW pochodząca z zewnątrz (482)
    • Klient zewnętrzny i usługa WWW .NET (483)
  • Platforma WCF (483)
    • Tworzenie projektu WCF (483)
    • Kontrakty WCF (484)
    • Testowy host i klient WCF (486)
    • Udostępnianie usługi WCF (489)
    • Pisanie klienta WCF (496)
    • Dwukierunkowa komunikacja z dwustronnymi kontraktami (504)
  • Protokół HTTP (513)
    • Klient WWW (514)
    • Klasy WebRequest i WebResponse (518)
  • Gniazda (525)
    • Protokoły IP, IPv6 oraz TCP (526)
    • Łączenie się z usługami za pomocą klasy Socket (531)
    • Implementowanie usług za pomocą klasy Socket (535)
  • Inne możliwości związane z siecią (540)
  • Podsumowanie (540)

14. Bazy danych (541)

  • Krajobraz możliwości dostępu do danych w ramach platformy .NET (541)
    • Klasyczny mechanizm ADO.NET (542)
    • LINQ i bazy danych (546)
    • Technologie dostępu do danych nieopracowane przez firmę Microsoft (548)
    • WCF Data Services (548)
    • Technologia Silverlight i dostęp do danych (549)
    • Bazy danych (550)
  • Model encji danych (551)
    • Wygenerowany kod (555)
    • Zmiana odwzorowywania (557)
    • Związki (558)
    • Dziedziczenie (565)
  • Zapytania (566)
    • LINQ to Entities (566)
    • Entity SQL (570)
    • Mieszanie języków ESQL oraz LINQ (573)
    • Dostawca ADO.NET EntityClient (574)
  • Kontekst obiektu (574)
    • Obsługa połączenia (574)
    • Tworzenie, aktualizowanie i usuwanie (577)
    • Transakcje (579)
    • Optymistyczna współbieżność (584)
    • Czas życia kontekstu i encji (586)
  • WCF Data Services (587)
  • Podsumowanie (591)

15. Podzespoły (593)

  • Komponenty .NET - podzespoły (593)
    • Odwołania (594)
    • Pisanie bibliotek (597)
    • Ochrona (599)
  • Nazwy (602)
    • Podpisywanie i silne nazwy (603)
  • Ładowanie (605)
    • Ładowanie z folderu aplikacji (606)
    • Ładowanie z bufora GAC (606)
    • Ładowanie z pliku Silverlight o rozszerzeniu xap (607)
    • Jawne ładowanie (607)
  • Podsumowanie (609)

16. Wątki i kod asynchroniczny (611)

  • Wątki (613)
    • Wątki i systemowy mechanizm szeregujący (615)
    • Stos (617)
    • Pula wątków (624)
    • Powinowactwo oraz kontekst wątków (625)
    • Popularne błędne opinie dotyczące wątków (627)
    • Tworzenie kodu wielowątkowego jest trudne (634)
    • Strategie tworzenia kodu wielowątkowego (637)
  • Podstawowe narzędzia synchronizacji (638)
    • Monitor (639)
    • Inne typy blokad (649)
    • Inne mechanizmy synchronizacji (653)
    • Zdarzenia (653)
    • Odliczanie (654)
  • Programowanie asynchroniczne (655)
    • Model programowania asynchronicznego (656)
    • Programowanie asynchroniczne bazujące na zdarzeniach (659)
    • Doraźne operacje asynchroniczne (660)
  • Task Parallel Library (661)
    • Zadania (661)
    • Obsługa anulowania (668)
    • Obsługa błędów (669)
  • Równoległość danych (671)
    • Metody Parallel.For oraz Parallel.ForEach (671)
    • PLINQ - równoległe LINQ (673)
  • Podsumowanie (674)

17. Atrybuty i odzwierciedlanie (675)

  • Atrybuty (675)
    • Typy atrybutów (676)
    • Własne atrybuty (677)
  • Odzwierciedlanie (681)
    • Badanie metadanych (681)
    • Odkrywanie typów (683)
    • Odzwierciedlanie na rzecz określonego typu (684)
    • Późne wiązanie (686)
  • Podsumowanie (689)

18. Typ dynamic (691)

  • Styl statyczny kontra styl dynamiczny (691)
    • Styl dynamiczny i automatyzacja COM (693)
  • Typ dynamic (694)
    • Typy obiektów i słowo dynamic (697)
  • Typ dynamic w zastosowaniach niezwiązanych z interoperacyjnością? (707)
  • Podsumowanie (710)

19. Współdziałanie z COM i Win32 (711)

  • Importowanie kontrolek ActiveX (711)
    • Importowanie kontrolek do projektów .NET (712)
  • Podzespoły współdziałania (714)
    • Bez PIA (716)
  • 64 czy 32 bity? (717)
  • Mechanizm P/Invoke (720)
  • Wskaźniki (724)
  • Rozszerzenia składni C# 4.0 (729)
    • Właściwości indeksowane (729)
    • Opcjonalny modyfikator ref (730)
  • Podsumowanie (731)

20. WPF i Silverlight (733)

  • XAML i kod ukryty (735)
    • XAML i obiekty (739)
  • Elementy i kontrolki (742)
    • Panele układów (743)
    • Elementy graficzne (752)
    • Kontrolki (759)
    • Kontrolki użytkownika (763)
  • Szablony kontrolek (765)
    • Style (767)
    • Menedżer stanu wizualnego (769)
  • Wiązanie danych (771)
    • Szablony danych (773)
  • Podsumowanie (776)

21. Tworzenie aplikacji w ASP.NET (777)

  • Podstawy technologii Web Forms (777)
    • Zdarzenia formularzy sieciowych (779)
    • Cykl życia stron w technologii Web Forms (780)
  • Tworzenie aplikacji internetowych (781)
    • Pliki kodu ukrytego (782)
    • Dodawanie kontrolek (783)
    • Kontrolki serwerowe (785)
  • Wiązanie danych (786)
    • Sprawdzanie kodu (789)
    • Dodawanie kontrolek i formularzy (792)
  • Podsumowanie (796)

22. Windows Forms (797)

  • Tworzenie aplikacji (798)
    • Dodawanie źródła wiązania (799)
  • Kontrolki (801)
    • Dokowanie i kotwiczenie (806)
  • Wiązanie danych (808)
  • Obsługa zdarzeń (813)
  • Podsumowanie (814)
Cena:    129.00   91.59zł


C# Programowanie Wydanie VIKsiążka informatyczna: C# Programowanie Wydanie VI
Księgarnia informatyczna aton.pl

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