Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00225 005048 20650593 na godz. na dobę w sumie
wyszukaj dokładnie | pobierz wtyczkę
Microsoft Visual Studio 2012. Programowanie w C# - książka
Microsoft Visual Studio 2012. Programowanie w C# - książka
Autor: Liczba stron: 200
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-6562-4 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> c# - programowanie
Porównaj ceny (książka, ebook, audiobook).
Czytaj online.
Komentuj

Visual Studio i język C# - potężny duet w rękach programisty!

O fantastycznych właściwościach Visual Studio 2012 z pewnością słyszał już każdy, kto choć odrobinę interesuje się tematem programowania. To środowisko programistyczne zapewnia użytkownikom komfort działania, jakiego próżno szukać gdziekolwiek indziej. Jego wygoda oraz łatwość obsługi pozwalają programiście skupić się na tym, co rzeczywiście chce osiągnąć, bez irytującego rozpraszania się na tysiące drobiazgów, o których kiedyś musiał pamiętać. Jeśli w dodatku ten programista poprawnie używa wydajnego, elastycznego języka C#, może stworzyć naprawdę świetną aplikację. Czy nie powinieneś w końcu się tego nauczyć?

Ta książka pomoże Ci wejść w świat programowania w C# z użyciem najnowszej wersji Visual Studio. Znajdziesz tu dokładny opis działania środowiska oraz szczegółowe informacje na temat posługiwania się językiem C# - od najprostszych operatorów i tablic, przez zachowania klas i obiektów, aż po tworzenie bibliotek i obsługę błędów. Dowiesz się, jak wykorzystać Asembler IL i na czym polega programowanie sieciowe. Odkryjesz, jak należy budować aplikację w stylu Metro dla systemu Windows 8, a na dokładkę dostaniesz listę słów kluczowych C# i zestaw instrukcji Asemblera IL. Co Ty na to?

Dzięki tej książce dowiesz się więcej o:

Programuj w C# - koniecznie z Visual Studio 2012!

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: Michał Mrowiec Projekt okładki: Studio Gravite / Olsztyn Obarek, Pokoński, Pazdrijowski, Zaprucki Fotografia na okładce została wykorzystana za zgodą Shutterstock.com 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?vs12pc Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję. ISBN: 978-83-246-6562-4 Copyright © Helion 2013 Printed in Poland. • Kup książkę • Poleć książkę • Oceń książkę • Księgarnia internetowa • Lubię to! » Nasza społeczność Spis treĈci Rozdziaä 1. Wstöp .............................................................................................. 9 1.1. O jĊzyku C# i platformie .NET .................................................................................. 9 1.2. Podstawowe pojĊcia .................................................................................................. 9 1.3. Potrzebne narzĊdzia ................................................................................................. 10 Rozdziaä 2. Microsoft Visual Studio 2012 ......................................................... 11 2.1. Co nowego? ............................................................................................................. 12 2.2. Instalacja .................................................................................................................. 12 2.3. Konfiguracja ............................................................................................................ 14 Pasek obsáugi odpluskwiania ................................................................................... 14 Numerowanie wierszy ............................................................................................. 14 2.4. Tworzenie nowego projektu .................................................................................... 15 2.5. Kompilacja i uruchamianie ...................................................................................... 15 2.6. Odpluskwianie (ang. Debugging) ............................................................................ 15 BáĊdy procesu kompilacji ........................................................................................ 15 BáĊdy pokompilacyjne ............................................................................................. 16 2.7. Okna, menu i paski narzĊdzi .................................................................................... 16 Okna ........................................................................................................................ 16 Górne menu ............................................................................................................. 16 Paski narzĊdzi .......................................................................................................... 17 2.8. Skáadniki pakietu ..................................................................................................... 17 2.9. Projektowanie diagramów UML .............................................................................. 18 Rozdziaä 3. Jözyk C#. Podstawy ....................................................................... 19 3.1. Struktura kodu Ĩródáowego ...................................................................................... 19 3.2. Komentarze .............................................................................................................. 20 Komentarz blokowy ................................................................................................ 20 Komentarz liniowy .................................................................................................. 20 Komentarz XML ..................................................................................................... 20 3.3. Program „Witaj, Ğwiecie!” ....................................................................................... 21 3.4. Typy danych ............................................................................................................ 21 Typy proste .............................................................................................................. 21 Typy referencyjne .................................................................................................... 22 Typ strukturalny ...................................................................................................... 24 Typ wyliczeniowy ................................................................................................... 24 Rzutowanie i konwersja typów ................................................................................ 24 3.5. Proste operacje wejĞcia/wyjĞcia ............................................................................... 25 Poleć książkęKup książkę 4 Microsoft Visual Studio 2012. Programowanie w C# WyĞwietlanie danych ............................................................................................... 25 Pobieranie danych ................................................................................................... 26 3.6. Preprocesor .............................................................................................................. 26 Dyrektywa #if .......................................................................................................... 26 Dyrektywa #else ...................................................................................................... 27 Dyrektywa #elif ....................................................................................................... 27 Dyrektywa #endif .................................................................................................... 27 Dyrektywa #define .................................................................................................. 27 Dyrektywa #undef ................................................................................................... 28 Dyrektywa #warning ............................................................................................... 28 Dyrektywa #error ..................................................................................................... 28 Dyrektywa #line ...................................................................................................... 28 Dyrektywa #region .................................................................................................. 29 Dyrektywa #endregion ............................................................................................ 29 Dyrektywa #pragma warning .................................................................................. 29 3.7. Zmienne i staáe ........................................................................................................ 30 3.8. Stos i sterta .............................................................................................................. 31 WydajnoĞü ............................................................................................................... 31 3.9. Instrukcja warunkowa if .......................................................................................... 32 3.10. Instrukcja wyboru switch ......................................................................................... 34 3.11. Operatory ................................................................................................................. 35 Podstawowe ............................................................................................................. 36 Jednoargumentowe .................................................................................................. 38 MnoĪenie, dzielenie i modulo .................................................................................. 40 PrzesuniĊcia ............................................................................................................. 40 Relacje i sprawdzanie typów ................................................................................... 41 RównoĞü i róĪnoĞü ................................................................................................... 42 Koniunkcja logiczna ................................................................................................ 42 Alternatywa wykluczająca logiczna ........................................................................ 42 Alternatywa logiczna ............................................................................................... 42 Koniunkcja warunkowa ........................................................................................... 43 Alternatywa warunkowa .......................................................................................... 43 Operator warunkowy ............................................................................................... 43 Przypisania .............................................................................................................. 43 3.12. PĊtle ......................................................................................................................... 45 PĊtla do-while .......................................................................................................... 45 PĊtla for ................................................................................................................... 45 PĊtla foreach ............................................................................................................ 48 PĊtla while ............................................................................................................... 49 Kontrola przepáywu ................................................................................................. 49 3.13. Argumenty wiersza poleceĔ ..................................................................................... 52 3.14. Metody ..................................................................................................................... 53 Deklaracja metod ..................................................................................................... 53 Przekazywanie przez referencjĊ lub przez wartoĞü .................................................. 54 3.15. Tablice ..................................................................................................................... 55 Przekazywanie tablic jako argumentów metod ........................................................ 56 Klasa System.Array ................................................................................................. 57 3.16. WskaĨniki ................................................................................................................ 60 Kod nienadzorowany (ang. unsafe code) ................................................................. 60 Typy wskaĨnikowe .................................................................................................. 61 Poleć książkęKup książkę Spis treĈci 5 Rozdziaä 4. Jözyk C#. Programowanie obiektowe .............................................. 63 4.1. Klasy i obiekty ......................................................................................................... 63 Sáowo kluczowe this ................................................................................................ 65 4.2. Konstruktor i destruktor ........................................................................................... 66 4.3. Dziedziczenie .......................................................................................................... 67 Klasy zagnieĪdĪone ................................................................................................. 68 4.4. Modyfikatory dostĊpu .............................................................................................. 69 Sáowo kluczowe readonly ........................................................................................ 70 Pola powinny byü prywatne ..................................................................................... 70 4.5. Wczesne i póĨne wiązanie ....................................................................................... 71 Wczesne wiązanie vs póĨne wiązanie ...................................................................... 71 Opakowywanie zmiennych ...................................................................................... 72 4.6. PrzeciąĪanie metod .................................................................................................. 72 4.7. PrzeciąĪanie operatorów .......................................................................................... 73 Sáowa kluczowe implicit i explicit ........................................................................... 75 4.8. Statyczne metody i pola ........................................................................................... 76 4.9. Klasy abstrakcyjne i zapieczĊtowane ....................................................................... 77 4.10. Serializacja ............................................................................................................... 78 UĪytecznoĞü serializacji .......................................................................................... 79 Zapis obiektu do pliku XML ................................................................................... 79 Odczyt obiektu z pliku XML ................................................................................... 79 4.11. Przestrzenie nazw .................................................................................................... 80 4.12. WáaĞciwoĞci ............................................................................................................. 82 4.13. Interfejsy .................................................................................................................. 83 Páytka i gáĊboka kopia obiektu ................................................................................ 84 4.14. Indeksery ................................................................................................................. 86 4.15. Polimorfizm ............................................................................................................. 88 Skáadowe wirtualne ................................................................................................. 91 Ukrywanie skáadowych klasy bazowej .................................................................... 92 Zapobieganie przesáanianiu wirtualnych skáadowych klasy pochodnej ................... 92 DostĊp do wirtualnych skáadowych klasy bazowej z klas pochodnych ................... 93 Przesáanianie metody ToString() ............................................................................. 94 4.16. Delegaty ................................................................................................................... 94 Metody anonimowe ................................................................................................. 95 WyraĪenia lambda ................................................................................................... 96 Delegat Func ............................................................................................................ 97 4.17. Zdarzenia ................................................................................................................. 98 4.18. Metody rozszerzające .............................................................................................. 98 4.19. Kolekcje ................................................................................................................... 99 Wybieranie klasy kolekcji ..................................................................................... 100 Klasa Queue .......................................................................................................... 101 Klasa Stack ............................................................................................................ 102 Klasa ArrayList ..................................................................................................... 103 Klasa StringCollection ........................................................................................... 103 Klasa Hashtable ..................................................................................................... 104 Klasa SortedList .................................................................................................... 105 Klasa ListDictionary .............................................................................................. 105 Klasa StringDictionary .......................................................................................... 106 Klasa NameObjectCollectionBase ......................................................................... 107 Klasa NameValueCollection ................................................................................. 110 4.20. Typy generyczne .................................................................................................... 111 Klasa generyczna Queue ....................................................................................... 112 Klasa generyczna Stack ......................................................................................... 113 Klasa generyczna LinkedList ................................................................................ 114 Poleć książkęKup książkę 6 Microsoft Visual Studio 2012. Programowanie w C# Klasa generyczna List ............................................................................................ 115 Klasa generyczna Dictionary ................................................................................. 116 Klasa generyczna SortedDictionary ....................................................................... 118 Klasa generyczna KeyedCollection ....................................................................... 120 Klasa generyczna SortedList ................................................................................. 123 4.21. Kontra i kowariancja .............................................................................................. 125 Rozdziaä 5. Jözyk C#. Pozostaäe zagadnienia ................................................... 127 5.1. Wywoáywanie funkcji przez PInvoke .................................................................... 127 5.2. Napisy (ang. Strings) ............................................................................................. 129 Deklaracja i inicjalizacja ....................................................................................... 129 NiezmiennoĞü obiektów String .............................................................................. 130 Znaki specjalne ...................................................................................................... 130 Formatowanie napisów .......................................................................................... 130 Napisy czĊĞciowe .................................................................................................. 131 DostĊp do pojedynczych znaków .......................................................................... 132 NajwaĪniejsze metody klasy String ....................................................................... 132 5.3. Arytmetyka duĪych liczb ....................................................................................... 132 5.4. Arytmetyka liczb zespolonych ............................................................................... 134 5.5. System plików i rejestr .......................................................................................... 134 Pliki i katalogi ....................................................................................................... 135 Strumienie ............................................................................................................. 137 Czytelnicy i pisarze ............................................................................................... 138 Asynchroniczne operacje wejĞcia/wyjĞcia ............................................................. 139 Kompresja ............................................................................................................. 139 Rejestr .................................................................................................................... 140 5.6. Tworzenie bibliotek ............................................................................................... 141 5.7. Procesy i wątki ...................................................................................................... 142 Procesy .................................................................................................................. 142 Wątki ..................................................................................................................... 143 5.8. Obsáuga báĊdów ..................................................................................................... 146 Podsumowanie ....................................................................................................... 147 Rozdziaä 6. Tworzenie interfejsu graficznego aplikacji ...................................... 149 6.1. Projektowanie interfejsu graficznego .................................................................... 149 6.2. WejĞcie klawiatury ................................................................................................ 150 6.3. WejĞcie myszy ....................................................................................................... 151 6.4. Symulowanie klawiatury i myszy .......................................................................... 151 Symulowanie klawiatury ....................................................................................... 152 Symulowanie myszy .............................................................................................. 152 6.5. Przeciągnij i upuĞü ................................................................................................. 153 6.6. Przegląd wybranych kontrolek .............................................................................. 153 6.7. WstĊp do Windows Presentation Foundation ........................................................ 155 Tworzenie projektu WPF ....................................................................................... 155 Przykáad: „Witaj, Ğwiecie WPF!” .......................................................................... 156 Rozdziaä 7. Podstawy programowania sieciowego ........................................... 159 7.1. System DNS .......................................................................................................... 159 7.2. Wysyáanie wiadomoĞci e-mail ............................................................................... 160 7.3. Protokóá FTP ......................................................................................................... 161 Przykáad: Jak wysáaü plik na serwer FTP? ............................................................. 161 7.4. Gniazda (ang. Sockets) .......................................................................................... 161 Poleć książkęKup książkę Spis treĈci 7 Rozdziaä 8. Asembler IL .................................................................................. 165 8.1. Co to jest? .............................................................................................................. 165 8.2. Program „Witaj, Ğwiecie!” ..................................................................................... 165 8.3. Kompilacja i uruchamianie .................................................................................... 166 8.4. Zmienne lokalne .................................................................................................... 166 8.5. Metody ................................................................................................................... 167 8.6. RozgaáĊzienia ........................................................................................................ 169 8.7. PĊtle ....................................................................................................................... 170 8.8. Przegląd wybranych instrukcji ............................................................................... 171 Instrukcje odkáadające wartoĞü na stos .................................................................. 171 Instrukcje zdejmujące wartoĞü ze stosu ................................................................. 172 Instrukcje rozgaáĊzieĔ ............................................................................................ 172 Instrukcje arytmetyczne ......................................................................................... 173 Pozostaáe instrukcje ............................................................................................... 173 Rozdziaä 9. Podstawy tworzenia aplikacji w stylu Metro dla Windows 8 ........... 175 9.1. Co to są aplikacje Metro? ...................................................................................... 175 9.2. Potrzebne narzĊdzia ............................................................................................... 176 9.3. Uzyskiwanie licencji dewelopera .......................................................................... 176 9.4. Program „Witaj, Ğwiecie Metro!” .......................................................................... 177 Tworzenie nowego projektu .................................................................................. 177 Zmodyfikuj stronĊ startową ................................................................................... 177 Dodaj obsáugĊ zdarzeĔ ........................................................................................... 178 Uruchom aplikacjĊ ................................................................................................. 178 9.5. Przegląd wybranych kontrolek .............................................................................. 178 App bar .................................................................................................................. 178 Button .................................................................................................................... 178 Check box .............................................................................................................. 179 Combo box ............................................................................................................ 179 Grid view ............................................................................................................... 179 Hyperlink ............................................................................................................... 179 List box .................................................................................................................. 180 List view ................................................................................................................ 180 Password box ......................................................................................................... 181 Progress bar ........................................................................................................... 181 Progress ring .......................................................................................................... 181 Radio button .......................................................................................................... 181 Slider ..................................................................................................................... 182 Text block .............................................................................................................. 182 Text box ................................................................................................................. 182 Toggle switch ........................................................................................................ 182 Tooltip ................................................................................................................... 183 Dodatek A Säowa kluczowe jözyka C# .............................................................. 185 Dodatek B Zestaw instrukcji Asemblera IL .................................................... 187 Operacje arytmetyczne ................................................................................................. 187 Dodawanie ............................................................................................................. 187 Odejmowanie ......................................................................................................... 187 MnoĪenie ............................................................................................................... 187 Dzielenie ................................................................................................................ 188 Modulo .................................................................................................................. 188 WartoĞü negatywna ............................................................................................... 188 Operacje bitowe ............................................................................................................ 188 Koniunkcja ............................................................................................................ 188 Poleć książkęKup książkę 8 Microsoft Visual Studio 2012. Programowanie w C# Alternatywa ........................................................................................................... 188 Negacja .................................................................................................................. 188 Alternatywa wykluczająca ..................................................................................... 188 PrzesuniĊcie bitowe w prawo ................................................................................ 188 PrzesuniĊcie bitowe w lewo ................................................................................... 188 Operacje odkáadania na stos ......................................................................................... 189 Operacje zdejmowania ze stosu i zapisywania ............................................................. 190 Konwersje ..................................................................................................................... 191 Porównywanie .............................................................................................................. 191 Skoki bezwarunkowe .................................................................................................... 192 Skoki warunkowe ......................................................................................................... 192 Wywoáywanie metod i powrót ...................................................................................... 192 Opakowywanie ............................................................................................................. 192 Wyjątki ......................................................................................................................... 193 Bloki pamiĊci ............................................................................................................... 193 WskaĨniki ..................................................................................................................... 193 Pozostaáe ....................................................................................................................... 193 Skorowidz ................................................................................... 195 Poleć książkęKup książkę Rozdziaä 5. Jözyk C#. Pozostaäe zagadnienia 5.1. Wywoäywanie funkcji przez PInvoke PInvoke to skrót od Platform Invocation Services. Usáugi te pozwalają z zarządzane- go kodu wywoáywaü niezarządzane funkcje zaimplementowane w bibliotece DLL. PInvoke polega na metadanych, aby zlokalizowaü eksportowane funkcje i uporząd- kowaü ich argumenty w czasie dziaáania programu. Proces ten zostaá przedstawiony na rysunku 5.1. Rysunek 5.1. Wywoáywanie funkcji poprzez PInvoke Proces ten moĪna teĪ scharakteryzowaü nastĊpującą listą kroków: 1. Zlokalizowanie biblioteki DLL, która zawiera funkcjĊ do wywoáania. 2. Zaáadowanie biblioteki DLL do pamiĊci. Poleć książkęKup książkę 128 Microsoft Visual Studio 2012. Programowanie w C# 3. Zlokalizowanie adresu funkcji w pamiĊci i odáoĪenie jej argumentów na stos, a takĪe porządkowanie ich, gdy zachodzi taka potrzeba. 4. Przekazanie kontroli do funkcji niezarządzanej. Lokalizowanie i äadowanie biblioteki DLL do pamiöci oraz lokalizowanie adresu funkcji nastöpuje tylko przy jej pierwszym wywoäaniu. PInvoke rzuca wyjñtki (spowodowane przez niezarzñdzane funkcje) do wywoäujñcego zarzñdzanego. Aby zadeklarowaü metodĊ, której implementacjĊ eksportuje biblioteka DLL, wykonaj nastĊpujące kroki:  Zadeklaruj metodĊ ze sáowami kluczowymi static i extern.  Zaáącz atrybut DllImport do metody. Atrybut ten pozwala okreĞliü nazwĊ biblioteki DLL zawierającej metodĊ. Jest taki zwyczaj, Īe metodĊ w kodzie C# nazywa siĊ tak samo jak metodĊ eksportowaną, moĪna jednak daü jej równieĪ inną nazwĊ.  Opcjonalnie okreĞl informacje porządkujące dla parametrów metody i wartoĞci zwracanej. PoniĪszy przykáad prezentuje, jak uĪyü atrybutu DllImport do wyĞwietlenia wiado- moĞci poprzez wywoáanie metody puts z biblioteki msvcrt.dll. using System; using System.Runtime.InteropServices; class Program { [DllImport( msvcrt.dll )] //zaimportowanie biblioteki DLL public static extern int puts(string c); //deklaracja funkcji z biblioteki [DllImport( msvcrt.dll )] //zaimportowanie biblioteki DLL internal static extern int _flushall(); //deklaracja funkcji z biblioteki static void Main() { puts( Witaj! ); //Wypisze na konsoli napis: Witaj! _flushall(); } } Byü moĪe teraz w Twojej gáowie pojawiáo siĊ pytanie, skąd braü sygnatury, które po- jawiáy siĊ w powyĪszym kodzie? Polecam Ci serwis http://www.pinvoke.net/. Jest tam bardzo duĪo materiaáów o usáugach PInvoke oraz sygnatury pogrupowane wedáug nazw bibliotek. Poleć książkęKup książkę Rozdziaä 5. i Jözyk C#. Pozostaäe zagadnienia 129 5.2. Napisy (ang. Strings) Napis jest obiektem typu String, którego wartoĞcią jest tekst. Patrząc od wnĊtrza, moglibyĞmy zobaczyü, Īe tekst w napisie jest przechowywany jako kolekcja obiektów typu Char (kolekcja tylko do odczytu). W jĊzyku C# napis nie koĔczy siĊ znakiem ze- rowym. WáaĞciwoĞü Length napisu reprezentuje liczbĊ obiektów Char, które zawiera, a nie liczbĊ znaków Unicode. Sáowo kluczowe string jest aliasem dla klasy System.String. Wynika z tego, Īe string i String są swoimi odpowiednikami i moĪesz uĪywaü takiej nazwy, jaką pre- ferujesz. Klasa String dostarcza wiele metod do bezpiecznego tworzenia, porówny- wania oraz do innych czynnoĞci, jakie moĪna wykonaü na napisie. Dodatkowo jĊzyk C# przeciąĪa niektóre operatory, aby moĪna byáo ich uĪyü do róĪnych operacji na napisach. Deklaracja i inicjalizacja Zadeklarowaü i zainicjalizowaü napis moĪna na róĪne sposoby: //deklaracja bez inicjalizacji string message1; //inicjalizacja za pomocą wartoĞci null string message2 = null; //inicjalizacja napisu jako pustego string message3 = System.String.Empty; //inicjalizacja napisu zwykáym tekstem string oldPath = c:\\Program Files\\Microsoft Visual Studio 8.0 ; //inicjalizacja napisu staáą napisową (zauwaĪ znak @ przed napisem) string newPath = @ c:\Program Files\Microsoft Visual Studio 9.0 ; //moĪna uĪyü peánej nazwy, czyli System.String zamiast String System.String greeting = Hello World! ; //zmienna lokalna (np. wewnątrz metody) var temp = Nadal jestem silnie typowanym napisem! ; //napis, w którym nie moĪna przechowaü innego tekstu const string message4 = Nie moľna siú mnie pozbyè! ; //UĪywaj konstruktora String tylko wtedy, gdy //tworzysz napis z char*, char[] lub sbyte*. char[] letters = { A , B , C }; string alphabet = new string(letters); Inicjalizując napisy wartoĞcią Empty zamiast null, zredukujesz szanse na otrzymanie wyjątku NullReferenceException. UĪywaj statycznej metody IsNullOrEmpty(String), aby sprawdziü wartoĞü napisu przed dostĊpem do niego. Poleć książkęKup książkę 130 Microsoft Visual Studio 2012. Programowanie w C# NiezmiennoĈè obiektów String Obiekty String są niezmienne: nie mogą byü zmienione po ich utworzeniu. MoĪe siĊ wydawaü, Īe metody i operatory dziaáające na napisach mogą zmieniaü ich wartoĞü. W kaĪdym z tych przypadków napis nie jest modyfikowany, zatem jest tworzony no- wy obiekt String. W przykáadzie poniĪej, gdy wartoĞci s1 i s2 są áączone, powstaje nowy napis, a dwa oryginalne napisy pozostają niezmienione. Nowy obiekt jest przy- pisywany do zmiennej s1, a oryginalny obiekt, który byá wczeĞniej do niej przypisany, zostaje zwolniony przez odĞmiecacz pamiĊci (ang. Garbage Collector), poniewaĪ Īadna zmienna nie przechowuje do niego referencji. string s1 = Napis to wiúcej ; string s2 = niľ znaki, jakie zawiera. ; //Poáączenie s1 i s2 tworzy nowy obiekt //i zachowuje go w s1, zwalniając //referencjĊ do oryginalnego obiektu s1 += s2; System.Console.WriteLine(s1); //Wypisze: Napis to wiĊcej niĪ znaki, jakie zawiera PoniewaĪ „modyfikacja” napisu polega na utworzeniu nowego napisu, musisz uwa- Īaü, gdy tworzysz do nich referencje. Gdy stworzysz referencjĊ do napisu, a nastĊpnie „zmodyfikujesz” oryginalny napis, to referencja nadal bĊdzie wskazywaü na oryginalny obiekt. Ilustruje to nastĊpujący przykáad: string s1 = Witaj ; string s2 = s1; s1 += ħwiecie! ; System.Console.WriteLine(s2); //Wypisze: Witaj Znaki specjalne W napisach moĪna uĪywaü znaków specjalnych, takich jak znak nowej linii czy ta- bulator. Znaki te przedstawia tabela 5.1. Tabela 5.1. Znaki specjalne w jĊzyku C# Znak specjalny Nazwa Apostrof \ Cudzysáów \ Backslash \\ Null \0 Alert \a Backspace \b Form feed \f Nowa linia \n Powrót karetki \r Kodowanie Unicode 0x0027 0x0022 0x005C 0x0000 0x0007 0x0008 0x000C 0x000A 0x000D Poleć książkęKup książkę Rozdziaä 5. i Jözyk C#. Pozostaäe zagadnienia 131 Tabela 5.1. Znaki specjalne w jĊzyku C# — ciąg dalszy Znak specjalny Nazwa \t \U \u \v \x Tabulator poziomy Sekwencja 8 cyfr heksadecymalnych oznaczających kod znaku Unicode Sekwencja 4 cyfr heksadecymalnych oznaczających kod znaku Unicode Tabulator pionowy Sekwencja od 1 do 4 cyfr heksadecymalnych oznaczających kod znaku Unicode Kodowanie Unicode 0x0009 \Unnnnnnnn \u0041 = A 0x000B \x0041 = A Formatowanie napisów Napis formatowany to napis, którego zawartoĞü okreĞlana jest dynamicznie (w czasie dziaáania programu). Tworzy siĊ go za pomocą statycznej metody Format. Oto przykáad: //Pobierz dane od uĪytkownika System.Console.WriteLine( Enter a number ); string input = System.Console.ReadLine(); //konwersja napisu (string) na liczbĊ caákowitą (int) int j; System.Int32.TryParse(input, out j); //wypisanie róĪnych napisów podczas kaĪdej iteracji pĊtli string s; for (int i = 0; i 10; i++) { s = System.String.Format( {0} * {1} = {2} , i, j, (i * j)); System.Console.WriteLine(s); } Napisy czöĈciowe Napis czĊĞciowy (ang. substring) to sekwencja znaków okreĞlonej dáugoĞci zawarta w napisie. Metoda IndexOf pozwala wyszukaü czĊĞci napisów. Metoda Replace zamienia wszystkie wystąpienia napisów czĊĞciowych w napisie. Oto przykáad: string s3 = Visual C# Express ; System.Console.WriteLine(s3.Substring(7, 2)); //Wypisze: C# System.Console.WriteLine(s3.Replace( C# , Basic )); //Wypisze: Visual Basic Express //Indeksy numerowane są od zera int index = s3.IndexOf( C ); //indeks = 7 Poleć książkęKup książkę 132 Microsoft Visual Studio 2012. Programowanie w C# Dostöp do pojedynczych znaków Do poszczególnych znaków napisu moĪesz uzyskaü dostĊp tak jak do tablicy, co pre- zentuje poniĪszy przykáad. OczywiĞcie dostĊp tylko do odczytu. string s5 = Piszú wstecz ; for (int i = 0; i s5.Length; i++) { System.Console.Write(s5[s5.Length - i - 1]); } //Wypisze: zcetsw ĊzsiP NajwaĔniejsze metody klasy String  Concat(String, String) — áączy dwa napisy w jeden.  Contains(String) — sprawdza, czy podany tekst wystĊpuje w napisie.  Insert(Int32, String) — wstawia tekst do napisu na podaną pozycjĊ.  IsNullOrEmpty(String) — sprawdza, czy napis jest pusty lub ma wartoĞü null.  Replace(String, String) — zastĊpuje wystąpienia napisu z drugiego parametru w napisie podanym jako pierwszy parametr (zwraca nowy napis).  ToLower() — zamienia litery w napisie na maáe (zwraca nowy napis).  ToUpper() — zamienia litery w napisie na duĪe (zwraca nowy napis). 5.3. Arytmetyka duĔych liczb Na początek pragnĊ wspomnieü o strukturach Int64 oraz UInt64. Pierwsza struktura reprezentuje 64-bitową liczbĊ caákowitą ze znakiem, a druga — bez znaku. Maksy- malna wartoĞü dla Int64 wynosi 9 223 372 036 854 775 807, a dla UInt64 jest to 18 446 744 073 709 551 615. Nie napisaáem o tym w rozdziale 3., wiĊc postanowiáem napisaü tutaj. Jednak nie to jest gáównym tematem tego rozdziaáu. Tym, czym siĊ za chwilĊ zajmiemy, bĊdą naprawdĊ duĪe liczby, a chodzi dokáadnie o strukturĊ BigInteger. W przestrzeni nazw System.Numerics znajduje siĊ struktura BigInteger, która wspo- maga operacje na duĪych liczbach. Zawiera ona wáaĞciwoĞci, metody i operatory do dziaáania na takich liczbach. Najpierw musimy dodaü referencjĊ do jednostki System.Numerics.dll. W okienku Solution Explorer kliknij prawym przyciskiem myszy References i wybierz Add Refe- rence..., odnajdĨ na liĞcie nazwĊ System.Numerics, zaznacz ją i kliknij przycisk OK. Teraz na górze swojego programu dopisz linijkĊ: using System.Numerics; Poleć książkęKup książkę Rozdziaä 5. i Jözyk C#. Pozostaäe zagadnienia 133 Od teraz moĪesz korzystaü z caáej przestrzeni nazw System.Numerics. Nową zmienną typu BigInteger moĪemy utworzyü nastĊpująco: //utworzenie zmiennej i zainicjalizowanie ją domyĞlną wartoĞcią (zero) BigInteger a = new BigInteger(); //utworzenie zmiennej i zainicjalizowanie ją podaną wartoĞcią BigInteger b = new BigInteger(18446744073709551615); Struktura BigInteger zawiera przeciąĪone operatory, takie jak na przykáad + (doda- wanie), — (odejmowanie), * (mnoĪenie) i / (dzielenie), co uáatwia wykonywanie podstawowych operacji na duĪych liczbach. Oto prosty kalkulator z uĪyciem BigInteger: using System; using System.Numerics; class Program { static void Main() { Console.WriteLine( Podaj pierwszæ liczbú: ); string strA = Console.ReadLine(); //Wczytaj liniĊ tekstu z konsoli Console.WriteLine( Podaj drugæ liczbú: ); string strB = Console.ReadLine(); //Wczytaj liniĊ tekstu z konsoli BigInteger a = BigInteger.Parse(strA); //Przekonwertuj napis na BigInteger BigInteger b = BigInteger.Parse(strB); //Przekonwertuj napis na BigInteger Console.WriteLine( Wyniki: ); Console.WriteLine( {0} + {1} = {2} , a, b, a + b); Console.WriteLine( {0} - {1} = {2} , a, b, a - b); Console.WriteLine( {0} * {1} = {2} , a, b, a * b); Console.WriteLine( {0} / {1} = {2} , a, b, a / b); } } Przykáadowe wyjĞcie programu: Podaj pierwszæ liczbú: 18446744073709551615 Podaj drugæ liczbú: 64 Wyniki: 18446744073709551615 + 64 = 18446744073709551679 18446744073709551615 - 64 = 18446744073709551551 18446744073709551615 * 64 = 1180591620717411303360 18446744073709551615 / 64 = 288230376151711743 Poleć książkęKup książkę 134 Microsoft Visual Studio 2012. Programowanie w C# 5.4. Arytmetyka liczb zespolonych W znanej nam juĪ przestrzeni nazw System.Numerics znajduje siĊ struktura Complex. Reprezentuje ona liczbĊ zespoloną. Liczba zespolona skáada siĊ z czĊĞci rzeczywistej i czĊĞci urojonej. Nową instancjĊ struktury Complex tworzymy w nastĊpujący sposób: Complex complex1 = new Complex(17.34, 12.87); Complex complex2 = new Complex(8.76, 5.19); gdzie pierwsza wartoĞü to czĊĞü rzeczywista, a druga to czĊĞü urojona. Na liczbach zespolonych moĪemy wykonywaü róĪne operacje. Struktura Complex z prze- strzeni nazw System.Numerics udostĊpnia naprawdĊ wiele przydatnych metod, wáa- ĞciwoĞci i operatorów. Oto przykáadowy kalkulator dziaáający na liczbach zespolonych: using System; using System.Numerics; class Program { static void Main() { Complex complex1 = new Complex(17.34, 12.87); Complex complex2 = new Complex(8.76, 5.19); Console.WriteLine( {0} + {1} = {2} , complex1, complex2, complex1 + complex2); Console.WriteLine( {0} - {1} = {2} , complex1, complex2, complex1 - complex2); Console.WriteLine( {0} * {1} = {2} , complex1, complex2, complex1 * complex2); Console.WriteLine( {0} / {1} = {2} , complex1, complex2, complex1 / complex2); } } WyjĞcie programu: (17.34, 12.87) + (8.76, 5.19) = (26.1, 18.06) (17.34, 12.87) - (8.76, 5.19) = (8.58, 7.68) (17.34, 12.87) * (8.76, 5.19) = (85.1031, 202.7358) (17.34, 12.87) / (8.76, 5.19) = (2.10944241403558, 0.219405693054265) 5.5. System plików i rejestr Operacje wejĞcia/wyjĞcia na plikach i strumieniach odnoszą siĊ do transferu danych do i z noĞnika danych. Przestrzenie nazw System.IO zawierają typy, które pozwalają czytaü i pisaü do strumieni danych i plików. Te przestrzenie nazw zawierają równieĪ Poleć książkęKup książkę Rozdziaä 5. i Jözyk C#. Pozostaäe zagadnienia 135 typy pozwalające na kompresjĊ i dekompresjĊ plików oraz typy pozwalające na ko- munikacjĊ poprzez áącza i porty. Plik jest uporządkowaną i nazwaną kolekcją bajtów. Gdy pracujesz z plikami, pracu- jesz równieĪ ze ĞcieĪkami dostĊpu, pamiĊcią oraz nazwami plików i katalogów. Pliki i katalogi MoĪesz uĪywaü typów z przestrzeni System.IO do interakcji z plikami i katalogami. Bazując na przykáad na okreĞlonych kryteriach wyszukiwania, moĪesz pobraü i usta- wiü wáaĞciwoĞci plików i katalogów, a takĪe pobraü kolekcjĊ plików i katalogów. PoniĪej lista czĊsto uĪywanych klas do pracy z plikami i katalogami:  File — dostarcza statyczne metody do tworzenia, kopiowania, usuwania, przenoszenia i otwierania plików.  FileInfo — dostarcza metody instancji do tworzenia, kopiowania, usuwania, przenoszenia i otwierania plików.  Directory — dostarcza statyczne metody do tworzenia, przenoszenia oraz wyliczania katalogów i podkatalogów.  DirectoryInfo — dostarcza metody instancji do tworzenia, przenoszenia i wyliczania katalogów i podkatalogów.  Path — dostarcza metody i wáaĞciwoĞci do przetwarzania ĞcieĪek dostĊpu do plików i katalogów. Przykäad: Jak kopiowaè katalogi? using System; using System.IO; class DirectoryCopyExample { static void Main() { //Kopiuje katalog cat1 do katalogu cat2 wraz z podkatalogami i plikami DirectoryCopy(@ C:\cat1 , @ C:\cat2 , true); } private static void DirectoryCopy(string sourceDirName, string destDirName, ´bool copySubDirs) { DirectoryInfo dir = new DirectoryInfo(sourceDirName); DirectoryInfo[] dirs = dir.GetDirectories(); if (!dir.Exists) { throw new DirectoryNotFoundException( Katalog ļródđowy nie istnieje lub nie moľe zostaè odnaleziony: + sourceDirName); } Poleć książkęKup książkę 136 Microsoft Visual Studio 2012. Programowanie w C# if (!Directory.Exists(destDirName)) { Directory.CreateDirectory(destDirName); } FileInfo[] files = dir.GetFiles(); foreach (FileInfo file in files) { string temppath = Path.Combine(destDirName, file.Name); file.CopyTo(temppath, false); } if (copySubDirs) { foreach (DirectoryInfo subdir in dirs) { string temppath = Path.Combine(destDirName, subdir.Name); DirectoryCopy(subdir.FullName, temppath, copySubDirs); } } } } Przykäad: Jak wylistowaè pliki w katalogu? using System; using System.IO; public class DirectoryLister { public static void Main(String[] args) { string path = Environment.CurrentDirectory; if (args.Length 0) { if (Directory.Exists(args[0])) { path = args[0]; } else { Console.WriteLine( {0} nie znaleziono; uľywajæc katalogu bieľæcego: , args[0]); } } DirectoryInfo dir = new DirectoryInfo(path); Console.WriteLine( Rozmiar \tData utworzenia \tNazwa ); foreach (FileInfo f in dir.GetFiles( *.exe )) { string name = f.Name; long size = f.Length; DateTime creationTime = f.CreationTime; Console.WriteLine( {0,-12:N0} \t{1,-20:g} \t{2} , size, creationTime, name); } } } Poleć książkęKup książkę Rozdziaä 5. i Jözyk C#. Pozostaäe zagadnienia 137 Przykäad: Jak wylistowaè katalogi w podanej ĈcieĔce? using System; using System.Collections.Generic; using System.IO; class Program { private static void Main(string[] args) { try { string dirPath = @ C:\ ; //katalog do przeszukania List string dirs = new List string (Directory. ´EnumerateDirectories(dirPath)); foreach (var dir in dirs) { Console.WriteLine( {0} , dir.Substring(dir.LastIndexOf( \\ ) + 1)); } Console.WriteLine( W sumie znaleziono {0} katalogów. , dirs.Count); } catch (UnauthorizedAccessException UAEx) { Console.WriteLine(UAEx.Message); } catch (PathTooLongException PathEx) { Console.WriteLine(PathEx.Message); } } } Strumienie Abstrakcyjna klasa bazowa Stream wspiera odczyt i zapis bajtów. Wszystkie klasy re- prezentujące strumienie dziedziczą z klasy Stream. Na strumieniach moĪemy wykonywaü trzy fundamentalne operacje:  Czytanie — transfer danych ze strumienia do struktury danych, takiej jak np. tablica bajtów.  Pisanie — transfer danych do strumienia z okreĞlonego Ĩródáa.  Szukanie — pobieranie i modyfikowanie bieĪącej pozycji w strumieniu. PoniĪej lista czĊsto uĪywanych klas do pracy ze strumieniami:  FileStream — do czytania z pliku i pisania do pliku.  MemoryStream — do czytania z pamiĊci i pisania do pamiĊci.  BufferedStream — do zwiĊkszenia wydajnoĞci operacji odczytu i zapisu. Poleć książkęKup książkę 138 Microsoft Visual Studio 2012. Programowanie w C#  NetworkStream — do czytania i pisania poprzez gniazda sieciowe.  PipeStream — do czytania i pisania poprzez áącza nienazwane i nazwane.  CryptoStream — do áączenia strumieni danych z transformacjami kryptograficznymi. Czytelnicy i pisarze PrzestrzeĔ nazw System.IO dostarcza typów do czytania znaków ze strumieni i zapisu ich do strumieni. DomyĞlnie strumienie stworzone są do pracy z bajtami. Typy czytelni- ków i pisarzy obsáugują konwersje znaków na bajty i bajtów na znaki. PoniĪej czĊsto uĪywane klasy czytelników i pisarzy:  BinaryReader i BinaryWriter — do odczytu i zapisu prymitywnych danych jako wartoĞci binarnych.  StreamReader i StreamWriter — do odczytu i zapisu znaków (z obsáugą konwersji znaków na bajty i odwrotnie).  StringReader i StringWriter — do odczytu i zapisu znaków do napisu (String) i z napisu (String).  TextReader i TextWriter — klasy bazowe dla innych czytelników i pisarzy do zapisu oraz odczytu znaków i napisów, ale nie danych binarnych. Przykäad: Jak odczytaè dane z pliku tekstowego? using System; using System.IO; class Test { public static void Main() { try { using (StreamReader sr = new StreamReader( TestFile.txt )) { String line = sr.ReadToEnd(); //Czytaj plik do koĔca Console.WriteLine(line); //WyĞwietl zawartoĞü na ekranie } } catch (Exception e) { Console.WriteLine( Nie moľna odczytaè danych z pliku: ); Console.WriteLine(e.Message); } } } Poleć książkęKup książkę Rozdziaä 5. i Jözyk C#. Pozostaäe zagadnienia 139 Przykäad: Jak zapisaè dane do pliku tekstowego? using System; using System.IO; class Program { private static void Main(string[] args) { string str = String.Empty; //Utwórz pusty napis str = Console.ReadLine(); //Pobierz tekst z konsoli i zapisz do zmiennej //Utwórz Pisarza using (StreamWriter outfile = new StreamWriter(@ C:\file1.txt )) { outfile.Write(str); //Zapisz dane ze zmiennej str do pliku } } } Asynchroniczne operacje wejĈcia/wyjĈcia Odczyt i zapis duĪej iloĞci danych moĪe powodowaü wiĊksze uĪycie zasobów. Powi- nieneĞ wykonywaü takie czynnoĞci asynchronicznie, aby aplikacja mogáa odpowiadaü uĪytkownikowi. Przy synchronicznych operacjach wejĞcia/wyjĞcia wątek obsáugi in- terfejsu uĪytkownika jest blokowany, dopóki nie skoĔczą siĊ te operacje. Skáadowe asynchroniczne zawierają w swojej nazwie sáowo Async, np. CopyToAsync, FlushAsync, ReadAsync czy WriteAsync. UĪywaj tych metod w poáączeniu ze sáowami kluczowymi async i await. Kompresja Kompresja polega na zmniejszaniu rozmiaru pliku. Dekompresja to proces wypako- wywania zawartoĞci skompresowanego pliku, aby moĪna byáo uĪyü tej zawartoĞci. Przykäad: Jak kompresowaè i wypakowywaè dane w formacie ZIP? using System; using System.IO; using System.IO.Compression; namespace ConsoleApplication { class Program { static void Main(string[] args) { string startPath = @ c:\example\start ; string zipPath = @ c:\example\result.zip ; string extractPath = @ c:\example\extract ; ZipFile.CreateFromDirectory(startPath, zipPath); Poleć książkęKup książkę 140 Microsoft Visual Studio 2012. Programowanie w C# ZipFile.ExtractToDirectory(zipPath, extractPath); } } } Aby uĔyè klasy ZipFile, musisz dodaè referencjö do jednostki System.IO.Compression. ´FileSystem w swoim projekcie. Rejestr W rejestrze moĪemy przechowywaü dane dotyczące stworzonej przez nas aplikacji, takie jak na przykáad jej informacje o konfiguracji. Przykäad: Jak stworzyè klucz w rejestrze? using System; using System.IO; using Microsoft.Win32; class Program { static void Main(string[] args) { const string userRoot = HKEY_CURRENT_USER ; const string subkey = Imiona ; const string keyName = userRoot + \\ + subkey; Registry.SetValue(keyName, Imiú , Izabela ); } } Przykäad: Jak odczytaè wartoĈè klucza z rejestru? using System; using System.IO; using Microsoft.Win32; class Program { static void Main(string[] args) { const string userRoot = HKEY_CURRENT_USER ; const string subkey = Imiona ; const string keyName = userRoot + \\ + subkey; string str = (string) Registry.GetValue(keyName, Imiú , brak ); Console.WriteLine( {0} , str); } } Poleć książkęKup książkę Rozdziaä 5. i Jözyk C#. Pozostaäe zagadnienia 141 Bezpieczniej jest zapisywaè dane do klucza gäównego HKEY_CURRENT_USER zamiast do klucza HKEY_LOCAL_MACHINE. 5.6. Tworzenie bibliotek BibliotekĊ tworzymy, wybierając typ nowego projektu o nazwie Class Library. Dla przykáadu stworzymy bibliotekĊ DLL z metodami do prostych operacji arytmetycz- nych, takich jak dodawanie, odejmowanie, mnoĪenie i dzielenie dwóch podanych liczb. Oto kod biblioteki: using System; public class Algebra { public double Addition(double x = 0, double y = 0) { return x + y; } public double Subtraction(double x = 0, double y = 0) { return x - y; } public double Multiplication(double x = 0, double y = 0) { return x * y; } public double Division(double x = 0, double y = 1) { return x / y; } } Gdy skompilujesz ten kod, w folderze z projektem biblioteki pojawi siĊ plik o rozsze- rzeniu *.dll, czyli gotowa biblioteka. Teraz stwórz nowy projekt aplikacji konsolowej, a nastĊpnie w oknie Solution Explorer kliknij prawym przyciskiem References i wybierz Add reference. PrzejdĨ do zakáadki Browse i wybierz plik Algebra.dll. W stworzonym projekcie wpisz poniĪszy kod: using System; using System.IO; class Program { Poleć książkęKup książkę 142 Microsoft Visual Studio 2012. Programowanie w C# private static void Main(string[] args) { Algebra alg1 = new Algebra(); //Utwórz obiekt klasy Algebra double a = 24.5; double b = 4.25; double c = alg1.Addition(a, b); //metoda Addition z klasy Algebra Console.WriteLine( {0} + {1} = {2} , a, b, c); //Wypisze: 24.5 + 4.25 = 28.75 } } Skompiluj powyĪszy projekt i uruchom. Jest to projekt z uĪyciem Twojej wáasnej bi- blioteki. To wszystko w tym rozdziale. 5.7. Procesy i wñtki Procesy Klasa Process z przestrzeni nazw System.Diagnostics daje dostĊp do lokalnych i zdal- nych procesów oraz pozwala uruchamiaü i zatrzymywaü procesy na lokalnym systemie. Przykáad pokazujący róĪne sposoby uruchamiania procesów: using System; using System.Diagnostics; namespace MyProcessSample { class MyProcess { //otwieranie aplikacji void OpenApplication(string myFavoritesPath) { //Uruchom przeglądarkĊ Internet Explorer Process.Start( IExplore.exe ); //WyĞwietl zawartoĞü folderu Ulubione Process.Start(myFavoritesPath); } //otwieranie stron i plików HTML przy uĪyciu przeglądarki Internet Explorer void OpenWithArguments() { //przekazanie adresu strony jako argumentu dla procesu Process.Start( IExplore.exe , www.helion.pl ); //otwieranie pliku HTML w przeglądarce Internet Explorer Process.Start( IExplore.exe , C:\\index.html ); } //uĪycie klasy ProcessStartInfo do uruchomienia procesu zminimalizowanego void OpenWithStartInfo() Poleć książkęKup książkę Rozdziaä 5. i Jözyk C#. Pozostaäe zagadnienia 143 { ProcessStartInfo startInfo = new ProcessStartInfo( IExplore.exe ); startInfo.WindowStyle = ProcessWindowStyle.Minimized; Process.Start(startInfo); startInfo.Arguments = www.helion.pl ; Process.Start(startInfo); } static void Main() { //Pobierz ĞcieĪkĊ do folderu Ulubione string myFavoritesPath = Environment.GetFolderPath(Environment.SpecialFolder.Favorites); MyProcess myProcess = new MyProcess(); myProcess.OpenApplication(myFavoritesPath); myProcess.OpenWithArguments(); myProcess.OpenWithStartInfo(); } } } Z klasy Process dwie metody są najwaĪniejsze do zapamiĊtania, pierwsza to metoda Start, która uruchamia proces, a druga to metoda Kill, która zabija okreĞlony proces. WiĊcej o procesach moĪesz znaleĨü na stronach MSDN. Wñtki Wątki pozwalają na wykonywanie kilku zadaĔ „jednoczeĞnie”. Dlaczego sáowo „jed- noczeĞnie” jest w cudzysáowie? Chodzi o to, Īe te zadania wykonują siĊ na przemian, a dzieje siĊ to tak szybko, Īe mamy wraĪenie, iĪ dzieje siĊ to równoczeĞnie. Najpierw wykona siĊ czĊĞü pierwszego zadania, potem nastĊpuje przeáączenie na drugie zada- nie, które teĪ siĊ wykona czĊĞciowo, nastĊpnie znów siĊ wykonuje pierwsze zadanie — i tak w kóáko. PoniĪszy przykáad tworzy klasĊ o nazwie Worker z metodą DoWork, która zostanie wy- woáana w osobnym wątku. Wątek rozpocznie wykonywanie przy wywoáaniu metody i zakoĔczy pracĊ automatycznie. Metoda DoWork wygląda tak: public void DoWork() { while (!_shouldStop) { Console.WriteLine( worker thread: working... ); } Console.WriteLine( worker thread: terminating gracefully. ); } Poleć książkęKup książkę 144 Microsoft Visual Studio 2012. Programowanie w C# Klasa Worker zawiera dodatkową metodĊ, która okreĞla, kiedy metoda DoWork powin- na siĊ zakoĔczyü. Metoda ta nazywa siĊ RequestStop i wygląda nastĊpująco: public void RequestStop() { _shouldStop = true; } Metoda RequestStop przypisuje skáadowej _shouldStop wartoĞü true. PoniewaĪ skáa- dowa ta jest sprawdzana przez metodĊ DoWork, przypisanie jej wartoĞci true spowo- duje zakoĔczenie pracy wątku z metodą DoWork. Warto zwróciü uwagĊ, Īe metody DoWork i RequestStop bĊdą uruchamiane przez osobne wątki, dlatego skáadowa _shouldStop powinna zostaü zadeklarowana ze sáowem kluczowym volatile. private volatile bool _shouldStop; Sáowo kluczowe volatile informuje kompilator, Īe dwa lub wiĊcej wątków bĊdzie miaáo dostĊp do tej skáadowej i kompilator nie powinien uĪywaü tutaj Īadnej optyma- lizacji. UĪycie sáowa kluczowego volatile przy skáadowej _shouldStop pozwala mieü do niej bezpieczny dostĊp z kilku wątków bez uĪycia jakichkolwiek technik synchroni- zacji. Jest tak tylko dlatego, Īe typ tej skáadowej to bool. Oznacza to, Īe tylko poje- dyncze operacje są uĪywane do modyfikacji tej skáadowej. Przed tworzeniem wątku funkcja Main tworzy obiekt typu Worker i instancjĊ klasy Thread. Obiekt wątku jest konfigurowany do uĪycia metody Worker.DoWork jako punkt wejĞcia poprzez przekazanie referencji tej metody do kontruktora. Worker workerObject = new Worker(); Thread workerThread = new Thread(workerObject.DoWork); W tym momencie obiekt wątku istnieje i jest skonfigurowany. Jednak wątek jeszcze nie dziaáa, zostanie on uruchomiony, gdy metoda Main wywoáa metodĊ Start wątku: workerThread.Start(); Po tym wątek juĪ dziaáa, ale jest to asynchroniczne wzglĊdem wątku gáównego. Oznacza to, Īe metoda Main wykonuje siĊ dalej. Aby wiĊc wątek nie zostaá zakoĔczony, musimy utworzyü pĊtlĊ, która bĊdzie czekaáa na zakoĔczenie wątku: while (!workerThread.IsAlive); NastĊpnie wątek gáówny jest usypiany na okreĞlony czas poprzez wywoáanie Sleep. Spowoduje to, Īe wątek roboczy wykona kilka iteracji pĊtli metody DoWork, zanim metoda Main wykona kolejne instrukcje. Thread.Sleep(1); Po upáywie 1 milisekundy funkcja Main za pomocą metody Worker.RequestStop daje sygnaá do wątku roboczego, Īe powinien siĊ zakoĔczyü. workerObject.Request
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Microsoft Visual Studio 2012. Programowanie w C#
Autor:
Sklep
Format
Cena
Helion.pl Helion.pl
książka
39,90 zł
Idź do sklepu »

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ą: