Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00418 006481 13425524 na godz. na dobę w sumie
Visual Studio 2013. Podręcznik programowania w C# z zadaniami - ebook/pdf
Visual Studio 2013. Podręcznik programowania w C# z zadaniami - ebook/pdf
Autor: , Liczba stron: 360
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-283-0027-9 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> visual c# - programowanie
Porównaj ceny (książka, ebook, audiobook).

Ucz się, projektuj, zarabiaj!

Współczesne oprogramowanie musi sprostać wysokim standardom — powinno być funkcjonalne, bezawaryjne i szybkie. Pisanie i kompilowanie takich programów znacznie ułatwiają Visual Studio 2013 oraz platforma .NET. Warto wykorzystać także obiektowy język programowania C# 5.0, sprawdzone rozwiązanie zaprojektowane i wykorzystywane przez Microsoft. Ta wiedza pomoże Ci odnieść sukces na elitarnym rynku programistów Windows.

Jeśli chcesz dowiedzieć się więcej o praktycznych aspektach działania Visual Studio, platformy .NET i programowaniu w języku C#, koniecznie przeczytaj tę książkę! Dowiesz się, jak pisać programy w C#, debugować je i kompilować. Zobaczysz, do czego służy biblioteka kontrolek i gdzie możesz bezpiecznie przechowywać dane. Przede wszystkim jednak będziesz miał możliwość rozwiązania wielu zadań, bo nic nie sprzyja nauce tak bardzo, jak samodzielne zmaganie się z ciekawymi zadaniami.

Twórz nowoczesne aplikacje w najnowszym Visual Studio i z platformą .NET!

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

Darmowy fragment publikacji:

Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną, fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym powoduje naruszenie praw autorskich niniejszej publikacji. Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądź towarowymi ich właścicieli. Autor oraz Wydawnictwo HELION dołożyli wszelkich starań, by zawarte w tej książce informacje były kompletne i rzetelne. Nie biorą jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane z tym ewentualne naruszenie praw patentowych lub autorskich. Autor oraz Wydawnictwo HELION nie ponoszą również żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji zawartych w książce. Redaktor prowadzący: Ewelina Burska Projekt okładki: Studio Gravite/Olsztyn Obarek, Pokoński, Pazdrijowski, Zaprucki Wydawnictwo HELION ul. Kościuszki 1c, 44-100 GLIWICE tel. 32 231 22 19, 32 230 98 63 e-mail: helion@helion.pl WWW: http://helion.pl (księgarnia internetowa, katalog książek) Drogi Czytelniku! Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres http://helion.pl/user/opinie/vs12pa Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję. ISBN: 978-83-246-6856-4 Copyright © Helion 2014 Printed in Poland. • Kup książkę • Poleć książkę • Oceń książkę • Księgarnia internetowa • Lubię to! » Nasza społeczność Spis tre(cid:264)ci Wst(cid:246)p ............................................................................................ 11 J(cid:246)zyk C# i platforma .NET ............................................. 13 Cz(cid:246)(cid:264)(cid:232) I Rozdzia(cid:228) 1. Pierwsze spotkanie ze (cid:264)rodowiskiem Visual Studio i j(cid:246)zykiem C# ..... 15 Klasa Console ................................................................................................................. 15 Projekt aplikacji konsolowej .................................................................................... 15 Drukowanie napisów w konsoli i podpowiadanie kodu ............................................... 18 Czekanie na akceptacj(cid:266) u(cid:298)ytkownika ....................................................................... 19 Odczytywanie danych z klawiatury .......................................................................... 20 Korzystanie z bibliotek DLL. Komunikat „okienkowy” w aplikacji konsolowej ..... 21 Informacje o (cid:286)rodowisku aplikacji .................................................................................. 23 Podstawowe informacje o systemie i profilu u(cid:298)ytkownika ...................................... 23 Katalogi specjalne zdefiniowane w bie(cid:298)(cid:261)cym profilu u(cid:298)ytkownika ......................... 24 Odczytywanie zmiennych (cid:286)rodowiskowych ............................................................. 25 Lista dysków logicznych .......................................................................................... 26 Rozdzia(cid:228) 2. O b(cid:228)(cid:246)dach i ich tropieniu ................................................................. 27 Program z b(cid:225)(cid:266)dem logicznym — pole do popisu dla debugera ....................................... 27 Kontrolowane uruchamianie aplikacji w Visual C# ....................................................... 28 (cid:285)ledzenie wykonywania programu krok po kroku (F10 i F11) ................................ 28 Run to Cursor (Ctrl+F10) ......................................................................................... 30 Breakpoint (F9) ........................................................................................................ 30 Okna Locals i Watch ................................................................................................ 31 Stan wyj(cid:261)tkowy .............................................................................................................. 33 Zg(cid:225)aszanie wyj(cid:261)tków ................................................................................................ 33 Przechwytywanie wyj(cid:261)tków w konstrukcji try..catch ............................................... 35 Wymuszenie kontroli zakresu zmiennych ................................................................ 37 Rozdzia(cid:228) 3. J(cid:246)zyk C# 5.0 .................................................................................. 39 Platforma .NET .............................................................................................................. 40 (cid:285)rodowisko uruchomieniowe ................................................................................... 40 Kod po(cid:286)redni i podwójna kompilacja ....................................................................... 40 Wersje ...................................................................................................................... 41 Skróty, które warto pozna(cid:252) ............................................................................................. 43 Podstawowe typy danych ............................................................................................... 44 Deklaracja i zmiana warto(cid:286)ci zmiennej .................................................................... 44 Typy liczbowe oraz typ znakowy ............................................................................. 45 Kup książkęPoleć książkę 6 Visual Studio 2013. Podr(cid:246)cznik programowania w C# z zadaniami Okre(cid:286)lanie typu zmiennej przy inicjacji (pseudotyp var) ............................................... 47 Operatory ................................................................................................................. 47 Konwersje typów podstawowych ............................................................................. 49 Operatory is i as ....................................................................................................... 50 (cid:224)a(cid:276)cuchy .................................................................................................................. 51 Typ wyliczeniowy .................................................................................................... 54 Leniwe inicjowanie zmiennych ................................................................................ 55 Metody ........................................................................................................................... 56 Przeci(cid:261)(cid:298)anie metod ................................................................................................... 57 Domy(cid:286)lne warto(cid:286)ci argumentów metod — argumenty opcjonalne .......................... 58 Argumenty nazwane ................................................................................................. 59 Warto(cid:286)ci zwracane przez metody ............................................................................. 59 Zwracanie warto(cid:286)ci przez argument metody ............................................................ 59 Delegacje i zdarzenia ............................................................................................... 61 Wyra(cid:298)enia lambda .................................................................................................... 64 Typy warto(cid:286)ciowe i referencyjne .................................................................................... 66 Nullable .................................................................................................................... 67 Pude(cid:225)kowanie ........................................................................................................... 68 Typy dynamiczne ........................................................................................................... 69 Sterowanie przep(cid:225)ywem ................................................................................................. 72 Instrukcja warunkowa if..else ................................................................................... 72 Instrukcja wyboru switch ......................................................................................... 73 P(cid:266)tle .......................................................................................................................... 74 Wyj(cid:261)tki ........................................................................................................................... 75 Dyrektywy preprocesora ................................................................................................. 77 Kompilacja warunkowa — ostrze(cid:298)enia .................................................................... 78 Definiowanie sta(cid:225)ych preprocesora .......................................................................... 78 Bloki ......................................................................................................................... 79 Atrybuty ......................................................................................................................... 80 Kolekcje ......................................................................................................................... 81 „Zwyk(cid:225)e” tablice ...................................................................................................... 81 P(cid:266)tla foreach ............................................................................................................. 83 Sortowanie ............................................................................................................... 84 Kolekcja List ............................................................................................................ 85 Kolekcja SortedList i inne s(cid:225)owniki ......................................................................... 87 Kolejka i stos ............................................................................................................ 88 Tablice jako argumenty metod oraz metody z nieokre(cid:286)lon(cid:261) liczb(cid:261) argumentów ...... 89 S(cid:225)owo kluczowe yield .............................................................................................. 90 Nowa forma inicjacji obiektów i tablic ........................................................................... 92 Caller Information .......................................................................................................... 93 Rozdzia(cid:228) 4. Programowanie obiektowe w C# ..................................................... 95 Przyk(cid:225)ad struktury (Ulamek) .......................................................................................... 96 Przygotowywanie projektu ....................................................................................... 96 Konstruktor i statyczne obiekty sk(cid:225)adowe ................................................................ 98 Modyfikatory const i readonly ................................................................................. 99 Pierwsze testy ........................................................................................................... 99 Konwersje na (cid:225)a(cid:276)cuch (metoda ToString) i na typ double ...................................... 100 Metoda upraszczaj(cid:261)ca u(cid:225)amek ................................................................................ 101 W(cid:225)a(cid:286)ciwo(cid:286)ci ........................................................................................................... 102 Domy(cid:286)lnie implementowane w(cid:225)a(cid:286)ciwo(cid:286)ci (ang. auto-implemented properties) ..... 104 Operatory arytmetyczne ......................................................................................... 105 Operatory porównania oraz metody Equals i GetHashCode .................................. 106 Operatory konwersji ............................................................................................... 108 Kup książkęPoleć książkę Spis treści 7 Implementacja interfejsu (na przykładzie IComparable) .............................................. 109 Definiowanie typów parametrycznych ......................................................................... 110 Definiowanie typów ogólnych ............................................................................... 111 Określanie warunków, jakie mają spełniać parametry ............................................ 113 Implementacja interfejsów przez typ ogólny .......................................................... 114 Definiowanie aliasów ............................................................................................. 115 Typy ogólne z wieloma parametrami ..................................................................... 116 Rozszerzenia ................................................................................................................. 117 Typy anonimowe .......................................................................................................... 119 Dziedziczenie ............................................................................................................... 119 Klasy bazowe i klasy potomne ............................................................................... 120 Nadpisywanie a przesłanianie metod ..................................................................... 123 Klasy abstrakcyjne ................................................................................................. 124 Metody wirtualne ................................................................................................... 126 Polimorfizm ............................................................................................................ 127 Konstruktory a dziedziczenie ................................................................................. 129 Singleton ....................................................................................................................... 131 Interfejsy ....................................................................................................................... 134 Rozdział 5. Biblioteki DLL .............................................................................. 137 Tworzenie zarządzanej biblioteki DLL ........................................................................ 138 Dodawanie do aplikacji referencji do biblioteki DLL .................................................. 139 Przenośne biblioteki DLL ............................................................................................. 140 Rozdział 6. Testy jednostkowe ....................................................................... 143 Projekt testów jednostkowych ...................................................................................... 144 Przygotowania do tworzenia testów ............................................................................. 144 Pierwszy test jednostkowy ............................................................................................ 145 Uruchamianie testów .................................................................................................... 146 Dostęp do prywatnych pól testowanej klasy ................................................................. 147 Testowanie wyjątków ................................................................................................... 148 Kolejne testy weryfikujące otrzymane wartości ........................................................... 148 Test ze złożoną weryfikacją .......................................................................................... 149 Powtarzane wielokrotnie testy losowe .......................................................................... 151 Niepowodzenie testu .................................................................................................... 152 Nieuniknione błędy ...................................................................................................... 154 Rozdział 7. Elementy programowania współbieżnego ....................................... 159 Równoległa pętla for .................................................................................................... 159 Przerywanie pętli .......................................................................................................... 161 Programowanie asynchroniczne. Modyfikator async i operator await (nowość języka C# 5.0) ..................................... 162 Część II Projektowanie aplikacji Windows Forms ...................... 169 Rozdział 8. Pierwszy projekt aplikacji Windows Forms .................................... 171 Projektowanie interfejsu aplikacji ................................................................................ 172 Tworzenie projektu ................................................................................................ 172 Dokowanie palety komponentów Toolbox ............................................................. 174 Tworzenie interfejsu za pomocą komponentów Windows Forms .......................... 175 Przełączanie między podglądem formy a kodem jej klasy ........................................... 176 Analiza kodu pierwszej aplikacji Windows Forms ....................................................... 176 Metody zdarzeniowe .................................................................................................... 182 Metoda uruchamiana w przypadku wystąpienia zdarzenia kontrolki ..................... 182 Testowanie metody zdarzeniowej .......................................................................... 183 Kup książkęPoleć książkę 8 Visual Studio 2013. Podr(cid:246)cznik programowania w C# z zadaniami Przypisywanie istniej(cid:261)cej metody do zdarze(cid:276) komponentów ................................. 185 Edycja metody zdarzeniowej .................................................................................. 185 Modyfikowanie w(cid:225)asno(cid:286)ci komponentów .............................................................. 186 Wywo(cid:225)ywanie metody zdarzeniowej z poziomu kodu ........................................... 186 Reakcja aplikacji na naciskanie klawiszy ............................................................... 187 Rozdzia(cid:228) 9. Przegl(cid:241)d komponentów biblioteki Windows Forms ......................... 189 Notatnik.NET ............................................................................................................... 189 Projektowanie interfejsu aplikacji i menu g(cid:225)ówne .................................................. 189 Okna dialogowe i pliki tekstowe ............................................................................ 196 Edycja i korzystanie ze schowka ............................................................................ 204 Drukowanie ............................................................................................................ 205 Elektroniczna kuku(cid:225)ka .................................................................................................. 214 Ekran powitalny (splash screen) ............................................................................. 214 Przygotowanie ikony w obszarze powiadamiania .................................................. 217 Odtwarzanie pliku d(cid:296)wi(cid:266)kowego ........................................................................... 220 Ustawienia aplikacji ..................................................................................................... 222 Dywan graficzny .......................................................................................................... 225 Rozdzia(cid:228) 10. Przeci(cid:241)gnij i upu(cid:264)(cid:232) ....................................................................... 231 Podstawy ...................................................................................................................... 231 Interfejs przyk(cid:225)adowej aplikacji ............................................................................. 232 Inicjacja procesu przeci(cid:261)gania ................................................................................ 233 Akceptacja upuszczenia elementu .......................................................................... 235 Reakcja na upuszczenie elementu .......................................................................... 236 Czynno(cid:286)ci wykonywane po zako(cid:276)czeniu procesu przenoszenia i upuszczania ...... 237 Przenoszenie elementów mi(cid:266)dzy ró(cid:298)nymi aplikacjami .......................................... 238 Zagadnienia zaawansowane .......................................................................................... 238 Opó(cid:296)nione inicjowanie procesu przenoszenia ........................................................ 238 Przenoszenie wielu elementów ............................................................................... 241 Przenoszenie plików ............................................................................................... 242 Cz(cid:246)(cid:264)(cid:232) III Dane w aplikacjach dla platformy .NET ....................... 245 Rozdzia(cid:228) 11. LINQ ............................................................................................ 247 Operatory LINQ ........................................................................................................... 247 Pobieranie danych (filtrowanie i sortowanie) ............................................................... 249 Analiza pobranych danych ........................................................................................... 250 Wybór elementu ........................................................................................................... 250 Weryfikowanie danych ................................................................................................. 251 Prezentacja w grupach .................................................................................................. 251 (cid:224)(cid:261)czenie zbiorów danych ............................................................................................. 252 (cid:224)(cid:261)czenie danych z ró(cid:298)nych (cid:296)róde(cid:225) w zapytaniu LINQ — operator join ....................... 252 Mo(cid:298)liwo(cid:286)(cid:252) modyfikacji danych (cid:296)ród(cid:225)a ......................................................................... 253 Rozdzia(cid:228) 12. Przechowywanie danych w plikach XML. LINQ to XML ................... 255 Podstawy j(cid:266)zyka XML ................................................................................................. 255 Deklaracja .............................................................................................................. 255 Elementy ................................................................................................................ 256 Atrybuty ................................................................................................................. 256 Komentarze ............................................................................................................ 256 LINQ to XML .............................................................................................................. 257 Tworzenie pliku XML za pomoc(cid:261) klas XDocument i XElement ........................... 257 Pobieranie warto(cid:286)ci z elementów o znanej pozycji w drzewie ............................... 259 Odwzorowanie struktury pliku XML w kontrolce TreeView ................................. 261 Kup książkęPoleć książkę Spis tre(cid:264)ci 9 Przenoszenie danych z kolekcji do pliku XML ...................................................... 262 Zapytania LINQ, czyli tworzenie kolekcji na bazie danych z pliku XML ............. 263 Modyfikacja pliku XML ........................................................................................ 264 Rozdzia(cid:228) 13. Baza danych SQL Server w projekcie Visual Studio ........................ 267 Odwzorowanie obiektowo-relacyjne ............................................................................ 267 Szalenie krótki wst(cid:266)p do SQL ...................................................................................... 269 Select ...................................................................................................................... 269 Insert ...................................................................................................................... 270 Delete ..................................................................................................................... 270 Projekt aplikacji z baz(cid:261) danych .................................................................................... 270 Dodawanie bazy danych do projektu aplikacji ....................................................... 270 (cid:224)a(cid:276)cuch po(cid:225)(cid:261)czenia (ang. connection string) ......................................................... 271 Dodawanie tabeli do bazy danych .......................................................................... 272 Edycja danych w tabeli ........................................................................................... 274 Druga tabela ........................................................................................................... 274 Procedura sk(cid:225)adowana — pobieranie danych ......................................................... 276 Procedura sk(cid:225)adowana — modyfikowanie danych ................................................. 276 Procedura sk(cid:225)adowana — dowolne polecenia SQL ................................................ 277 Widok ..................................................................................................................... 277 Rozdzia(cid:228) 14. LINQ to SQL ................................................................................. 279 Klasa encji .................................................................................................................... 280 Pobieranie danych ........................................................................................................ 281 Prezentacja danych w siatce DataGridView ................................................................. 283 Aktualizacja danych w bazie ........................................................................................ 283 Modyfikacje istniej(cid:261)cych rekordów ....................................................................... 284 Dodawanie i usuwanie rekordów ........................................................................... 285 Inne operacje .......................................................................................................... 286 Wizualne projektowanie klasy encji ............................................................................. 286 O/R Designer .......................................................................................................... 287 Wspó(cid:225)praca z kontrolkami tworz(cid:261)cymi interfejs aplikacji ..................................... 290 Korzystanie z widoków .......................................................................................... 291 (cid:224)(cid:261)czenie danych z dwóch tabel — operator join .................................................... 292 Relacje (Associations) ............................................................................................ 292 Korzystanie z procedur sk(cid:225)adowanych ......................................................................... 294 Pobieranie danych za pomoc(cid:261) procedur sk(cid:225)adowanych ............................................. 294 Modyfikowanie danych za pomoc(cid:261) procedur sk(cid:225)adowanych ................................. 295 Rozdzia(cid:228) 15. Kreator (cid:274)róde(cid:228) danych ................................................................... 297 Kreator (cid:296)ród(cid:225)a danych .................................................................................................. 297 Zautomatyzowane tworzenie interfejsu u(cid:298)ytkownika ................................................... 300 Prezentacja tabeli w siatce ...................................................................................... 300 Klasa BindingSource .............................................................................................. 301 Sortowanie ............................................................................................................. 301 Filtrowanie ............................................................................................................. 302 Prezentacja rekordów tabeli w formularzu ............................................................. 302 Dwie siatki w uk(cid:225)adzie master-details .................................................................... 304 Rozdzia(cid:228) 16. Tradycyjne ADO.NET (DataSet) ..................................................... 307 Konfiguracja (cid:296)ród(cid:225)a danych DataSet ............................................................................ 307 Edycja klasy DataSet i tworzenie relacji mi(cid:266)dzy tabelami ........................................... 309 Podgl(cid:261)d danych udost(cid:266)pnianych przez komponent DataSet ......................................... 310 Prezentacja danych w siatce ......................................................................................... 311 Zapisywanie zmodyfikowanych danych ....................................................................... 314 Kup książkęPoleć książkę 10 Visual Studio 2013. Podręcznik programowania w C# z zadaniami Prezentacja danych w formularzu ................................................................................. 316 Sortowanie i filtrowanie ............................................................................................... 319 Odczytywanie z poziomu kodu wartości przechowywanych w komórkach tabeli ....... 319 Zapytania LINQ do danych z DataSet .......................................................................... 322 Rozdział 17. Entity Framework ......................................................................... 323 Tworzenie modelu danych EDM dla istniejącej bazy danych ...................................... 324 Użycie klasy kontekstu z modelu danych EF ............................................................... 327 LINQ to Entities ........................................................................................................... 329 Prezentacja i edycja danych w siatce ............................................................................ 330 Asynchroniczne wczytywanie danych .......................................................................... 332 Użycie widoku i procedur składowanych ......................................................................... 333 Połączenie między tabelami ......................................................................................... 334 Tworzenie źródła danych .............................................................................................. 336 Automatyczne tworzenie interfejsu .............................................................................. 338 Edycja i zapis zmian ..................................................................................................... 341 Część IV Dodatki ...................................................................... 343 Zadania ....................................................................................... 345 Skorowidz .................................................................................... 355 Kup książkęPoleć książkę Rozdzia(cid:228) 5. Biblioteki DLL Biblioteki DLL (ang. dynamic link library) s(cid:261) g(cid:225)ównym sposobem dystrybucji klas i komponentów zarówno w aplikacjach dla platformy Win32, jak i dla platformy .NET. Oczywi(cid:286)cie biblioteki obu platform ró(cid:298)ni(cid:261) si(cid:266) w takim samym stopniu jak ich pliki wy- konywalne .exe1. Niemniej jednak idea stoj(cid:261)ca za umieszczaniem modu(cid:225)ów aplikacji w osobnych bibliotekach jest podobna. Poni(cid:298)ej pokazuj(cid:266), jak utworzy(cid:252) bibliotek(cid:266) DLL zawieraj(cid:261)c(cid:261) klasy .NET. U(cid:298)yjemy do tego przygotowanej w poprzednim rozdziale klasy Ulamek. Nast(cid:266)pnie wykorzystamy j(cid:261) w aplikacji konsolowej. Ogranicz(cid:266) si(cid:266) przy tym wy(cid:225)(cid:261)cznie do tzw. statycznego (cid:225)(cid:261)- czenia bibliotek2. W efekcie klasa Ulamek nie zostanie wkompilowana do pliku .exe tej aplikacji — biblioteka b(cid:266)dzie (cid:225)adowana do pami(cid:266)ci w momencie uruchamiania apli- kacji. Taki sposób post(cid:266)powania ma kilka zalet. Je(cid:298)eli napiszemy lepsz(cid:261) wersj(cid:266) klasy Ulamek, ale tak(cid:261), której interfejs nie ulegnie zmianie, to (cid:225)atwo mo(cid:298)na zaktualizowa(cid:252) ca(cid:225)y program bez potrzeby ponownej kompilacji i dystrybucji pliku .exe. Wystarczy podmieni(cid:252) plik .dll. W wi(cid:266)kszych aplikacjach mo(cid:298)e to bardzo u(cid:225)atwi(cid:252) rozpowszech- nianie uaktualnie(cid:276). Wa(cid:298)ne jest równie(cid:298) to, (cid:298)e klasy umieszczone w bibliotece DLL mog(cid:261) by(cid:252) wielokrotnie wykorzystywane przez ró(cid:298)ne aplikacje bez konieczno(cid:286)ci ich wkompilowywania w ka(cid:298)d(cid:261) z nich osobno. Dodatkow(cid:261) zalet(cid:261) jest przeno(cid:286)no(cid:286)(cid:252) bi- bliotek PCL (ang. Portable Class Library). Biblioteki tego typu mog(cid:261) by(cid:252) u(cid:298)ywane bez rekompilacji w ró(cid:298)nych platformach zarz(cid:261)dzanych Microsoftu. Jest to szczególnie interesuj(cid:261)ce w kontek(cid:286)cie niedawno og(cid:225)oszonej wspó(cid:225)pracy Microsoftu i Xamarin, który rozszerzy list(cid:266) platform obs(cid:225)ugiwanych przez te biblioteki o Android i iOS (na bazie platformy Mono). 1 Zarówno pliki .dll, jak i pliki .exe s(cid:261) podzespo(cid:225)ami (ang. assembly), czyli skompilowanymi do kodu po(cid:286)redniego MSIL samodzielnymi kawa(cid:225)kami kodu. Na poziomie podzespo(cid:225)ów realizowana jest g(cid:225)ówna polityka bezpiecze(cid:276)stwa platformy .NET. 2 Zagadnienia dynamicznego (cid:225)adowania biblioteki ju(cid:298) w trakcie dzia(cid:225)ania aplikacji oraz zwi(cid:261)zane z tym zagadnienia dynamicznego typowania (s(cid:225)owo kluczowe dynamic) oraz korzystanie z platformy MEF do tworzenia bibliotek DLL funkcjonuj(cid:261)cych jako wtyczki omówione zosta(cid:225)y w ksi(cid:261)(cid:298)ce Visual Studio 2010 dla programistów C#, Helion, 2011 (obecnie dost(cid:266)pna w postaci ebooka). Umieszczone w tej ksi(cid:261)(cid:298)ce informacje s(cid:261) nadal aktualne dla Visual Studio 2013. Kup książkęPoleć książkę 138 Cz(cid:246)(cid:264)(cid:232) I (cid:105) J(cid:246)zyk C# i platforma .NET Tworzenie zarz(cid:241)dzanej biblioteki DLL Je(cid:298)eli dysponujemy gotowymi klasami, które chcemy umie(cid:286)ci(cid:252) w zarz(cid:261)dzanej biblio- tece DLL, stworzenie takiej biblioteki zajmie krótk(cid:261) chwil(cid:266). Prze(cid:252)wiczmy to, umiesz- czaj(cid:261)c w bibliotece DLL klas(cid:266) Ulamek z poprzedniego rozdzia(cid:225)u. 1. Otwórz opisane w poprzednim rozdziale rozwi(cid:261)zanie UlamekDemo zawieraj(cid:261)ce projekt UlamekDemo z klas(cid:261) Ulamek. 2. Do projektu dodajmy projekt biblioteki. W tym celu: a) Z menu File wybierz polecenie New Project lub wci(cid:286)nij kombinacj(cid:266) klawiszy Ctrl+Shift+N. b) Zaznacz ikon(cid:266) Class Library. c) W polu Name wpisz nazw(cid:266) UlamekBiblioteka. d) Poniewa(cid:298) chcemy nowy projekt doda(cid:252) do istniej(cid:261)cego rozwi(cid:261)zania, nale(cid:298)y w oknie New Project prze(cid:225)(cid:261)czy(cid:252) rozwijan(cid:261) list(cid:266) Solution z Create new solution na Add to solution. e) Kliknij OK. 3. Po utworzeniu projektu zobaczysz okno edytora kodu z definicj(cid:261) pustej klasy. Jednocze(cid:286)nie w podoknie Solution Explorer widoczny b(cid:266)dzie nowy projekt w bie(cid:298)(cid:261)cym rozwi(cid:261)zaniu, a w nim wy(cid:286)wietlany w edytorze plik Class1.cs. Usu(cid:276)my ten plik, zaznaczaj(cid:261)c go w podoknie Solution Explorer i naciskaj(cid:261)c klawisz Delete. Zostaniemy zapytani o potwierdzenie. 4. W jego miejsce skopiujmy plik Ulamek.cs z projektu UlamekDemo. Wystarczy go przeci(cid:261)gn(cid:261)(cid:252) w podoknie Solution Explorer i upu(cid:286)ci(cid:252) na pozycj(cid:266) UlamekBiblioteka. 5. W pliku Ulamek.cs musimy wprowadzi(cid:252) trzy zmiany (listing 5.1). Tylko pierwsza jest naprawd(cid:266) wa(cid:298)na, dwie nast(cid:266)pne to zmiany czysto kosmetyczne. a) Pierwsz(cid:261) jest dodanie do deklaracji klasy Ulamek modyfikatora public. Bez tego nie b(cid:266)dzie ona widoczna poza bibliotek(cid:261). b) Drug(cid:261) zmian(cid:261) jest zmiana nazwy przestrzeni nazw. Wystarczy w kodzie zmieni(cid:252) nazw(cid:266) za s(cid:225)owem kluczowym namespace z UlamekDemo na Helion. c) Trzecia to usuni(cid:266)cie niepotrzebnych polece(cid:276) using w nag(cid:225)ówku pliku. Z zadeklarowanych tam przestrzeni nazw u(cid:298)ywamy tak naprawd(cid:266) tylko przestrzeni System. Co ciekawe, nie musimy sami sprawdza(cid:252), które polecenia using s(cid:261) potrzebne, a które zb(cid:266)dne. Wystarczy, (cid:298)e z menu kontekstowego w edytorze wybierzemy pozycj(cid:266) Organize Usings, a z rozwini(cid:266)tego w ten sposób podmenu (cid:127) polecenie Remove Unused Usings. Listing 5.1. Zmiany w pliku Ulamek.cs using System; using System.Collections.Generic; using System.Linq; Kup książkęPoleć książkę Rozdzia(cid:228) 5. (cid:105) Biblioteki DLL 139 using System.Text; using System.Threading.Tasks; namespace Helion { public struct Ulamek : IComparable Ulamek { private int licznik, mianownik; ... 6. Aby sprawdzi(cid:252), czy wszystko jest w porz(cid:261)dku, skompilujmy projekt biblioteki. W tym celu z menu kontekstowego pozycji UlamekBiblioteka wybierzmy polecenie Build. Po chwili na pasku stanu Visual Studio powinni(cid:286)my zobaczy(cid:252) komunikat Build succeded. Efektem kompilacji jest biblioteka UlamekBiblioteka.dll, któr(cid:241) znajdziemy w pod- katalogu UlamekDemo\UlamekBiblioteka\bin\Debug (je(cid:276)eli kompilujemy projekt w trybie Debug). 7. Je(cid:298)eli kompilacja si(cid:266) powiod(cid:225)a, mo(cid:298)emy (cid:286)mia(cid:225)o skasowa(cid:252) plik Ulamek.cs z projektu UlamekDemo. Projekt nie b(cid:266)dzie chcia(cid:225) si(cid:266) skompilowa(cid:252), ale nied(cid:225)ugo to naprawimy. Je(cid:286)li chcieliby(cid:286)my zachowa(cid:252) konwencj(cid:266) nazewnictwa proponowan(cid:261) w platformie .NET, nasza biblioteka powinna przej(cid:261)(cid:252) nazw(cid:266) po przestrzeni nazw, tj. powinna na- zywa(cid:252) si(cid:266) Helion.dll. Skoro jednak nasza biblioteka zawiera tylko jedn(cid:261) klas(cid:266), uwa(cid:298)am, (cid:298)e wi(cid:266)kszy sens ma wyeksponowanie nazwy tej klasy. Dodawanie do aplikacji referencji do biblioteki DLL W tej chwili projekt UlamekDemo nie chce si(cid:266) skompilowa(cid:252), poniewa(cid:298) nie widzi klasy Ulamek, do której odwo(cid:225)uje si(cid:266) w statycznej metodzie Program.Main. Musimy podpo- wiedzie(cid:252) kompilatorowi, (cid:298)eby klasy Ulamek szuka(cid:225) w bibliotece UlamekBiblioteka.dll. 1. W podoknie Solution Explorer z menu kontekstowego projektu UlamekDemo wybierz pozycj(cid:266) Add, Reference.... 2. Pojawi si(cid:266) okno Reference Manager — UlamekDemo (rysunek 5.1). W lewym panelu zaznaczmy pozycj(cid:266) Solution. Ograniczy to wy(cid:286)wietlane biblioteki do tych, które s(cid:261) zdefiniowane w bie(cid:298)(cid:261)cym rozwi(cid:261)zaniu, a wi(cid:266)c tylko do jednej. 3. Z lewej strony tej biblioteki na li(cid:286)cie znajduje si(cid:266) s(cid:225)abo widoczne pole opcji, które nale(cid:298)y zaznaczy(cid:252). 4. Nast(cid:266)pnie klikamy OK. Kup książkęPoleć książkę 140 Cz(cid:246)(cid:264)(cid:232) I (cid:105) J(cid:246)zyk C# i platforma .NET Rysunek 5.1. Dodawanie do projektu referencji do biblioteki DLL 5. Dodanie biblioteki jednak nie wystarczy. Znajduje si(cid:266) ona bowiem w innej przestrzeni nazw ni(cid:298) przestrze(cid:276) nazw projektu aplikacji (je(cid:298)eli zmienili(cid:286)my nazw(cid:266) przestrzeni nazw na Helion). Musimy wobec tego zadeklarowa(cid:252) u(cid:298)ycie tej przestrzeni nazw, dodaj(cid:261)c na pocz(cid:261)tku pliku Program.cs instrukcj(cid:266) using Helion;. 6. Po tym oba projekty powinny si(cid:266) kompilowa(cid:252) bez problemów. Klasa Ulamek jest dost(cid:266)pna i jej metody mog(cid:261) by(cid:252) swobodnie wywo(cid:225)ywane z metody Program.Main. To najprostszy, a jednocze(cid:286)nie najcz(cid:266)stszy sposób tworzenia i u(cid:298)ycia zarz(cid:261)dzanych bibliotek DLL. Jest to tzw. statyczne (cid:225)(cid:261)czenie bibliotek. Oprócz tego mo(cid:298)liwe jest ich (cid:225)adowanie dynamiczne ju(cid:298) w trakcie dzia(cid:225)ania programu. Wówczas konieczna jest czasem analiza zawarto(cid:286)ci biblioteki i rozpoznawanie umieszczonych w niej typów, weryfikowanie, czy biblioteka zawiera konkretn(cid:261) klas(cid:266), której chcemy u(cid:298)y(cid:252), i czy ta z kolei zawiera potrzebn(cid:261) nam metod(cid:266). Konieczne jest wówczas korzystanie z tech- nologii odzwierciedlania typów (ang. reflection). Jest to odpowiednik RTTI z C++. Kolejnym zagadnieniem jest uruchomienie znalezionych metod. Wysi(cid:225)ek w(cid:225)o(cid:298)ony w przygotowanie odpowiedniego kodu mo(cid:298)e si(cid:266) op(cid:225)aca(cid:252), np. w sytuacji, w której bibliotek DLL chcemy u(cid:298)ywa(cid:252) jako znajdywanych ju(cid:298) w trakcie dzia(cid:225)ania programu pluginów. Wówczas jednak lepiej u(cid:298)y(cid:252) technologii MEF (zobacz ksi(cid:261)(cid:298)k(cid:266) polecan(cid:261) w przypisie nr 2). Przeno(cid:264)ne biblioteki DLL W Visual Studio 2012 pojawi(cid:225)a si(cid:266) mo(cid:298)liwo(cid:286)(cid:252) tworzenia bibliotek przeno(cid:286)nych PCL (ang. Portable Class Library), których mo(cid:298)na u(cid:298)ywa(cid:252) na kilku zarz(cid:261)dzanych platfor- mach oferowanych przez Microsoft. Po(cid:286)ród nich s(cid:261): platforma .NET, WinRT, XNA, Kup książkęPoleć książkę Rozdzia(cid:228) 5. (cid:105) Biblioteki DLL 141 platforma instalowana w Xbox czy urz(cid:261)dzeniach z Windows Phone. Ma to ogromn(cid:261) zalet(cid:266) — raz przygotowany kod nie musi by(cid:252) modyfikowany w siostrzanych projek- tach dla ró(cid:298)nego typu urz(cid:261)dze(cid:276). A tym samym u(cid:225)atwia zarz(cid:261)dzanie zmianami, które s(cid:261) zmor(cid:261) projektów wieloplatformowych. Tworzenie tego typu bibliotek nie ró(cid:298)ni si(cid:266) zbytnio od tworzenia zwyk(cid:225)ej biblioteki klas: 1. W podoknie Solution Explorer zaznaczmy pozycj(cid:266) UlamekDemo odpowiadaj(cid:261)c(cid:261) ca(cid:225)emu rozwi(cid:261)zaniu (nie projektowi aplikacji). 2. Z jej menu kontekstowego wybierzmy Add, a nast(cid:266)pnie New Project.... 3. Pojawi si(cid:266) znajome okno Add New Project. Zaznaczmy w nim pozycj(cid:266) Portable Class Library. 4. W polu Name wpisujemy UlamekBibliotekaPrzenosna i klikamy OK. 5. Zanim utworzony zostanie nowy projekt, zostaniemy spytani o to, z jakimi platformami nowa biblioteka ma by(cid:252) zgodna (rysunek 5.2). Ja obni(cid:298)y(cid:225)em tylko wymóg co do wersji platformy .NET do wersji 4. Dzi(cid:266)ki temu uzyskali(cid:286)my zgodno(cid:286)(cid:252) wsteczn(cid:261) z Visual Studio 2010. Rysunek 5.2. Wybór platform, z którymi nowa biblioteka ma by(cid:252) zgodna 6. Nast(cid:266)pnie klikamy OK. Powstanie biblioteka PCL. Dalsze post(cid:266)powanie jest identyczne jak w przypadku zwyk(cid:225)ej biblioteki, tj. kasujemy plik Class1.cs, a w zamian kopiujemy do nowego projektu plik Ulamek.cs. Do(cid:225)(cid:261)cza- nie referencji do bibliotek przeno(cid:286)nych PCL równie(cid:298) odbywa si(cid:266) identycznie jak zwyk(cid:225)ych bibliotek DLL. Jedyna ró(cid:298)nica polega na tym, (cid:298)e tak utworzonej biblioteki PCL mo(cid:298)emy u(cid:298)y(cid:252) nie tylko w aplikacjach konsolowych, Windows Forms, WPF lub aplikacjach internetowych ASP.NET, ale równie(cid:298) w aplikacjach dla Windows 8 na ekran Start (tzw. aplikacje Windows Store) lub w aplikacjach dla smartfonów z systemem Windows Phone. Kup książkęPoleć książkę 142 Cz(cid:246)(cid:264)(cid:232) I (cid:105) J(cid:246)zyk C# i platforma .NET Oprócz platform, które widoczne s(cid:241) na rysunku 5.2, mo(cid:276)liwe jest tak(cid:276)e zainstalo- wanie dodatkowych. Zobaczymy je, klikaj(cid:241)c (cid:228)(cid:241)cze Install additional frameworks... widoczne w oknie Add Portable Class Library. S(cid:241) to m.in. Windows Azure, Xbox czy Kinect for Windows. Kup książkęPoleć książkę Skorowidz A ADO.NET, 267, 307, 309 algorytm Euklidesa, 101 alias, 115 aplikacja b(cid:225)(cid:261)d, 27 debugowanie, 27, 30, 31 obs(cid:225)uga wyj(cid:261)tków, 33 Entity Framework, 162 ikona w zasobniku, 217, 219 inicjacja asynchroniczna, 332 interfejs, Patrz: interfejs aplikacji konsolowa, 15, 26, 76 menu Edycja, 204 g(cid:225)ówne, 194 Plik, 194, 196, 202, 205 Widok, 203 projekt, 190 punkt wej(cid:286)ciowy, 17 (cid:286)rodowisko, 23 tryb pojedynczego w(cid:261)tku, 181 uruchamianie bez debugowania, 18 breakpoint, 30 do kursora, 30 obs(cid:225)uga wyj(cid:261)tków, 35 w trybie (cid:286)ledzenia, 28 z debugowaniem, 19 ustawienia, 222, 223, 224 Windows Forms, 26, 76, 171, 176, 257 interfejs, Patrz: interfejs aplikacji Windows Forms Windows Phone, 39, 141 Windows Store, 39, 40, 162, 165 WPF, 26, 39 z baz(cid:261) danych SQL Server, 270 zamykanie, 196, 197 auto-implemented properties, Patrz: w(cid:225)a(cid:286)ciwo(cid:286)(cid:252) domy(cid:286)lnie implementowana B balloon, Patrz: dymek baza danych, 40, 267, 323 aktualizacja, 283 Microsoft Access, 309 obiektowa, 267 odwzorowanie obiektowo-relacyjne, Patrz: ORM w klasie .NET, 267 rekord, 285 SQL Server, 267, 271, 279, 309 SQL Server Compact, 279 biblioteka, 72 ASP.NET, 193 DLL, 137, 144 przeno(cid:286)na, Patrz: biblioteka PCL referencja, 139 Entity Framework, 193, 326 EntityFramework.SqlServer.d ll, 326 Forms.dll, 21 kontrolek, 171 (cid:225)(cid:261)czenie dynamiczne, 140 statyczne, 137, 140 PCL, 137, 140, 144 STL, 111 System.Data.Linq.dll, 280 TPL, 159 WCF, 193 Windows Forms, 171, 193 kontrolka, 189 WPF, 171, 193 biblioteka DLL, 138 blok, 79 boxing, Patrz: pude(cid:225)kowanie buforowanie podwójne, 227 C callback, Patrz: funkcja zwrotna Caller Information, 93 CAS, 43 CIL, 41, 43 CLR, 39, 40, 43 CLS, 43 Code Access Security, Patrz: CAS Common Intermediate Language, Patrz: CIL Common Language Runtime, Patrz: CLR Common Language Specification, Patrz: CLS Common Type System, Patrz: CTS connection string, Patrz: (cid:225)a(cid:276)cuch konfiguruj(cid:261)cy po(cid:225)(cid:261)czenie, Patrz: (cid:225)a(cid:276)cuch po(cid:225)(cid:261)czenia CTS, 43 czcionka, 203 Kup książkęPoleć książkę 356 Visual Studio 2013. Podr(cid:246)cznik programowania w C# z zadaniami D dane baza, Patrz: baza danych filtrowanie, 302, 319 (cid:225)(cid:261)czenie zbiorów, 252 modyfikacja, 276, 295 pobieranie, 276, 283 sortowanie, 301, 319 typ, Patrz: zmienna typ (cid:296)ród(cid:225)o, 298, 299, 304, 307, 334, 336 kreator, 297 data source, Patrz: dane (cid:296)ród(cid:225)o delegacja, 61, 64, 95, 118 DLR, 40, 43 drag drop, Patrz: przeci(cid:261)gnij i upu(cid:286)(cid:252) drukowanie, 205, 208, 209 d(cid:225)ugich linii, 210, 212 w tle, 213 drzewo, 81 dymek, 219 Dynamic Language Runtime, Patrz: DLR dyrektywa #define, 79 #endregion, 79, 80 #if, 78 #region, 79, 80 dyrektywa preprocesora, 77, 78 dziedziczenie, 117, 120, 122, 129, 131 wielokrotne, 134 E edytor Create Unit Test, 144 kodu, 17, 80 O/R Designer, 281, 286, 287 relacji, 292 EF, Patrz: Entity Framework ekran powitalny, 214, 215 entity class, Patrz: klasa encji Entity Framework, 268, 307, 323, 326, 341 entry point, Patrz: aplikacja punkt wej(cid:286)ciowy Euklidesa algorytm, Patrz: algorytm Euklidesa exception, Patrz: wyj(cid:261)tek extension method, Patrz: rozszerzenie F FIFO, 88 FILO, 88 formularz, 302, 316 funkcja, 56 Average, 250 GetSystemMetrics, 238 haszuj(cid:261)ca, 108 Max, 250 Min, 250 Sum, 250 trygonometryczna, 159 zwrotna, 64 G garbage collector, Patrz: od(cid:286)miecacz generator liczb pseudolosowych, generic types, Patrz: zmienna graphical user interface, Patrz: 73 typ ogólny GUI GUI, 171, 231 H Hejlsberg Anders, 39, 268 I indeksator, 95 inheritance, Patrz: dziedziczenie instrukcja break, 74, 101 continue, 74 DELETE, 270 INSERT, 270 return, 76 SELECT, 269 using warunkowa if..else, 72 System.Data.Linq.Mapping, 280 wyboru switch, 73 IntelliSense, 18, 72, 123, 331 tryb, 18 interfejs, 95, 111, 134, 135 aplikacji, 189, 190 kontrolka, Patrz: kontrolka Windows Forms, 171, 172 graficzny u(cid:298)ytkownika, Patrz: GUI IComparable, 84, 109, 114 IConvertible, 100 IDictionary, 87 IDirectory, 25 IEnumerable, 247, 248, 250 implementacja, 109, 131 przez typ ogólny, 114 master-details, 334 Modern UI, 165 tworzenie, 338 u(cid:298)ytkownika, 298, 300 J Java, 39 j(cid:266)zyk C#, 17, 39, 40, 95 wielko(cid:286)(cid:252) liter, 18 C++, 17, 39 dynamiczny, 40 Java, Patrz: Java Python, 40 Ruby, 40 SQL, Patrz: SQL Transact SQL, Patrz: j(cid:266)zyk T-SQL T-SQL, 269, 279 XML, 255 atrybut, 256 deklaracja, 255, 258 dokument, 255 element, 256 komentarz, 256, 258 zapyta(cid:276), Patrz: LINQ JIT, 43 Just-In-Time, Patrz: JIT K katalog domowy, 25 specjalny, 24 klasa, 15, 66, 67 abstrakcyjna, 124, 125, 127, 135 Array, 65, 81 bazowa, 98, 100, 112, 113, 115, 120, 123, 127, 134 bazuj(cid:261)ca na typie, 110 BindingSource, 301 Kup książkęPoleć książkę Skorowidz 357 DataContext, 268, 279, 281, 286, 294 DataSet, 307, 309 definiowanie, 95 encji, 279, 280, 281, 286, 287, 293, 323 Enum, 54 Environment, 23, 24 Graphics, 205, 225 HttpClient, 165 instancja, Patrz: obiekt Lazy, 55 List, 81 MessageBox, 21 opakowuj(cid:261)ca, 45 ORM, 287, 309, 323 Panel, 175 Parallel, 160 ParallelLoopState, 161 pole, Patrz: pole potomna, 117, 120, 123, 127 PrivateObject, 147 Queue, 87 Random, 73 SoundPlayer, 221 Stack, 87 statyczna, 131 klawisz, 20 Alt, 187 Ctrl, 187 Esc, 187 F10, 28, 29 F11, 28, 29 F4, 174 F5, 19, 184 F7, 176 dziedziczenie, 131 instancja, 131 StorageFile, 165 StreamReader, 165 StreamWriter, 165 String, 51, 52 StringBuilder, 53 SystemColor, 189 Task, 159 Trace, 93 TrackBar, 175 WCF, 165 w(cid:225)a(cid:286)ciwo(cid:286)(cid:252), Patrz: w(cid:225)a(cid:286)ciwo(cid:286)(cid:252) XDocument, 258 XmlReader, 165 klawiatura, 187 odczytywanie danych, 20 F9, 30 Shift, 175, 187 specjalny, 187 Tab, 180 klawisze skrótów debugera, 29 edytora, 19 klucz — warto(cid:286)(cid:252), 87 kod maszynowy, 43 oparty na refleksji, 72 po(cid:286)redni, Patrz: CIL (cid:296)ród(cid:225)owy, 79, 80 kolejka, 81, 87, 88 kolekcja, 44, 75, 81, 85 Dictionary, 87 List, 85 SortedDictionary, 87 SortedList, 87, 88 kompilacja, 80 atrybut, 80 dwustopniowa, 40 warunkowa, 78, 79 kompilator, 40, 43 jako us(cid:225)uga, 40 komponent, Patrz: kontrolka konstruktor, 129, 177 bezargumentowy, 98, 130 domy(cid:286)lny, 98, 104, 130, 132 prywatny, 132 kontrolka, 175, 189, 290 ComboBox, 302, 303 DataGridView, 283, 290, 291, 300, 311, 330 DataSet, 267, 307 Label, 214 panel, 175 suwak, 175 TextBox, 302 TreeView, 261 zdarzenie domy(cid:286)lne, 196 kreator modelu danych EDM, 327 (cid:296)ród(cid:225)a danych, 297 kursor myszy, 231, 234, 236 kszta(cid:225)t, 235, 236 po(cid:225)o(cid:298)enie, 238 L Language Integrated Query, Patrz: LINQ, zapytanie LINQ LINQ, 247, 248, 249 LINQ to Entities, 329 LINQ to SQL, 268, 279, 280, 281, 282, 284, 285, 294, 297, 307 LINQ to XML, 257, 259 Linux, 40 lista, 81, 85 dwukolumnowa, 87 dysków logicznych, 26 szablonów, 100 z kluczem, 88 litera(cid:225) liczbowy, Patrz: sta(cid:225)a liczbowa (cid:227) (cid:225)a(cid:276)cuch, 51, 53 konfiguruj(cid:261)cy po(cid:225)(cid:261)czenie, 308 po(cid:225)(cid:261)czenia, 271 znaków, 20, 199 M makro, 78 metoda, 44, 95 abstrakcyjna, 125, 127 anonimowa, 64, 65 Append, 54 argument, 57, Patrz te(cid:298): metoda parametr asynchroniczna, 165 atrybut ClassCleanup, 150 ClassInitialize, 150 TestCleanup, 150 TestInitialize, 150 Break, 161 CompareTo, 84 Console, 18, 21 CreateDatabase, 286 DeleteDatabase, 286 DoDragDrop, 231, 233, 234, 236, 238 Equals, 106 ExecuteCommand, 286 GetEnvironmentVariable, 25 GetEnvironmentVariables, 25 GetHashCode, 106, 107 GetValueOrDefault, 67 g(cid:225)owa, 57 Insert, 53 LoadAsync, 332 MessageBox, 200 Min, 65 Kup książkęPoleć książkę 358 Visual Studio 2013. Podr(cid:246)cznik programowania w C# z zadaniami metoda nadpisywanie, 123, 126, 127, 180 OrderBy, 248 Parallel.For, 161 parametr, 57, 113, Patrz te(cid:298): metoda argument nazwany, 59 opcjonalny, 58 tablica, 89 typ referencyjny, 58, 60 typ warto(cid:286)ciowy, 58, 60 warto(cid:286)(cid:252) domy(cid:286)lna, 46, 58 zwracana warto(cid:286)(cid:252), 59 PrivateObject, 147 przeci(cid:261)gnij i upu(cid:286)(cid:252), Patrz: przeci(cid:261)gnij i upu(cid:286)(cid:252) przeci(cid:261)(cid:298)anie, 57 przes(cid:225)anianie, 124 Read, 20 ReadKey, 20 ReadLine, 20 Remove, 53 Replace, 53 rozszerzaj(cid:261)ca, 65, 117, 118, 248, 250, 332 SaveChangesAsync, 333 Select, 248 SetError, 21 SetIn, 21 SetOut, 21 Show, 21 Single, 250 Sort, 84 statyczna, 17, 18, 56, 99 Stop, 161 SubmitChanges, 283, 294 sygnatura, 57 Where, 248 witrualna, 126, 127 WriteLine, 20, 21 wywo(cid:225)anie, 93 zdarzeniowa, 95, 182, 183, 185, 196 testowanie, 183 wywo(cid:225)ywanie z poziomu kodu, 186 zwracana warto(cid:286)(cid:252), 59 zwrotna, 166 mock object, Patrz: za(cid:286)lepka modyfikator async, 165 const, 99 event, 63 explicit, 109 implicit, 109 internal, 97 new, 124 override, 124, 126 private, 97, 123 protected, 97 protected internal, 97 public, 97, 123 readonly, 98, 99 sealed, 123 static, 56, 98, 99 virtual, 124, 127 MSIL, Patrz: CIL N nadawca, 186 najwi(cid:266)kszy wspólny dzielnik, 101 namespace, Patrz: przestrze(cid:276) nazw nHibernate, 267, 307 NUnit, 143 O obiekt, 66, 95 anonimowy, 249 formy, 173 inicjacja, 92 klonowanie, 53 kopiowanie, 66 sortowanie, Patrz: sortowanie zast(cid:266)pczy, 157 object-relational mapping, Patrz: ORM obszar powiadamiania, Patrz: zasobnik od(cid:286)miecacz, 67, 96, 180 odwzorowanie obiektowo- relacyjne, Patrz: ORM okno, 21 aplikacji, 173 ikona, 191 Locals, 31 nazwa, 191 Properties, 174 Toolbox, 174, 175 Watch, 31 w(cid:225)asno(cid:286)ci, 174 OLE DB, 267 operator, 47, 48, 49 !=, 106, 107 +=, 53, 54, 62, 63 , 106, 107 =, 106 =, 54 -=, 62 ==, 106, 107 = , 64 , 106, 107 =, 106 arytmetyczny, 47, 50, 105, 111, 154, 155 as, 50 await, 162, 163, 165, 166, 167 bitowy, 47 from, 248 is, 50 join, 252, 253, 292 konwersji, 49, 108 LINQ, 247 new, 66 orderby, 248 porównania, 106 priorytet, 47 przeci(cid:261)(cid:298)anie, 105 przypisania, 44, 53, 63 select, 248 where, 248 oprogramowania testowanie, Patrz: test ORM, 267, 279, 323 overload, Patrz: metoda przeci(cid:261)(cid:298)anie P pami(cid:266)(cid:252) wyciek, 67 zarz(cid:261)dzanie, 39 Parallel Extensions, 159 pasek stanu, 192, 198 p(cid:266)tla, 74 do..while, 74 for, 74 równoleg(cid:225)a, 159, 161 foreach, 75, 83 while, 74 platforma, 142 .NET, 39, 40, 140 historia, 41 wersja, 41, 193 wydajno(cid:286)(cid:252), 96 Mono, 40, 137 Kup książkęPoleć książkę Skorowidz 359 WinRT, 40, 140 Xbox, 141 XNA, 40, 140 plik .bmp, 214 .dll, 41 .emf, 214 .exe, 41, 137 .gif, 214 .ico, 191 .jpeg, 214 .png, 214 .wav, 220, 221 .wmf, 214 AssemblyInfo.cs, 80 d(cid:296)wi(cid:266)kowy, 220 przenoszenie, 242 tekstowy, 199, 202 wybór, 200 XML, 255, 257, 260 pole, 95 modyfikowanie, 264 przeno(cid:286)no(cid:286)(cid:252), 262 deklaracja, 98 prywatne, 97, 147, 180 statyczne, 98 tylko do odczytu, 98 polimorfizm, 127 Portable Class Library, Patrz: biblioteka PCL, Patrz: biblioteka PCL preprocesor dyrektywa, Patrz: dyrektywa preprocesora sta(cid:225)a, Patrz: sta(cid:225)a preprocesora procedura sk(cid:225)adowana, 276, 277, 294, 295, 327, 333 testowanie, 294 programowanie asynchroniczne, 40, 162 dynamiczne, 43 obiektowe, 95, 119 wizualne, 172 wspó(cid:225)bie(cid:298)ne, 40, 159 zdarzeniowe, 196 projektowanie wizualne, 308 przeci(cid:261)gnij i upu(cid:286)(cid:252), 231, 237, 238 wiele elementów, 241 przestrze(cid:276) nazw, 17 System.Collections, 81 System.Collections.Specialized, 81 System.Data.Entities, 333 System.Data.Entity, 331 System.Data.Linq.Mapping, 280 System.Entity.Data, 329 System.Linq, 248 System.Xml.Linq, 257 pude(cid:225)kowanie, 68 Q queue, Patrz: kolejka R relacja, 292 jeden do wielu, 304 ReSharper, 72 rozszerzenie, 65, 117, 118, 248, 250, 332 S schowek, 204 sender, Patrz: nadawca siatka DataGridView, Patrz: kontrolka DataGridView singleton, 123, 131 s(cid:225)ownik, 81, 87, 88 s(cid:225)owo kluczowe abstract, 125 break, 74 checked, 33, 37 class, 97 continue, 74 default, 46 delegate, 61 dynamic, 69, 72 event, 62, 63 namespace, 17 out, 61 override, 100 params, 89 ref, 61 return, 59 struct, 66, 97 this, 98, 118, 180 throw, 77 try, 75 using, 17, 200 var, 47, 72, 247 void, 57 yield, 90 sortowanie, 84 splash screen, Patrz: ekran powitalny SQL, 247, 269, 277 stack, Patrz: stos sta(cid:225)a, 66 liczbowa, 46 preprocesora, 78 stored procedure, Patrz: procedura sk(cid:225)adowana stos, 66, 87, 88, 96 wywo(cid:225)a(cid:276), 33 strongly typed, 280 struktura, 66, 67, 96, 120 bazuj(cid:261)ca na typie, 110 strumie(cid:276) b(cid:225)(cid:266)dów, 21 przekierowanie, 21 standardowy wyj(cid:286)cia, 20 StringReader, 208 szablon, 100, 111 (cid:263) (cid:286)rodowisko CLR, Patrz: CLR T tabela, 327 aktualizacja, 283 dodawanie do bazy danych, edycja danych, 274 (cid:225)(cid:261)czenie, 292 prezentacja w formularzu, 272 302 relacja, 310 tablica, 81, 85, 109 jako argument metody, 89 (cid:225)a(cid:276)cuchów, 199 wielowymiarowa, 84 Target Framework, 193 Task Parallel Library, Patrz: biblioteka TPL technologia LINQ, Patrz: LINQ test funkcjonalny aplikacji, 143 integracyjny, 143 jednostkowy, 143, 144, 152 konstruktora, 147 pola prywatnego, 147 projekt, 144 tworzenie, 145 uruchamianie, 146 wyj(cid:261)tków, 148 Kup książkęPoleć książkę 360 Visual Studio 2013. Podr(cid:246)cznik programowania w C# z zadaniami test losowy, 151 metody zdarzeniowej, 183 operatorów arytmetycznych, 155 procedury sk(cid:225)adowanej, 294 systemowy, 143 wydajno(cid:286)ciowy, 143 typ, Patrz: zmienna typ U u(cid:298)ytkownika profil katalog domowy, 25 katalog specjalny, 24 W widok, 16, 277, 291, 327, 333 Windows, 39 Windows Presentation Foundation, Patrz: biblioteka WPF w(cid:225)a(cid:286)ciwo(cid:286)(cid:252), 95, 102 domy(cid:286)lnie implementowana, 103, 104 wyj(cid:261)tek, 75 DivideByZeroException, 50 filtrowanie, 200 InvalidOperationException, 109 nieobs(cid:225)u(cid:298)ony, 76 obs(cid:225)uga, 76 OverflowException, 37 zg(cid:225)aszanie, 77 wyra(cid:298)enie lambda, 64, 65, 248, 250 Z zapytanie LINQ, 39, 65, 72, 90, 248, 257, 263, 279, 329 SQL, 248, 267, 277 T-SQL, 279 zintegrowane z j(cid:266)zykiem programowania, Patrz: LINQ, zapytanie LINQ zasobnik, 217 za(cid:286)lepka, 157 zdarzenie, 62, 95, 186, 196 domy(cid:286)lne, 196 DragDrop, 231, 234 DragEnter, 231 DragOver, 231, 234, 235 FormClosed, 257 KeyPress, 187 MouseDown, 231 Paint, 208, 225 zintegrowany j(cid:266)zyk zapyta(cid:276), Patrz: LINQ zmienna, 44 ca(cid:225)kowita, 44, 49 deklaracja, 44 globalna, 131 inicjowanie leniwe, 55 int, 33 (cid:225)a(cid:276)cuchowa, 44 null, 67, 68 obiektowa, 180 (cid:286)rodowiskowa USERPROFILE, 25 typ, 44, 45, 47 anonimowy, 119 Delegacja, 61 dynamiczny, 47, 69, 71 Graphics, 226 konwersja, 49, 100, 108, 127 Nullable, 67 object, 71 ogólny, 110, 111, 116 Panel, 180 parametryczny, Patrz: zmienna typ ogólny referencyjny, 47, 58, 60, 66, 67, 71, 83, 96, 120, 180 Task, 165 warto(cid:286)ciowy, 47, 55, 58, 60, 66, 67, 68, 83, 96, 120 warto(cid:286)(cid:252) domy(cid:286)lna, 46, 58 wyliczeniowy, 54 XComment, 258 XDeclaration, 258 znakowy, 46 zmiennoprzecinkowa, 44, 49, 50 znak !=, 106, 107 +=, 53, 54, 62 , 106, 107 =, 106 -=, 62 =:, 44 ==, 106, 107 = , 64 , 106, 107 =, 106 \b, 51 backslash, Patrz: znak lewego uko(cid:286)nika cudzys(cid:225)ów, 18 ko(cid:276)ca linii, 18, 51 lewego uko(cid:286)nika, 51 (cid:225)a(cid:276)cuch, Patrz: (cid:225)a(cid:276)cuch znaków \n, Patrz: znak ko(cid:276)ca linii spacji, 18 \u, 51 zapytania, 68 Kup książkęPoleć książkę
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Visual Studio 2013. Podręcznik programowania w C# z zadaniami
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ą: