Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00554 008281 13404299 na godz. na dobę w sumie
Microsoft Visual C# 2010 Krok po kroku - ebook/pdf
Microsoft Visual C# 2010 Krok po kroku - ebook/pdf
Autor: Liczba stron:
Wydawca: Promise Język publikacji: polski
ISBN: 978-83-7541-285-7 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie
Porównaj ceny (książka, ebook, audiobook).

Praktyczny przewodnik krok po kroku nauki programowania w języku Visual C#. Naucz się krok po kroku, jak tworzyć własne aplikacje w oparciu o język Visual C# 2010 oraz platformę Microsoft .NET Framework 4.0.

Książka jest przeznaczona dla osób posiadających już podstawowe umiejętności w zakresie programowania, pozwalając w serii ćwiczeń praktycznie opanować zasady języka C# i tworzenie aplikacji i składników dla systemu Windows.

Dowiedz się jak:
• Używać zmiennych, instrukcji, operatorów i metod
• Utworzyć aplikację opartą na platformie Windows Presentation Foundation
• Tworzyć interfejs użytkownika i sprawdzać poprawność wprowadzanych danych
• Zarządzać błędami i obsługiwać wyjątki
• Zarządzać zasobami przy użyciu procesu oczyszczania pamięci
• Używać typów ogólnych, tworzyć nowe typy danych oraz składniki wielokrotnego użytku
• Odpytywać i manipulować danymi przy użyciu zapytań w języku LINQ oraz bibliotek ADO.NET
• Badać obsługę wielowątkowości oferowaną przez bibliotekę Task Parallel Library
• Rozpocząć tworzenie własnych usług webowych przy użyciu platformy Windows Communication Foundation
(Dla czytelników eBook'a obraz dysku CD towarzyszącego książce jest dostępny na stronie wydawcy - dokładny link podano we wstępie eBook'a).

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

Darmowy fragment publikacji:

Microsoft® Visual C# ® 2010 Krok po kroku John Sharp przekład: Maria Chaniewska, Krzysztof Szkudlarek ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Microsoft® Visual C#® 2010 Krok po kroku © 2010 APN PROMISE Sp. z o. o. Authorized translation of English edition of Microsoft® Visual C#® 2010 Step by Step © 2010 John Sharp This translation is published and sold by permission of O’Reilly Media, Inc., which owns or controls of all rights to publish and sell the same. APN PROMISE Sp. z o. o., biuro: ul. Kryniczna 2, 03-934 Warszawa tel. +48 22 35 51 642, fax +48 22 35 51 699 e-mail: mspress@promise.pl Wszystkie prawa zastrzeżone. Żadna część niniejszej książki nie może być powielana ani rozpowszechniana w jakiejkolwiek formie i w jakikolwiek sposób (elektroniczny, mechaniczny), włącznie z fotokopiowaniem, nagrywaniem na taśmy lub przy użyciu innych systemów bez pisemnej zgody wydawcy. Microsoft, Microsoft Press, Access, ActiveX, Arc, Azure, DataTips, Excel, Expression, Halo, IntelliSense, Internet Explorer, MS, MSDN, MS-DOS, PowerPoint, SharePoint, Silverlight, SQL Server, Visual Basic, Visual C#, Visual C++, Visual InterDev, Visual Studio, Windows, Windows Azure, Windows Server, Windows Vista oraz Zoo Tycoon są zarejestrowanymi znakami towarowymi Micros oft Corporation. Wszystkie inne nazwy handlowe i towarowe występujące w niniejszej publikacji mogą być znakami towarowymi zastrzeżonymi lub nazwami zastrzeżonymi odpowiednich firm odnośnych właścicieli. Przykłady firm, produktów, osób i wydarzeń opisane w niniejszej książce są fikcyjne i nie odnoszą się do żadnych konkretnych firm, produktów, osób i wydarzeń. Ewentualne podobieństwo do jakiejkolwiek rzeczywistej firmy, organizacji, produktu, nazwy domeny, adresu poczty elektronicznej, logo, osoby, miejsca lub zdarzenia jest przypadkowe i niezamierzone. APN PROMISE Sp. z o. o. dołożyła wszelkich starań, aby zapewnić najwyższą jakość tej publikacji. Jednakże nikomu nie udziela się rękojmi ani gwarancji. APN PROMISE Sp. z o. o. nie jest w żadnym wypadku odpowiedzialna za jakiekolwiek szkody będące następstwem korzystania z informacji zawartych w niniejszej publikacji, nawet jeśli APN PROMISE została powiadomiona o możliwości wystąpienia szkód. ISBN: 978-83-7541-066-2 Przekład: Maria Chaniewska, Krzysztof Szkudlarek Redakcja: Marek Włodarz Korekta: Ewa Swędrowska, Anna Wojdanowicz Skład i łamanie: MAWart Marek Włodarz ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Spis treści Wstęp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Określenie najlepszego miejsca, od którego należy rozpocząć lekturę tej książki . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xiv Wymagania sprzętowe i programowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xvii Korzystanie z obrazu dysku CD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xvii xiii Część I Wprowadzenie do języka Microsoft Visual C# oraz Microsoft Visual Studio 2010 1 Wprowadzenie do języka C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 Rozpoczynamy programowanie przy użyciu środowiska Visual Studio 2010 4 Piszemy pierwszy program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 15 Przestrzenie nazw . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 Tworzenie aplikacji graficznej . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Krótkie podsumowanie rozdziału 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30 2 Zmienne, operatory i wyrażenia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31 31 Instrukcje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Identyfikatory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 33 Słowa kluczowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34 Zmienne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34 Nazywanie zmiennych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35 Deklarowanie zmiennych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Podstawowe typy danych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36 36 Zmienne lokalne bez przypisanej wartości . . . . . . . . . . . . . . . . . . . . . . . 37 Wyświetlanie wartości podstawowych typów danych . . . . . . . . . . . . . . 42 Posługiwanie się operatorami arytmetycznymi . . . . . . . . . . . . . . . . . . . . . . Operatory i typy danych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42 44 Poznajemy operatory arytmetyczne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47 Kontrolowanie pierwszeństwa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48 Stosowanie zasad łączności przy wyznaczaniu wartości wyrażeń . . . . . Zasady łączności a operator przypisania . . . . . . . . . . . . . . . . . . . . . . . . . 48 50 Inkrementacja i dekrementacja wartości zmiennych . . . . . . . . . . . . . . . . . . Formy przyrostkowe i przedrostkowe . . . . . . . . . . . . . . . . . . . . . . . . . . . 50 Deklarowanie zmiennych lokalnych o niejawnie określonym typie danych 51 Krótkie podsumowanie rozdziału 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53 3 Tworzenie metod i stosowanie zasięgów zmiennych . . . . . . . . . . . 55 55 Tworzenie metod . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56 Deklarowanie metody . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Zwracanie danych przez metodę . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57 ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== iii Wywoływanie metod . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Określanie składni wywołania metody . . . . . . . . . . . . . . . . . . . . . . . . . . . Stosowanie zasięgu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Definiowanie zasięgu lokalnego . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Definiowanie zasięgu klasy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Przeciążanie metod . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Tworzenie metod . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Stosowanie parametrów opcjonalnych oraz nazwanych argumentów . . . . Definiowanie parametrów opcjonalnych . . . . . . . . . . . . . . . . . . . . . . . . . Przekazywanie nazwanych argumentów . . . . . . . . . . . . . . . . . . . . . . . . . Rozwiązywanie niejednoznaczności związanych z parametrami opcjonalnymi i argumentami nazwanymi . . . . . . . . . Krótkie podsumowanie rozdziału 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 Instrukcje wyboru . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Deklarowanie zmiennych logicznych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Stosowanie operatorów logicznych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Operatory równościowe oraz operatory relacji . . . . . . . . . . . . . . . . . . . . Warunkowe operatory logiczne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Skracanie działania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Podsumowanie informacji o pierwszeństwie oraz łączności 59 59 62 62 63 63 64 73 74 75 76 81 83 83 84 84 85 86 87 operatorów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88 Podejmowanie decyzji przy użyciu instrukcji if . . . . . . . . . . . . . . . . . . . . . . . Składnia instrukcji if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88 Grupowanie instrukcji w bloki . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89 Kaskadowe łączenie instrukcji if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90 96 Stosowanie instrukcji switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96 Składnia instrukcji switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97 Reguły stosowania instrukcji switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Krótkie podsumowanie rozdziału 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101 5 Złożone instrukcje przypisania oraz instrukcje iteracji . . . . . . . . . 103 103 Złożone operatory przypisania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105 Instrukcja while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Instrukcja for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110 111 Zasięg instrukcji for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112 Instrukcja do . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122 Krótkie podsumowanie rozdziału 5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 Obsługa błędów i wyjątków . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123 124 Zmaganie się z błędami . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124 Wypróbowywanie kodu i przechwytywanie wyjątków . . . . . . . . . . . . . . . 126 Nieobsłużone wyjątki . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Stosowanie kilku bloków obsługi pułapki . . . . . . . . . . . . . . . . . . . . . . . 127 128 Przechwytywanie wielu wyjątków . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Wykonywanie operacji arytmetycznych z kontrolą lub bez kontroli przepełnienia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Pisanie instrukcji objętych kontrolą przepełniania . . . . . . . . . . . . . . . . 133 134 iv Spis treści ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Pisanie wyrażeń objętych kontrolą przepełniania . . . . . . . . . . . . . . . . . 135 Zgłaszanie wyjątków . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137 141 Stosowanie bloku finally . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Krótkie podsumowanie rozdziału 6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143 Część II Język C# 7 Tworzenie i zarządzanie klasami oraz obiektami . . . . . . . . . . . . . . Omówienie klasyfikacji . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Cele hermetyzacji . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Definiowanie i używanie klas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Kontrolowanie dostępności . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Konstruktory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Przeciążanie konstruktorów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Metody i dane statyczne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Tworzenie pól współdzielonych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Tworzenie pól statycznych przy użyciu słowa kluczowego const . . . . . Klasy statyczne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Klasy anonimowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Krótkie podsumowanie rozdziału 7 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 Wartości i referencje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Kopiowanie klas oraz zmiennych typu wartościowego . . . . . . . . . . . . . . . Wartości Null oraz typy danych dopuszczające stosowanie wartości Null . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Typy danych dopuszczające stosowanie wartości Null . . . . . . . . . . . . . Właściwości typów danych dopuszczających stosowanie wartości Null . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Używanie parametrów typu ref i out . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Tworzenie parametrów typu ref . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Tworzenie parametrów typu out . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Sposób organizacji pamięci komputera . . . . . . . . . . . . . . . . . . . . . . . . . . . Korzystanie ze stosu oraz ze sterty . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Klasa System.Object . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Opakowywanie typów danych wewnątrz obiektów . . . . . . . . . . . . . . . . . . Rozpakowywanie typów danych, opakowanych wewnątrz obiektów . . . Bezpieczne rzutowanie danych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Operator is . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Operator as . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Krótkie podsumowanie rozdziału 8 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 Tworzenie typów wartości przy użyciu wyliczeń oraz struktur . . Wyliczeniowe typy danych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Deklarowanie wyliczeniowego typu danych . . . . . . . . . . . . . . . . . . . . . Stosowanie wyliczeniowych typów danych . . . . . . . . . . . . . . . . . . . . . . Wybór wartości literałów wyliczeniowych . . . . . . . . . . . . . . . . . . . . . . . 147 148 148 149 150 152 153 161 162 163 163 167 169 171 171 177 178 179 180 181 182 184 185 186 187 188 190 190 191 195 197 197 198 198 199 Spis treści v ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Wybór typu danych używanego do wewnętrznego 200 reprezentowania wartości wyliczeniowych . . . . . . . . . . . . . . . . . . . . 203 Struktury . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204 Deklarowanie struktury . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205 Omówienie różnicy pomiędzy strukturami i klasami . . . . . . . . . . . . . . 207 Deklarowanie zmiennych strukturalnych . . . . . . . . . . . . . . . . . . . . . . . . Omówienie inicjalizacji struktur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208 Kopiowanie zmiennych strukturalnych . . . . . . . . . . . . . . . . . . . . . . . . . . 212 216 Krótkie podsumowanie rozdziału 9 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 Tablice i kolekcje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217 217 Czym jest tablica? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218 Deklarowanie zmiennych tablicowych . . . . . . . . . . . . . . . . . . . . . . . . . . 218 Tworzenie instancji tabeli . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219 Inicjalizowanie zmiennych tablicowych . . . . . . . . . . . . . . . . . . . . . . . . . Tworzenie tablic o niejawnie określonym typie elementów . . . . . . . . . 220 Korzystanie z indywidualnych elementów tablicy . . . . . . . . . . . . . . . . . 221 Wykonywanie iteracji poprzez elementy tablicy . . . . . . . . . . . . . . . . . . 222 224 Kopiowanie tablic . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225 Tablice wielowymiarowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226 Wykorzystanie tablic do gry w karty . . . . . . . . . . . . . . . . . . . . . . . . . . . Co to są klasy kolekcji? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233 Klasa kolekcji ArrayList . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235 237 Klasa kolekcji Queue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 238 Klasa kolekcji Stack . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Klasa kolekcji Hashtable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239 240 Klasa kolekcji SortedList . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241 Inicjalizowanie kolekcji . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242 Porównanie tablic i kolekcji . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Wykorzystanie klas kolekcji do gry w karty . . . . . . . . . . . . . . . . . . . . . . 242 246 Krótkie podsumowanie rozdziału 10 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 Tablice parametrów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247 Używanie argumentów będących tablicami . . . . . . . . . . . . . . . . . . . . . . . . 248 Deklarowanie tablicy parametrów typu params . . . . . . . . . . . . . . . . . . 249 Używanie parametru typu params object[ ] . . . . . . . . . . . . . . . . . . . . . . 251 253 Stosowanie tablicy parametrów typu params . . . . . . . . . . . . . . . . . . . . 256 Porównanie tablic parametrów z parametrami opcjonalnymi . . . . . . . . . Krótkie podsumowanie rozdziału 11 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 258 12 Dziedziczenie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259 259 Czym jest dziedziczenie? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Korzystanie z mechanizmów dziedziczenia . . . . . . . . . . . . . . . . . . . . . . . . 260 Wywoływanie konstruktora klasy bazowej . . . . . . . . . . . . . . . . . . . . . . . 262 263 Przypisywanie klas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265 Deklarowanie metod z użyciem słowa kluczowego new . . . . . . . . . . . 267 Deklarowanie metod wirtualnych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Deklarowanie metod z użyciem słowa kluczowego override . . . . . . . . 268 vi Spis treści ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Omówienie dostępu chronionego . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Metody rozszerzające . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Krótkie podsumowanie rozdziału 12 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 Tworzenie interfejsów oraz definiowanie klas abstrakcyjnych . . Interfejsy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Definiowanie interfejsu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Implementowanie interfejsu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Odwoływanie się do klasy za pomocą jej interfejsu . . . . . . . . . . . . . . . Praca z wieloma interfejsami . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Jawne implementowanie interfejsu . . . . . . . . . . . . . . . . . . . . . . . . . . . . Ograniczenia interfejsu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Definiowanie i używanie interfejsów . . . . . . . . . . . . . . . . . . . . . . . . . . . Klasy abstrakcyjne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Metody abstrakcyjne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Klasy zamknięte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Metody zamknięte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Implementowanie i używanie klas abstrakcyjnych . . . . . . . . . . . . . . . . Krótkie podsumowanie rozdziału 13 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14 Proces oczyszczania pamięci i zarządzanie zasobami . . . . . . . . . . Żywot obiektu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Tworzenie destruktorów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Dlaczego istnieje proces oczyszczania pamięci? . . . . . . . . . . . . . . . . . . Sposób działania procesu oczyszczania pamięci . . . . . . . . . . . . . . . . . . Zalecenia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Zarządzanie zasobami . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Metody sprzątające . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Sprzątanie w sposób odporny na występowanie wyjątków . . . . . . . . . Instrukcja using . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Wywoływanie metody Dispose z poziomu destruktora . . . . . . . . . . . . Implementacja metody sprzątającej w sposób odporny na występowanie wyjątków . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Krótkie podsumowanie rozdziału 14 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Część III Tworzenie komponentów 15 Implementacja właściwości w celu dostępu do pól . . . . . . . . . . . . Implementacja kapsułkowania za pomocą metod . . . . . . . . . . . . . . . . . . . Co to są właściwości? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Używanie właściwości . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Właściwości tylko do odczytu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Właściwości tylko do zapisu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Dostępność właściwości . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Ograniczenia właściwości . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Deklaracja właściwości interfejsu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Używanie właściwości w aplikacji Windows . . . . . . . . . . . . . . . . . . . . . . 271 277 281 283 283 285 285 286 287 287 290 290 300 301 302 302 303 308 309 309 311 312 314 315 315 316 316 317 319 321 324 327 328 330 331 332 332 333 334 336 337 ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Spis treści vii 339 Generowanie automatycznych właściwości . . . . . . . . . . . . . . . . . . . . . . . . 340 Inicjalizacja obiektów przez użycie właściwości . . . . . . . . . . . . . . . . . . . . . 345 Krótkie podsumowanie rozdziału 15 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 Indeksatory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 347 347 Co to jest indeksator? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 348 Przykład bez użycia indeksatorów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349 Ten sam przykład z wykorzystaniem indeksatorów . . . . . . . . . . . . . . . . 351 Akcesory indeksatora . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 352 Porównanie indeksatorów i tablic . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Indeksatory w interfejsach . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 354 Korzystanie z indeksatorów w aplikacji Windows . . . . . . . . . . . . . . . . . . . . 355 Krótkie podsumowanie rozdziału 16 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 361 17 Przerywanie działania programu oraz obsługa zdarzeń . . . . . . . . 363 364 Deklarowanie i używanie delegatów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364 Przykład zautomatyzowanej fabryki . . . . . . . . . . . . . . . . . . . . . . . . . . . . Implementacja fabryki bez używania delegatów . . . . . . . . . . . . . . . . . 365 365 Implementacja fabryki z wykorzystaniem delegata . . . . . . . . . . . . . . . 368 Korzystanie z delegatów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 373 Wyrażenia lambda a delegaty . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Tworzenie adaptera metody . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 373 374 Korzystanie z wyrażenia lambda jako adaptera . . . . . . . . . . . . . . . . . . . 374 Postać wyrażeń lambda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 376 Włączanie powiadomień za pomocą zdarzeń . . . . . . . . . . . . . . . . . . . . . . 377 Deklarowanie zdarzenia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Subskrypcja zdarzenia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 377 378 Odwołanie subskrypcji zdarzenia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378 Wywoływanie zdarzenia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 379 Zdarzenia interfejsu użytkownika WPF . . . . . . . . . . . . . . . . . . . . . . . . . . . . Używanie zdarzeń . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 380 384 Krótkie podsumowanie rozdziału 17 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18 Typy ogólne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 387 Problem z typem object . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 387 389 Rozwiązanie za pomocą typów ogólnych . . . . . . . . . . . . . . . . . . . . . . . . . . 391 Typy ogólne a klasy uogólnione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 392 Typy ogólne a ograniczenia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 392 Tworzenie klasy ogólnej . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Teoria drzew binarnych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 392 395 Budowa klasy drzewa binarnego przy użyciu typów ogólnych . . . . . . Tworzenie metody ogólnej . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 404 Definiowanie metody ogólnej do budowy drzewa binarnego . . . . . . . 405 407 409 410 413 Wariancja i interfejsy ogólne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Interfejsy kowariantne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Interfejsy kontrawariantne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Krótkie podsumowanie rozdziału 18 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . viii Spis treści ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== 19 Wyliczanie kolekcji . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 415 415 Wyliczanie elementów kolekcji . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Ręczna implementacja modułu wyliczającego . . . . . . . . . . . . . . . . . . . 417 Implementacja interfejsu IEnumerable . . . . . . . . . . . . . . . . . . . . . . . . . . 421 423 423 Implementacja modułu wyliczeniowego z wykorzystaniem iteratora . . . Prosty iterator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Definiowanie modułu wyliczającego dla klasy Tree TItem z wykorzystaniem iteratora . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Krótkie podsumowanie rozdziału 19 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 425 428 20 Odpytywanie danych znajdujących się w pamięci przy użyciu wyrażeń w języku zapytań . . . . . . . . . . . . . . . . . . . . . . . . . . . . Co to jest Language Integrated Query? . . . . . . . . . . . . . . . . . . . . . . . . . . . Używanie LINQ w aplikacji C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Wybieranie danych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Filtrowanie danych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Porządkowanie, grupowanie i agregowanie danych . . . . . . . . . . . . . . . Łączenie danych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Korzystanie z operatorów zapytań . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Odpytywanie danych w obiektach Tree TItem . . . . . . . . . . . . . . . . . . LINQ i odroczona ewaluacja . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Krótkie podsumowanie rozdziału 20 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 Przeciążanie operatorów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 429 429 430 432 434 435 437 439 441 446 449 451 Pojęcie operatorów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 451 452 452 454 456 457 458 459 460 466 466 Ograniczenia operatorów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Operatory przeciążone . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Tworzenie operatorów symetrycznych . . . . . . . . . . . . . . . . . . . . . . . . . . Złożone przypisanie z obliczaniem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Deklarowanie operatorów zwiększających i zmniejszających . . . . . . . . . . Porównanie operatorów w strukturach i klasach . . . . . . . . . . . . . . . . . . . . Definiowanie par operatorów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Implementacja operatorów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Operatory konwersji . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Świadczenie wbudowanej konwersji . . . . . . . . . . . . . . . . . . . . . . . . . . . Implementacja definiowanych przez użytkownika operatorów konwersji . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Tworzenie operatorów symetrycznych – uzupełnienie . . . . . . . . . . . . . Pisanie operatorów konwersji . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Krótkie podsumowanie rozdziału 21 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 467 468 469 472 Część IV Budowanie aplikacji Windows Presentation Foundation 22 Omówienie platformy Windows Presentation Foundation . . . . . 475 476 476 490 Tworzenie aplikacji WPF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Budowanie aplikacji WPF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Dodawanie kontrolek do formularza . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Spis treści ix ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Korzystanie z kontrolek WPF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Dynamiczne zmienianie właściwości . . . . . . . . . . . . . . . . . . . . . . . . . . . Obsługa zdarzeń w formularzu WPF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Przetwarzanie zdarzeń w formularzach Windows . . . . . . . . . . . . . . . . . Krótkie podsumowanie rozdziału 22 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 Interakcja z użytkownikiem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Wskazówki i style menu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Menu i zdarzenia menu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Tworzenie menu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Obsługiwanie zdarzeń menu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Menu podręczne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Tworzenie menu podręcznych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Typowe okna dialogowe systemu Windows . . . . . . . . . . . . . . . . . . . . . . . . Korzystanie z klasy SaveFileDialog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Zwiększanie interakcyjności w aplikacji WPF . . . . . . . . . . . . . . . . . . . . . . . Krótkie podsumowanie rozdziału 23 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24 Wykonywanie walidacji . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Walidacja danych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Strategie sprawdzania danych użytkownika . . . . . . . . . . . . . . . . . . . . . Przykład – Zamawianie biletów na imprezy . . . . . . . . . . . . . . . . . . . . . . . . Walidacja przy użyciu wiązania danych . . . . . . . . . . . . . . . . . . . . . . . . . Zmiana momentu przeprowadzania walidacji . . . . . . . . . . . . . . . . . . . . Krótkie podsumowanie rozdziału 24 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Część V Zarządzanie danymi 25 Zapytania do bazy danych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Wprowadzanie zapytań do bazy danych za pomocą ADO .NET . . . . . . . . Baza danych Northwind . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Tworzenie bazy danych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Korzystanie z ADO .NET do tworzenia zapytań dotyczących 490 498 502 502 507 509 510 510 511 517 522 523 526 527 530 539 541 541 542 542 543 559 563 567 568 568 569 591 596 597 598 informacji o zamówieniach . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 570 581 581 583 585 586 590 590 Zapytania do bazy danych za pomocą LINQ to SQL . . . . . . . . . . . . . . . . . Definiowanie klasy encji . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Tworzenie i uruchamianie zapytania LINQ to SQL . . . . . . . . . . . . . . . . Opóźnione i natychmiastowe pobieranie danych . . . . . . . . . . . . . . . . . Łączenie tabel i tworzenie relacji . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Odroczone i natychmiastowe pozyskiwanie danych, uzupełnienie . . . Definiowanie własnej klasy DataContext . . . . . . . . . . . . . . . . . . . . . . . . Korzystanie z LINQ to SQL do odczytywania informacji o zamówieniach . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Krótkie podsumowanie rozdziału 25 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 Wyświetlanie i edycja danych przy użyciu Entity Framework i wiązania danych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Stosowanie wiązania danych z Entity Framework . . . . . . . . . . . . . . . . . . . x Spis treści ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Używanie wiązania danych do modyfikacji danych . . . . . . . . . . . . . . . . . . Aktualizacja istniejących danych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Obsługa konfliktów aktualizacji . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Dodawanie i usuwanie danych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Krótkie podsumowanie rozdziału 26 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 615 615 616 619 628 Część VI Tworzenie profesjonalnych rozwiązań przy użyciu Visual Studio 2010 27 Biblioteka równoległego realizowania zadań . . . . . . . . . . . . . . . . . 631 Po co stosować wielozadaniowość przy użyciu przetwarzania 632 równoległego? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 634 Era procesorów wielordzeniowych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 635 Implementowanie wielozadaniowości w aplikacjach desktopowych . . . . 636 Zadania, wątki i klasa ThreadPool . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 638 Tworzenie, uruchamianie i kontrolowanie zadań . . . . . . . . . . . . . . . . . 642 Implementowanie równoległego działania przy użyciu klasy Task . . . Tworzenie abstrakcji zadań przy użyciu klasy Parallel . . . . . . . . . . . . . . 651 Zwracanie wartości z poziomu zadania . . . . . . . . . . . . . . . . . . . . . . . . . 659 664 668 668 Używanie zadań w połączeniu z interfejsem użytkownika . . . . . . . . . . . . Anulowanie zadań i obsługiwanie wyjątków . . . . . . . . . . . . . . . . . . . . . . . Mechanizm kooperatywnego anulowania . . . . . . . . . . . . . . . . . . . . . . . Obsługiwanie wyjątków zadania za pomocą klasy Używanie kontynuacji dla anulowanych lub nieudanych zadań . . . . . Krótkie podsumowanie rozdziału 27 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 Równoległy dostęp do danych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . AggregateException . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 678 681 682 685 Używanie technologii PLINQ do zrównoleglania deklaratywnego dostępu do danych . . . . . . . . . . . . . . . . . . . . . . . . . . . Używanie technologii PLINQ do zwiększenia wydajności iteracji poprzez elementy kolekcji . . . . . . . . . . . . . . . . . . . . . . . . . . . Określanie opcji dla zapytania PLINQ . . . . . . . . . . . . . . . . . . . . . . . . . . Anulowanie zapytania PLINQ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Synchronizowanie jednoczesnego dostępu do danych . . . . . . . . . . . . . . . Blokowanie danych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Podstawowe typy danych służące do synchronizacji 686 687 692 693 693 697 oferowane przez bibliotekę TPL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 698 Mechanizmy anulowania a podstawowe typy danych służące do synchronizacji . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Klasy kolekcji przystosowane do środowiska wielowątkowego . . . . . . Wykorzystanie wielowątkowych klas kolekcji oraz blokad do zaimplementowania bezpiecznego dostępu do danych w środowisku wielowątkowym . . . . . . . . . . . . . . . . . . . . Krótkie podsumowanie rozdziału 28 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 706 706 709 720 Spis treści xi ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== 29 Tworzenie i wykorzystywanie usług webowych . . . . . . . . . . . . . . . Czym jest usługa webowa? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Rola platformy Windows Communication Foundation . . . . . . . . . . . . . Architektura usługi webowej . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Usługi webowe typu SOAP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Usługi webowe typu REST . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Tworzenie usług webowych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 723 724 724 725 725 729 730 Tworzenie usługi webowej typu SOAP ProductInformation . . . . . . . . . 730 Usługi webowe typu SOAP, klienci i pośrednicy . . . . . . . . . . . . . . . . . . 739 741 Korzystanie z usługi webowej typu SOAP: ProductInformation . . . . . . 747 Tworzenie usługi webowej typu REST: ProductDetails . . . . . . . . . . . . . 755 Korzystanie z usługi webowej typu REST: ProductDetails . . . . . . . . . . . Krótkie podsumowanie rozdziału 29 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 760 Dodatek Współdziałanie z dynamicznymi językami programowania . . . . 761 762 Czym jest dynamiczne środowisko uruchomieniowe? . . . . . . . . . . . . . . . . 764 Słowo kluczowe dynamic . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Przykład: IronPython . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 764 767 Przykład: IronRuby . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 770 Podsumowanie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Indeks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 771 O autorze . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 806 xii Spis treści ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Wstęp Język Microsoft Visual C# jest bardzo potężnym, a jednocześnie prostym językiem pro- gramowania, przeznaczonym głównie dla programistów tworzących aplikacje oparte na platformie Microsoft .NET Framework. Język ten odziedziczył wiele z najlepszych cech języka C++ oraz Microsoft Visual Basic, a tylko kilka spośród występujących w tych językach niespójności lub anachronizmów, co zaowocowało powstaniem bar- dziej przejrzystego i bardziej logicznego języka programowania. Język C# w wersji 1.0 miał swój publiczny debiut w roku 2001. Pojawienie się wersji C# 2.0 wraz z progra- mem Visual Studio 2005 oznaczało dodanie do tego języka kilku ważnych i nowych funkcji, takich jak ogólne typy wyliczeniowe i metody anonimowe. W wersji C# 3.0, która pojawiła się wraz z opublikowaniem programu Visual Studio 2008, dodana została obsługa metod rozszerzających, wyrażeń lambda oraz najważniejszej ze wszyst- kich nowości – obsługi zapytań w języku LINQ (Language Integrated Query). Ostat- nie wcielenie języka C#, którym jest wersja 4.0, przyniosło kolejne udoskonalenia w zakresie polepszenia możliwości współdziałania z innymi technologiami i językami programowania. Funkcje te obejmują obsługę nazwanych i opcjonalnych argumen- tów, typ dynamic, którego użycie wskazuje, że środowisko uruchomieniowe powinno stosować dla danego obiektu tzw. późne wiązanie (ang. late binding) oraz wariancje, których wprowadzenie rozwiązuje pewne problemy związane ze sposobem definiowa- nia ogólnych interfejsów. Język C# 4.0 wykorzystuje w pełni możliwości najnowszej wersji platformy .NET Framework, która również ma numer wersji 4.0. W wersji tej wprowadzono do platformy .NET Framework wiele dodatkowych funkcji, ale zapewne najważniejsze z nich to klasy i typy danych składające się na bibliotekę równoległego realizowania zadań – TPL (Task Parallel Library). Korzystając z biblioteki TPL można szybko i łatwo tworzyć wysoko skalowalne aplikacje, które będą w pełni wykorzy- stywać możliwości wielordzeniowych procesorów. Rozszerzona została także obsługa usług webowych oraz platformy WCF (Windows Communication Foundation). Obec- nie możliwe jest już tworzenie usług zgodnych z modelem REST, a także takich, które wykorzystują bardziej tradycyjny schemat SOAP. Dzięki środowisku programowania oferowanemu przez program Microsoft Visual Studio 2010 wszystkie te rozbudowane i zaawansowane funkcje są bardzo łatwe w użyciu, a wiele nowych kreatorów i udoskonaleń programu Visual Studio 2010 może znacząco podnieść wydajność pracy każdego programisty. ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== xiii Dla kogo przeznaczona jest ta książka Niniejsza książka zakłada, że jej Czytelnik ma już pewne doświadczenie w programo- waniu i pragnie poznać podstawy programowania w języku C# przy użyciu programu Visual Studio 2010 i platformy .NET Framework w wersji 4.0. Dzięki tej książce Czytelnicy będą mieli okazję poznać wszystkie cechy języka C# i nauczyć się wykorzy- stywać je do tworzenia aplikacji działających w systemie operacyjnym Microsoft Win- dows. Po przeczytaniu tej książki Czytelnicy powinni dysponować dobrą znajomością języka C# i umieć używać tego języka do tworzenia aplikacji typu WPF (Windows Presentation Foundation), odczytywania danych z baz danych Microsoft SQL Server przy użyciu technologii ADO.NET oraz zapytań LINQ, tworzenia skalowalnych aplika- cji opartych na bibliotece TPL oraz do tworzenia usług webowych typu REST i SOAP opartych na platformie WCF. Określenie najlepszego miejsca, od którego należy rozpocząć lekturę tej książki Niniejsza książka ma za zadanie ułatwić Czytelnikowi podniesienie umiejętności w kil- ku podstawowych obszarach. Z książki tej mogą korzystać zarówno początkujący programiści, jak również programiści mający już pewne doświadczenie w innych języ- kach programowania, takich jak C, C++, Java lub Visual Basic. Zamieszczona poniżej tabela powinna ułatwić każdemu określenie najlepszego miejsca, od którego należy rozpocząć lekturę tej książki. Jeżeli jesteś Początkującym programi- stą w dziedzinie progra- mowania zorientowanego obiektowo Programistą dobrze obeznanym z procedural- nymi językami progra- mowania, takimi jak np. język C, ale nie znasz jeszcze języka C# Wykonaj następujące kroki 1. Zainstaluj pliki używane w opisywanych w tej książce ćwiczeniach, z godnie z opisem podanym w dalszej czę- ści, zatytułowanej „Instalowanie przykładowych kodów źródłowych”. 2. Przeczytaj po kolei wszystkie rozdziały z części I, II i III. 3. Przeczytaj odpowiednie rozdziały z części IV, V i VI, sto- sownie do poziomu swojego doświadczenia oraz poziomu swoich potrzeb. 1. Zainstaluj pliki używane w opisywanych w tej książce ćwiczeniach, z godnie z opisem podanym w dalszej czę- ści, zatytułowanej „Instalowanie przykładowych kodów źródłowych”. Zapoznaj się pobieżnie z treścią pierwszych pięciu rozdziałów, aby uzyskać ogólny obraz języka C# oraz możliwości programu Visual Studio 2010, a następ- nie skoncentruj się na rozdziałach od 6 do 21. 2. Przeczytaj odpowiednie rozdziały z części IV, V i VI, sto- sownie do poziomu swojego doświadczenia oraz poziomu swoich potrzeb. xiv ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Jeżeli jesteś Programistą mającym już doświadczenie w innych zorientowanych obiekto- wo językach programo- wania, takich jak np. C++ lub Java, i pragnącym nauczyć się języka C# Wykonaj następujące kroki 1. Zainstaluj pliki używane w opisywanych w tej książce ćwiczeniach, z godnie z opisem podanym w dalszej czę- ści, zatytułowanej „Instalowanie przykładowych kodów źródłowych”. 2. Zapoznaj się pobieżnie z treścią pierwszych siedmiu roz- działów, aby uzyskać ogólny obraz języka C# oraz moż- liwości programu Visual Studio 2010, a następnie skon- centruj się na rozdziałach od 8 do 21. 3. Przeczytaj rozdziały z części IV i V, aby dowiedzieć się, w jaki sposób tworzyć aplikacje dla systemu Windows oraz w jaki sposób korzystać z baz danych. 4. Przeczytaj rozdziały z części VI, aby dowiedzieć się, w jaki sposób tworzyć skalowalne aplikacje oraz usługi webowe. Programistą znającym język Visual Basic 6 i pragnącym nauczyć się języka C# 1. Zainstaluj pliki używane w opisywanych w tej książce ćwiczeniach, z godnie z opisem podanym w dalszej czę- ści, zatytułowanej „Instalowanie przykładowych kodów źródłowych”. 2. Przeczytaj po kolei wszystkie rozdziały z części I, II i III. 3. Przeczytaj rozdziały z części IV, aby dowiedzieć się, w jaki sposób tworzyć aplikacje dla systemu Windows. 4. Przeczytaj rozdziały z części V, aby dowiedzieć się, w jaki sposób korzystać z danych znajdujących się w bazach danych. 5. Przeczytaj rozdziały z części VI, aby dowiedzieć się, w jaki sposób tworzyć skalowalne aplikacje oraz usługi webowe. 6. Przeczytaj krótkie podsumowania, znajdujące się na koń- cu każdego rozdziału, aby szybko uzyskać potrzebne informacje na temat konkretnych konstrukcji języka C# oraz funkcji programu Visual Studio 2010. Zainteresowany znale- zieniem potrzebnych informacji, związanych z prezentowanymi w tej książce ćwiczeniami 1. Skorzystaj z indeksu lub spisu treści, aby znaleźć potrzeb- ne informacje na konkretny temat. 2. Przeczytaj krótkie podsumowania, znajdujące się na koń- cu każdego rozdziału, aby szybko zapoznać się z oma- wianymi w danym rozdziale technikami oraz elementami składni. ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== xv Konwencje i cechy charakterystyczne stosowane w tej książce Zawarte w tej książce informacje są prezentowane przy użyciu konwencji poprawiają- cych czytelność oraz ułatwiających śledzenie toku narracji. Konwencje n Każde ćwiczenie składa się z serii zadań. Każde zadanie prezentowane jest jako seria ponumerowanych kroków (1, 2, itd). n Uwagi oznaczone etykietą „wskazówka” zawierają dodatkowe informacje lub opis alternatywnego sposobu wykonania danego kroku. n Uwagi oznaczone etykietą „ważne” mają za zadanie zwrócenie uwagi na informacje, które należy sprawdzić przed kontynuowaniem danego ćwiczenia. n Tekst, który powinien zostać wpisany przez Czytelnika, wyróżniany jest za pomocą pogrubionej czcionki. n Znak plus (+) występujący pomiędzy nazwami dwóch klawiszy oznacza, że klawi- sze te należy wcisnąć równocześnie. Np. zdanie „Wciśnij klawisze Alt+Tab” ozna- cza, że najpierw należy wcisnąć klawisz Alt, a następnie trzymając ten klawisz wciśnięty wcisnąć klawisz Tab. Inne cechy charakterystyczne n Występujące w tej książce notatki uzupełniające zawierają bardziej wyczerpujące informacje na temat danego ćwiczenia. Notatki uzupełniające mogą zawierać infor- macje wyjaśniające podstawy, na których opiera się dane ćwiczenie, wskazówki projektowe lub opis funkcji związanych z omawianymi właśnie informacjami. n Każdy rozdział kończy się krótkim podsumowaniem. Sekcja „Krótkie podsumowa- nie rozdziału ...” zawiera krótkie streszczenie przypominające sposób wykonywania zadań omawianych w danym rozdziale. Wstępna wersja oprogramowania Przy pisaniu tej książki posługiwałem się programem Visual Studio 2010 w wersji Beta 2. Zamieszczone w tej książce przykłady zostały również przejrzane i przete- stowane przy użyciu finalnej wersji tego oprogramowania. Może się jednak zdarzyć, że pomiędzy wersją produkcyjną programu Visual Studio a prezentowanymi w tej książce przykładami, tekstami i zrzutami ekranowymi występować będą niewielkie różnice. xvi ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Wymagania sprzętowe i programowe Do wykonania prezentowanych w tej książce ćwiczeń potrzebny będzie komputer spełniający następujące wymagania sprzętowe i programowe: n System operacyjny Microsoft Windows 7 Home Premium, Windows 7 Professional, Windows 7 Enterprise lub Windows 7 Ultimate. Prezentowane ćwiczenia będą również działać w systemie Microsoft Windows Vista z dodatkiem Service Pack 2 lub nowszym. n Oprogramowanie Microsoft Visual Studio 2010 Standard, Visual Studio 2010 Pro- fessional lub Microsoft Visual C# 2010 Express oraz Microsoft Visual Web Develo- per 2010 Express. n Oprogramowanie Microsoft SQL Server 2008 Express (oprogramowanie to jest dostarczane razem ze wszystkimi edycjami programów Visual Studio 2010, Visual C# 2010 Express oraz Visual Web Developer 2010 Express). n Procesor taktowany zegarem o częstotliwości 1,6 GHz lub wyższej. Do przepro- wadzenia ćwiczeń z rozdziału 27 i 28 wymagany jest procesor dwurdzeniowy lub z większą liczbą rdzeni. n 1 GB dostępnej pamięci RAM w przypadku procesora 32 bitowego lub 2 GB w przypadku procesora 64 bitowego. n Monitor (o rozdzielczości 1024 ×768 lub wyższej) wyświetlający co najmniej 256 kolorów. n Napęd CD-ROM lub DVD-ROM. n Mysz lub inne kompatybilne urządzenie wskazujące. Skonfigurowanie oprogramowania SQL Server 2008 Express Edition wymagać będzie także dostępu do konta z uprawnieniami administracyjnymi. Korzystanie z obrazu dysku CD Obraz dysku CD towarzyszącego książce jest dostępny na stronie wydawcy przy opisie książki w zakładce Dodatkowe informacje, pod adresem: http://www.ksiazki.promise.pl/aspx/produkt.aspx?pid=55291 Na podstawie tego obrazu można wykonać fizyczny dysk CD lub zainstalować go jako napęd wirtualny. Dys
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Microsoft Visual C# 2010 Krok po kroku
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ą: