Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00767 008371 10458932 na godz. na dobę w sumie
C# i .NET - książka
C# i .NET - książka
Autor: Liczba stron: 912
Wydawca: Helion Język publikacji: polski
ISBN: 83-246-0320-4 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> c# - programowanie
Porównaj ceny (książka, ebook, audiobook).

Doskonałe źródło wiedzy dla wszystkich programistów C#

Platforma .NET i język C# spowodowały prawdziwą rewolucję na rynku narzędzi programistycznych. Wersja 2.0 przyniosła kilka interesujących rozwiązań, w tym nowe typy danych, komponenty i klasy. Dodatkowe funkcje języka C# pozwalają na przyspieszenie i usprawnienie procesu tworzenia aplikacji oraz jej wdrażania i rozwijania. Dzięki platformie .NET przygotowanie wydajnej, bezpiecznej i łatwej do rozbudowy aplikacji stało się znacznie prostsze i szybsze.

Książka 'C# i .NET' przedstawia możliwości platformy .NET i napisanego specjalnie dla niej języka C#. Opisuje elementy platformy, składnię i możliwości języka C# oraz zagadnienia związane z tworzeniem programów za pomocą tych narzędzi. Omawia zasady pisania aplikacji Window Forms i efektywne techniki stosowania klas graficznych z biblioteki GDI+. Charakteryzuje także technologię ADO.NET, metody korzystania z plików XML, przetwarzanie wielowątkowe oraz techniki tworzenia wydajnych aplikacji internetowych w technologii ASP.NET. Szczególną uwagę poświęcono bezpieczeństwu programów i danych oraz skalowaniu i lokalizacji oprogramowania.

Jeśli chcesz napisać w C# aplikację dobrej jakości, sięgnij po tę książkę.

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

IDZ DO IDZ DO PRZYK£ADOWY ROZDZIA£ PRZYK£ADOWY ROZDZIA£ SPIS TREŒCI SPIS TREŒCI KATALOG KSI¥¯EK KATALOG KSI¥¯EK KATALOG ONLINE KATALOG ONLINE ZAMÓW DRUKOWANY KATALOG ZAMÓW DRUKOWANY KATALOG TWÓJ KOSZYK TWÓJ KOSZYK DODAJ DO KOSZYKA DODAJ DO KOSZYKA CENNIK I INFORMACJE CENNIK I INFORMACJE ZAMÓW INFORMACJE ZAMÓW INFORMACJE O NOWOŒCIACH O NOWOŒCIACH ZAMÓW CENNIK ZAMÓW CENNIK CZYTELNIA CZYTELNIA FRAGMENTY KSI¥¯EK ONLINE FRAGMENTY KSI¥¯EK ONLINE Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel. (32)230-98-63 e-mail: helion@helion.pl C# i .NET Autor: Stephen C. Perry T³umaczenie: Miko³aj Szczepaniak (przedmowa, rozdz. 1 – 10), Tomasz Walczak (rozdz. 11 – 18, dod. A, B) ISBN: 83-246-0320-4 Tytu³ orygina³u: Core C# and .NET Format: B5, stron: 912 Doskona³e Ÿród³o wiedzy dla wszystkich programistów C# (cid:127) Szczegó³owe omówienie C# i .NET w wersji 2.0 (cid:129) Techniki tworzenia i zabezpieczania aplikacji oraz zarz¹dzania kodem Ÿród³owym i wersjami (cid:129) Dziesi¹tki przyk³adów i kodów Ÿród³owych Platforma .NET i jêzyk C# spowodowa³y prawdziw¹ rewolucjê na rynku narzêdzi programistycznych. Wersja 2.0 przynios³a kilka interesuj¹cych rozwi¹zañ, w tym nowe typy danych, komponenty i klasy. Dodatkowe funkcje jêzyka C# pozwalaj¹ na przyspieszenie i usprawnienie procesu tworzenia aplikacji oraz jej wdra¿ania i rozwijania. Dziêki platformie .NET przygotowanie wydajnej, bezpiecznej i ³atwej do rozbudowy aplikacji sta³o siê znacznie prostsze i szybsze. Ksi¹¿ka „C# i .NET” przedstawia mo¿liwoœci platformy .NET i napisanego specjalnie dla niej jêzyka C#. Opisuje elementy platformy, sk³adniê i mo¿liwoœci jêzyka C# oraz zagadnienia zwi¹zane z tworzeniem programów za pomoc¹ tych narzêdzi. Omawia zasady pisania aplikacji Window Forms i efektywne techniki stosowania klas graficznych z biblioteki GDI+. Charakteryzuje tak¿e technologiê ADO.NET, metody korzystania z plików XML, przetwarzanie wielow¹tkowe oraz techniki tworzenia wydajnych aplikacji internetowych w technologii ASP.NET. Szczególn¹ uwagê poœwiêcono bezpieczeñstwu programów i danych oraz skalowaniu i lokalizacji oprogramowania. (cid:129) Elementy platformy .NET (cid:129) Podstawy jêzyka C# (cid:129) Praca z klasami i obiektami w C# (cid:129) Przetwarzanie tekstu oraz operacje wejœcia i wyjœcia (cid:129) Tworzenie aplikacji Window Forms (cid:129) Korzystanie z biblioteki GDI+ (cid:129) Po³¹czenia z bazami danych za pomoc¹ ADO.NET (cid:129) Aplikacje wielow¹tkowe oraz rozproszone (cid:129) Tworzenie aplikacji internetowych Jeœli chcesz napisaæ w C# aplikacjê dobrej jakoœci, siêgnij po tê ksi¹¿kê O autorze ....................................................................................................................................................17 Podziękowania ...........................................................................................................................................18 Słowo wstępne ...........................................................................................................................................19 Przedmowa ................................................................................................................................................21 Część I Podstawy programowania w języku C# i wprowadzenie do technologii .NET 25 Rozdział 1. Wprowadzenie do technologii .NET i języka C# .................................................................... 27 1.1. Przegląd składników platformy .NET ...................................................................... 28 Microsoft .NET i standardy CLI ............................................................................. 30 1.2. Wspólne środowisko uruchomieniowe (CLR) .......................................................... 32 Kompilacja kodu platformy .NET ........................................................................... 32 Wspólny system typów (CTS) ................................................................................ 34 Zestawy .NET ...................................................................................................... 36 1.3. Biblioteka klas platformy (FCL) ............................................................................. 41 1.4. Praca z platformą .NET i zestawem narzędzi .NET Framework SDK .......................... 44 Aktualizowanie platformy .NET Framework ............................................................. 45 Narzędzia platformy .NET Framework .................................................................... 46 Ildasm.exe .......................................................................................................... 47 wincv.exe ........................................................................................................... 50 Narzędzie Framework Configuration ...................................................................... 50 1.5. Wyjaśnienie działania kompilatora C# ................................................................... 53 Lokalizowanie kompilatora ................................................................................... 53 Kompilowanie oprogramowania z poziomu wiersza poleceń ..................................... 54 1.6. Podsumowanie ................................................................................................... 57 1.7. Sprawdź, czego się nauczyłeś .............................................................................. 57 Rozdział 2. Podstawy języka C# ............................................................................................................. 59 2.1. Podstawowa struktura programu C# ...................................................................... 60 Ogólne uwagi odnośnie programowania w języku C# ............................................... 62 2.2. Typy proste ......................................................................................................... 65 decimal .............................................................................................................. 67 bool ................................................................................................................... 67 6 C# i .NET char ................................................................................................................... 67 byte, sbyte .......................................................................................................... 68 short, int, long .................................................................................................... 68 single i double .................................................................................................... 68 Konwertowanie łańcuchów numerycznych za pomocą metod Parse() i TryParse() ....... 69 2.3. Operatory arytmetyczne, logiczne i warunkowe ........................................................ 69 Operatory arytmetyczne ........................................................................................ 69 Operatory warunkowe i relacyjne ........................................................................... 70 Instrukcje kontrolujące przepływ sterowania .......................................................... 71 if-else ................................................................................................................. 71 switch ................................................................................................................ 73 2.4. Pętle .................................................................................................................. 74 Pętla while .......................................................................................................... 74 Pętla do ............................................................................................................. 74 Pętla for ............................................................................................................. 75 Pętla foreach ...................................................................................................... 75 Kontrola przepływu sterowania w pętlach .............................................................. 76 2.5. Dyrektywy preprocesora C# .................................................................................. 76 Kompilacja warunkowa ........................................................................................ 77 Dyrektywy diagnostyczne ...................................................................................... 79 Regiony (obszary) kodu ........................................................................................ 79 2.6. Łańcuchy znaków ................................................................................................ 79 Stałe łańcuchowe ................................................................................................ 80 Operacje na łańcuchach ....................................................................................... 81 2.7. Typy wyliczeniowe ................................................................................................ 84 Praca z typami wyliczeniowymi .............................................................................. 84 Metody klasy System.Enum ................................................................................. 85 Typy wyliczeniowe i flagi bitowe ............................................................................ 86 2.8. Tablice ............................................................................................................... 87 Deklarowanie i tworzenie tablic ............................................................................. 88 Stosowanie metod i właściwości tablicy System.Array ............................................ 88 2.9. Typy referencyjne i wartościowe ............................................................................ 90 Klasy System.Object i System.ValueType .............................................................. 90 Techniki przydzielania pamięci dla typów referencyjnych i typów wartościowych ........ 91 Technika pakowania ............................................................................................ 92 Podsumowanie różnic pomiędzy typami wartościowymi a typami referencyjnymi ........ 94 2.10. Podsumowanie ................................................................................................... 95 2.11. Sprawdź, czego się nauczyłeś .............................................................................. 95 Rozdział 3. Projektowanie klas w języku C# ......................................................................................... 97 3.1. Wprowadzenie do klas języka C# .......................................................................... 98 3.2. Definiowanie klas ................................................................................................ 98 Atrybuty .............................................................................................................. 99 Modyfikatory dostępu ........................................................................................ 102 Modyfikatory abstract, sealed i static .................................................................. 102 Identyfikator klasy ............................................................................................. 103 Klasy bazowe, interfejsy i dziedziczenie ............................................................... 103 3.3. Przegląd składowych klasy ................................................................................. 104 Modyfikatory dostępu do składowych .................................................................. 104 3.4. Stałe, pola i właściwości .................................................................................... 104 Stałe ................................................................................................................ 106 Pola ................................................................................................................. 107 Spis treści 7 Właściwości ...................................................................................................... 109 Indeksery ......................................................................................................... 111 3.5. Metody ............................................................................................................. 113 Modyfikatory metod ........................................................................................... 113 Przekazywanie parametrów ................................................................................. 118 3.6. Konstruktory ..................................................................................................... 120 Konstruktor instancji ......................................................................................... 120 Konstruktor prywatny ......................................................................................... 124 Konstruktor statyczny ........................................................................................ 125 3.7. Delegacje i zdarzenia ......................................................................................... 126 Delegacje ......................................................................................................... 127 Obsługa zdarzeń z wykorzystaniem delegacji ........................................................ 129 3.8. Przeciążanie operatorów .................................................................................... 136 3.9. Interfejsy .......................................................................................................... 139 Tworzenie i stosowanie interfejsów niestandardowych .......................................... 139 Praca z interfejsami ........................................................................................... 142 3.10. Klasy uniwersalne ............................................................................................. 143 3.11. Struktury .......................................................................................................... 146 Definiowanie struktur ......................................................................................... 147 Stosowanie struktur z metodami i właściwościami ............................................... 148 3.12. Struktury kontra klasy ....................................................................................... 149 Struktury są typami wartościowymi, klasy są typami referencyjnymi ....................... 149 W przeciwieństwie do klas struktury nie mogą być dziedziczone ............................ 150 Ogólne reguły, które należy uwzględniać, wybierając pomiędzy strukturami a klasami ....................................................... 150 3.13. Podsumowanie ................................................................................................. 151 3.14. Sprawdź, czego się nauczyłeś ............................................................................ 151 Rozdział 4. Praca z obiektami w języku C# ...........................................................................................155 4.1. Tworzenie obiektów ........................................................................................... 156 Przykład: Tworzenie obiektów za pomocą wielu klas fabrykujących ......................... 158 4.2. Obsługa wyjątków .............................................................................................. 159 Klasa System.Exception .................................................................................... 160 Pisanie kodu obsługującego wyjątki .................................................................... 160 Przykład: Obsługa wspólnych wyjątków SystemException ...................................... 163 Tworzenie niestandardowych klas wyjątków ......................................................... 164 Wyjątki nieobsługiwane ...................................................................................... 167 Wskazówki dotyczące obsługi wyjątków ............................................................... 168 4.3. Implementowanie metod klasy System.Object w klasach niestandardowych ........... 170 Metoda ToString() jako narzędzie opisywania obiektów ......................................... 170 Metoda Equals() jako narzędzie porównywania obiektów ....................................... 172 Klonowanie jako sposób tworzenia kopii obiektów ................................................ 174 4.4. Praca z klasami i interfejsami kolekcji technologii .NET ........................................ 176 Interfejsy kolekcji .............................................................................................. 176 Przestrzeń nazw System.Collections ................................................................... 185 Klasy Stack i Queue .......................................................................................... 185 Klasa ArrayList .................................................................................................. 187 Klasa Hashtable ............................................................................................... 188 Przestrzeń nazw System.Collections.Generic ....................................................... 191 4.5. Serializacja obiektów ......................................................................................... 195 Serializacja binarna ........................................................................................... 195 8 C# i .NET 4.6. Zarządzanie cyklem życia obiektów ..................................................................... 199 Odzyskiwanie pamięci w technologii .NET ............................................................ 199 4.7. Podsumowanie .................................................................................................. 205 4.8. Sprawdź, czego się nauczyłeś ............................................................................. 205 Część II Tworzenie aplikacji z wykorzystaniem biblioteki klas platformy .NET Framework 207 Rozdział 5. Przetwarzanie tekstu i plikowe operacje wejścia-wyjścia w języku C# ......................209 5.1. Znaki i format Unicode ....................................................................................... 210 Format Unicode ................................................................................................. 211 Praca ze znakami .............................................................................................. 212 5.2. Klasa String ...................................................................................................... 215 Tworzenie łańcuchów ......................................................................................... 216 Przegląd operacji na łańcuchach znakowych ........................................................ 218 5.3. Porównywanie łańcuchów znakowych .................................................................. 219 Stosowanie metody String.Compare() ................................................................. 219 Stosowanie metody String.CompareOrdinal() ....................................................... 221 5.4. Przeszukiwanie, modyfikowanie i kodowanie zawartości łańcuchów ....................... 222 Przeszukiwanie zawartości łańcuchów ................................................................. 222 Przeszukiwanie łańcuchów zawierających pary zastępcze ...................................... 222 Przekształcanie łańcuchów ................................................................................. 223 Kodowanie łańcuchów ....................................................................................... 225 5.5. Klasa StringBuilder ............................................................................................ 226 Przegląd składowych klasy StringBuilder .............................................................. 227 Konkatenacja w klasie StringBuilder kontra tradycyjna konkatenacja łańcuchów ..... 228 5.6. Formatowanie wartości liczbowych oraz daty i godziny .......................................... 229 Konstruowanie elementów formatowania ............................................................ 230 Formatowanie wartości liczbowych ...................................................................... 231 Formatowanie daty i godziny ............................................................................... 231 5.7. Wyrażenia regularne .......................................................................................... 236 Klasa Regex ..................................................................................................... 237 Tworzenie wyrażeń regularnych ........................................................................... 242 Przykład dopasowywania wzorca do łańcucha ...................................................... 242 Praca z grupami ................................................................................................ 245 Przykłady stosowania wyrażeń regularnych ........................................................... 247 5.8. Przestrzeń nazw System.IO — klasy obsługujące odczytywanie i zapisywanie strumieni danych ............................................................................................... 248 Klasa Stream .................................................................................................... 249 Klasa FileStream ............................................................................................... 249 Klasa MemoryStream ........................................................................................ 251 Klasa BufferedStream ....................................................................................... 252 Stosowanie klas StreamReader i StreamWriter odpowiednio do odczytywania i zapisywania wierszy tekstu ............................................................................. 253 Klasy StringWriter i StringReader ........................................................................ 255 Szyfrowanie danych za pomocą klasy CryptoStream ............................................. 256 5.9. Przestrzeń nazw System.IO — katalogi i pliki ....................................................... 259 Klasa FileSystemInfo ......................................................................................... 259 Praca z katalogami za pomocą klas DirectoryInfo, Directory oraz Path .................... 260 Praca z plikami za pomocą klas FileInfo i File ....................................................... 263 5.10. Podsumowanie ................................................................................................. 265 5.11. Sprawdź, czego się nauczyłeś ............................................................................ 266 Spis treści 9 Rozdział 6. Budowanie aplikacji Windows Forms .................................................................................269 6.1. Programowanie aplikacji Windows Forms ............................................................. 270 Ręczne konstruowanie aplikacji Windows Forms .................................................. 271 6.2. Klasy kontrolek przestrzeni nazw Windows.Forms ................................................ 274 Klasa Control .................................................................................................... 274 Praca z kontrolkami ........................................................................................... 276 Zdarzenia związane z kontrolkami ....................................................................... 281 6.3. Klasa Form ....................................................................................................... 286 Konfigurowanie wyglądu formularza ..................................................................... 288 Ustawianie położenia i rozmiaru formularza ......................................................... 291 Wyświetlanie formularzy ..................................................................................... 292 Cykl życia formularza niemodalnego .................................................................... 293 Wzajemne oddziaływanie formularzy — przykład prostej aplikacji ........................... 295 Formularz właściciela i formularze własności ....................................................... 298 Okna komunikatów i okna dialogowe ................................................................... 300 Formularze MDI ................................................................................................. 302 6.4. Praca z menu .................................................................................................... 306 Właściwości klasy MenuItem .............................................................................. 306 Menu kontekstowe ............................................................................................ 307 6.5. Dodawanie pomocy do formularza ...................................................................... 308 Podpowiedzi ...................................................................................................... 309 Obsługa zdarzeń naciśnięcia klawisza F1 i kliknięcia przycisku Pomoc ................... 310 Komponent HelpProvider .................................................................................... 312 6.6. Dziedziczenie formularzy .................................................................................... 313 Konstruowanie i korzystanie z bibliotek formularzy ............................................... 313 Korzystanie z formularzy potomnych .................................................................... 314 6.7. Podsumowanie .................................................................................................. 315 6.8. Sprawdź, czego się nauczyłeś ............................................................................. 316 Rozdział 7. Kontrolki formularzy Windows Forms ...............................................................................317 7.1. Przegląd dostępnych w technologii .NET kontrolek formularzy Windows Forms ........ 318 7.2. Klasy przycisków, grup kontrolek, paneli i etykiet ................................................. 321 Klasa Button ..................................................................................................... 321 Klasa CheckBox ................................................................................................ 323 Klasa RadioButton ............................................................................................ 324 Klasa GroupBox ................................................................................................ 325 Klasa Panel ...................................................................................................... 326 Klasa Label ...................................................................................................... 328 7.3. Kontrolki PictureBox i TextBox ............................................................................ 329 Klasa PictureBox ............................................................................................... 329 Klasa TextBox ................................................................................................... 331 7.4. Klasy ListBox, CheckedListBox i ComboBox ......................................................... 333 Klasa ListBox .................................................................................................... 333 Pozostałe kontrolki list: ComboBox i CheckedListBox ........................................... 338 7.5. Klasy ListView i TreeView ................................................................................... 339 Klasa ListView .................................................................................................. 339 Klasa TreeView ................................................................................................. 346 7.6.Klasy ProgressBar, Timer i StatusStrip ................................................................ 351 Konstruowanie obiektów kontrolek StatusStrip .................................................... 351 7.7. Konstruowanie kontrolek niestandardowych ........................................................ 353 Rozbudowa istniejącej kontrolki .......................................................................... 354 Budowa niestandardowej kontrolki użytkownika ................................................... 354 10 C# i .NET Przykład kontrolki UserControl ............................................................................ 355 Stosowanie niestandardowych kontrolek użytkownika ........................................... 356 Praca z kontrolkami użytkownika na etapie projektowania aplikacji ........................ 357 7.8. Stosowanie techniki przeciągania i upuszczania w kontrolkach formularzy WinForms ................................................................... 358 Wprowadzenie do techniki przeciągania i upuszczania .......................................... 358 7.9. Korzystanie z zasobów ....................................................................................... 364 Praca z plikami zasobów .................................................................................... 364 Stosowanie plików zasobów w procesie tworzenia formularzy obsługujących wiele języków .................................................................................................. 368 7.10. Podsumowanie ................................................................................................. 371 7.11. Sprawdź, czego się nauczyłeś ............................................................................ 371 Rozdział 8. Elementy graficzne biblioteki GDI+ w technologii .NET ......................................................373 8.1. Przegląd biblioteki GDI+ ..................................................................................... 374 Klasa Graphics ................................................................................................. 375 Zdarzenie Paint ................................................................................................. 379 8.2. Używanie obiektów klasy Graphics ...................................................................... 382 Podstawowe operacje grafiki dwuwymiarowej ....................................................... 383 Pióra ................................................................................................................ 387 Pędzle .............................................................................................................. 389 Kolory .............................................................................................................. 393 Przykładowy projekt: budowa przeglądarki kolorów ............................................... 396 8.3. Obrazy .............................................................................................................. 400 Wczytywanie i zapisywanie obrazów .................................................................... 400 Operacje na obrazach ........................................................................................ 403 Przykładowy projekt: praca z obrazami ................................................................. 406 Uwaga odnośnie biblioteki GDI i BitBlt dla platformy Microsoft Windows ................ 412 8.4. Podsumowanie .................................................................................................. 413 8.5. Sprawdź, czego się nauczyłeś ............................................................................. 414 Rozdział 9. Czcionki, tekst i techniki drukowania .................................................................................417 9.1. Czcionki ........................................................................................................... 418 Rodziny czcionek ............................................................................................... 419 Klasa Font ........................................................................................................ 420 9.2. Rysowanie łańcuchów tekstowych ....................................................................... 424 Rysowanie tekstu wielowierszowego ................................................................... 424 Formatowanie łańcuchów za pomocą klasy StringFormat ...................................... 425 Stosowanie pozycji tabulacyjnych ........................................................................ 425 Przycinanie, wyrównywanie i zawijanie łańcuchów ................................................. 428 9.3. Drukowanie ....................................................................................................... 429 Wprowadzenie ................................................................................................... 430 Klasa PrintDocument ......................................................................................... 431 Ustawienia drukarki ........................................................................................... 431 Ustawienia strony .............................................................................................. 434 Zdarzenia PrintDocument ................................................................................... 435 Zdarzenie PrintPage ........................................................................................... 437 Podgląd raportu przeznaczonego do wydrukowania ............................................... 438 Przykład raportu ................................................................................................ 439 Tworzenie niestandardowych klas potomnych względem klasy PrintDocument ........ 443 9.4. Podsumowanie .................................................................................................. 445 9.5. Sprawdź, czego się nauczyłeś ............................................................................. 446 Spis treści 11 Rozdział 10. Praca z formatem XML w technologii .NET .......................................................................447 10.1. Praca z formatem XML ....................................................................................... 448 Tworzenie dokumentów XML za pomocą mechanizmu serializacji do formatu XML .. 449 Definicja schematu XML (XSD) ........................................................................... 452 Stosowanie arkuszy stylów XML .......................................................................... 454 10.2. Techniki odczytu danych w formacie XML ............................................................ 457 Klasa XmlReader ............................................................................................... 458 Klasa XmlNodeReader ....................................................................................... 463 Klasa XmlReaderSettings ................................................................................... 464 Weryfikacja danych XML z wykorzystaniem schematu XML .................................... 464 Opcje związane z odczytem danych XML .............................................................. 466 10.3. Techniki zapisywania danych w formacie XML ...................................................... 466 10.4. Przeszukiwanie kodu XML za pomocą instrukcji języka XPath ................................ 469 Konstruowanie zapytań języka XPath ................................................................... 470 Klasa XmlDocument i instrukcje języka XPath ...................................................... 473 Klasa XPathDocument i instrukcje języka XPath ................................................... 473 Klasa XmlDataDocument i instrukcje języka XPath ............................................... 474 10.5. Podsumowanie .................................................................................................. 476 10.6. Sprawdź, czego się nauczyłeś ............................................................................. 477 Rozdział 11. ADO.NET ................................................................................................................................479 11.1. Architektura ADO.NET ........................................................................................ 480 Dostawca danych OLE DB w .NET ....................................................................... 481 Dostawca danych .NET ...................................................................................... 481 11.2. Modele dostępu do danych — połączeniowy i bezpołączeniowy ............................. 483 Model połączeniowy .......................................................................................... 484 Model bezpołączeniowy ..................................................................................... 485 11.3. Model połączeniowy ADO.NET ............................................................................ 487 Klasy do obsługi połączenia ............................................................................... 487 Obiekt polecenia ............................................................................................... 490 Obiekt DataReader ............................................................................................ 494 11.4. Klasy DataSet, DataTable i model bezpołączeniowy ............................................. 497 Klasa DataSet .................................................................................................. 497 Kolekcja DataTable ........................................................................................... 497 Ładowanie danych do obiektu DataSet ................................................................ 501 Używanie obiektu DataAdapter do aktualizacji bazy danych ................................... 503 Definiowanie relacji między tabelami w obiekcie DataSet ...................................... 506 Wybór między modelem połączeniowym a bezpołączeniowym ................................ 509 11.5. XML i ADO.NET ................................................................................................. 509 Używanie obiektów DataSet do tworzenia plików z danymi i szablonami XML .............. 510 Tworzenie szablonu obiektu DataSet na podstawie pliku XML ............................... 512 Wczytywanie danych XML do obiektu DataSet ...................................................... 512 11.6. Podsumowanie .................................................................................................. 515 11.7. Sprawdź, czego się nauczyłeś ............................................................................. 515 Rozdział 12. Wiązanie danych z kontrolkami Windows Forms .............................................................517 12.1. Wprowadzenie do wiązania danych ..................................................................... 518 Proste wiązanie danych ...................................................................................... 518 Złożone wiązanie danych z kontrolkami obsługującymi listy ................................... 520 Jednostronne i dwustronne wiązanie danych ........................................................ 521 Użycie menedżerów wiązania .............................................................................. 523 12 C# i .NET 12.2. Używanie prostego i złożonego wiązania danych w aplikacjach .............................. 526 Wiązanie z obiektem DataTable .......................................................................... 526 Wiązanie kontrolek z obiektem ArrayList .............................................................. 528 Dodawanie elementów do źródła danych ............................................................. 530 Identyfikacja aktualizacji .................................................................................... 531 Aktualizacja oryginalnej bazy danych ................................................................... 532 12.3. Klasa DataGridView ........................................................................................... 532 Właściwości ...................................................................................................... 532 Zdarzenia ......................................................................................................... 539 Ustawianie relacji nadrzędna-szczegółowa w kontrolkach DataGridView .................. 543 Tryb wirtualny .................................................................................................... 545 12.4. Podsumowanie .................................................................................................. 550 12.5. Sprawdź, czego się nauczyłeś ............................................................................. 550 Część III Zaawansowane techniki jezyka C# i platformy .NET 553 Rozdział 13. Programowanie asynchroniczne i wielowątkowość ......................................................555 13.1. Czym jest wątek? .............................................................................................. 556 Wielowątkowość ................................................................................................ 556 13.2. Programowanie asynchroniczne .......................................................................... 559 Delegacje asynchroniczne .................................................................................. 560 Przykłady implementacji wywołań asynchronicznych .............................................. 563 13.3. Bezpośrednie używanie wątków .......................................................................... 571 Tworzenie i używanie wątków .............................................................................. 571 Praktyczne wykorzystanie wielowątkowości .......................................................... 574 Używanie puli wątków ........................................................................................ 577 Klasy Timer ....................................................................................................... 578 13.4. Synchronizacja wątków ...................................................................................... 580 Atrybut Synchronization ...................................................................................... 582 Klasa Monitor ................................................................................................... 583 Muteksy ........................................................................................................... 584 Semafory .......................................................................................................... 585 Unikanie zakleszczenia ...................................................................................... 587 Podsumowanie technik synchronizacji ................................................................. 588 13.5. Podsumowanie .................................................................................................. 589 13.6. Sprawdź, czego się nauczyłeś ............................................................................. 590 Rozdział 14. Tworzenie aplikacji rozproszonych za pomocą technologii Remoting ..........................593 14.1. Domeny aplikacji ............................................................................................... 594 Zalety domen aplikacji ....................................................................................... 594 Domeny aplikacji i zestawy ................................................................................. 595 Używanie klasy AppDomain ................................................................................ 596 14.2. Zdalne korzystanie z obiektów ............................................................................ 598 Architektura technologii Remoting ....................................................................... 600 Rodzaje wywołań zdalnych .................................................................................. 603 Obiekty aktywowane przez klienta ....................................................................... 604 Obiekty aktywowane przez serwer ....................................................................... 605 Rejestracja typów .............................................................................................. 606 Zdalne wywołania obiektów aktywowanych przez serwer ....................................... 609 Zdalne wywoływanie obiektów aktywowanych przez klienta .................................... 616 Projektowanie aplikacji rozproszonych ................................................................. 621 Spis treści 13 14.3. Dzierżawy i sponsorowanie ................................................................................. 622 Dzierżawa ......................................................................................................... 623 Sponsorowanie ................................................................................................. 626 14.4. Podsumowanie .................................................................................................. 628 14.5. Sprawdź, czego się nauczyłeś ............................................................................. 628 Rozdział 15. Usprawnianie kodu, bezpieczeństwo i instalacja .............................................................631 15.1. Stosowanie standardów programowania platformy .NET ....................................... 633 Używanie FxCop ................................................................................................ 633 15.2. Zestawy z silną nazwą ....................................................................................... 636 Tworzenie zestawów z silną nazwą ...................................................................... 637 Podpisywanie opóźnione .................................................................................... 638 Globalna pamięć podręczna zestawów (GAC) ....................................................... 639 Kontrola wersji .................................................................................................. 640 15.3. Bezpieczeństwo ................................................................................................ 641 Uprawnienia i zbiory uprawnień ........................................................................... 642 Dowód .............................................................................................................. 646 Zasady bezpieczeństwa ..................................................................................... 648 Konfigurowanie zasad bezpieczeństwa ................................................................ 650 Narzędzie konfiguracyjne platformy .NET ............................................................. 651 Konfiguracja bezpieczeństwa opartego na uprawnieniach kodu za pomocą narzędzia konfiguracyjnego — przykład praktyczny ............................................................ 653 Żądanie uprawnień dla zestawu .......................................................................... 657 Zabezpieczanie programowe ............................................................................... 660 15.4. Instalowanie aplikacji ........................................................................................ 667 Instalacja w systemie Windows — XCOPY a instalator Windows ............................ 667 Instalowanie zestawów w globalnej pamięci podręcznej zestawów ......................... 668 Instalowanie zestawów prywatnych ..................................................................... 668 Konfigurowanie za pomocą elementu codeBase ................................................... 669 Używanie pliku konfiguracyjnego do zarządzania różnymi wersjami zestawów .......... 670 Wersje zestawu i informacje o produkcie ............................................................. 670 15.5. Podsumowanie .................................................................................................. 671 15.6. Sprawdź, czego się nauczyłeś ............................................................................. 672 Część IV Programowanie aplikacji internetowych 675 Rozdział 16. Formularze i kontrolki ASP.NET .........................................................................................677 16.1. Komunikacja klient-serwer poprzez połączenie internetowe ................................... 678 Przykładowa aplikacja internetowa ...................................................................... 680 Kalkulator BMI w języku ASP.NET ........................................................................ 684 Model wykorzystujący kod inline ......................................................................... 685 Model wykorzystujący kod ukryty ......................................................................... 691 Kod ukryty i klasy częściowe .............................................................................. 695 Klasa Page ....................................................................................................... 696 16.2. Kontrolki formularzy Web ................................................................................... 699 Przegląd kontrolek Web ..................................................................................... 700 Określanie wyglądu kontrolek Web ...................................................................... 701 Proste kontrolki ................................................................................................. 701 Kontrolki do obsługi list ..................................................................................... 706 Kontrolka DataList ............................................................................................ 708 14 C# i .NET 16.3. Wiązanie danych oraz kontrolki do obsługi źródeł danych ...................................... 711 Wiązanie z obiektem DataReader ....................................................................... 711 Wiązanie z obiektem DataSet ............................................................................. 712 Kontrolki do obsługi źródeł danych ...................................................................... 714 16.4. Kontrolki walidacyjne ......................................................................................... 721 Używanie kontrolek walidacyjnych ....................................................................... 721 16.5. Strony główne i strony z treścią .......................................................................... 725 Tworzenie strony głównej ................................................................................... 726 Tworzenie stron z treścią ................................................................................... 727 Dostęp do strony głównej ze stron z treścią ......................................................... 728 16.6. Tworzenie i używanie niestandardowych kontrolek Web ........................................ 729 Przykładowa niestandardowa kontrolka ............................................................... 729 Używanie niestandardowych kontrolek ................................................................. 732 Zarządzanie stanem kontrolki ............................................................................. 732 Kontrolki złożone ............................................................................................... 733 16.7. Wybór kontrolki Web do wyświetlania danych ....................................................... 736 16.8. Podsumowanie .................................................................................................. 737 16.9. Sprawdź, czego się nauczyłeś ............................................................................. 737 Rozdział 17. Środowisko aplikacji ASP.NET ...........................................................................................739 17.1. Klasy HttpRequest i HttpResponse ..................................................................... 740 Obiekt HttpRequest ........................................................................................... 741 Obiekt HttpResponse ........................................................................................ 744 17.2. ASP.NET i pliki konfiguracyjne ............................................................................ 748 Zawartość pliku web.config ................................................................................ 749 Dodawanie niestandardowych elementów konfiguracyjnych ................................... 753 17.3. Bezpieczeństwo aplikacji ASP.NET ...................................................................... 756 Uwierzytelnianie przy użyciu formularzy ................................................................ 757 Przykład zastosowania uwierzytelniania przy użyciu formularzy ............................... 759 17.4. Przechowywanie stanu ....................................................................................... 763 Stan aplikacji .................................................................................................... 765 Stan sesji ......................................................................................................... 766 17.5. Pamięć podręczna ............................................................................................. 769 Umieszczanie w pamięci podręcznej odpowiedzi ................................................... 769 Umieszczanie danych w pamięci podręcznej ........................................................ 772 17.6. Tworzenie klienta używającego klas WebRequest i WebResponse ......................... 775 Klasy WebRequest i WebResponse ..................................................................... 775 Przykładowy klient internetowy ............................................................................ 775 17.7. Potoki HTTP ...................................................................................................... 777 Przetwarzania żądania w potoku ......................................................................... 778 Klasa HttpApplication ........................................................................................ 779 Moduły HTTP ..................................................................................................... 782 Obiekty obsługi HTTP ......................................................................................... 787 17.8. Podsumowanie .................................................................................................. 790 17.9. Sprawdź, czego się nauczyłeś ............................................................................. 791 Rozdział 18. Usługi Web ..........................................................................................................................793 18.1. Wprowadzenie do usług Web .............................................................................. 794 Wyszukiwanie i używanie usług Web .................................................................... 796 18.2. Tworzenie usługi Web ........................................................................................ 798 Samodzielne tworzenie usługi Web ..................................................................... 799 Tworzenie usługi Web za pomocą środowiska VS.NET .......................................... 802 Rozszerzanie usług Web za pomocą atrybutów WebService i WebMethod ............... 803 Spis treści 15 18.3. Tworzenie klienta usługi Web ............................................................................. 806 Tworzenie prostego klienta używającego klasy usługi Web .................................... 807 Tworzenie pośrednika za pomocą środowiska Visual Studio .NET .......................... 814 18.4. Język WSDL i protokół SOAP ............................................................................... 815 Język opisu usług Web (WSDL) ........................................................................... 815 Prosty protokół dostępu do obiektów (SOAP) ....................................................... 818 18.5. Używanie złożonych typów danych w usługach Web .............................................. 825 Usługa Web zwracająca rysunki .......................................................................... 825 Używanie usług Web Amazonu ............................................................................ 827 Tworzenie pośrednika dla usług Web Amazonu .................................................... 829 Tworzenie klienta usługi Web za pomocą formularzy Windows ............................... 830 18.6. Wydajność usług Web ........................................................................................ 832 Konfigurowanie połączenia HTTP ........................................................................ 833 Obsługa dużych ilości danych ............................................................................. 834 18.7. Podsumowanie .................................................................................................. 835 18.8. Sprawdź, czego się nauczyłeś ............................................................................. 835 Dodatki 837 Dodatek A Elementy wprowadzone w .NET 2.0 i C# 2.0 .......................................................................839 Dodatek B Zdarzenia i delegacje kontrolki DataGridView ...................................................................843 Odpowiedzi do pytań ...............................................................................................................................853 Skorowidz ...............................................................................................................................................869 Rozdział 1. n Wprowadzenie do technologii .NET i języka C# 27 Zagadnienia omawiane w tym rozdziale: n Przegląd składników platformy .NET — architektura i najważniejsze cechy technologii .NET. n Wspólne środowisko uruchomieniowe (CLR) — przegląd zadań wykonywanych przez część uruchomieniową (wykonawczą) platformy .NET Framework, czyli funkcjonowania kompilatora „na bieżąco” (JIT), mechanizmów wczytywania zestawów oraz technik weryfikacji kodu. n Wspólny system typów (CTS) i specyfikacja wspólnego języka (CLS) — mechanizmy wspólnego środowiska uruchomieniowego (CLR) w zakresie zapewniania zgodności i możliwości współpracy języków programowania. n Zestawy .NET — analiza struktury zestawów, filozofii tych zestawów oraz różnic pomiędzy zestawami prywatnymi a zestawami współdzielonymi. n Biblioteka klas platformy (FCL) — biblioteka platformy .NET oferuje setki klas bazowych pogrupowane w ramach logicznych przestrzeni nazw. n Narzędzia programowania — wraz z platformą .NET otrzymujemy wiele narzędzi ułatwiających wytwarzanie kodu źródłowego. Mamy do dyspozycji między innymi narzędzie Ildasm do odwracania kompilacji kodu, WinCV do przeglądania właściwości klasy oraz narzędzie konfiguracyjne Framework Configuration. n Kompilowanie i uruchamianie programów napisanych w języku C# — korzystanie z kompilatora języka programowania C# z poziomu wiersza poleceń wraz z omówieniem opcji decydujących o strukturze kompilowanej aplikacji. Efektywne używanie języka programowania wymaga czegoś więcej niż dobrej znajomości jego składni i oferowanych mechanizmów. W praktyce podczas poznawania najnowszych technologii coraz większą rolę odgrywa dogłębne studiowanie samych środowisk progra- mowania. Nie wystarczy więc opanowanie do perfekcji samego języka C# — wydajny 28 Część I n Podstawy programowania w języku C# i wprowadzenie do technologii .NET i skuteczny programista czy architekt oprogramowania musi też nabrać biegłości w korzy- staniu z odpowiednich bibliotek klas i narzędzi umożliwiającej zagłębianie się w te biblio- teki, diagnozowanie kodu oraz sprawdzanie faktycznej efektywności stosowanych konstrukcji programistycznych. Celem tego rozdziału jest uświadomienie Czytelnikom istnienia najważniejszych rozwiązań oferowanych w ramach środowiska .NET, zanim jeszcze przystąpią do nauki składni i se- mantyki języka programowania C#. Skupimy się przede wszystkim na tym, jak to środowi- sko (nie język) wpływa na sposób wytwarzania oprogramowania. Jeśli nie masz doświad- czenia w korzystaniu z technologii .NET, powinieneś uważnie przestudiować kilka nowych koncepcji, które tam wprowadzono. .NET zmienia sposób myślenia o dziedziczonym (często przestarzałym) kodzie oraz kontroli wersji, zmienia sposób dysponowania zasobami pro- gramowymi, umożliwia korzystanie z kodu napisanego w jednym z poziomu innego języka, upraszcza wdrażanie kodu, ponieważ eliminuje niepotrzebne związki z rejestrem systemo- wym, oraz tworzy samo-opisujący metajęzyk, który może być wykorzystywany do określania logiki programu w czasie jego wykonywania. Z każdym z tych elementów będziesz miał do czynienia na różnych etapach procesu wytwarzania oprogramowania i każdy z nich będzie miał wpływ na sposób projektowania i wdrażania Twoich aplikacji. Z punktu widzenia programisty platforma .NET składa się ze środowiska uruchomieniowego (wykonawczego) połączonego z biblioteką klas bazowych. Organizacja tego rozdziału odpo- wiada właśnie takiemu postrzeganiu platformy .NET. Rozdział zawiera dwa osobne podroz- działy poświęcone odpowiednio wspólnemu środowisku uruchomieniowemu (ang. Common Language Runtime — CLR) oraz bibliotece klas platformy (ang. Framework Class Library — FCL). W dalszej części tego rozdziału zostaną przedstawione podstawowe narzędzia, dzięki którym programista może nie tylko w sposób wręcz intuicyjny realizować pewne za- dania w procesie wytwarzaniem oprogramowania dla platformy .NET, ale też zarządzać i dys- trybuować aplikacje. W ostatnim podrozdziale, swoistym preludium rozdziału 2., Czytelnik zostanie wprowadzony w świat kompilatora C# wraz z kilkoma przykładami praktycznych zastosowań. Platformę .NET zaprojektowano jako zintegrowane środowisko, które w założeniu ma umoż- liwiać bezproblemowe wytwarzanie i uruchamianie aplikacji internetowych, aplikacji ba- zujących na Windows Forms, a nawet aplikacji dla urządzeń mobilnych (z wykorzystaniem platformy Compact Framework). Na poniższej liście wymieniono podstawowe cele, jakie po- stawili sobie twórcy tej platformy: n Zapewnienie logicznie spójnego, obiektowego środowiska dla rozmaitych aplikacji. n Zapewnienie środowiska, które pozwoli zminimalizować konflikty wersji (popularnie nazywane „piekłem DLL”), które przez wiele lat prześladowały programistów Windows (COM) i — tym samym — uprościć proces dystrybucji (instalacji) kodu. Rozdział 1. n Wprowadzenie do technologii .NET i języka C# 29 n Zapewnienie przenośnego środowiska, które będzie bazowało na certyfikowanych standardach i które będzie dawało możliwość zarządzania przez dowolny system operacyjny. Już teraz język programowania C# i podstawowy składnik środowiska uruchomieniowego technologii .NET, infrastruktura wspólnego języka (ang. Common Language Infrastructure — CLI), są objęte odpowiednimi standardami ECMA1. n Zapewnienie środowiska zarządzanego, w którym weryfikacja kodu pod kątem bezpieczeństwa wykonywania będzie możliwie prosta. Aby zrealizować te ambitne cele, projektanci platformy .NET Framework opracowali dość specyficzną architekturę, która dzieli tę platformę na dwie części: wspólne środowisko uru- chomieniowe (CLR) oraz bibliotekę klas platformy (FCL). Na rysunku 1.1 przedstawiono gra- ficzną reprezentację zastosowanego podejścia. Rysunek 1.1. Platforma .NET Środowisko uruchomieniowe CLR, czyli opracowana przez firmę Microsoft
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

C# i .NET
Autor:

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: