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)