Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00380 007003 14246638 na godz. na dobę w sumie
C#. Tworzenie aplikacji sieciowych. Gotowe projekty - książka
C#. Tworzenie aplikacji sieciowych. Gotowe projekty - książka
Autor: , Liczba stron: 312
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-2910-7 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> .net - programowanie
Porównaj ceny (książka, ebook, audiobook).

Wykorzystaj rewolucję sieciową i twórz nowatorskie aplikacje!

Całkiem duża część współczesnego życia na stałe przeniosła się do Internetu. Nikt dziś nie wyobraża już sobie świata, w którym nie można sprawdzić pogody, zrobić zakupów czy szybko znaleźć potrzebnych informacji - właśnie w sieci. A skoro tak, wciąż rośnie zapotrzebowanie na programistów mogących zaspokoić rosnące oczekiwania rzeszy klientów oraz dostarczyć im wygodnych, świetnie działających aplikacji sieciowych, skrojonych na potrzeby konkretnych użytkowników. To właśnie było źródłem niezwykłej popularności pierwszego wydania niniejszej książki, w praktyczny sposób przekazującej wiedzę na temat sposobów tworzenia takich aplikacji i spełniania różnych warunków związanych ze specyfiką określonych projektów programistycznych.

'C#. Tworzenie aplikacji sieciowych. Gotowe projekty' to podręcznik przeznaczony dla osób z choćby pobieżną znajomością zasad programowania, które chcą rozwinąć i wykorzystać w praktyce swoje umiejętności. Jej autor tłumaczy, dlaczego wybrał język C#, a także wskazuje możliwości i zalety platformy .NET oraz środowiska Visual Studio. Następnie skupia się na projektach obejmujących wszystkie aspekty komunikacji internetowej, od wykorzystania różnych protokołów sieciowych, przez budowę interfejsu, wysyłanie e-maili, obsługę FTP, komunikatorów, czatów, aż po kontaktowanie się z bazami danych, tworzenie wielojęzycznych serwerów i udostępnianie usługi. Jeśli chcesz szybko i bez kłopotu podszkolić się w zakresie aplikacji sieciowych, by w krótkim czasie osiągnąć spektakularne efekty, nie znajdziesz nic lepszego!

Aplikacje sieciowe - wykorzystaj potencjał Internetu!


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

Darmowy fragment publikacji:

Autorstwo: Sławomir Orłowski (wstęp, rozdziały 1-8), Maciej Grabek (rozdział 9). Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną, fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym powoduje naruszenie praw autorskich niniejszej publikacji. Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądź towarowymi ich właścicieli. Autor oraz Wydawnictwo HELION dołożyli wszelkich starań, by zawarte w tej książce informacje były kompletne i rzetelne. Nie biorą jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane z tym ewentualne naruszenie praw patentowych lub autorskich. Autor oraz Wydawnictwo HELION nie ponoszą również żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji zawartych w książce. Redaktor prowadzący: Ewelina Burska Projekt okładki: Jan Paluch Materiały graficzne na okładce zostały wykorzystane za zgodą Shutterstock. 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?cshta2 Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję. ISBN: 978-83-246-2910-7 Copyright © Helion 2012 Printed in Poland. • Kup książkę • Poleć książkę • Oceń książkę • Księgarnia internetowa • Lubię to! » Nasza społeczność Spis treĈci Wstöp .............................................................................................. 7 Rozdziaä 1. Jözyk C# i platforma .NET ................................................................. 9 Technologia .NET. Krótki wstĊp ...................................................................................... 9 Elementy jĊzyka C# i programowanie zorientowane obiektowo .................................... 11 Przestrzenie nazw ..................................................................................................... 15 Kolekcje ................................................................................................................... 16 Zdarzenia i metody zdarzeniowe .............................................................................. 17 Delegacje .................................................................................................................. 17 Wyjątki ..................................................................................................................... 17 Interfejsy .................................................................................................................. 19 Rozdziaä 2. Visual C# 2010 Express Edition. Opis Ĉrodowiska ........................... 21 Projekt 1. Budujemy interfejs pierwszej aplikacji. Projekt Windows Forms .................. 22 Projekt 2. Poznajemy pliki projektu pierwszej aplikacji ................................................. 25 Projekt 3. Interakcja aplikacji z uĪytkownikiem. Metody zdarzeniowe .......................... 29 Rozdziaä 3. Visual Web Developer 2010 Express Edition. Opis Ĉrodowiska ......... 33 Projekt 4. Pierwsza strona ASP.NET. Tworzymy interfejs ............................................ 33 Projekt 5. Pierwsza strona ASP.NET. Poznajemy pliki projektu .................................... 37 Projekt 6. Pierwsza strona ASP.NET. Metody zdarzeniowe .......................................... 40 Rozdziaä 4. Programowanie sieciowe ................................................................ 43 Sieci komputerowe ......................................................................................................... 43 Protokoáy TCP i UDP ..................................................................................................... 46 Protokóá IP i adresy MAC .............................................................................................. 48 Programowanie klient-serwer i peer-to-peer ................................................................... 49 Popularne protokoáy sieciowe ......................................................................................... 50 Protokóá ICMP ......................................................................................................... 50 Protokóá HTTP ......................................................................................................... 51 Protokóá FTP ............................................................................................................ 51 Protokóá POP3 .......................................................................................................... 52 Rozdziaä 5. Aplikacje TCP i UDP ....................................................................... 53 Projekt 7. Poáączenie TCP. Klient .................................................................................. 53 Projekt 8. Poáączenie TCP. Serwer ................................................................................. 56 Projekt 9. Odczytanie adresu IP przyáączonego hosta .................................................... 60 Projekt 10. Poáączenie UDP. Klient ................................................................................ 61 4 C#. Tworzenie aplikacji sieciowych. Gotowe projekty Projekt 11. Poáączenie UDP. Serwer .............................................................................. 62 Projekt 12. Asynchroniczne poáączenie TCP .................................................................. 64 Projekt 13. Prosty skaner otwartych portów hosta zdalnego ........................................... 67 Projekt 14. Skaner otwartych portów lokalnego hosta .................................................... 68 Projekt 15. Sprawdzenie adresu IP naszego komputera .................................................. 69 Projekt 16. Komplet informacji na temat poáączeĔ sieciowych ...................................... 72 Projekt 17. Ping .............................................................................................................. 74 Projekt 18. Ping. Przeciwdziaáanie zablokowaniu interfejsu .......................................... 77 Projekt 19. NetDetect. Sprawdzanie dostĊpnych komputerów w sieci ........................... 79 Projekt 20. Traceroute. ĝledzenie drogi pakietu ICMP .................................................. 81 Projekt 21. Protokóá HTTP. Sprawdzanie dostĊpnych uaktualnieĔ ................................ 85 Projekt 22. Pobieranie pliku z uĪyciem protokoáu HTTP ............................................... 86 Projekt 23. Pobranie Ĩródáa strony z serwera WWW ...................................................... 88 Projekt 24. Przeglądarka WWW ..................................................................................... 89 Projekt 25. Edytor HTML. Budowanie interfejsu ........................................................... 91 Projekt 26. Edytor HTML. Obsáuga plików tekstowych ................................................ 92 Projekt 27. Edytor HTML. Wspóápraca ze schowkiem .................................................. 95 Projekt 28. Edytor HTML. Wprowadzanie tagów .......................................................... 95 Projekt 29. Edytor HTML. Podgląd bieĪącej strony ....................................................... 98 Projekt 30. Wysyáanie wiadomoĞci e-mail bez uwierzytelniania .................................... 99 Projekt 31. Wysyáanie sformatowanej wiadomoĞci e-mail z zaáącznikami .................. 102 Projekt 32. Wysyáanie poczty za pomocą serwera wymagającego uwierzytelnienia .... 105 Projekt 33. Masowe wysyáanie wiadomoĞci e-mail ...................................................... 106 Projekt 34. Klient FTP. Interfejs aplikacji .................................................................... 110 Projekt 35. Klient FTP. Definiowanie pól i wáasnoĞci klasy FTPClient ....................... 112 Projekt 36. Klient FTP. Listowanie katalogów serwera FTP ........................................ 116 Projekt 37. Klient FTP. Zmiana katalogu ..................................................................... 119 Projekt 38. Klient FTP. Metoda pobierająca plik asynchronicznie ............................... 122 Projekt 39. Klient FTP. Wywoáanie metody pobierającej plik asynchronicznie ........... 125 Projekt 40. Klient FTP. Metoda wysyáająca plik asynchronicznie ............................... 127 Projekt 41. Klient FTP. Wywoáanie metody wysyáającej plik asynchronicznie ........... 129 Projekt 42. Klient FTP. Kasowanie pliku ..................................................................... 131 Projekt 43. MenedĪer pobierania plików w tle. Budowa interfejsu .............................. 133 Projekt 44. MenedĪer pobierania plików w tle. Pobieranie pliku ................................. 135 Projekt 45. MenedĪer pobierania plików w tle. Przerwanie pobierania pliku ............... 137 Projekt 46. Serwer UĞmiechu. Budowa interfejsu ........................................................ 138 Projekt 47. Serwer UĞmiechu. Lista kontaktów ............................................................ 140 Projekt 48. Serwer UĞmiechu. Wysyáanie danych do wielu odbiorców ....................... 143 Projekt 49. Klient UĞmiechu. Umieszczenie ikony w zasobniku systemowym ............ 144 Projekt 50. Klient UĞmiechu. Oczekiwanie na poáączenie w osobnym wątku ............. 147 Projekt 51. Klient UĞmiechu. Bezpieczne odwoáywanie siĊ do wáasnoĞci kontrolek formy z poziomu innego wątku ............................................ 149 Projekt 52. Komunikator. Serwer. Budowa interfejsu .................................................. 150 Projekt 53. Komunikator. Serwer. Bezpieczne odwoáywanie siĊ do wáasnoĞci kontrolek formy z poziomu innego wątku ............................................ 153 Projekt 54. Komunikator. Serwer. Obsáuga rozmowy .................................................. 154 Projekt 55. Komunikator. Klient ................................................................................... 159 Projekt 56. Zdalny screenshot. Klient. Zrzut ekranu .................................................... 162 Projekt 57. Zdalny screenshot. Klient ........................................................................... 162 Projekt 58. Klient. Wysyáanie informacji o dostĊpnoĞci klienta ................................... 165 Projekt 59. Serwer screenshot. Budowa interfejsu ........................................................ 166 Projekt 60. Serwer screenshot. Bezpieczne odwoáywanie siĊ do wáasnoĞci kontrolek formy z poziomu innego wątku ............................................ 167 Projekt 61. Serwer screenshot. Lista aktywnych klientów ............................................ 168 Spis treĈci 5 Projekt 62. Serwer screenshot. Pobranie zrzutu ekranu ................................................ 169 Projekt 63. Serwer Czat. Budowanie interfejsu ............................................................ 171 Projekt 64. Serwer Czat. Bezpieczne odwoáywanie siĊ do wáasnoĞci kontrolek formy z poziomu innego wątku ............................................ 173 Projekt 65. Serwer Czat. Klasa formy oraz pĊtla gáówna programu ............................. 174 Projekt 66. Serwer Czat. Obsáuga wątków związanych z klientami ............................. 179 Projekt 67. Serwer Czat. Rozáączenie klienta ............................................................... 180 Projekt 68. Czat. Klient ................................................................................................ 181 Rozdziaä 6. Remoting ..................................................................................... 187 Projekt 69. Serwer HTTP ............................................................................................. 188 Projekt 70. Klient HTTP ............................................................................................... 193 Projekt 71. Serwer TCP ................................................................................................ 195 Projekt 72. Klient TCP ................................................................................................. 197 Projekt 73. Serwer TCP. Plik konfiguracyjny ............................................................... 199 Projekt 74. Klient TCP. Plik konfiguracyjny ................................................................ 202 Projekt 75. Czat. Klasa serwera .................................................................................... 203 Projekt 76. Czat. Serwer ............................................................................................... 205 Projekt 77. Czat. Klient ................................................................................................ 206 Rozdziaä 7. ASP.NET i ADO.NET ...................................................................... 211 Projekt 78. Pozycjonowanie kontrolek na stronie ......................................................... 212 Projekt 79. Ping ............................................................................................................ 217 Projekt 80. Wysyáanie wiadomoĞci e-mail ................................................................... 218 Projekt 81. Pobieranie plików na serwer ...................................................................... 220 Projekt 82. Wysyáanie wiadomoĞci e-mail z zaáącznikami ........................................... 221 Projekt 83. KsiĊga goĞci. Wspóápraca z plikiem XML ................................................. 222 Projekt 84. KsiĊga goĞci. WyĞwietlanie zawartoĞci pliku XML ................................... 226 Projekt 85. KsiĊga goĞci. Sprawdzanie poprawnoĞci wpisywanych danych ................. 228 Projekt 86. KsiĊga goĞci. Liczba goĞci online .............................................................. 230 Projekt 87. WielojĊzyczny serwis internetowy. Zasoby lokalne ................................... 232 Projekt 88. WielojĊzyczny serwis internetowy. Zasoby globalne ................................. 237 Projekt 89. WielojĊzyczny serwis internetowy. Wybór jĊzyka przez uĪytkownika ...... 239 Projekt 90. Identyfikacja uĪytkowników ...................................................................... 241 Projekt 91. Rejestrowanie nowych uĪytkowników ....................................................... 245 Projekt 92. Identyfikacja uĪytkowników, czĊĞü II ........................................................ 246 Projekt 93. Baza ksiąĪek. Stworzenie bazy danych ...................................................... 247 Projekt 94. Baza ksiąĪek. Przyáączenie siĊ do bazy danych ......................................... 250 Projekt 95. Baza ksiąĪek. Prezentacja danych .............................................................. 251 Rozdziaä 8. Web Services ............................................................................... 255 Projekt 96. Pierwsza usáuga sieciowa ........................................................................... 256 Projekt 97. Korzystanie z usáugi sieciowej ................................................................... 259 Projekt 98. Usáuga Maps Account Center wyszukiwarki bing. Rejestracja usáugi ....... 261 Projekt 99. Bing Maps. Klient ...................................................................................... 262 Projekt 100. Bing Maps. Modyfikacja klienta .............................................................. 265 Rozdziaä 9. WCF — ponad transportem .......................................................... 267 WstĊp ............................................................................................................................ 267 Podstawy dziaáania ....................................................................................................... 269 WCF = E = A + B + C .................................................................................................. 269 A jak address .......................................................................................................... 270 B jak binding .......................................................................................................... 270 C jak contract ......................................................................................................... 273 Punkt koĔcowy ....................................................................................................... 273 6 C#. Tworzenie aplikacji sieciowych. Gotowe projekty Projekt 101. Definiowanie kontraktu ............................................................................ 273 Projekt 102. UdostĊpnianie usáugi ................................................................................ 280 Self hosting ............................................................................................................. 281 IIS ........................................................................................................................... 285 Serwis Windows ..................................................................................................... 287 Projekt 103. Tworzenie klienta ..................................................................................... 290 ChannelFactory ...................................................................................................... 290 Referencja .............................................................................................................. 292 Skorowidz .................................................................................... 299 Rozdziaä 6. Remoting Technologia Remoting pozwala na komunikacjĊ pomiĊdzy aplikacjami Ğrodowiska .NET niezaleĪnie od tego, czy znajdują siĊ one na tym samym komputerze, czy w sieci. Technologia ta jest skáadową platformy .NET. Jej odpowiednikiem w jĊzyku Java jest technologia RMI (ang. Remote Method Invocation). Innym przykáadem moĪe byü rozwiązanie CORBA (ang. Common Object Request Broker Architecture), które zapewnia komunikacjĊ miĊdzy obiektami znajdującymi siĊ w róĪnych systemach komputerowych. Przodkiem Remotingu byáa technologia DCOM (ang. Distributed Component Object Model), która obecnie nie jest juĪ rozwijana. Dobra definicja .NET Remoting znajduje siĊ na stronach MSDN: „Microsoft® .NET Remoting zapewnia bogatą i rozszerzalną infrastrukturĊ komunikacyjną dla obiektów znajdujących siĊ w róĪnych domenach aplikacji AppDomains, w róĪnych procesach i na róĪnych komputerach. .NET Remoting oferuje silny, a jednoczeĞnie prosty model programistyczny i wsparcie w czasie wykonania, co sprawia, Īe infrastruktura komunikacyjna jest niewidoczna”. MyĞlĊ, Īe bardzo dobrze oddaje ona ideĊ tej skáadowej platformy .NET. Zwykle budowa rozproszonej aplikacji, opartej na technologii Remoting, skáada siĊ z trzech faz:  Stworzenie obiektu odpowiedzialnego za funkcjonalnoĞü rozproszonej aplikacji.  Utworzenie serwera, który bĊdzie odpowiadaá za rejestracjĊ, udostĊpnienie oraz zarządzanie zdalnym obiektem.  Napisanie aplikacji klienckich korzystających z udostĊpnionej przez serwer usáugi. Wszystkie projekty zebrane w tym rozdziale bĊdą budowane w trzech opisanych wyĪej krokach. Ogromną zaletą technologii Remoting jest to, Īe nie musimy dbaü o poáączenia i wymianĊ danych, tak jak miaáo to miejsce w projektach z rozdziaáu 5. Tutaj dzielony obiekt jest automatycznie udostĊpniany przez serwer. Do dyspozycji mamy trzy rodzaje poáączeĔ: TCP, IPC i HTTP. Pierwsze dwa poáączenia przesyáają dane w formacie bi- narnym. Poáączenie HTTP przesyáa informacje w formacie tekstowym. UdostĊpniany obiekt moĪe byü przekazywany przez referencjĊ bądĨ wartoĞü. W przypadku referencji obiekt zdalny istnieje wyáącznie na serwerze. Podczas komunikowania siĊ z klientem otrzymuje on jedynie referencje do obiektu. Aby klasa zdalna przekazywaáa dane przez 188 C#. Tworzenie aplikacji sieciowych. Gotowe projekty referencjĊ, musi dziedziczyü po klasie MarshalByRefObject. Klasa ta zapewnia nie- zbĊdne mechanizmy udostĊpniania. JeĪeli zdecydujemy siĊ na przekazywanie przez wartoĞü, wówczas klient bĊdzie miaá peáną wiedzĊ na temat obiektu zdalnego oraz bĊdzie posiadaá kopiĊ przeznaczoną tylko dla niego. W definicji klasy obiektu zdal- nego musimy wstawiü wtedy atrybut [Serializable]. W naszych projektach bĊ- dziemy uĪywaü przekazywania przez referencjĊ. Z racji tego, Īe technologia Remo- ting jest czĊĞcią skáadową platformy .NET, moĪe byü uĪywana jedynie przez aplikacje stworzone dla tej platformy. JeĪeli chcielibyĞmy uĪywaü pewnych usáug z poziomu róĪ- nych systemów komputerowych, wówczas lepszym rozwiązaniem wydają siĊ byü usáugi sieciowe (ang. web services) opisane w rozdziale 8. Technologia .NET Remo- ting jest obecnie zastąpiona przez Windows Communication Foundation (rozdziaá 9.). Stanowi wiĊc technologiĊ, która powoli schodzi ze sceny. Nie zaleca siĊ uĪywania jej w nowych projektach. Projekty, które juĪ są w uĪyciu, powinny migrowaü w stronĊ WCF. JeĞli to niemoĪliwe, powinny przynajmniej integrowaü siĊ z WCF. W .NET Remoting istnieją trzy podstawowe typy obiektów zdalnych, które poĞredni- czą w transakcjach pomiĊdzy klientem a serwerem:  SingleCall. Obiekt, który obsáuguje jedno Īądanie. Nie przechowuje on informacji pomiĊdzy wywoáaniami. Nie zapamiĊtuje wiĊc stanu.  Singleton. Zgodnie z wzorcem projektowym o nazwie Singleton jest to obiekt wspólny dla wielu klientów. Jedna instancja przechowująca stan dla wszystkich wywoáaĔ. UmoĪliwia jawne wspóádzielenie danych.  CAO (Client Activated Object). Obiekt aktywowany na Īądanie klienta, dziaáający po stronie serwera. Do komunikacji wykorzystuje klasĊ poĞredniczącą. ZapamiĊtuje stan dla danego klienta, nie dla wszystkich klientów. Rozdziaá ten stanowi jedynie bardzo krótki wstĊp, który ma za zadanie zaznajomiü Czy- telnika z podstawami technologii Remoting. Brak tu takich zagadnieĔ, jak szyfrowanie danych, ukrywanie implementacji obiektu zdalnego przed klientami oraz zarządzanie czasem Īycia. MyĞlĊ jednak, Īe w opisie podstaw programowania sieciowego dla plat- formy .NET nie mogáo zabraknąü choüby podstawowego opisu technologii Remoting. Istnieje jeszcze wiele projektów, które z niej korzystają. Warto ją wiĊc poznaü w celu zakonserwowania dotychczasowych rozwiązaĔ i ich przeniesienia do WCF. JeĞli stoisz przed wyborem: .NET Remoting czy WCF, to naleĪy wybraü WCF. Projekt 69. Serwer HTTP Napiszemy teraz serwer oparty na poáączeniu HTTP. Jako pierwszą utworzymy klasĊ odpowiedzialną za usáugĊ zdalną. Nasza usáuga bĊdzie polegaáa na wyĞwietlaniu od- powiedniego komunikatu w przypadku poáączenia siĊ z klientem. BĊdzie to bardzo prosty projekt, odpowiednik projektu „witaj Ğwiecie”. Jego zadaniem jest pokazanie, w jaki sposób naleĪy budowaü projekty .NET Remoting. Nie bĊdziemy skupiaü siĊ w tym miejscu na jakimĞ skomplikowanym projekcie. Rozdziaä 6. i Remoting 189 1. Z menu File wybieramy opcjĊ New project…. 2. Zaznaczamy ikonĊ Class Library. W polu Name wpisujemy RemotingExample. Przypominam, Īe jest to nazwa przestrzeni nazw, w której znajdą siĊ nasze przykáadowe klasy. Do nazywania zmiennych bĊdziemy uĪywaü jĊzyka angielskiego. MyĞlĊ, Īe jest to dobry nawyk. Warto juĪ teraz przyzwyczajaü siĊ do anglojĊzycznych nazw zmiennych w programie. 3. Piszemy prostą klasĊ RemotingObject z jedną publiczną metodą, która zwraca pewien tekst. Konstruktor bezparametrowy zostanie pusty. Kod klasy jest pokazany na listingu 6.1. NaleĪy zwróciü uwagĊ na fakt, Īe nasza klasa ma dziedziczyü z klasy MarshalByRefObject. Dla aplikacji, które obsáugują Remoting, oznacza to udostĊpnienie obiektu tej klasy nie tylko w ramach jednej domeny aplikacji. Listing 6.1. Klasa odpowiedzialna za usáugĊ using System; using System.Text; namespace RemotingExample { public class RemotingObject: MarshalByRefObject { public RemotingObject() { } public string Test() { return .NET Remoting test ; } } } 4. Zapisujemy teraz nasz projekt pod nazwą RemotingObject oraz kompilujemy go (klawisz F6). W wyniku kompilacji otrzymujemy bibliotekĊ RemotingObject.dll. Naszą klasĊ nazwaliĞmy RemotingObject. Dziedziczy ona po klasie Marshal ´ByRefObject, co zapewnia przesyáanie do przyáączonych klientów jedynie referencji obiektu RemotingObject. StworzyliĞmy pusty konstruktor oraz jedną publiczną, bezparametrową metodĊ Test, zwracającą tekst .NET Remoting test. Jak widaü, przykáad ten nie jest skomplikowany. PrzejdĨmy teraz do napisania aplikacji serwera, która bĊdzie korzystaáa ze stworzonej przed chwilą biblioteki. 5. Do naszego rozwiązania doáączymy nowy projekt. Przypominam, Īe najszybciej moĪna to zrobiü, klikając prawym klawiszem w oknie Solution Explorer nazwĊ naszego rozwiązania (ang. solution). Z menu podrĊcznego wybieramy opcjĊ Add oraz New Project…. Rozpoczynamy nowy projekt Windows Forms Application. W polu Name wpisujemy RemotingGUI. DziĊki temu poprzednia biblioteka i nasz projekt bĊdą znajdowaáy siĊ w tej samej przestrzeni nazw. OczywiĞcie nie jest to konieczne, ale wygodne. 190 C#. Tworzenie aplikacji sieciowych. Gotowe projekty 6. Ustawiamy projekt RemotingGUI jako startowy. Aby to zrobiü, klikamy prawym klawiszem nazwĊ projektu, a nastĊpnie wybieramy opcjĊ Set as StarUp Project. Po tych czynnoĞciach okno Visual Studio powinno przypominaü to z rysunku 6.1. Rysunek 6.1. Dwa projekty w ramach jednego rozwiązania 7. Do projektu dodajemy referencjĊ do biblioteki System.Runtime.Remoting.dll, która nie jest standardowo zamieszczana w projektach typu Windows Forms Application. W tym celu z menu gáównego wybieramy opcjĊ Project, a nastĊpnie klikamy pozycjĊ Add Reference…. Otworzy siĊ okno z wyborem referencji (rysunek 6.2). NaleĪy pamiĊtaü, aby wybraü zakáadkĊ .NET. Rysunek 6.2. Okno Add Reference Rozdziaä 6. i Remoting 191 8. Na zakáadce .NET wyszukujemy i zaznaczamy komponent o nazwie System.Runtime.Remoting. Klikamy przycisk OK. W ten sposób referencja zostaáa dodana. Aby to sprawdziü, moĪemy w oknie Solution Explorer rozwinąü gaáąĨ References. Powinien siĊ tam znajdowaü wpis System.Runtime.Remoting. 9. Przeáączmy siĊ do widoku kodu projektu RemotingGUI (klawisz F7). W sekcji odpowiedzialnej za uĪyte w projekcie przestrzenie nazw dodajemy nowe wpisy: using System.Runtime.Remoting; using System.Runtime.Remoting.Channels; using System.Runtime.Remoting.Channels.Http; 10. W oknie widoku projektu na formĊ wrzucamy kontrolkĊ button1. Jej wáasnoĞü Text ustawiamy na Start. 11. Do projektu dodajemy kontrolkĊ textBox1. WáasnoĞü ReadOnly zmieniamy na true. 12. Musimy dodaü jeszcze referencje do stworzonej wczeĞniej biblioteki RemotingObject.dll. Robimy to podobnie jak w przypadku dodawania referencji System.Runtime.Remoting. Po otwarciu okna Add Reference zmieniamy zakáadkĊ na Projects i wybieramy projekt RemotingObject. Klikamy przycisk OK. Biblioteka zostaáa dodana do referencji naszego projektu. 13. Serwer powinien wystartowaü w momencie klikniĊcia przycisku Start. Wobec tego piszemy metodĊ zdarzeniową Click (listing 6.2). Listing 6.2. Metoda uruchamiająca serwer using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; using System.Runtime.Remoting; using System.Runtime.Remoting.Channels; using System.Runtime.Remoting.Channels.Http; namespace RemotingExample { public partial class Form1 : Form { public Form1() { InitializeComponent(); } private void button1_Click(object sender, EventArgs e) { try { HttpChannel channel = new HttpChannel(25000); ChannelServices.RegisterChannel(channel, false); 192 C#. Tworzenie aplikacji sieciowych. Gotowe projekty RemotingConfiguration.RegisterWellKnownServiceType(typeof(RemotingObject), Remoting , WellKnownObjectMode.SingleCall); textBox1.Text = Serwer oczekuje .. ; } catch (Exception ex) { MessageBox.Show(ex.Message, Bđæd ); } } } } Dla naszej aplikacji rezerwujemy port 25000, na którym bĊdzie ona nasáuchiwaü wywoáaĔ opartych na protokole HTTP. UĪywając metody RegisterChannel klasy ChannelServices, rejestrujemy nasz kanaá HTTP. Pierwszym argumentem jest kanaá. Drugi argument odpowiada za zabezpieczenie (true — zabezpieczony, false — niezabezpieczony). JeĪeli spróbowalibyĞmy jeszcze raz zarejestrowaü ten kanaá, zostaáby zgáoszony wyjątek informujący nas, Īe kanaá juĪ jest zarejestrowany. Dalej korzystamy z metody RegisterWellKnownServiceType klasy RemotingConfiguration. Metoda ta rejestruje nasz serwis w usáudze Remoting. Jej pierwszym argumentem jest typ klasy, która bĊdzie dostĊpna jako usáuga. Drugi argument to nazwa Uri, czyli unikalna nazwa áącząca usáugĊ z obiektem. Celowo uĪyliĞmy nazwy Remoting, aby pokazaü, iĪ klient wcale nie musi znaü nazwy klasy odpowiedzialnej za usáugĊ. Wystarczy, Īe zna adres i port serwera oraz nazwĊ samej usáugi. W ten sposób moĪemy równieĪ udostĊpniaü wiele usáug na jednym porcie. Usáugi te muszą mieü inne Uri. Ostatni parametr mówi, w jaki sposób obiekt ma byü tworzony po stronie serwera. Mamy do dyspozycji dwie opcje: SingleCall i Singleton. JeĪeli wybieramy pierwszą, wówczas kaĪda przychodząca wiadomoĞü jest obsáugiwana przez nową instancjĊ obiektu. W drugim przypadku wszystkie przychodzące wiadomoĞci są obsáugiwane przez tĊ samą instancjĊ obiektu. CaáoĞü jest zamkniĊta w bloku ochronnym try/catch, poniewaĪ metody tu uĪyte mogą generowaü wyjątki. Serwer bĊdzie dziaáaá, dopóki nie wyáączymy aplikacji. 14. Uruchamiamy teraz nasz projekt. Wáączamy serwer. Musimy pamiĊtaü o tym, aby ustawiü odpowiednio firewall. 15. Sprawdzimy teraz, czy nasz serwer rzeczywiĞcie dziaáa. Otwieramy przeglądarkĊ internetową i jeĪeli nie jesteĞmy podáączeni do sieci, wpisujemy w niej adres http://localhost:25000/Remoting?wsdl. W przypadku gdy nasz komputer posiada adres IP, zamiast localhost wpisujemy ten adres. Powinna ukazaü siĊ strona XML z informacjami o naszym obiekcie RemotingObject. JĊzyk WSDL (ang. Web Services Description Language) opisuje usáugi sieciowe. OdpowiedĨ w przypadku lokalnego hosta zawiera listing 6.3. Listing 6.3. OdpowiedĨ serwera definitions name= RemotingObject targetNamespace= http://schemas.microsoft.com/clr/nsassem/RemotingExample/RemotingO bject 2C 20Version 3D1.0.0.0 2C 20Culture 3Dneutral 2C 20PublicKeyToken 3Dnull Rozdziaä 6. i Remoting 193 message name= RemotingObject.TestInput /message message name= RemotingObject.TestOutput part name= return type= xsd:string / /message portType name= RemotingObjectPortType operation name= Test input name= TestRequest message= tns:RemotingObject.TestInput / output name= TestResponse message= tns:RemotingObject.TestOutput / /operation /portType binding name= RemotingObjectBinding type= tns:RemotingObjectPortType soap:binding style= rpc transport= http://schemas.xmlsoap.org/soap/http / suds:class type= ns0:RemotingObject rootType= MarshalByRefObject /suds:class operation name= Test soap:operation soapAction= http://schemas.microsoft.com/clr/nsassem/RemotingExample.RemotingObject /RemotingObject#Test / suds:method attributes= public / input name= TestRequest soap:body use= encoded encodingStyle= http://schemas.xmlsoap.org/soap/encoding/ namespace= http://schemas.microsoft.com/clr/nsassem/RemotingExample.RemotingObject/ RemotingObject / /input output name= TestResponse soap:body use= encoded encodingStyle= http://schemas.xmlsoap.org/soap/encoding/ namespace= http://schemas.microsoft.com/clr/nsassem/RemotingExample.RemotingObject/ RemotingObject / /output /operation /binding service name= RemotingObjectService port name= RemotingObjectPort binding= tns:RemotingObjectBinding soap:address location= http://localhost:25000/Remoting / /port /service /definitions W odpowiedzi opisane są wszystkie szczegóáy naszego serwisu .NET Remoting. Na listingu 6.3 wyróĪniono kilka najwaĪniejszych. Projekt 70. Klient HTTP Nasz klient bĊdzie miaá za zadanie poáączyü siĊ z usáugą (z serwerem), uruchomiü metodĊ i wyĞwietliü jej wyniki. 1. Tworzymy nowy projekt Windows Forms. W polu Name wpisujemy RemotingClient. 2. Podobnie jak w poprzednim projekcie tutaj takĪe dodajemy referencje do bibliotek RemotingObject.dll oraz System.Runtime.Remoting.dll. W tym celu moĪna uĪyü zakáadki Recent z okna Add Reference, gdzie powinny siĊ juĪ znajdowaü wczeĞniej dodane referencje. 3. Zapisujemy projekt pod nazwą RemotingClient. Zmieniamy przestrzeĔ nazw projektu na RemotingExample. MoĪna to zrobiü np. za pomocą narzĊdzia Refactor. 4. W podglądzie kodu dodajemy odpowiednie przestrzenie nazw: 194 C#. Tworzenie aplikacji sieciowych. Gotowe projekty using System.Runtime.Remoting; using System.Runtime.Remoting.Channels; using System.Runtime.Remoting.Channels.Http; 5. Na formĊ wrzucamy pole edycyjne textBox1. Tutaj bĊdziemy wprowadzaü adres serwera. 6. Do projektu dodajemy kontrolkĊ numericUpDown1ʊ bĊdzie ona przechowywaáa numer portu, na którym nasáuchuje serwer. 7. FormĊ uzupeániamy o kontrolkĊ listBox1. BĊdziemy tu wypisywaü wszystkie komunikaty. 8. Na formĊ wrzucamy przycisk button1. WáasnoĞü Text zmieniamy na Poáącz. 9. Dla domyĞlnej metody zdarzeniowej kontrolki button1 piszemy kod z listingu 6.4. Listing 6.4. Uzyskanie poáączenia z serwerem private void button1_Click(object sender, EventArgs e) { string address = textBox1.Text; if (!address.StartsWith( http:// )) address = http:// + textBox1.Text; int port = (int)numericUpDown1.Value; HttpClientChannel channel = null; try { channel = new HttpClientChannel(); ChannelServices.RegisterChannel(channel, false); RemotingObject remotingObject = (RemotingObject)Activator.GetObject ´(typeof(RemotingObject), address + : + port.ToString() + ´ /Remoting ); listBox1.Items.Add( Pođæczenie: + address + : + port.ToString() ´+ /Remoting ); listBox1.Items.Add(remotingObject.Test()); ChannelServices.UnregisterChannel(channel); listBox1.Items.Add( Pođæczenie zakoēczone ); } catch (Exception ex) { MessageBox.Show(ex.Message, Bđæd ); listBox1.Items.Add( Pođæczenie przerwane ); ChannelServices.UnregisterChannel(channel); } } W tej metodzie tworzymy kanaá typu HttpClientChannel. NastĊpnie za pomocą metody GetObject klasy Activator tworzony jest obiekt typu RemotingObject. Pierwszym ar- gumentem tej metody jest typ obiektu. Drugi argument to opisany wczeĞniej obiekt Uri. JeĪeli aktywacja siĊ powiedzie, wówczas mamy dostĊp do metody Test(). Jej wywoáanie zostaáo wyróĪnione na listingu 6.4. NaleĪy pamiĊtaü, Īe w tym przypadku mamy do czynienia z obiektem zdalnym, kontrolowanym przez serwer. Po wywoáaniu metody Test() zamykamy kanaá metodą UnregisterChannel. CaáoĞü musimy umieĞciü w blo- ku ochronnym, poniewaĪ w trakcie dziaáania aplikacji mogą byü zgáaszane wyjątki. Rozdziaä 6. i Remoting 195 Pora teraz przetestowaü nasze rozwiązanie. W jego skáad wchodzą dwa projekty, które powinny byü uruchomione jednoczeĞnie. W Visual Studio poradzimy sobie z tym bez problemu. W oknie Solution Explorer klikamy prawym klawiszem nazwĊ rozwiązania. Otworzy siĊ podrĊczne menu, z którego wybieramy opcjĊ Properties. MoĪemy równieĪ uĪyü skrótu klawiszowego Alt+Enter. Wybieramy teraz opcjĊ Startup Project. W kolej- nym kroku zaznaczamy opcjĊ Multiple startup projects. MoĪemy wskazaü, które projekty mają wystartowaü w momencie kompilacji i uruchomienia rozwiązania. Wybieramy projekty RemotingClient oraz RemotingGUI (rysunek 6.3). Po naciĞniĊciu klawisza F5 uruchomią siĊ wskazane projekty. W projekcie serwera klikamy przycisk Start. W polu adresu na formie klienta wpisujemy localhost oraz port 25000. Teraz klikamy Poáącz. Klient powinien nawiązaü poáączenie i wyĞwietliü wynik dziaáania metody Test(). Rysunek 6.3. Okno wáaĞciwoĞci rozwiązania Projekt 71. Serwer TCP Protokóá TCP równieĪ moĪe sáuĪyü do udostĊpniania usáug za pomocą technologii .NET Remoting. W ramach obiektu zdalnego napiszemy prostą metodĊ dodającą dwie liczby i zwracającą wynik. Tak jak w poprzednich projektach z tego rozdziaáu tutaj równieĪ nie zaleĪy nam na rozbudowanych przykáadach. W tym i kolejnym projekcie skupimy siĊ na zasadzie tworzenia rozwiązania opartego na protokole TCP. 1. Rozpoczynamy nowy projekt Class Library. W polu Name wpisujemy RemotingTCP. 2. Naszą klasĊ nazwiemy, trochĊ na wyrost, RemotingMath. Dodamy bezparametrowy konstruktor oraz publiczną metodĊ Add, która zwróci wynik dodawania dwóch liczb przekazanych jako argumenty. MetodĊ przeciąĪymy dla typów double i int. OczywiĞcie to nie koniec. Powinno siĊ jeszcze bardziej przeciąĪyü metodĊ Add. Nie bĊdziemy siĊ tym zajmowaü teraz, poniewaĪ co innego jest celem tego üwiczenia. Caáy kod tej klasy zawiera listing 6.5. Klasa ta nie róĪni siĊ znacząco od klasy napisanej w projekcie 69. Tutaj takĪe dziedziczymy po klasie MarshalByRefObject. 196 C#. Tworzenie aplikacji sieciowych. Gotowe projekty Listing 6.5. Klasa Matematyka using System; using System.Collections.Generic; using System.Text; namespace RemotingTCP { public class RemotingMath: MarshalByRefObject { public RemotingMath() { } public double Add(double a, double b) { return a + b; } public int Add(int a, int b) { return a + b; } } } 3. Zapisujemy projekt pod nazwą RemotingMath, a rozwiązanie pod nazwą RemotingTCP, nastĊpnie caáoĞü kompilujemy. W ten sposób otrzymamy bibliotekĊ RemotingMath.dll. 4. Tworzymy nowy projekt Windows Forms o nazwie RemotingServer i umieszczamy go w tym samym rozwiązaniu. Sposób zostaá opisany w poprzednich projektach z tego rozdziaáu (projekty 69. i 70.). 5. Do projektu dodajemy referencje do System.Runtime.Remoting.dll oraz do projektu RemotingMath (patrz projekt 70.). 6. Przenosimy siĊ do widoku kodu (klawisz F7). W bloku definiującym przestrzenie nazw dodajemy wpis: using System.Runtime.Remoting; using System.Runtime.Remoting.Channels; using System.Runtime.Remoting.Channels.Tcp; 7. Na formĊ wrzucamy kontrolkĊ textBox1. Jej wáasnoĞü ReadOnly zmieniamy na true. 8. Do projektu dodajemy przycisk button1. Tworzymy dla niego metodĊ zdarzeniową Click i wpisujemy kod z listingu 6.6. Komentarz z projektu 69. odnosi siĊ równieĪ do tego listingu. Jedyną róĪnicą jest uĪycie obiektu klasy TcpServerChannel. Listing 6.6. Inicjacja serwera TCP private void button1_Click(object sender, EventArgs e) { try { TcpServerChannel channel = new TcpServerChannel(20000); Rozdziaä 6. i Remoting 197 ChannelServices.RegisterChannel(channel, false); RemotingConfiguration.RegisterWellKnownServiceType(typeof(RemotingMath), Math , WellKnownObjectMode.SingleCall); textBox1.Text = Serwer oczekuje na pođæczenia ... ; } catch (Exception ex) { MessageBox.Show(ex.Message, Bđæd ); } } Projekt 72. Klient TCP Idea klienta .NET Remoting zostaáa juĪ opisana w projekcie 70. Ten projekt bĊdzie nieco bardziej rozbudowany. RozwaĪymy róĪne przypadki uĪycia tej maáej aplikacji. Za- bieramy siĊ wiĊc od razu do kodowania: 1. Tworzymy nowy projekt Windows Forms. W polu Name wpisujemy RemotingClient. Jak poprzednio projekt ten powinien byü dodany do tego samego rozwiązania. Uáatwi nam to zarządzanie projektami i testowanie ich. 2. Dodajemy referencjĊ do System.Runtime.Remoting.dll oraz RemotingMath (patrz projekt 69.). 3. Projekt uzupeániamy o nastĊpujące definicje przestrzeni nazw: using System.Runtime.Remoting; using System.Runtime.Remoting.Channels; using System.Runtime.Remoting.Channels.Tcp; 4. Na formĊ wrzucamy kontrolki textBox1, textBox2 i textBox3 (rysunek 6.4). Rysunek 6.4. Widok formy klienta .Net Remoting TCP 5. WáasnoĞü ReadOnly kontrolki textBox3 ustawiamy na true. 6. Do projektu dodajemy przycisk button1. WáasnoĞü Text zmieniamy na =. 7. Dodajemy dwa prywatne pola klasy formy (listing 6.7). Listing 6.7. Klient TCP. Pola prywatne using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Text; 198 C#. Tworzenie aplikacji sieciowych. Gotowe projekty using System.Windows.Forms; using System.Runtime.Remoting; using System.Runtime.Remoting.Channels; using System.Runtime.Remoting.Channels.Tcp; namespace RemotingTCP { public partial class Form1 : Form { private TcpClientChannel channel; private RemotingMath remotingMath; public Form1() { InitializeComponent(); } } 8. Tworzymy metodĊ zdarzeniową Load formy. Zainicjalizujemy w niej obiekty, których dalej uĪyjemy w poáączeniu .NET Remoting (listing 6.8). NaleĪy zwróciü uwagĊ, Īe inicjalizacja obiektów nie oznacza nawiązania poáączenia. Innymi sáowy, nawet jeĞli serwer nie jest wáączony, metoda Load nie spowoduje báĊdów. Listing 6.8. Klient TCP. Metoda inicjalizująca poáączenie .NET Remoting private void Form1_Load(object sender, EventArgs e) { channel = new TcpClientChannel(); ChannelServices.RegisterChannel(channel, false); WellKnownClientTypeEntry config = new WellKnownClientTypeEntry(typeof ´(RemotingMath), tcp://localhost:20000/Math ); RemotingConfiguration.RegisterWellKnownClientType(config); remotingMath = new RemotingMath(); } 9. Tworzymy nową metodĊ zdarzeniową Click kontrolki button1 i wpisujemy do niej kod z listingu 6.9. Metoda ta uĪyje zdalnego obiektu i wykona na nim metodĊ Add. Listing 6.9. Klient TCP private void button1_Click(object sender, EventArgs e) { if (textBox1.Text == null textBox2.Text == null textBox3.Text == null) return; double a = 0.0; double b = 0.0; if (!Double.TryParse(textBox1.Text, out a)) { textBox3.Text = Bđæd! ; return; Rozdziaä 6. i Remoting 199 } if (!Double.TryParse(textBox2.Text, out b)) { textBox3.Text = Bđæd! ; return; } try { textBox3.Text = (remotingMath.Add(a, b)).ToString(); } catch (Exception ex) { MessageBox.Show(ex.Message, Bđæd ); ChannelServices.UnregisterChannel(channel); } } Jak to czĊsto bywa, kod osáaniający ewentualne záe uĪycie metody jest bardziej rozbudo- wany niĪ samo uĪycie metody. Ta aplikacja jest odpowiednikiem programu z listingu 6.4. Istnieją jednak pewne róĪnice. Aplikacja klienta uĪywa metody RegisterWellKnown ´ClientType klasy RemotingConfiguration do poáączenia siĊ z serwerem. Dalej two- rzona jest instancja klasy RemotingMath. Pomimo Īe dzieje siĊ to w klasie klienta, in- stancja ta nie jest w peáni lokalnym obiektem. Zarządzana jest przez aplikacjĊ serwe- ra. BĊdzie to dobrze widoczne w projektach 75 – 77. W ten sposób pokazaliĞmy dwa rozwiązania, które moĪemy zastosowaü do aktywacji dostĊpu do zdalnego obiektu po stronie klienta. Projekt 73. Serwer TCP. Plik konfiguracyjny W poprzednich projektach aplikacje serwerowe byáy konfigurowane w kodzie pro- gramu. KaĪdorazowa zmiana nazwy udziaáu, portu lub innego parametru wiąĪe siĊ z ponownym skompilowaniem projektu. Zamiast konfigurowaü serwer w kodzie, mo- Īemy skonfigurowaü go za pomocą pliku konfigurującego. Jest on standardu XML. Takie rozwiązanie jest o wiele bardziej elastyczne. 1. Tworzymy nowy projekt Windows Forms. 2. Do projektu dodajemy referencje System.Runtime.Remoting.dll i RemotingMath.dll. 3. Dodamy teraz do projektu plik XML. Z menu Project wybieramy opcjĊ Add New Item…. 4. Zaznaczamy ikonĊ XML File i w polu Name wpisujemy config.xml. Klikamy Add. 5. W otwartym pliku XML wpisujemy kod z listingu 6.10. 200 C#. Tworzenie aplikacji sieciowych. Gotowe projekty Listing 6.10. Plik konfiguracyjny serwera configuration system.runtime.remoting application service wellknown mode= SingleCall objectUri= Math type= RemotingTCP.RemotingMath, RemotingMath / activated type= RemotingTCP.RemotingMath, RemotingMath / /service channels channel ref= tcp port= 20000 / /channels /application /system.runtime.remoting /configuration Rozpoczynamy kluczem configuration . Kolejny klucz to definicja przestrzeni nazw. W kluczu service definiujemy parametry serwisu. W znaczniku wellknown podajemy tryb inicjalizacji obiektu (SingleCall), Uri oraz przestrzeĔ nazw i nazwĊ klasy obiektu. Znacznik activated zapewnia moĪliwoĞü tworzenia przez klienta lokalnej kopii obiektu. Na koĔcu zdefiniowaliĞmy typ transmisji oraz numer portu, na którym serwer bĊdzie prowadziá nasáuch. 6. Teraz przechodzimy do kodu Form1.cs. Jak zwykle dodajemy trzy przestrzenie nazw: using System.Runtime.Remoting; using System.Runtime.Remoting.Channels; using System.Runtime.Remoting.Channels.Tcp; 7. Do projektu dodajemy pole edycyjne textBox1. 8. Na formĊ wrzucamy przycisk button1. Dla jego domyĞlnej metody zdarzeniowej piszemy kod z listingu 6.11. Listing 6.11. Inicjacja serwera na podstawie pliku konfiguracyjnego private void button1_Click(object sender, EventArgs e) { try { RemotingConfiguration.Configure( config.xml , false); textBox1.Text = Serwer nasđuchuje ... ; } catch (Exception ex) { MessageBox.Show(ex.Message); } } Inicjacja serwera polega jedynie na uĪyciu metody Configure klasy RemotingConfiguration, za pomocą której wskazujemy plik konfiguracyjny. JeĪeli do naszego serwisu dodaliĞmy plik config.xml, wówczas standardowo bĊdzie siĊ on znajdowaá w katalogu projektu. W momencie uruchomienia Rozdziaä 6. i Remoting 201 serwera jesteĞmy przenoszeni do katalogu katalog_projektu/bin/Debug. Aby plik config.xml byá kopiowany do katalogu wynikowego aplikacji, musimy zmieniü konfiguracjĊ budowania aplikacji. Otwieramy okno wáasnoĞci (Properties) projektu. Odnajdujemy zakáadkĊ Build Events. W miejscu Post-build event command line wpisujemy nastĊpujące polecenie: copy $(ProjectDir)config.xml $(TargetDir) Spowoduje to skopiowanie pliku config.xml do katalogu wynikowego aplikacji. PosáuĪyliĞmy siĊ w tym miejscu makrodefinicjami. Warto sprawdziü opcjĊ Edit Post-build…. Jest to edytor, który zawiera wszystkie makrodefinicje dostĊpne w Visual Studio (rysunek 6.5). Napisaną aplikacjĊ moĪemy teraz przetestowaü. Rysunek 6.5. Okno wáasnoĞci projektu z otwartym edytorem Post-build event 9. Zapisujemy i uruchamiamy serwer. 10. W katalogu projektu 72. odnajdujemy plik wykonywalny klienta TCP. Uruchamiamy tĊ aplikacjĊ. W polach edycyjnych wpisujemy dowolne liczby i klikamy przycisk =. Poáączenie z nowo utworzonym serwerem powinno zostaü ustanowione i odpowiednie dziaáanie powinno byü wykonane. 202 C#. Tworzenie aplikacji sieciowych. Gotowe projekty Projekt 74. Klient TCP. Plik konfiguracyjny Klient równieĪ moĪe zostaü skonfigurowany za pomocą pliku XML zawierającego odpowiednie wpisy. 1. Tworzymy nowy projekt Windows Forms. W polu Name wpisujemy, tak jak poprzednio, RemotingTCP. DziĊki temu bĊdziemy siĊ znajdowaü w tej samej przestrzeni nazw co serwer. NazwĊ projektu moĪemy zmieniü potem w oknie Solution Explorer. 2. Interfejs naszej aplikacji bĊdzie identyczny z interfejsem klienta TCP z projektu 71. 3. Dodajemy równieĪ te same referencje (RemotingMath.dll i System.Runtime.Remoting.dll). 4. Projekt uzupeániamy o definicje nastĊpujących przestrzeni nazw: using System.Runtime.Remoting; using System.Runtime.Remoting.Channels; using System.Runtime.Remoting.Channels.Tcp; 5. Do projektu dodajemy plik XML (patrz punkt 3. w projekcie 73.). Nazwiemy go config.xml. 6. W utworzonym pliku wpisujemy kod z listingu 6.12. Listing 6.12. Plik konfiguracyjny klienta TCP ?xml version= 1.0 encoding= utf-8 ? configuration system.runtime.remoting application channels channel ref= tcp clientProviders formatter ref= binary / /clientProviders /channel /channels client wellknown url= tcp://localhost:20000/Math type= RemotingTCP.RemotingMath, RemotingMath / /client /application /system.runtime.remoting /configuration W pliku tym uĪyliĞmy tych samych tagów co w projekcie 73. Znacznik formater defi- niuje format przesyáania danych. W tym przypadku dane zostają przesyáane binarnie. Rozdziaä 6. i Remoting 203 Projekt 75. Czat. Klasa serwera Program, który teraz napiszemy, bĊdzie odpowiadaá projektowi czat z rozdziaáu 5. RóĪnica bĊdzie polegaü na zastosowaniu technologii Remoting. W projekcie 72. przeko- nywaáem, Īe obiekt stworzony na podstawie klasy RemotingMath nie jest obiektem wyáącznie lokalnym, choü samo stworzenie go za pomocą operatora new wskazywaáoby na to, iĪ jest to obiekt lokalny, kontrolowany przez aplikacjĊ klienta. W tym projekcie i dwóch kolejnych bĊdziemy mieli szansĊ sprawdziü, Īe tak utworzony obiekt jest dzie- lony przez wszystkich klientów, a jego stan jest kontrolowany przez serwer. 1. Tworzymy nowy projekt Class Library i nazywamy go ChatRemoting. 2. Stworzoną klasĊ nazywamy Chat. Jako klasĊ bazową dla nowej klasy wybierzemy MarshalByRefObject (listing 6.13). Do klasy dodamy jeszcze bezparametrowy konstruktor i przestrzeĔ nazw System.Collections. Listing 6.13. Szablon klasy Czat using System; using System.Collections.Generic; using System.Collections; using System.Text; namespace ChatRemoting { public class Chat : MarshalByRefObject { private ArrayList usersList = new ArrayList(); private String talk = String.Empty; public Chat() { } } } JeĪeli zlikwidowalibyĞmy dziedziczenie po klasie MarshalByRefObject, to kaĪdy klient na czas sesji posiadaáby wáasną, niezaleĪną kopiĊ obiektu. Kopia ta nie byáaby uzupeániana o nowe wiadomoĞci bądĨ nowych klientów. Dziedziczenie z klasy bazowej MarshalByRefObject umoĪliwia wspóádzielenie obiektu klasy pochodnej Chat. 3. W klasie Chat umieszczamy dwa prywatne pola: usersList i talk (listing 6.13). Pierwsze z nich bĊdzie przechowywaáo listĊ aktualnie przyáączonych uĪytkowników. ZastosowaliĞmy tutaj dynamiczną tablicĊ klasy ArrayList. Pole talk bĊdzie przechowywaáo caáą rozmowĊ, począwszy od startu serwera. Pola inicjalizujemy w miejscu definicji. 4. Do klasy Chat dodajemy metodĊ umoĪliwiającą dodawanie nowych uĪytkowników (listing 6.14). Zabezpieczymy siĊ w niej przed dodawaniem uĪytkowników o tych samych pseudonimach. PoniewaĪ pole usersList jest de facto dzielone pomiĊdzy aplikacje klienckie wykorzystujące obiekt klasy Chat, dodawanie umieszczamy w sekcji krytycznej. W przypadku nieudanej próby dodania uĪytkownika metoda zwróci false. 204 C#. Tworzenie aplikacji sieciowych. Gotowe projekty Listing 6.14. Dodawanie nowych uĪytkowników serwisu public bool AddUser(string userName) { if (usersList.Contains(userName)) return false; if (userName != null userName.Trim() != null) { lock (usersList) { usersList.Add(userName); } return true; } return false; } 5. JeĪeli uĪytkownik siĊ odáączy, wówczas powinien zostaü usuniĊty z listy usersList. Odpowiedni kod realizujący to zadanie zostaá umieszczony na listingu 6.15. Listing 6.15. UsuniĊcie uĪytkownika z listy uĪytkowników public void RemoveUser(string userName) { lock (usersList) { usersList.Remove(userName); } } 6. Do naszej klasy dodajemy metodĊ, która bĊdzie umieszczaáa w polu rozmowa nową wiadomoĞü wysáaną przez klienta (listing 6.16). Metoda ta sprawdza równieĪ, czy w podanym ciągu nie znajdują siĊ znaki formatujące tabulacji i koĔca linii. Na potrzeby tego przykáadu jest to wystarczające, ale powinno siĊ zwiĊkszyü kontrolĊ wprowadzanych znaków. Listing 6.16. Dodawanie nowej wiadomoĞci public void AddMessage(string newMessage) { if (newMessage != null newMessage.Trim() != null) { newMessage.Replace( , ); newMessage.Replace( , ); lock (talk) { talk += newMessage + ; } } } Rozdziaä 6. i Remoting 205 7. Aby uzyskaü dostĊp do prywatnych pól klasy Czat, tworzymy wáasnoĞci tylko do odczytu (listing 6.17). Pola te nie mogą byü modyfikowane bezpoĞrednio z zewnątrz klasy. Listing 6.17. WáasnoĞci wyĞwietlające listĊ uĪytkowników i rozmowĊ public ArrayList UsersList { get { return usersList; } } public string Talk { get { return talk; } } 8. Projekt zapisujemy (np. pod nazwą ChatRemoting) i kompilujemy. W ten sposób stworzyliĞmy klasĊ, której nastĊpnie uĪyjemy do poáączenia z klientami. PoniewaĪ jednoczeĞnie kilku uĪytkowników usáugi mogáoby chcieü uzyskaü dostĊp do pól klasy poprzez metody AddUser, RemoveUser i AddMessage, zastosowaliĞmy metodĊ lock. Blokuje ona okreĞlone zasoby, tak aby metody z innych wątków programu nie miaáy do nich dostĊpu tak dáugo, jak dáugo aktualny wątek musi korzystaü z tych zasobów. Jest to sposób czĊsto uĪywany w synchronizowaniu wątków. Projekt 76. Czat. Serwer Aplikacja serwera bĊdzie niezwykle prosta. Ograniczymy siĊ w niej tylko do urucho- mienia usáugi związanej ze stworzoną wczeĞniej biblioteką ChatRemoting.dll. Ponie- waĪ bĊdziemy przesyáaü wiadomoĞci tekstowe, najwygodniejszym rozwiązaniem jest zastosowanie poáączenia HTTP. 1. Rozpoczynamy nowy projekt Windows Forms. Dodajemy go do juĪ istniejącego rozwiązania. W polu Name wpisujemy ChatServer. Niech przestrzeĔ nazw bĊdzie ta sama co w projekcie 75., czyli ChatRemoting. Najszybciej moĪna zamieniü nazwĊ przestrzeni nazw, uĪywając narzĊdzia Refactor. 2. Do projektu dodajemy referencjĊ System.Runtime.Remoting.dll oraz referencjĊ do projektu 75. 3. Tradycyjnie dodajemy nastĊpujące przestrzenie nazw: using System.Runtime.Remoting; using System.Runtime.Remoting.Channels; using System.Runtime.Remoting.Channels.Http; 4. Na formĊ wrzucamy przycisk button1. Dla jego domyĞlnej metody zdarzeniowej piszemy kod z listingu 6.18. 206 C#. Tworzenie aplikacji sieciowych. Gotowe projekty Listing 6.18. Gáówna metoda serwera private void button1_Click(object sender, EventArgs e) { try { HttpChannel channel = new HttpChannel(1978); ChannelServices.RegisterChannel(channel, false); RemotingConfiguration.RegisterWellKnownServiceType(typeof(Chat), ´ Chat , WellKnownObjectMode.Singleton); } catch (Exception ex) { MessageBox.Show(ex.Message); } } Poáączenie bĊdzie nawiązywane w trybie Singleton. Oznacza to, Īe kaĪdy z klientów bĊdzie miaá dostĊp do tego samego (jednego) obiektu. Zmiany wprowadzone przez jednego klienta bĊdą widoczne z poziomu kaĪdego innego (nawet nowo przyáączonego). W naszym przypadku jest to naturalny wybór, poniewaĪ chcemy, aby wszystkie aplikacje klienckie mogáy ze sobą rozmawiaü. Stąd równieĪ w metodach modyfikujących klasĊ ChatRemoting znajdują siĊ sekcje krytyczne. Projekt 77. Czat. Klient Pora na aplikacjĊ klienta. Aplikacja ta bĊdzie nieco bardziej skomplikowana od po- przedniej, choü jej napisanie nie przysporzy nam wiĊkszych káopotów. 1. Tworzymy nowy projekt Windows Forms. W polu Name wpisujemy ChatClient. Jak poprzednio musimy zadbaü, aby klasa znajdowaáa siĊ w tej samej przestrzeni nazw co pozostaáe klasy projektu. Jest to oczekiwana wáasnoĞü, która uchroni nas przed dodawaniem w sekcji using referencji do nowych przestrzeni nazw. 2. Podobnie jak w projekcie 76. tutaj takĪe dodajemy referencjĊ do biblioteki System.Runtime.Remoting.dll oraz do projektu CzatRemoting. 3. Do projektu dodajemy nowe przestrzenie nazw: using System.Collections; using System.Runtime.Remoting; using System.Runtime.Remoting.Channels; using System.Runtime.Remoting.Channels.Http; 4. KlasĊ Form1 uzupeániamy o nowe pola: private Chat chat; private HttpChannel channel; private bool isConnected = false; Rozdziaä 6. i Remoting 207 5. Zaprojektujemy teraz interfejs aplikacji. Na formĊ wrzucamy pole edycyjne textBox1. Tutaj uĪytkownik bĊdzie mógá wprowadzaü wiadomoĞü do wysáania. 6. Do projektu dodajemy pole edycyjne textBox2, które bĊdzie przechowywaáo nasze imiĊ. 7. FormĊ uzupeániamy o kontrolkĊ textBox3. W niej bĊdzie widoczna rozmowa. WáasnoĞü ReadOnly ustawiamy na true. WáasnoĞü Multiline ustawiamy na true. 8. Na formie umieszczamy listĊ listBox1, która bĊdzie zawieraáa aktualnie podáączonych uĪytkowników. 9. Na formĊ wrzucamy przycisk button1. Jego wáasnoĞü Text zmieniamy na Poáącz. 10. Dodajemy kontrolkĊ timer1 klasy Timer. Jest to „stoper” odmierzający czas w milisekundach. WáasnoĞü Interval ustawiamy na 1000. Oznacza to, Īe w odstĊpach czasu równych 1000 ms, czyli 1 s, bĊdzie nastĊpowaáo zdarzenie Tick. Jest to wygodne narzĊdzie do oprogramowania periodycznie powtarzających siĊ funkcji aplikacji. Jego uĪycie zostanie przedyskutowane niĪej. 11. Tworzymy metodĊ zdarzeniową Click kontrolki button1 i umieszczamy w niej kod z listingu 6.19. Listing 6.19. Poáączenie z serwerem private void button1_Click(object sender, EventArgs e) { if (isConnected) { MessageBox.Show( Juľ podđæczony , Bđæd ); return; } try { channel = new HttpChannel(); ChannelServices.RegisterChannel(channel, false); RemotingConfiguration.RegisterWellKnownClientType(typeof(Chat), ´ http://localhost/Chat ); chat = new Chat(); bool status = chat.AddUser(textBox2.Text.Trim()); if (status == false) { MessageBox.Show( Uľytkownik juľ istnieje , Bđæd ); ChannelServices.UnregisterChannel(channel); timer1.Enabled = false; isConnected = false; button1.Enabled = true; textBox2.ReadOnly = false; return; } chat.AddMessage( Uľytkownik [ + textBox2.Text + ] dođæczyđ ´do rozmowy ); timer1.Enabled = true; isConnected = true; button1.Enabled = false; textBox2.ReadOnly = true; } 208 C#. Tworzenie aplikacji sieciowych. Gotowe projekty catch (Exception ex) { MessageBox.Show(ex.Message, Bđæd ); textBox3.Text = Nie udađo siú nawiæzaè pođæczenia ... ; ChannelServices.UnregisterChannel(channel); timer1.Enabled = false; isConnected = false; button1.Enabled = true; textBox2.ReadOnly = false; channel = null; } } Kod, za pomocą którego áączymy siĊ z serwerem, jest prawie taki sam jak w projekcie 70. Jedyna róĪnica polega na tym, Īe po podáączeniu do serwera wysyáamy wiadomoĞü, uĪywając metody AddUser. W momencie przyáączenia siĊ do serwera i utworzenia obiektu klasy Chat uzyskujemy dostĊp do dzielonego obiektu. JeĪeli rozmowa bĊdzie siĊ juĪ toczyü jakiĞ czas, a nowy klient dopiero siĊ podáączy, wówczas dostanie on wszystkie wiadomoĞci od momentu rozpoczĊcia usáugi (wáączenia serwera). 12. Do projektu dodajemy przycisk button2. Jego klikniĊcie spowoduje dodanie wiadomoĞci do pola talk. Odpowiedni kod zawiera listing 6.20. Listing 6.20. Dodanie nowej wiadomoĞci private void button2_Click(object sender, EventArgs e) { if (isConnected) if (textBox2.Text != null textBox2.Text.Trim() != null) chat.AddMessage( [ + textBox2.Text + ] + textBox1.Text); } 13. Dla komponentu timer1 tworzymy metodĊ zdarzeniową Tick (listing 6.21). Listing 6.21. Metoda pobierająca nowe wiadomoĞci i nowych uĪytkowników private void timer1_Tick(object sender, EventArgs e) { ArrayList users = chat.UsersList; listBox1.Items.Clear(); foreach (string user in users) listBox1.Items.Add(user); textBox3.Clear(); textBox3.Text = chat.Talk; } Jak sprawdziü, czy ktoĞ coĞ napisaá lub czy ktoĞ nowy doáączyá do rozmowy? Pomysá jest bardzo prosty. Co jedną sekundĊ odĞwieĪamy zawartoĞü pola edycyjnego textBox3, które przechowuje stan rozmowy oraz zawartoĞü listy goĞci (kontrolka listBox1). Pomysá ten jest od razu najsáabszym punktem rozwiązania. Musimy mieü na uwadze, jakie wprowadza ograniczenia. WielkoĞü Rozdziaä 6. i Remoting 209 pamiĊci rozmowy nie moĪe byü zbyt duĪa. Spowodowaáoby to przeciąĪenie sieci. Dodatkowo po co od nowa pobieraü rozmowĊ, którą juĪ pobraliĞmy? ProponujĊ, aby problemy te potraktowaü jako ciekawe üwiczenie. Omówiony projekt jest jedynie początkiem. NaleĪy go zmodyfikowaü i rozszerzyü. 14. Do projektu dodajemy jeszcze przycisk button3. Jego wáasnoĞü Text zmieniamy na Rozáącz. 15. Kod klasy uzupeániamy o metodĊ zdarzeniową Click kontrolki button3 (listing 6.22). Listing 6.22. Rozáączenie uĪytkownika private void button3_Click(object sender, EventArgs e) { if (isConnected) { chat.AddMessage( Uľytkownik [ + textBox2.Text + ] opuħciđ rozmowú ); chat.RemoveUser(textBox2.Text); listBox1.Items.Clear(); timer1.Enabled = false; ChannelServices.UnregisterChannel(channel); isConnected = false; button1.Enabled = true; textBox2.ReadOnly = false; } } Aby rozáączyü uĪytkownika, naleĪy usunąü go z listy rozmówców oraz uĪyü metody UnregisterChannel klasy ChannelServices, która zakoĔczy poáączenie z serwerem. MoĪna równieĪ wysáaü odpowiedni komunikat do wszystkich uĪytkowników usáugi. Rozdziaá ten, jak wspomniaáem na początku, jest szybkim wstĊpem do technologii .NET Remoting, która… w zasadzie zanika. JeĞli nie musisz jej uĪywaü, po prostu jej nie uĪywaj. Wsparcie dla niej moĪe w jednej z kolejny
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

C#. Tworzenie aplikacji sieciowych. Gotowe projekty
Autor:
,

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


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