Wstęp (11)

CZĘŚĆ I PROJEKTOWANIE APLIKACJI WINDOWS (13)

Rozdział 1. Środowisko Visual Studio (15)

• Projektowanie interfejsu aplikacji (15)
  
  • Tworzenie projektu (16)
  • Dokowanie palety komponentów Toolbox (18)
  • Tworzenie interfejsu za pomocą komponentów Windows Forms (19)
  • Zapisywanie i wczytywanie projektu (20)
• Ukryta prawda (21)
  
• Analiza kodu pierwszej aplikacji (22)
  
• Metody zdarzeniowe (26)
  
  • Metoda uruchamiana w przypadku wystąpienia zdarzenia kontrolki (26)
  • Testowanie metody zdarzeniowej (27)
  • Przypisywanie istniejącej metody do zdarzeń komponentów (29)
  • Edycja metody zdarzeniowej (30)
  • Modyfikowanie własności komponentów (30)
  • Wywoływanie metody zdarzeniowej z poziomu kodu (31)
  • Reakcja aplikacji na naciskanie klawiszy (32)
• Platforma aplikacji (application framework) (32)

Rozdział 2. Debugowanie kodu (35)

• Skąd biorą się błędy i jak ich unikać? (35)
  
• Kontrolowane uruchamianie aplikacji (36)
  
  • Program z błędem - pole do popisu dla debuggera (36)
  • Śledzenie wykonywania programu krok po kroku (klawisze F10 i F11) (37)
  • Run to Cursor (klawisze Ctrl+F10) (38)
  • Breakpoint (klawisz F9) (39)
  • Okna Locals i Watch (40)
• Stan wyjątkowy (42)
  
  • Przechwytywanie wyjątków w konstrukcji try..catch (43)
  • Zgłaszanie wyjątków (45)

Rozdział 3. Język Visual Basic (47)

• Platforma .NET (47)
  
• Trivia (49)
  
• Podstawowe typy danych (49)
  
  • Deklaracja i zmiana wartości zmiennej (49)
  • Typy liczbowe oraz znakowy (50)
  • Opcje Strict, Infer i Explicit (53)
  • Priorytety operatorów (56)
  • Weryfikacja typów (58)
  • Łańcuchy (59)
  • Weryfikowanie zgodności łańcucha ze wzorcem (62)
  • Typ wyliczeniowy (63)
  • Leniwe inicjowanie zmiennych (65)
• Funkcje i metody (65)
  
  • Przeciążanie metod (66)
  • Domyślne wartości argumentów metod - argumenty opcjonalne (67)
  • Wartości zwracane przez metody (68)
  • Zwracanie wartości przez argument metody (ByRef) (68)
  • Delegacje i zdarzenia (70)
  • Wyrażenia lambda (71)
• Typy wartościowe i referencyjne (72)
  
  • Nullable (74)
  • Pudełkowanie (75)
• Sterowanie przepływem (76)
  
  • Instrukcja warunkowa If..Else (76)
  • Instrukcja wyboru Select (77)
  • Pętle (77)
• Wyjątki (79)
  
• Dyrektywy preprocesora (82)
  
  • Kompilacja warunkowa - ostrzeżenia (82)
  • Definiowanie stałych preprocesora (83)
  • Bloki (83)
• Atrybuty (84)
  
• Kolekcje (84)
  
  • "Zwykłe" tablice (85)
  • Pętla foreach (88)
  • Sortowanie (89)
  • Kolekcja List (90)
  • Kolekcja SortedList i inne słowniki (91)
  • Kolejka i stos (92)

Rozdział 4. Projektowanie zorientowane obiektowo (95)

• Przykład struktury (Ulamek) (96)
  
  • Przygotowanie projektu (96)
  • Konstruktor i współdzielone obiekty składowe (97)
  • Pierwsze testy (98)
  • Konwersje na łańcuch (metoda ToString) i na typ double (99)
  • Metoda upraszczająca ułamek (99)
  • Własności (100)
  • Operatory arytmetyczne (101)
  • Operatory porównania oraz metody Equals i GetHashCode (103)
  • Operatory konwersji (104)
• Implementacja interfejsu (na przykładzie IComparable) (105)
  
• Definiowanie typów parametrycznych (107)
  
  • Definiowanie typów ogólnych (108)
  • Określanie warunków, jakie mają spełniać parametry (109)
  • Implementacja interfejsów przez typ ogólny (110)
  • Definiowanie aliasów (112)
  • Typy ogólne z wieloma parametrami (113)
• Rozszerzenia (114)
  
• Słowo kluczowe With (116)
  
• Typy anonimowe (117)

Rozdział 5. Przegląd komponentów biblioteki Windows Forms (119)

• Notatnik.NET (119)
  
  • Projektowanie interfejsu aplikacji i menu główne (120)
  • Okna dialogowe i pliki tekstowe (126)
  • Edycja i korzystanie ze schowka (134)
  • Drukowanie (135)
• Elektroniczna kukułka (145)
  
  • Ekran powitalny (splash screen) (145)
  • Przygotowanie ikony w obszarze powiadamiania (148)
  • Odtwarzanie pliku dźwiękowego (151)
• Ustawienia aplikacji (153)
  
  • Tworzenie ustawień w trakcie projektowania aplikacji (153)
  • Odczytywanie ustawień z poziomu kodu (154)
  • Zapisywanie ustawień z poziomu kodu (155)
• Dywan graficzny (156)
  
  • Zdarzenie Paint formy (156)
  • Kolorowy wzór (157)
  • Buforowanie (158)
  • Zapisywanie obrazu dywanu do pliku (159)
• Rysowanie zbiorów Mandelbrota i Julii (160)
  
  • Trochę teorii (160)
  • Implementacja (163)
• Lista uruchomionych procesów (166)

Rozdział 6. Przeciągnij i upuść (169)

• Podstawy (169)
  
  • Interfejs przykładowej aplikacji (170)
  • Inicjacja procesu przeciągania (171)
  • Akceptacja upuszczenia elementu (173)
  • Reakcja na upuszczenie elementu (174)
  • Czynności wykonywane po zakończeniu procesu przenoszenia i upuszczania (175)
  • Przenoszenie elementów między różnymi aplikacjami (176)
• Zagadnienia zaawansowane (176)
  
  • Opóźnione inicjowanie procesu przenoszenia (176)
  • Przenoszenie wielu elementów (179)
  • Przenoszenie plików (181)

Rozdział 7. Przezroczyste okna o dowolnym kształcie (183)

• Konfiguracja formy (183)
  
• Wczytywanie obrazu (184)
  
• Przezroczystość i łagodne znikanie okna (186)
  
• Zamykanie klawiszem Esc (187)
  
• Przenoszenie formy za dowolny punkt (188)
  
• Menu kontekstowe (189)

Rozdział 8. Projektowanie kontrolek (193)

• Komponent FileListBox (194)
  
  • Implementacja podstawowych funkcjonalności (194)
  • Rozbudowa komponentu o możliwość zmiany katalogu (203)
  • Właściwości (205)
  • Zdarzenia - interakcja z komponentem (210)
  • Odświeżanie komponentu i automatyczne śledzenie zmian w prezentowanym katalogu (216)
  • Kompilacja komponentu do postaci biblioteki DLL (219)
  • Prosty przykład wykorzystania komponentu FileListBox: przeglądanie plików tekstowych (224)
• Kolorowy pasek postępu (228)
  
  • Tworzenie projektu (228)
  • Rysowanie obramowania kontrolki (229)
  • Pola i własności (230)
  • Rysowanie paska postępu (233)
  • Metody (234)
  • Zdarzenia (235)

Rozdział 9. Zarządzane biblioteki DLL i mechanizm rozpoznawania typów (239)

• Tworzenie zarządzanej biblioteki DLL (240)
  
  • Projekt biblioteki DLL (240)
  • Dodawanie referencji do biblioteki systemowej platformy .NET (241)
  • Wyświetlanie informacji o systemie i platformie .NET (242)
• Zmiana przestrzeni nazw biblioteki (243)
  
• Statyczne ładowanie bibliotek DLL (243)
  
  • Dołączanie do projektu bibliotek DLL użytkownika (243)
• Dynamiczne ładowanie zarządzanych bibliotek DLL i dynamiczne rozpoznawanie typów (245)
  
  • Dynamiczne ładowanie zarządzanej biblioteki .dll (245)
  • Analiza zawartości biblioteki załadowanej dynamicznie (246)
  • Weryfikacja obecności w bibliotece DLL klasy o znanej nazwie (247)
  • Lista metod w klasie z biblioteki DLL (248)
  • Weryfikacja obecności konkretnej metody w klasie z biblioteki DLL (249)
  • Lista argumentów wybranej metody (250)
  • Uruchamianie metody współdzielonej z klasy wczytanej z biblioteki DLL (252)
  • Uruchamianie metody na rzecz instancji obiektu. Przekazywanie parametrów i odczytywanie zwracanej wartości (254)
• Późne wiązanie na typie Object (255)

Rozdział 10. Aplikacje konsolowe i informacje o systemie (257)

• Klasa Console (257)
  
  • Projekt aplikacji konsolowej (257)
  • Drukowanie napisów w konsoli (259)
  • Czekanie na akceptację użytkownika (259)
  • Odczytywanie danych z klawiatury (260)
  • Komunikat "okienkowy" w aplikacji konsolowej (261)
• Informacje o środowisku aplikacji (262)
  
  • Podstawowe informacje o systemie i profilu użytkownika (263)
  • Katalogi specjalne zdefiniowane w bieżącym profilu użytkownika (264)
  • Odczytywanie zmiennych środowiskowych (264)
  • Lista dysków logicznych (265)

Rozdział 11. Wątki, równoległa pętla Parallel.For oraz programowanie asynchroniczne (Async/Await) (267)

• Monte Carlo (268)
  
• Obliczenia bez użycia dodatkowych wątków (269)
  
• Przeniesienie obliczeń do osobnego wątku (270)
  
• Usypianie wątku (272)
  
• Przerywanie działania wątku (Abort) (273)
  
• Wstrzymywanie i wznawianie działania wątku (274)
  
• Wątki działające w tle (275)
  
• Zmiana priorytetu wątku (276)
  
• Użycie wielu wątków i problemy z generatorem liczb pseudolosowych (276)
  
• Czekanie na ukończenie pracy wątku (Join) (280)
  
• Sekcje krytyczne (lock) (282)
  
• Przesyłanie danych do wątku (283)
  
• Pula wątków (285)
  
• Jeszcze raz o komunikacji między wątkami (288)
  
• Korzystanie z muteksów w celu zapobiegania uruchamianiu wielu instancji aplikacji (290)
  
• Klasa Parallel z biblioteki TPL (290)
  
  • Równoległa pętla For (291)
  • Przerywanie pętli (293)
• Programowanie asynchroniczne (Async/Await) (294)

Rozdział 12. Podstawy ADO.NET i SQL Server (297)

• Bardzo krótki wstęp do SQL (298)
  
  • Select (298)
  • Insert (299)
  • Delete (299)
• Aplikacje "bazodanowe" (299)
  
  • Projekt aplikacji z bazą danych (299)
  • Konfiguracja komponentu DataSet (302)
  • Server Explorer (304)
  • Podgląd danych udostępnianych przez komponent DataSet (304)
  • Prezentacja danych w siatce DataGridView (305)
  • Edycja danych (307)
  • Projektowanie formularzy prezentujących pojedyncze rekordy (309)
  • Sortowanie (312)
  • Filtrowanie (312)
  • Odczytywanie z poziomu kodu wartości przechowywanych w komórkach (313)

CZĘŚĆ II LINQ (315)

Rozdział 13. Wprowadzenie do zapytań LINQ na przykładzie kolekcji (LINQ to Objects) (317)

• Pobieranie danych (filtrowanie i sortowanie) (319)
  
• Najprostsza prezentacja pobranych danych (320)
  
• Analiza pobranych danych (320)
  
• Wybór elementu (320)
  
• Weryfikowanie danych (321)
  
• Prezentacja w grupach (321)
  
• Łączenie zbiorów danych (322)
  
• Łączenie danych z różnych źródeł w zapytaniu LINQ - operator join (322)
  
• Możliwość modyfikacji danych źródła (323)

Rozdział 14. LINQ to DataSet (325)

• Konfiguracja kontrolki DataSet (326)
  
• LINQ to DataSet, czyli tam i z powrotem (328)
  
• Rozszerzenie AsEnumerable klasy DataTable (332)
  
  • Obliczenia wykonywane na danych z tabeli (332)
  • Dowolność sortowania i filtrowania pobieranych danych (332)

Rozdział 15. LINQ to SQL (335)

• Klasa encji (336)
  
• Pobieranie danych (337)
  
• Aktualizacja danych w bazie (338)
  
  • Modyfikacje istniejących rekordów (339)
  • Dodawanie i usuwanie rekordów (340)
  • Inne operacje (341)
• Wizualne projektowanie klasy encji (342)
  
  • O/R Designer (342)
  • Współpraca z kontrolkami tworzącymi interfejs aplikacji (346)
  • Kreator źródła danych i automatyczne tworzenie interfejsu użytkownika (347)
  • Łączenie danych z dwóch tabel - operator join (349)
  • Relacje (Associations) (351)
• Korzystanie z procedur składowanych (353)
  
  • Pobieranie danych za pomocą procedur składowanych (353)
  • Modyfikowanie danych za pomocą procedur składowanych (355)
  • Wykonywanie dowolnych poleceń SQL (355)

Rozdział 16. Kilka sposobów na odczytywanie i zapisywanie danych w plikach XML (357)

• Podstawy języka XML (357)
  
  • Deklaracja (358)
  • Elementy (358)
  • Atrybuty (359)
  • Komentarze (359)
• Klasy XmlTextReader i XmlTextWriter (359)
  
  • Zapis do pliku XML (359)
  • Odczyt danych z pliku XML (361)
  • Analiza i odczyt pliku XML o nieznanej strukturze (363)
• Serializacja obiektów do pliku XML (365)
  
  • Serializacja obiektu do pliku XML (366)
  • Deserializacja obiektu z pliku XML (367)
• XML i ADO.NET (368)
  
  • Wczytywanie danych z pliku XML do komponentu DataSet (369)
  • Zapisywanie zmian do pliku XML za pośrednictwem DataSet (370)
• LINQ to XML (371)
  
  • Tworzenie pliku XML za pomocą klas XDocument i XElement (371)
  • Pobieranie wartości z elementów o znanej pozycji w drzewie (373)
  • Przenoszenie danych z kolekcji do pliku XML (375)
  • Przenoszenie danych z bazy danych (komponentu DataSet) do pliku XML (377)
  • Zapytania LINQ (378)
  • Modyfikacja pliku XML (379)

CZĘŚĆ III TECHNOLOGIE WINDOWS (381)

Rozdział 17. Rejestr systemu Windows (383)

• Korzystanie z rejestru (383)
  
  • Odczytywanie danych z rejestru (383)
  • Zapisywanie oraz odczytywanie położenia i rozmiaru formy w prywatnym kluczu aplikacji (386)
  • Usuwanie klucza z rejestru (388)
• Przeglądarka skojarzeń plików (389)
  
  • Informacja o typach plików przechowywana w rejestrze (389)
  • Przygotowanie interfejsu (391)
  • Odczytywanie listy rozszerzeń (392)
  • Pobieranie opisu, polecenia głównego i domyślnego edytora dla podanego typu plików (394)

Rozdział 18. Mechanizm PInvoke (399)

• Funkcja bez argumentów (399)
  
• Problemy z argumentami (401)
  
• Zwracanie wartości przez argumenty (403)
  
• Zwracanie tablicy znaków w funkcjach WinAPI (406)

Rozdział 19. Komunikaty Windows (407)

• Wysyłanie komunikatów Windows (407)
  
  • Identyfikacja aplikacji (408)
  • Wysyłanie komunikatu do okna o znanym uchwycie (409)
  • Komunikaty jako sposób porozumiewania się z systemem (410)
• Odbieranie komunikatów Windows (411)
  
  • Monitor komunikatów (411)
  • Reakcja na wybrany komunikat (412)

Skorowidz (415)

• Tytuł: Visual Basic .NET w praktyce. Błyskawiczne tworzenie aplikacji
• Autor: Jacek Matulewski
• ISBN: 978-83-246-6483-2, 9788324664832
• Data wydania: 2012-08-27
• Format: Ebook
• Identyfikator pozycji: vbnepr
• Wydawca: Helion