księgarnia informatyczna aton.pl

Visual Basic .NET w praktyce Błyskawiczne tworzenie aplikacji

Wydawnictwo HELION

Cena:    69.00   20.70zł

Visual Basic .NET w praktyce Błyskawiczne tworzenie aplikacji


Autor: Jacek Matulewski
ISBN: 978-83-246-4898-6
Ilość stron: 424
Data wydania: 10/2012
Oprawa: Miękka
Format: 158x235
Wydawnictwo: HELION


Wykorzystaj potęgę technologii Windows!

Visual Basic to język programowania o bardzo długiej tradycji. Kiedy kilka lat temu przeniesiono go na platformę .NET, zyskał nowe możliwości rozwoju. Dziś chętnie używają go osoby, które potrzebują wygodnego narzędzia, pozwalającego szybko stworzyć aplikację do prezentacji i analizy konkretnych danych. Jasna, niezbyt skomplikowana składnia, doskonała biblioteka gotowych kontrolek i bezkolizyjna współpraca z bazą danych to najważniejsze atuty VB.NET.

Jeśli jesteś początkującym użytkownikiem Visual Basic na platformie .NET, trafiłeś w dziesiątkę. Tu znajdziesz podstawy języka oraz wszystkie funkcje potrzebne do swobodnego projektowania aplikacji — bez nadmiernego wchodzenia w szczegóły. Zorientujesz się, jak działa środowisko Visual Studio i jak za pomocą jego narzędzi tworzyć aplikacje VB.NET. Dowiesz się więcej o debugowaniu kodu, programowaniu zorientowanym obiektowo i używaniu kontrolek, zarówno tych z biblioteki Windows Forms, jak i zaprojektowanych osobiście. Odkryjesz, jak można połączyć aplikację z bazą danych i jak wykorzystać technologie systemu Windows. To wszystko, czego Ci trzeba!

  • Środowisko Visual Studio i język Visual Basic
  • Przegląd komponentów biblioteki Windows Forms
  • Projektowanie zorientowane obiektowo i projektowanie kontrolek
  • Zarządzane biblioteki DLL i mechanizm rozpoznawania typów
  • Aplikacje konsolowe i informacje o systemie
  • Wątki, równoległa pętla Parallel.For oraz programowanie asynchroniczne (Async/Await)
  • Podstawy ADO.NET i SQL Server
  • Wprowadzenie do zapytań LINQ na przykładzie kolekcji (LINQ to Objects)
  • LINQ to DataSet i LINQ to SQL
  • Odczytywanie i zapisywanie danych w plikach XML
  • Rejestr systemu Windows, mechanizm PInvoke i komunikaty Windows

Wypróbuj Visual Basic i twórz dynamiczne rozwiązania!

Rozdziały:

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)
Cena:    69.00   20.70zł


Visual Basic .NET w praktyce Błyskawiczne tworzenie aplikacjiKsiążka informatyczna: Visual Basic .NET w praktyce Błyskawiczne tworzenie aplikacji
Księgarnia informatyczna aton.pl

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