C# 2005. Warsztat programisty

Autorzy:

Szczegóły książki w Helionie
Tytuł oryginału: C# 2005 Programmers Reference
ISBN: 978-83-246-1065-5
Cena: 57 zł
Oprawa: twarda
Format: B5
Data wydania: 2007.11.23
Liczba stron: 392
Przykładowy rozdział: ftp://ftp.helion.pl/online/cshwar/cshwar-4.pdf
Kategoria: CH

Wyjątkowy podręcznik języka C#

  • Elementy języka i podstawowe koncepcje programistyczne
  • Techniki tworzenia najwyższej klasy aplikacji dla platformy .NET
  • Metody poprawy bezpieczeństwa i wydajności aplikacji

Język C#, pomimo stosunkowo krótkiej obecności na rynku, zyskał ogromną popularność i jest wykorzystywany przez wielu programistów. Trudno się temu dziwić -- ten łączący w sobie najlepsze cechy Javy i C++ obiektowy język programowania jest niezwykle uniwersalny. Można wykorzystać go w niemal każdym projekcie -- programów dla systemu Windows, dynamicznych witryn internetowych w technologii ASP.NET oraz aplikacji mobilnych dla platformy PocketPC. Prosta składnia, rozbudowane mechanizmy obsługi wyjątków i dostęp do ogromnej biblioteki klas .NET sprawiają, że C# jest doskonałym narzędziem.

Książka "C# 2005. Warsztat programisty" to połączenie kursu i podręcznika programowania w tym języku. Czytając ją, opanujesz zarówno podstawy C#, jak i zaawansowane zagadnienia związane z tworzeniem bezpiecznych i wydajnych aplikacji. Poznasz typy danych, zasady stosowania zmiennych oraz składnię instrukcji i wyrażeń. Przeczytasz o programowaniu obiektowym, typach generycznych, obsłudze wyjątków i technikach programowania w C#. Znajdziesz tu również omówienie gramatyki języka C#, konwencji nazewniczych i zasad umieszczania komentarzy w dokumentacji XML.

  • Narzędzia programistyczne
  • Struktura języka C#
  • Typy danych
  • Wyrażenia i instrukcje
  • Przestrzenie nazw
  • Klasy i obiekty
  • Typy wyliczeniowe
  • Obsługa wyjątków
  • Typy generyczne

Poznaj nowoczesne metody tworzenia aplikacji.

C# 2005. Warsztat programisty -- spis treści

O autorach (15)

Wprowadzenie (17)

Rozdział 1. Czym jest C#? (23)

  • Nazwa (23)
  • Ogólny rzut oka na C# (23)
    • Historia (24)
    • C# i CLR (24)
    • Wzmianka o .NET (25)
    • Standardy (25)
    • Inne implementacje (25)
  • Przykładowy kod C# (26)
  • Korzyści z nauki programowania w C# (28)
  • Podsumowanie (28)

Rozdział 2. Początki pracy z C# (29)

  • Początki pracy z C# są tańsze, niż mogłoby się wydawać! (29)
    • Tanie opcje (29)
    • Jak pisać kod C#, stosując bezpłatne narzędzia (32)
  • Tanie narzędzie, które ułatwia życie! (35)
  • Alternatywne edytory tekstowe i narzędzia C# (37)
  • Narzędzia komercyjne: Visual Studio i Visual C# (37)
  • Podsumowanie (38)

Rozdział 3. Ogólny rzut oka na C# (39)

  • C# (39)
  • Podstawy C# (39)
    • Czytanie źródłowego kodu C# (40)
  • Typy (41)
    • Typy wartości (41)
    • Typy referencyjne (41)
    • Typy predefiniowane (42)
    • Przeciążanie (44)
    • Przekształcenia (44)
    • Typy tablicowe (45)
  • Zmienne i parametry (45)
  • Wyrażenia (47)
  • Instrukcje (48)
  • Klasy (49)
    • Stałe (50)
    • Pola (50)
    • Metody (50)
    • Właściwości (51)
    • Zdarzenia (51)
    • Operatory (51)
    • Indeksatory (51)
    • Konstruktory instancji (51)
    • Destruktory (52)
    • Konstruktory statyczne (52)
    • Dziedziczenie (52)
    • Klasy statyczne (52)
  • Struktury (53)
  • Interfejsy (53)
  • Delegacje (53)
  • Typy wyliczeniowe (54)
  • Typy generyczne (54)
  • Iteratory (54)
  • Typy dopuszczające wartość pustą (55)
  • Podsumowanie (55)

Rozdział 4. Struktura języka C# (57)

  • Programy C# (57)
  • Gramatyka (59)
    • Dwuznaczności gramatyczne (59)
    • Analiza leksykalna (61)
  • Podsumowanie (77)

Rozdział 5. Koncepcje języka C# (79)

  • Uruchamianie aplikacji (79)
  • Zamykanie aplikacji (80)
  • Deklaracje w C# (80)
  • Składowe (83)
    • Składowe przestrzeni nazw (83)
    • Składowe struktur (83)
    • Składowe wyliczeniowe (83)
    • Składowe klas (83)
    • Składowe interfejsów (84)
    • Składowe tablic (85)
    • Składowe delegacji (85)
  • Dostęp do składowych (85)
    • Deklarowana dostępność (85)
  • Sygnatury (86)
    • Sygnatury indeksatorów (86)
    • Sygnatury konstruktorów instancji (86)
    • Sygnatury metod (86)
    • Sygnatury operatorów (87)
    • Sygnatury i przeciążanie (87)
  • Zasięg (88)
  • Nazwy przestrzeni nazw i typów (89)
  • Zarządzanie pamięcią w C# (89)
  • Podsumowanie (90)

Rozdział 6. Typy (91)

  • Trzy typy typów (91)
    • Różnice pomiędzy typami wartościowymi i referencyjnymi (91)
  • System typów w C# (92)
  • Typy wartościowe (92)
    • System.ValueType (94)
    • Konstruktory domyślne (94)
    • Typy strukturalne (94)
    • Typy proste (95)
    • Typy całkowitoliczbowe (96)
    • Określanie typów (97)
    • Typy zmiennoprzecinkowe (98)
    • Typy dziesiętne (98)
    • Typ bool (99)
    • Typy wyliczeniowe (99)
  • Typy referencyjne (99)
    • Typy klas (100)
    • Typ object (101)
    • Typ string (101)
    • Typy tablicowe (101)
    • Typy delegacji (101)
    • Typ null (101)
    • Pakowanie i odpakowywanie (101)
    • Typy nullable (102)
  • Podsumowanie (103)

Rozdział 7. Zmienne (105)

  • Czym są zmienne? (105)
    • Nie wszystkie zmienne tworzy się w ten sam sposób (105)
  • Kategorie zmiennych (106)
    • Zmienne statyczne (107)
    • Elementy tablicy (107)
    • Zmienne instancji (108)
    • Parametry wartości (109)
    • Parametry referencyjne (109)
    • Parametry wyjściowe (110)
    • Zmienne lokalne (111)
  • Wartości domyślne (111)
  • Przypisania niewątpliwe (111)
    • Zmienne zainicjalizowane (112)
    • Zmienne niezainicjalizowane (112)
  • Podsumowanie (121)

Rozdział 8. Przekształcenia (123)

  • Przekształcenia niejawne (123)
    • Przekształcenia tożsamościowe (124)
    • Niejawne przekształcenia liczbowe (124)
    • Niejawne przekształcenia wyliczeniowe (125)
    • Niejawne przekształcenia referencyjne (125)
    • Przekształcenia typu opakowywanie (126)
    • Niejawne przekształcenia parametrów typów (127)
    • Niejawne przekształcenia wyrażeń stałych (127)
    • Niejawne przekształcenia definiowane przez użytkownika (127)
  • Przekształcenia jawne (128)
    • Jawne przekształcenia liczbowe (128)
    • Jawne przekształcenia wyliczeniowe (130)
    • Jawne przekształcenia referencyjne (131)
    • Przekształcenia typu odpakowywanie (132)
    • Jawne przekształcenia parametrów typu (132)
    • Jawne przekształcenia definiowane przez użytkownika (132)
  • Przekształcenia standardowe (132)
    • Standardowe przekształcenia niejawne (133)
    • Standardowe przekształcenia jawne (133)
    • Przekształcenia definiowane przez użytkownika (133)
  • Przekształcenia metod anonimowych (134)
  • Przekształcenia grup metod (134)
  • Przekształcenia typu null (135)
    • Przekształcenia dopuszczające wartość pustą (135)
  • Podsumowanie (136)

Rozdział 9. Wyrażenia (137)

  • Klasyfikacja wyrażeń (137)
    • Wyniki wyrażeń (138)
  • Wartości wyrażeń (138)
  • Wyrażenia i operatory (138)
    • Trzy rodzaje operatorów (139)
    • Priorytet i łączność operatorów (139)
    • Przeciążanie operatorów (141)
    • Operatory rozszerzone (144)
  • Wyszukiwanie składowej (146)
    • Typy bazowe (147)
  • Składowe funkcyjne (147)
  • Wyrażenia podstawowe (151)
    • Literały (152)
    • Nazwy proste (152)
    • Wyrażenia nawiasowe (152)
    • Dostęp do składowej (152)
    • Wyrażenia wywołania (153)
    • Dostęp do elementu (154)
    • Wyrażenie wartości domyślnej (157)
    • Metody anonimowe (157)
  • Wyrażenia jednoargumentowe (158)
  • Wyrażenia rzutowania (158)
  • Operatory arytmetyczne (158)
  • Operatory przesunięcia (159)
  • Operatory relacyjne (159)
  • Operatory logiczne (160)
  • Logiczne operatory warunkowe (161)
  • Operator null coalescing (161)
  • Operatory przypisania (162)
  • Wyrażenie (163)
  • Wyrażenia stałe (163)
  • Wyrażenia boolowskie (165)
  • Podsumowanie (166)

Rozdział 10. Instrukcje (167)

  • Czym są instrukcje? (167)
  • Instrukcje C# (169)
    • Punkt końcowy i osiągalność (170)
    • Punkt końcowy (170)
    • Osiągalność (170)
  • Bloki kodu (172)
    • Listy instrukcji (172)
  • Instrukcje puste (173)
  • Instrukcje etykietowane (173)
  • Instrukcje deklaracyjne (174)
    • Deklaracje zmiennych lokalnych (174)
    • Deklaracje stałych lokalnych (175)
  • Instrukcje wyrażeniowe (176)
    • Instrukcje wyboru (176)
    • Instrukcje iteracyjne (182)
    • Instrukcje skoku (184)
    • Instrukcja using (187)
    • Instrukcja yield (188)
  • Podsumowanie (189)

Rozdział 11. Przestrzenie nazw (191)

  • Czym są przestrzenie nazw? (191)
    • Organizowanie klas (191)
    • Kontrolowanie zasięgu (192)
  • Jednostki kompilacji (192)
  • Deklaracje przestrzeni nazw (193)
  • Dyrektywy użycia synonimu zewnętrznego (194)
  • Dyrektywy użycia (195)
    • Składowe przestrzeni nazw (196)
    • Deklaracje typów (196)
    • Kwalifikowane składowe synonimów (197)
  • Podsumowanie (199)

Rozdział 12. Klasy (201)

  • Czym są klasy? (201)
  • Deklaracje klas (201)
    • Modyfikatory klas (202)
    • Wskazanie klasy bazowej (203)
    • Klasy bazowe (203)
    • Implementacje interfejsów (203)
    • Ciało klasy (204)
    • Deklaracje częściowe (204)
  • Składowe klasy (204)
    • Dziedziczenie (206)
    • Modyfikator new (206)
    • Modyfikatory dostępu (206)
    • Składowe statyczne i instancji (206)
    • Stałe (207)
  • Pola (208)
    • Pola statyczne i instancji (209)
    • Pola readonly (209)
  • Metody (210)
    • Parametry metody (211)
    • Metody statyczne i instancji (212)
    • Metody wirtualne (212)
    • Metody przesłaniające (213)
    • Metody ostateczne (213)
    • Metody abstrakcyjne (213)
    • Ciało metody (213)
  • Właściwości (214)
    • Właściwości statyczne i instancji (215)
    • Akcesory (215)
    • Akcesory wirtualne, ostateczne, przesłaniające i abstrakcyjne (216)
  • Zdarzenia (216)
    • Zdarzenia jako pola (217)
    • Zdarzenia statyczne i instancji (217)
    • Akcesory wirtualne, ostateczne, przesłaniające i abstrakcyjne (218)
  • Indeksatory (218)
  • Operatory (220)
    • Operatory jednoargumentowe (221)
    • Operatory dwuargumentowe (222)
    • Operatory przekształcenia (222)
  • Konstruktory instancji (222)
  • Konstruktory statyczne (223)
  • Destruktory (224)
  • Podsumowanie (224)

Rozdział 13. Struktury (225)

  • Czym są struktury? (225)
  • Deklaracje struktur (226)
    • Modyfikatory struktury (227)
    • Interfejsy struktury (227)
    • Ciało struktury (227)
    • Składowe struktury (228)
  • Różnice między klasą a strukturą (228)
    • Semantyka wartości (229)
    • Dziedziczenie (229)
    • Przypisania (230)
    • Wartości domyślne (230)
    • Opakowywanie i rozpakowywanie (230)
    • this (231)
    • Inicjalizatory pól (231)
    • Konstruktory (231)
    • Destruktory (231)
    • Konstruktory statyczne (232)
  • Kiedy korzystać ze struktur (232)
  • Podsumowanie (232)

Rozdział 14. Tablice (233)

  • Czym jest tablica? (233)
  • Typy tablicowe (235)
    • Typ System.Array (236)
  • Tworzenie tablic (236)
    • Dostęp do elementów tablicy (237)
    • Składowe tablic (237)
    • Kowariancja tablic (237)
    • Inicjalizatory tablic (238)
  • Podsumowanie (240)

Rozdział 15. Interfejsy (241)

  • Czym jest interfejs? (241)
  • Definiowanie interfejsu (242)
  • Deklaracje interfejsów (242)
    • Modyfikatory (243)
    • Jawne interfejsy bazowe (243)
    • Ciało interfejsu (244)
    • Składowe interfejsu (244)
    • Metody interfejsu (244)
    • Właściwości interfejsu (244)
    • Zdarzenia interfejsu (245)
  • Podsumowanie (245)

Rozdział 16. Typy wyliczeniowe (247)

  • Deklaracje typów wyliczeniowych (248)
  • Modyfikatory typów wyliczeniowych (249)
  • Składowe typów wyliczeniowych (250)
  • Przestroga przed referencjami cyklicznymi (251)
  • System.Enum (251)
    • Wartości i operacje typów wyliczeniowych (252)
  • Podsumowanie (252)

Rozdział 17. Delegacje (253)

  • Delegacje w działaniu (253)
  • Deklaracje delegacji (254)
    • Modyfikatory (254)
    • Deklarowanie delegacji (255)
    • Lista wywoławcza (255)
    • Tworzenie instancji delegacji (256)
  • Podsumowanie (257)

Rozdział 18. Wyjątki (259)

  • Zgłaszanie wyjątków (259)
  • System.Exception (260)
  • Typowe klasy wyjątków (260)
  • Obsługa wyjątków (261)
    • Co się dzieje, gdy klauzula catch nie zostaje odnaleziona? (261)
  • Podsumowanie (262)

Rozdział 19. Atrybuty (263)

  • Wprowadzenie do atrybutów (263)
  • Klasy atrybutów (264)
    • Parametry pozycyjne i nazwane (264)
    • Użycie atrybutów (264)
    • Typy parametrów atrybutu (265)
  • Specyfikacja atrybutów (266)
  • Instancje atrybutów (269)
    • Kompilacja atrybutów (269)
    • Odczytywanie instancji atrybutu podczas wykonywania programu (269)
  • Atrybuty zastrzeżone (270)
    • Atrybut Conditional (270)
  • Podsumowanie (272)

Rozdział 20. Typy generyczne (275)

  • Typy generyczne w C# i szablony w C++ (275)
    • Zalety typów generycznych (276)
  • Deklaracje klas generycznych (276)
    • Parametry typu (277)
    • Różnice parametrów typu (278)
    • Typ instancji (279)
    • Składowe klas generycznych (279)
    • Pola statyczne w klasach generycznych (280)
    • Konstruktory statyczne w klasach generycznych (280)
    • Dostęp do składowych chronionych (281)
    • Przeciążanie w klasach generycznych (281)
    • Operatory w klasach generycznych (281)
  • Deklaracje struktur generycznych (282)
  • Deklaracje interfejsów generycznych (282)
  • Jawne implementacje składowych interfejsu (283)
  • Deklaracje delegacji generycznych (283)
  • Typy konstruowane (283)
    • Argumenty typu (284)
    • Typy otwarte i zamknięte (284)
    • Składowe typów konstruowanych (284)
    • Stosowanie dyrektyw użycia synonimów (285)
    • Metody generyczne (285)
  • Gdzie nie używa się typów generycznych (287)
  • Ograniczenia (288)
  • Podsumowanie (291)

Rozdział 21. Iteratory (293)

  • Blok iteratora (294)
    • Bloki iteratora i błędy czasu kompilacji (295)
    • Interfejsy enumeratora (295)
    • Interfejsy wyliczeniowe (295)
    • Typ yield (296)
    • This (296)
  • Obiekty enumeratora (296)
    • Metoda MoveNext (297)
    • Przerwanie wykonywania kodu (298)
    • Właściwość Current (298)
    • Metoda Dispose (299)
  • Obiekty przeliczalne (300)
    • Metoda GetEnumerator (300)
  • Podsumowanie (301)

Rozdział 22. Kod nienadzorowany (303)

  • Czym jest kod nienadzorowany? (303)
  • Zalety i wady kodu nienadzorowanego (304)
    • Zalety kodu nienadzorowanego (304)
    • Wady kodu nienadzorowanego (304)
  • Konteksty kodu nienadzorowanego (305)
  • Podstawowe informacje o wskaźnikach (306)
    • Wskaźniki void (307)
    • Operatory wskaźnikowe (307)
  • Kod nienadzorowany w działaniu (308)
    • Stosowanie modyfikatora fixed (309)
  • Operator sizeof (310)
  • Użycie słowa kluczowego stackalloc (311)
  • Kompilowanie kodu nienadzorowanego (312)
  • Podsumowanie (312)

Dodatek A Gramatyka języka C# (313)

Dodatek B Konwencje nazewnicze (349)

Dodatek C Biblioteka standardowa (357)

Dodatek D Przenaszalność (371)

Dodatek E Komentarze dokumentacyjne XML (375)

Skorowidz (379)

©2007 Włodzimierz Gajda | prace magisterskie | Dubai | Korekta prac magisterskich , Ebooki programowanie androida, Pozycjonowanie stron Poznań