Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00653 008470 10490579 na godz. na dobę w sumie
Visual C# 2008. Projektowanie aplikacji. Pierwsze starcie - książka
Visual C# 2008. Projektowanie aplikacji. Pierwsze starcie - książka
Autor: Liczba stron: 280
Wydawca: Helion Język publikacji: polski
ISBN: 83-246-1288-2 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> visual c# - programowanie
Porównaj ceny (książka, ebook, audiobook).

Czysta przyjemność tworzenia... projektowanie aplikacji w przyjaznym środowisku Visual C# 2008

Środowisko programistyczne Visual C#, będące elementem szerszego pakietu Microsoft Visual Studio 2008, jest obecnie najczęściej wykorzystywanym środowiskiem służącym do projektowania aplikacji na platformy .NET 2.0, 3.0 i 3.5. Ułatwia ono zarówno pisanie kodu C#, jak i projektowanie graficznego interfejsu programu, zapewniając łatwą edycję kodu, wizualizację oraz możliwość kontrolowanego uruchamiania przygotowywanej aplikacji. Wspomaga także programistę w usuwaniu błędów kodu oraz oferuje mu dwie biblioteki kontrolek (Windows Forms i Windows Presentation Foundation), które pozwalają na bezproblemową budowę graficznego interfejsu użytkownika (także zgodnego ze stylem używanym w systemie Windows Vista). Pakiet Visual Studio 2008 oferuje również łączenie kontrolek danych z bazami danych SQL Server i Access oraz wykorzystanie ogromnych możliwości plików XML.

Książka 'Visual C# 2008. Projektowanie aplikacji. Pierwsze starcie' ma za zadanie bezboleśnie i szybko wprowadzić Cię w arkana działania środowiska Visual C#, jak również udostępnić Ci wszelkie informacje dotyczące zachodzących w nim zmian. To znacznie ułatwi Ci projektowanie aplikacji w przyszłości. Podzielona na trzy odrębne części tematyczne, poświęcone kolejno podstawom poruszania się w tym środowisku, bibliotece Windows Forms oraz nowej bibliotece Windows Presentation Foundation, jest w istocie zbiorem praktycznych ćwiczeń opatrzonych komentarzami. Pozbawiona zbędnych opisów i dywagacji teoretycznych, zawiera jednak krótkie objaśnienia wszelkich trudniejszych kwestii. Zaopatrzono ją także w dodatki przeznaczone dla osób rozpoczynających dopiero naukę programowania.

Programowanie będzie łatwiejsze, jeśli dobrze poznasz najnowszą wersję środowiska Visual C# 2008!
Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

Visual C# 2008. Projektowanie aplikacji. Pierwsze starcie Autor: Jacek Matulewski ISBN: 978-83-246-1288-8 Format: B5, stron: 267 Czysta przyjemno(cid:156)(cid:230) tworzenia(cid:133) projektowanie aplikacji w przyjaznym (cid:156)rodowisku Visual C# 2008 (cid:140)rodowisko programistyczne Visual C#, bŒd„ce elementem szerszego pakietu Microsoft Visual Studio 2008, jest obecnie najczŒ(cid:156)ciej wykorzystywanym (cid:156)rodowiskiem s‡u¿„cym do projektowania aplikacji na platformy .NET 2.0, 3.0 i 3.5. U‡atwia ono zar(cid:243)wno pisanie kodu C#, jak i projektowanie graficznego interfejsu programu, zapewniaj„c ‡atw„ edycjŒ kodu, wizualizacjŒ oraz mo¿liwo(cid:156)(cid:230) kontrolowanego uruchamiania przygotowywanej aplikacji. Wspomaga tak¿e programistŒ w usuwaniu b‡Œd(cid:243)w kodu oraz oferuje mu dwie biblioteki kontrolek (Windows Forms i Windows Presentation Foundation), kt(cid:243)re pozwalaj„ na bezproblemow„ budowŒ graficznego interfejsu u¿ytkownika (tak¿e zgodnego ze stylem u¿ywanym w systemie Windows Vista). Pakiet Visual Studio 2008 oferuje r(cid:243)wnie¿ ‡„czenie kontrolek danych z bazami danych SQL Server i Access oraz wykorzystanie ogromnych mo¿liwo(cid:156)ci plik(cid:243)w XML. Ksi„¿ka (cid:132)Visual C# 2008. Projektowanie aplikacji. Pierwsze starcie(cid:148) ma za zadanie bezbole(cid:156)nie i szybko wprowadzi(cid:230) CiŒ w arkana dzia‡ania (cid:156)rodowiska Visual C#, jak r(cid:243)wnie¿ udostŒpni(cid:230) Ci wszelkie informacje dotycz„ce zachodz„cych w nim zmian. To znacznie u‡atwi Ci projektowanie aplikacji w przysz‡o(cid:156)ci. Podzielona na trzy odrŒbne czŒ(cid:156)ci tematyczne, po(cid:156)wiŒcone kolejno podstawom poruszania siŒ w tym (cid:156)rodowisku, bibliotece Windows Forms oraz nowej bibliotece Windows Presentation Foundation, jest w istocie zbiorem praktycznych (cid:230)wiczeæ opatrzonych komentarzami. Pozbawiona zbŒdnych opis(cid:243)w i dywagacji teoretycznych, zawiera jednak kr(cid:243)tkie obja(cid:156)nienia wszelkich trudniejszych kwestii. Zaopatrzono j„ tak¿e w dodatki przeznaczone dla os(cid:243)b rozpoczynaj„cych dopiero naukŒ programowania. (cid:149) Projektowanie interfejsu aplikacji (cid:149) Analiza kodu i usuwanie b‡Œd(cid:243)w (cid:149) Aplikacje Windows Forms (cid:149) Techniki programowania (cid:149) Operacje na plikach XML (cid:149) Biblioteka ADO.NET i baza danych Server SQL (cid:149) .NET 2.0, .NET 3.0 (cid:151) podobieæstwa i r(cid:243)¿nice (cid:149) WPF i XAML (cid:151) nowe narzŒdzia wizualizacji (cid:149) Elementy zagnie¿d¿one (cid:149) Transformacje i animacje (cid:149) JŒzyk C# 2.0 i kolekcje (cid:149) Projektowanie zorientowane obiektowo w C# 2.0 (cid:149) Podstawy SQL Programowanie bŒdzie ‡atwiejsze, je(cid:156)li dobrze poznasz najnowsz„ wersjŒ (cid:156)rodowiska Visual C# 2008! Wydawnictwo Helion ul. Ko(cid:156)ciuszki 1c 44-100 Gliwice tel. 032 230 98 63 e-mail: helion@helion.pl Spis treści Wstęp .............................................................................................. 7 Część I Środowisko Visual C# ..................................................... 9 Rozdział 1. Pierwsze kroki ............................................................................... 11 Projektowanie interfejsu aplikacji .................................................................................. 13 Analiza kodu pierwszej aplikacji .................................................................................... 17 Metody zdarzeniowe ....................................................................................................... 23 Rozdział 2. Debugowanie kodu ......................................................................... 31 Teoria Murphy’ego wyjaśniająca przyczynę powstawania błędów w kodach programów oraz to, jak ich unikać ............................................................................... 31 Kontrolowane uruchamianie aplikacji w Visual C# ....................................................... 32 Śledzenie wykonywania programu krok po kroku (F10 i F11) ................................ 34 Run to Cursor (Ctrl+F10) ......................................................................................... 35 Breakpoint (F9) ........................................................................................................ 36 Okna Locals i Watch ................................................................................................ 37 Stan wyjątkowy .............................................................................................................. 39 Część II Platforma .NET 2.0 ....................................................... 43 Rozdział 3. Aplikacje Windows Forms ............................................................... 45 Notatnik .NET ................................................................................................................ 45 Projektowanie interfejsu aplikacji — menu główne ................................................. 45 Okna dialogowe i pliki tekstowe .............................................................................. 52 Edycja i korzystanie ze schowka .............................................................................. 60 Drukowanie .............................................................................................................. 61 Elektroniczna kukułka .................................................................................................... 70 Ekran powitalny (splash screen) ............................................................................... 70 Przygotowanie ikony w obszarze powiadamiania .................................................... 72 Odtwarzanie pliku dźwiękowego ............................................................................. 75 Ustawienia aplikacji ....................................................................................................... 76 Rozdział 4. Mechanizm drag drop .................................................................. 81 Podstawy ........................................................................................................................ 81 Zagadnienia zaawansowane ............................................................................................ 88 4 Visual C# 2008. Projektowanie aplikacji. Pierwsze starcie Rozdział 5. Wybrane techniki programowania dla systemu Windows .................. 95 Dostęp do rejestrów systemu Windows .......................................................................... 95 Zarządzane biblioteki DLL ........................................................................................... 101 Tworzenie zarządzanej biblioteki DLL .................................................................. 102 Statyczne ładowanie bibliotek DLL ....................................................................... 106 Dynamiczne ładowanie zarządzanych bibliotek DLL i dynamiczne rozpoznawanie typów .......................................................................................... 108 Mechanizm PInvoke i funkcje WinAPI ........................................................................ 118 Komunikaty Windows .................................................................................................. 125 Wysyłanie komunikatów Windows ........................................................................ 125 Odbieranie komunikatów Windows ....................................................................... 129 Rozdział 6. Odczytywanie i zapisywanie danych w plikach XML ....................... 133 Podstawy języka XML ................................................................................................. 133 Deklaracja .............................................................................................................. 134 Elementy ................................................................................................................ 134 Atrybuty ................................................................................................................. 134 Komentarze ............................................................................................................ 135 Zapis i odczyt danych z pliku XML ............................................................................. 135 Serializacja obiektów do pliku XML ............................................................................ 141 XML i ADO.NET ......................................................................................................... 144 Rozdział 7. Biblioteka ADO.NET i SQL Server .................................................. 147 Część III Platforma .NET 3.0 ..................................................... 163 Rozdział 8. Krótka historia platformy .NET, czyli przewodnik po jej wersjach ...... 165 Historia ......................................................................................................................... 165 Teraźniejszość .............................................................................................................. 167 Rozdział 9. WPF i XAML — nowe narzędzia projektowania wizualnego ............. 169 Kolory w WPF .............................................................................................................. 171 Analiza kodu XAML aplikacji WPF ............................................................................ 174 Wyzwalacze (triggers) .................................................................................................. 175 Wypełnienie gradientem ............................................................................................... 179 Tworzenie obiektu w kodzie XAML ............................................................................ 182 WPF Browser Application ............................................................................................ 185 Rozdział 10. Historia pewnego przycisku .......................................................... 189 Elementy zagnieżdżone ................................................................................................ 189 Style .............................................................................................................................. 195 Rozdział 11. Transformacje i animacje .............................................................. 199 Transformacje ............................................................................................................... 199 Animacje ...................................................................................................................... 203 Szablony ....................................................................................................................... 207 Część IV Dodatki ...................................................................... 209 Dodatek A Język C# ....................................................................................... 211 Język C# 2.0 .................................................................................................................. 211 Podstawowe typy danych ........................................................................................ 212 Sterowanie przepływem .......................................................................................... 220 Zwracanie wartości przez argument metody ........................................................... 223 Wyjątki.................................................................................................................... 224 Dyrektywy preprocesora ......................................................................................... 226 Atrybuty .................................................................................................................. 229 Spis treści 5 Kolekcje ........................................................................................................................ 229 Nowości języka C# 3.0.................................................................................................. 236 Dodatek B Projektowanie zorientowane obiektowo w C# 2.0........................... 245 Typy wartościowe i referencyjne................................................................................... 245 Przykład struktury (Ulamek) ......................................................................................... 247 Implementacja interfejsu (IComparable)................................................................. 256 Definiowanie typów parametrycznych.................................................................... 257 Dodatek C Szalenie krótki wstęp do SQL ........................................................ 265 Select ............................................................................................................................. 265 Insert.............................................................................................................................. 266 Delete ............................................................................................................................ 266 Skorowidz ..................................................................................... 267 Rozdział 5. Wybrane techniki programowania dla systemu Windows Platforma .NET stanowi osobną, w dużej mierze autonomiczną warstwę systemu Win- dows. Aplikacje uruchamiane w jej obrębie nie muszą, a wręcz nie powinny odwoływać się do głębszych poziomów systemu. Czasem jest to jednak trudne do uniknięcia. Albo dlatego, że nie ma innej możliwości, aby uzyskać od systemu Windows to, czego akurat nasz program potrzebuje, albo po prostu dlatego, że taka droga jest znacznie łatwiejsza do realizacji. Musimy sobie jednak zdawać sprawę z kilku niebezpieczeństw związanych z sięganiem do macierzystej platformy Windows. Każde odwołanie do bibliotek Win32, jak na- zywa się teraz oryginalną warstwę WinAPI systemu Windows, pociąga za sobą brak możliwości przeniesienia całego projektu. Nie można bowiem zakładać, że w innych systemach istnieją biblioteki o tej samej nazwie i zawierające te same funkcje. Pamię- tajmy także, że każde odwołanie do bibliotek spoza platformy .NET utrudnia lub wręcz uniemożliwia kontrolę bezpieczeństwa jej podzespołów (ang. assembly), a zasoby z platformy Win32 nie mogą być kontrolowane przez garbage collector. To tyle utyskiwania i ostrzeżeń, a teraz zróbmy krótki przegląd najważniejszych tech- nologii, które pozwalają na korzystanie z mechanizmów platformy Win32. Jedynym wyjątkiem w tym rozdziale jest fragment dotyczący zarządzanych bibliotek DLL, które nie wymagają odwołań do Win32. Dostęp do rejestrów systemu Windows Windows udostępnia rejestr systemowy jako miejsce, w którym aplikacje Win32 po- winny przechowywać swoje ustawienia i inne niebyt obszerne dane. Każdy użytkownik posiada własną część rejestru, co bardzo ułatwia personalizację ustawień aplikacji. 96 Część II ♦ Platforma .NET 2.0 Rejestr może być także przydatny w inny sposób — z ustawień użytkownika znajdu- jących się w rejestrze można bowiem odczytać niektóre informacje o systemie, np. po- łożenie katalogów specjalnych. I właśnie w taki sposób wykorzystamy rejestr w pierw- szym zadaniu tego podrozdziału. Przygotujemy aplikację, która będzie wyświetlać ścieżkę do katalogu specjalnego Moje dokumenty użytkownika odczytaną z rejestru (każdy użytkownik ma swój własny katalog tego typu). Ścieżkę dostępu do tego katalogu można odczytać w rejestrze systemowym w części danych użytkownika (tj. w części umiesz- czonej w kluczu głównym HKEY_CURRENT_USER), w kluczu SoftwareMicrosoft Windows CurrentVersionExplorerShell Folders z wartości Personal. Aby nieco zo- rientować się w strukturze zawartości rejestru oraz sprawdzić istnienie interesującego nas klucza, można wykorzystać systemowy edytor rejestru (polecenie regedit z linii poleceń, rysunek 5.1). Rysunek 5.1. Klucz rejestru przechowujący informacje o ścieżkach do katalogów specjalnych Odczytywanie ścieżki do katalogów specjalnych wprost z rejestru nie jest optymalnym rozwiązaniem. O wiele prościej jest skorzystać z klasy SpecialFolders w przestrzeni nazw System.Environment. Przykładowo ścieżkę do katalogu Moje dokumenty można odczytać z własności System.Environment.SpecialFolder.MyDocuments. Jeszcze raz chciałbym zwrócić uwagę na to, że aplikacje, które pisaliśmy do tej pory, były w znacznym stopniu niezależne od systemu operacyjnego, na którym osadzona jest platforma .NET. Oznacza to, że nasze programy mogą zostać uruchomione na kom- puterach działających pod kontrolą innych systemów, jeżeli tylko zainstalowana jest na nich odpowiednia wersja środowiska .NET lub alternatywnego środowiska Mono. Natomiast jeżeli zdecydujemy się użyć rejestru Windows do przechowywania danych, to z powodu braku jego odpowiednika w innych systemach aplikacja natychmiast traci zaletę przenaszalności. Rozdział 5. ♦ Wybrane techniki programowania dla systemu Windows 97 Ćwiczenie 5.1. Odczytywanie informacji z rejestru systemu Windows Odczytaj z rejestru systemu Windows ścieżkę do katalogu specjalnego Moje Dokumenty z wartości Personal obecnej w kluczu SoftwareMicrosoftWindowsCurrentVersion ExplorerShell Folders użytkownika. 1. Tworzymy nowy projekt aplikacji Windows Forms Application. 2. W pliku Form1.cs deklarujemy użycie przestrzeni nazw zawierającej klasę Registry, dodając na początku pliku polecenie using Microsoft.Win32;. 3. Na formie umieszczamy komponent Label. 4. Do klasy Form1 dodajemy metodę z listingu 5.1 odczytującą ścieżkę do katalogu specjalnego z wartości wskazanej przez argument nazwaWartosci. Listing 5.1. Otwórz klucz rejestru, odczytaj wartość, zamknij klucz private string pobierzSciezkeDoKataloguSpecjalnego(string nazwaWartosci) { const string nazwaKlucza = Software\Microsoft\Windows\CurrentVersion\ (cid:180)Explorer\Shell Folders ; try { RegistryKey rejestr=Registry.CurrentUser.OpenSubKey(nazwaKlucza); if (rejestr == null) throw new Exception( brak klucza +nazwaKlucza+ ); string sciezkaKatalogu = (string)rejestr.GetValue(nazwaWartosci); if (sciezkaKatalogu == null) throw new Exception( brak wartosci + nazwaWartosci + ); rejestr.Close(); return sciezkaKatalogu; } catch(Exception exc) { MessageBox.Show( Błąd przy czytaniu rejestru: + exc.Message + . ,this.Text); return null; } } 5. Możemy zdefiniować metodę pomocniczą, która będzie odczytywać ścieżkę do katalogu Moje dokumenty (listing 5.2) Listing 5.2. Ukłon w stronę wygody private string sciezkaMojeDokumenty() { return pobierzSciezkeDoKataloguSpecjalnego( Personal ); } 6. Do konstruktora klasy Form1 dodajemy polecenie umieszczające ścieżkę do katalogu Moje dokumenty na komponencie label1 (listing 5.3). 98 Część II ♦ Platforma .NET 2.0 Listing 5.3. Ścieżka do katalogu zostanie odczytana każdorazowo podczas uruchamiania aplikacji public Form1() { InitializeComponent(); label1.Text = sciezkaMojeDokumenty(); } Przypominam jeszcze raz, że ścieżkę do katalogu Moje dokumenty łatwiej odczytać z własności System.Environment.SpecialFolder.MyDocuments. Powyższa metoda jest tylko ilustracją tego, jak odczytywać dane z rejestru. Przestudiujmy metodę z czwartego punktu (listing 5.1). W pierwszej linii definiowany jest łańcuch zawierający nazwę klucza, z którego odczytamy ścieżkę do katalogu. Na- zwa wartości przekazywana jest przez argument metody. Następnie od słowa kluczo- wego try rozpoczyna się obsługa wyjątków otaczająca całą istotną część metody. Jeżeli pojawi się w trakcie jej wykonywania wyjątek, wyświetlany jest komunikat (polece- nie w sekcji catch) i działanie metody kończy się zwróceniem wartości null. W pierwszej linii sekcji try tworzony jest obiekt klasy RegistryKey, który reprezentuje klucz rejestru. Instancję klasy RegistryKey można utworzyć metodą OpenSubKey, która pobiera jako argument nazwę klucza, a zwraca jego referencję w razie powodzenia lub null, jeżeli nazwa klucza jest nieprawidłowa albo użytkownik nie ma odpowiednich uprawnień. Pojawia się tu jednak problem, który polega na tym, że OpenSubKey nie jest metodą statyczną — musimy więc dysponować obiektem typu RegistryKey, żeby go dopiero utworzyć metodą OpenSubKey. Oczywiście, tylko pozornie jest to sytuacja bez wyjścia. W klasie Registry istnieją bowiem predefiniowane obiekty typu RegistryKey odpowiadające głównym kluczom rejestru. Wśród nich znajduje się obiekt CurrentUser reprezentujący klucz HKEY_CURRENT_USER, w którym znajduje się potrzebna nam informacja. Polecenie tworzące obiekt reprezentujący klucz rejestru jest więc dość skom- plikowane: RegistryKey rejestr=Registry.CurrentUser.OpenSubKey(nazwaKlucza); Za to dalej jest już łatwiej. W kolejnej linii sprawdzamy, czy zwrócona przez OpenSubKey referencja nie jest przypadkiem pusta. Jeżeli jest, zgłaszamy wyjątek z komunikatem „brak klucza”. Natomiast jeżeli obiekt został utworzony, to możemy odczytać intere- sującą nas wartość za pomocą metody rejestr.GetValue(nazwaWartosci); i zapisać ją do zmiennej sciezkaKatalogu (konieczne jest przy tym jawne rzutowanie na typ łań- cuchowy string). Jeżeli referencja zwracana przez GetValue jest pusta, zgłaszamy kolejny wyjątek z komunikatem „brak wartości”. Jeżeli natomiast wszystko jest w po- rządku, zamykamy klucz metodą Close i kończymy działanie metody, zwracając łań- cuch zawierający pełną ścieżkę do wskazanego w argumencie katalogu specjalnego. Należy zauważyć, że wystarczy mała modyfikacja sygnatury i pierwszych linii przy- gotowanej w poprzednim ćwiczeniu metody, aby mogła ona służyć do czytania do- wolnego klucza w rejestrze użytkownika — wystarczy przez głowę tej metody pobrać obie zmienne: nazwaKlucza i nazwaWartosci. Rozdział 5. ♦ Wybrane techniki programowania dla systemu Windows 99 Przygotujemy teraz metody, które będą zapisywać i odczytywać dane z klucza prywat- nego danej aplikacji, tj. określonego schematem HKEY_CURRENT_USERSoftware WydawcaNazwaAplikacji. Jest to typowy sposób przechowywania informacji przez aplikacje systemu Windows (Win32). Zagwarantowana jest w ten sposób pełna per- sonalizacja tych danych, bo klucz ten należy do aktualnie zalogowanego użytkownika. Informacje, które nie muszą być spersonalizowane, można przechowywać w analogicz- nym kluczu, ale umieszczonym w kluczu głównym HKEY_LOCAL_MACHINE. Ćwiczenie 5.2. Zapisywanie i odczytywanie położenia i rozmiaru formy w prywatnym kluczu aplikacji W naszym przykładzie użyjemy rejestru do zapisywania położenia okna przy zamknięciu i odczytywania go podczas otwierania aplikacji. 1. Do klasy Form1 dodajemy metodę czytajPolozenieOkna (listing 5.4). W zasadzie nie różni się ona wiele od metody służącej do odczytywania ścieżki katalogu specjalnego (listing 5.1). Inne są oczywiście klucz i wartości, które odczytujemy, ale kolejność poleceń jest taka sama. Ścieżka klucza jest zapisana poza metodą, w stałej kluczAplikacji typu String (pierwsza linia listingu 5.4). Listing 5.4. Odczytywanie położenia okna zapamiętanego w rejestrze const string kluczAplikacji = Software\Helion\PrzykladRejestr ; private void czytajPolozenieOkna(string nazwaKlucza) { RegistryKey rejestr = Registry.CurrentUser.OpenSubKey(nazwaKlucza); if (rejestr == null) { //tu mozna umiescic polecenia wykonywane przy pierwszym uruchomieniu aplikacji MessageBox.Show( Pierwsze uruchomienie programu. ,this.Text); return; } //x object wartosc=rejestr.GetValue( left ); if (wartosc != null) this.Left = (int)wartosc; //y wartosc=rejestr.GetValue( top ); if (wartosc != null) this.Top = (int)wartosc; //szer wartosc=rejestr.GetValue( width ); if (wartosc != null) this.Width = (int)wartosc; //wys wartosc=rejestr.GetValue( height ); if (wartosc != null) this.Height = (int)wartosc; rejestr.Close(); } 2. Teraz wystarczy utworzyć metodę zdarzeniową do zdarzenia Load formy i umieścić w niej wywołanie powyższej metody (listing 5.5). 100 Część II ♦ Platforma .NET 2.0 Listing 5.5. Położenie okna należy zmienić we właściwej metodzie zdarzeniowej private void Form1_Load(object sender, EventArgs e) { try { czytajPolozenieOkna(kluczAplikacji); } catch (Exception ex) { MessageBox.Show( Błąd przy odtwarzaniu położenia okna: + ex.Message); } } 3. Teraz zajmiemy się zapisywaniem położenia okna w rejestrze. Do klasy Form1 dodajemy metodę zapiszPolozenieOkna widoczną na listingu 5.6. Listing 5.6. Zapisywanie położenia okna w rejestrze private void zapiszPolozenieOkna(string nazwaKlucza) { RegistryKey rejestr = Registry.CurrentUser.OpenSubKey(nazwaKlucza,true); if (rejestr == null) { //pierwsze uruchomienie programu po instalacji MessageBox.Show( Tworzę klucz rejestru dla aplikacji , this.Text); rejestr = Registry.CurrentUser.CreateSubKey(nazwaKlucza); } rejestr.SetValue( left , this.Left); rejestr.SetValue( top , this.Top); rejestr.SetValue( width , this.Width); rejestr.SetValue( height , this.Height); rejestr.Close(); } 1. Jej wywołanie należy umieścić w metodzie zdarzeniowej związanej ze zdarzeniem FormClosed. Na wszelki wypadek jeszcze raz przypomnę, że w przypadku aplikacji zarządzanych platformy .NET 2.0 do przechowywania ustawień lepiej korzystać z mechanizmu application settings opisanego w rozdziale 3. niż z rejestru. Umieszczenie wywołania metody odczytującej położenie okna w konstruktorze klasy Form1 dałoby tylko połowiczny efekt: rozmiar okna zostałby odtworzony, ale jego poło- żenie nie. Dzieje się tak, dlatego że położenie okna ustalane jest przez system Windows już po utworzeniu jego obiektu (a więc po wykonaniu poleceń konstruktora), ale jesz- cze przed jego pokazaniem na ekranie. Właśnie dlatego metodę czytajPolozenieOkna wywołujemy z metody zdarzeniowej związanej ze zdarzeniem Load. Jest ona wykony- wana już po ustaleniu wstępnego położenia okna, dzięki czemu położenie ustalone przez nas nie zostanie już zmienione. Rozdział 5. ♦ Wybrane techniki programowania dla systemu Windows 101 Tym razem zrezygnowałem z korzystania z wyjątków i ich obsługi wewnątrz metody odczytującej wartości z rejestru. W metodzie zapiszPolozenieOkna jest miejsce, w którym możemy wywołać polece- nia lub metody, jakie chcemy wywołać tylko przy pierwszym uruchomieniu aplikacji (po instalacji). Można łatwo rozpoznać taką sytuację — nie ma klucza w rejestrze. Zwróćmy uwagę na dodatkowy argument w metodzie OpenSubKey z listingu 5.6. Tym razem, otwierając klucz, skorzystaliśmy z przeciążonej wersji tej metody, w której drugi argument wskazuje, czy klucz jest otwierany w trybie pozwalającym tworzyć nowe wartości i modyfikować istniejące. Ćwiczenie 5.3. Usuwanie klucza z rejestru Umiemy tworzyć i odczytywać wpisy w rejestrze. Co jednak należy zrobić, gdy chcemy usunąć klucz, np. podczas odinstalowywania aplikacji? Wiele niezbyt starannie napi- sanych aplikacji zwyczajnie pozostawia klucze w rejestrze, szczególnie jeżeli korzy- stają z zewnętrznych instalatorów. Nie jest to jednak dobry zwyczaj. 1. W widoku projektowania na formie aplikacji umieśćmy przycisk (kontrolka Button). 2. Kliknijmy go dwukrotnie, aby utworzyć domyślną metodę zdarzeniową. 3. Umieśćmy w niej polecenie Registry.CurrentUser.DeleteSubKey(kluczAplikacji, false);. Drugi argument w poleceniu z punktu 3. decyduje o tym, czy w przypadku braku klu- cza przed jego usunięciem metoda ma zgłosić wyjątek. Zniknięcie klucza po kliknięciu przycisku możemy potwierdzić za pomocą edytora reje- stru. Oczywiście zostanie on ponownie utworzony przy zamykaniu aplikacji. Jeżeli chcemy tego uniknąć, musimy zdefiniować pole klasy — flagę, która będzie blokować zapisy- wanie klucza po jego usunięciu (rozwiązanie tego problemu dostępne jest w dołączonych do książki źródłach). Zarządzane biblioteki DLL Biblioteki DLL (z ang. Dynamic Link Library) są głównym sposobem dystrybucji klas i komponentów, zarówno w aplikacjach dla platformy Win32, jak i dla platformy .NET. Biblioteki obu platform różnią się oczywiście w takim samym stopniu jak ich pliki wykonywalne1. Niemniej jednak idea stojąca za umieszczaniem modułów aplikacji w osobnych bibliotekach jest podobna. 1 Zarówno pliki .dll, jak i pliki .exe są podzespołami (ang. assembly), czyli skompilowanymi do kodu pośredniego MSIL samodzielnymi kawałkami kodu. Na poziomie podzespołów realizowana jest główna polityka bezpieczeństwa platfomy .NET. 102 Część II ♦ Platforma .NET 2.0 Biblioteki DLL mogą być ładowane przez aplikację na dwa sposoby: statycznie lub dynamicznie. Pierwszy sposób jest znacznie łatwiejszy, ponieważ w tym przypadku zawartość biblioteki i umieszczonych w niej klas znana jest już podczas projektowania aplikacji. W drugim przypadku zawartość biblioteki może nie być znana lub nawet sama biblioteka może być wybrana przez użytkownika albo określona przez zapis w reje- strach systemowych dopiero po uruchomieniu aplikacji. Wówczas potrzebna jest „pełna diagnostyka” biblioteki DLL. Jest to jednak przypadek rzadki, najczęściej wystarczy sprawdzić, czy w bibliotece znajdują się klasy, których potrzebujemy. Tak czy inaczej, dynamiczne ładowanie bibliotek wiąże się z rozległym zagadnieniem dynamicznego rozpoznawania typów, o którym kilka słów można znaleźć w dalszej części rozdziału. Zasadnicza różnica między dynamicznym i statycznym ładowaniem biblioteki DLL polega na momencie jej wczytania. Przy ładowaniu statycznym biblioteka zostaje za- ładowana przed wywołaniem metody Main, a więc programista nie ma na to żadnego wpływu. W przypadku ładowania dynamicznego jest przeciwnie — programista ma pełen wpływ na moment i sposób załadowania biblioteki, sam musi zaprogramować wszystkie konieczne do tego czynności. Osobnym zagadnieniem jest wykorzystywanie bibliotek DLL zawierających kod nie- zarządzany (unmanaged), tj. kod maszynowy systemu Windows, a nie kod pośredni platformy .NET. Dostęp do tych bibliotek umożliwia atrybut DllImport pozwalający, znowu statycznie, zadeklarować metodę, której definicją jest funkcja odczytana z bi- blioteki DLL. Tym zagadnieniem zajmiemy się w podrozdziale „Mechanizm PInvoke i funkcje WinAPI”. Tworzenie zarządzanej biblioteki DLL Umieśćmy w osobnej bibliotece DLL klasę, której jedynym zadaniem będzie wyświe- tlenie podstawowych informacji o wersji używanej platformy .NET. Ćwiczenie 5.4. Projekt biblioteki DLL. Narzędzia refactoringu Przygotuj projekt zarządzanej biblioteki DLL i za pomocą narzędzi refactoringu zmień nazwę przestrzeni nazw i klasy. 1. Tworzymy nowy projekt: a) Z menu File wybieramy polecenie New Project lub przyciskamy kombinację klawiszy Ctrl+Shift+N. b) Zaznaczamy ikonę Class Library. c) W polu Name wpisujemy nazwę SysInfo. d) Klikamy OK. 2. Po utworzeniu projektu zobaczymy okno edytora kodu z definicją pustej klasy jak na listingu 5.7. Nieciekawa jest nazwa tej klasy oraz przestrzeń nazw, w której została umieszczona. Zmieńmy przestrzeń nazw na Helion, a nazwę klasy na SysInfo. Rozdział 5. ♦ Wybrane techniki programowania dla systemu Windows 103 Listing 5.7. „Pusta” klasa utworzona w projekcie biblioteki DLL using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace SysInfo { public class Class1 { } } 3. Zmieniamy nazwę przestrzeni nazw za pomocą narzędzi refactoringu: a) Klikamy prawym klawiszem myszy nazwę przestrzeni nazw w edytorze kodu. b) Z menu kontekstowego wybieramy polecenie Refactor/Rename (rysunek 5.2). Rysunek 5.2. Narzędzie refactoringu wbudowane w Visual C# c) Pojawi się okno, w którym możemy podać nową nazwę przestrzeni nazw. Wpiszmy Helion. d) Kolejne okno prezentuje zmiany, jakie zostaną wprowadzone do kodu (rysunek 5.3). W naszym przypadku zmiana zostanie wprowadzona tylko w jednej linii. Klikamy w nim przycisk Apply. e) Wówczas zobaczymy okno z ostrzeżeniem, że nowa przestrzeń nazw będzie ustalona także jako przestrzeń domyślna projektu, i pytaniem o to, czy nadal chcemy dokonać tej zmiany. Kliknijmy przycisk Tak. 104 Rysunek 5.3. Zmiana nazwy przestrzeni nazw Część II ♦ Platforma .NET 2.0 4. W bardzo podobny sposób możemy zmienić nazwę klasy z Class1 na SysInfo. 5. Jeżeli teraz skompilujemy bibliotekę, naciskając klawisz F6, w podkatalogu DocumentsVisual Studio 2008ProjectsSysInfoSysInfoibRelease powstanie plik SysInfo.dll zawierający naszą „pustą” klasę. Akurat w projekcie biblioteki DLL, który składa się z tylko jednego pliku z kodem źródłowym, korzystanie z narzędzi refactoringu do zmiany nazwy klasy i przestrzeni nazw występujących w kodzie tylko raz jest stanowczą przesadą. Ale skoro nadarzyła się okazja, żeby przedstawić to narzędzie, nie chciałem jej stracić. Narzędzie to jest bardziej użyteczne, a nawet staje się nieocenione, gdy projekt obejmuje kilka tysięcy linii kodu. Jeżeli spojrzymy na kod źródłowy automatycznie tworzonej klasy (listing 5.7), za- uważymy, że w bloku instrukcji using są tylko trzy przestrzenie nazw zawierające pod- stawowe typy C#, kolekcje oparte na typach ogólnych i typach związanych z obsługą łańcuchów. Brakuje tam m. in. przestrzeni nazw zawierającej kontrolki biblioteki Win- dows Forms (System.Windows.Forms). Jednak dodanie do tego bloku odpowiedniej in- strukcji nie pomoże — projekt nie posiada odwołania (referencji) do biblioteki zawie- rającej owe kontrolki. Należy bowiem wiedzieć, że standardowe klasy i komponenty platformy .NET zostały umieszczone w zarządzanych bibliotekach, które są zgroma- dzone w katalogach WindowsMicrosoft.NETFrameworkv2.0.50727, v3.0 i v3.5, gdzie nazwa katalogu najbardziej zagnieżdżonego odpowiada numerowi wersji wykorzysty- wanej przez nas platformy .NET. Rozdział 5. ♦ Wybrane techniki programowania dla systemu Windows 105 Ćwiczenie 5.5. Dodawanie referencji do biblioteki systemowej platformy .NET Dodaj do projektu referencję do biblioteki System.Windows.Forms.dll. 1. Z menu Project wybieramy polecenie Add Reference.... Pojawi się okno Add Reference widoczne na rysunku 5.4. 2. Na zakładce .NET wybieramy bibliotekę System.Windows.Forms i klikamy OK. Rysunek 5.4. Oprócz klas z bibliotek zarządzanych platformy .NET możemy używać bibliotek .ocx (niezarządzane komponenty ActiveX) Dopiero teraz widoczna będzie przestrzeń nazw System.Windows.Forms i dopiero teraz ma sens dodanie jej do zbioru poleceń using na początku pliku. Ćwiczenie 5.6. Klasa wyświetlająca informacje o systemie i platformie .NET Wyposaż klasę SysInfo w jedną metodę statyczną2, która będzie wyświetlać komunikat z informacją o systemie. Do wyświetlenia tego komunikatu użyjemy klasy System. Windows.Forms.MessageBox. Właśnie po to, aby można było użyć klasy z przestrzeni nazw System.Windows.Forms, dodaliśmy w projekcie naszej biblioteki SysInfo.dll referencję do biblioteki System. Windows.Forms.dll (poprzednie ćwiczenie). Sam komunikat zawierać będzie pełną nazwę systemu operacyjnego wraz z wersją, wersję platformy .NET, nazwę kom- putera i katalog systemowy Windows. Większość z tych informacji można pobrać z klasy Environment (listing 5.8). 2 Po wyjaśnienia tego, czym metody statyczne różnią się od zwykłych, odsyłam do dodatku B dostępnego pod adresem ftp://ftp.helion.pl/online/inne/cwvcsh_rozdz_dodatkowy.pdf. 106 Część II ♦ Platforma .NET 2.0 Listing 5.8. Pełen kod klasy po dodaniu metody Show using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace Helion { public class SysInfo { static public void Show() { string informacje = Informacje o systemie: + Wersja systemu: + Environment.OSVersion + Wersja Microsoft .NET Framework: + Environment.Version + Nazwa komputera: + Environment.MachineName + Katalog systemowy: + Environment.SystemDirectory + ; System.Windows.Forms.MessageBox.Show(informacje, Informacje (cid:180)o platformie .NET ); } } } Po dodaniu do klasy metody Show naciskamy klawisz F6, aby zbudować wersję „release” biblioteki DLL (SysInfo.dll). Znajdziemy ją w katalogu DocumentsVisual Studio 2008 ProjectsSysInfoSysInfoinRelease. Jeśli chcemy zachować konwencję nazewnictwa proponowaną w platformie .NET, nasza biblioteka powinna przejąć nazwę po przestrzeni nazw, tj. powinna nazywać się Helion.dll. Jednak skoro przestrzeń ta zawiera tylko jedną klasę, większy moim zdaniem sens ma wyeksponowanie nazwy tej klasy. Statyczne ładowanie bibliotek DLL Przygotujmy teraz aplikację, która korzystając z klasy SysInfo umieszczonej w bi- bliotece DLL, będzie wyświetlać informacje o systemie po kliknięciu przycisku. Klasa SysInfo nie zostanie wkompilowana do pliku .exe tej aplikacji — biblioteka będzie ładowana do pamięci w momencie uruchamiania aplikacji. Zalety takiego postępowa- nia są identyczne jak w przypadku zwykłych bibliotek DLL w klasycznych (tj. nieza- rządzanych) aplikacjach. Jeżeli napiszemy lepszą wersję klasy prezentującej informa- cje o systemie, ale taką, której interfejs nie ulegnie zmianie (tj. w naszym przypadku nadal zawierać będzie bezargumentową statyczną i publiczną metodę Show), aby jej użyć, wystarczy podmienić plik .dll, bez potrzeby ponownej kompilacji i dystrybucji całego projektu. W przypadku większych aplikacji może to bardzo ułatwić dystrybucję uaktualnień. Ważne jest również to, że klasy umieszczone w bibliotece DLL mogą być wielokrotnie wykorzystane przez różne aplikacje bez konieczność ich wkompilowywa- nia w każdą z nich osobno. Rozdział 5. ♦ Wybrane techniki programowania dla systemu Windows 107 Ćwiczenie 5.7. Dołączanie bibliotek DLL użytkownika Przygotuj projekt aplikacji z dodaną referencją do samodzielnie zaprojektowanej biblio- teki DLL. 1. Tworzymy nowy projekt typu Windows Forms Application. 2. Postępując analogicznie jak w ćwiczeniu 5.5, dodajemy do projektu aplikacji referencję do biblioteki SysInfo.dll: a) Z menu Project wybieramy Add Reference. b) W oknie Add Reference przechodzimy na zakładkę Browse (rysunek 5.5). Rysunek 5.5. Dodawanie do projektu przygotowanej samodzielnie lub ściągniętej z sieci biblioteki c) Przechodząc do odpowiedniego katalogu, wskazujemy plik SysInfo.dll. d) Klikamy OK. 3. Teraz wystarczy przejść do widoku projektowania, umieścić na formie przycisk, kliknąć go dwukrotnie, aby utworzyć domyślną metodę zdarzeniową i umieścić w niej wywołanie metody statycznej klasy Show z klasy Helion.SysInfo (listing 5.9). Listing 5.9. Wywołanie funkcji z biblioteki DLL private void button1_Click(object sender, EventArgs e) { Helion.SysInfo.Show(); } Pierwszym sprawdzianem potwierdzającym, że klasa SysInfo z biblioteki DLL jest w pełni widoczna w projekcie aplikacji, jest pojawienie się przestrzeni nazw Helion w liście proponowanej przez Code Insight, a następnie klasy SysInfo i jej metod. 108 Część II ♦ Platforma .NET 2.0 Teraz możemy nacisnąć klawisz F5, a po skompilowaniu projektu kliknąć przycisk widoczny na formie uruchomionej aplikacji. Powinniśmy zobaczyć komunikat zawie- rający informacje o systemie (rysunek 5.6). Warto zwrócić uwagę na to, że podczas każdej kompilacji Visual C# kopiuje najnowszą wersję biblioteki SysInfo.dll do kata- logu, w którym umieszcza plik .exe wykorzystującej ją aplikacji. Nie ma zatem pro- blemu z niezgodnością wersji biblioteki. Rysunek 5.6. Za okno widocznego na rysunku komunikatu odpowiedzialna jest metoda klasy wczytanej z biblioteki DLL Dynamiczne ładowanie zarządzanych bibliotek DLL i dynamiczne rozpoznawanie typów Dopiero próbując załadować tę samą bibliotekę samodzielnie, docenimy, jak wiele pracy zostało nam oszczędzone przy ładowaniu statycznym. Przede wszystkim, dodając do pro- jektu referencję, powiadamialiśmy kompilator o klasie SysInfo i jej zawartości. Przy ładowaniu dynamicznym nie jest to możliwe, bo ani kompilator, ani aplikacja po uru- chomieniu nie wie, co jest w pliku DLL. Konieczne jest wówczas korzystanie z tzw. dynamicznej kontroli typów3. Ćwiczenie 5.8. Dynamiczne ładowanie zarządzanej biblioteki .dll Utwórz projekt aplikacji dynamicznie ładującej do pamięci bibliotekę SysInfo.dll. 1. Tworzymy nowy projekt aplikacji Windows Forms Application. 2. W klasie Form1 deklarujemy użycie przestrzeni nazw zawierającej klasę Assembly, którą wykorzystamy do wczytania biblioteki: using System.Reflection;. 3. Deklarujemy prywatne pole klasy Form1, które będzie przechowywać ścieżkę do pliku biblioteki DLL4. 3 Odczytywanie informacji o typach jest możliwe dzięki mechanizmowi o nazwie Reflection (odpowiednik RTTI z C++), w który wyposażona jest platforma .NET. 4 Oczywiście, można ją także wskazać w trakcie działania aplikacji, np. za pomocą okna dialogowego. Aplikacja AssemblyExplorer, która wczytuje dowolną, zarządzaną bibliotekę DLL i analizuje jej zawartość, znajduje się w dołączonych do książki źródłach i zostanie jeszcze omówiona. Rozdział 5. ♦ Wybrane techniki programowania dla systemu Windows 109 private const string nazwaPlikuDLL = c:/Users/Jacek/Documents/Visual Studio (cid:180)2008/Projects/SysInfo/SysInfo/bin/Release/SysInfo.dll ; 4. Na formie umieszczamy przycisk i tworzymy jego domyślną metodę zdarzeniową. 5. W metodzie umieszczamy polecenia z listingu 5.10. Listing 5.10. Wczytywanie wskazanej biblioteki DLL do pamięci private void button1_Click(object sender, EventArgs e) { try { if (!System.IO.File.Exists(nazwaPlikuDLL)) throw new Exception( Brak pliku biblioteki DLL ); Assembly a=Assembly.LoadFrom(nazwaPlikuDLL); MessageBox.Show( Wczytano podzespół: +a.FullName+ z pliku +a.Location); } catch(Exception exc) { MessageBox.Show( Wczytanie podzespołu z pliku +nazwaPlikuDLL+ nie powiodło (cid:180)się ( +exc.Message+ ). ); return; } } Jeżeli wczytanie biblioteki powiodło się, zostanie wyświetlony komunikat zawie- rający opis wczytanego podzespołu. W naszym przypadku będzie to Helion.SysInfo, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null. Ćwiczenie 5.9. Analiza zawartości biblioteki załadowanej dynamicznie Wyświetl listę klas udostępnianych przez bibliotekę SysInfo.dll. Warto wrócić do projektu biblioteki SysInfo, aby dodać do niej kilka dodatkowych klas i metod, tak byśmy mieli co analizować. Dodałem dodatkową klasę zawierającą po- nadto klasę zagnieżdżoną (listing 5.11). Listing 5.11. Klasa z klasą zagnieżdżoną public class Dodatkowa { public class Zagniezdzona { } } Zabierzmy się teraz za prześwietlenie zawartości wczytanego podzespołu. Po powro- cie do projektu aplikacji, w której dynamicznie wczytujemy bibliotekę DLL, dodajmy do formy kolejny przycisk. Aby wyświetlić listę klas zdefiniowanych w bibliotece, umieśćmy w nowej metodzie polecenia widoczne na listingu 5.12. W imię przejrzy- stości pominąłem instrukcję try..catch, którą w normalnej sytuacji należałoby ko- niecznie otoczyć przynajmniej poleceniem wczytania biblioteki do pamięci. 110 Część II ♦ Platforma .NET 2.0 Listing 5.12. Wyświetlanie listy typów (klas) umieszczonych w bibliotece DLL private void button2_Click(object sender, EventArgs e) { Assembly a=Assembly.LoadFrom(nazwaPlikuDLL); string nazwyTypow = Nazwy klas: ; Type[] typy = a.GetTypes(); foreach (Type typ in typy) nazwyTypow += typ.FullName + ; MessageBox.Show(nazwyTypow); } Komunikat, jaki otrzymałem w wyniku analizy biblioteki SysInfo.dll, jest pokazany na rysunku 5.7. Widoczna jest nie tylko klasa SysInfo, ale również dodatkowa klasa Dodatkowa i zagnieżdżona w niej klasa Zagniezdzona. Rysunek 5.7. Lista klas uzyskana dzięki badaniu wczytanego z biblioteki podzespołu Jak wspomniałem, w praktyce zamiast poznawać wszystkie klasy znajdujące się w bi- bliotece, wystarczy sprawdzić, czy znajduje się w niej poszukiwana przez nas kon- kretna klasa lub struktura, której instancję chcemy utworzyć. Ćwiczenie 5.10. Weryfikacja obecności klasy o znanej nazwie w bibliotece DLL Sprawdź, czy w bibliotece DLL jest klasa Helion.SysInfo. Do formy należy dodać następny przycisk i kolejną metodę zdarzeniową, a w niej pole- cenia sprawdzające, czy interesująca nas klasa jest w bibliotece DLL (listing 5.13). Podobnie jak wcześniej, pominąłem sekcję try..catch. Listing 5.13. Czy w bibliotece znajduje się potrzebna nam klasa? private const string nazwaKlasy = Helion.SysInfo ; private void button3_Click(object sender, EventArgs e) { Assembly a=Assembly.LoadFrom(nazwaPlikuDLL); Rozdział 5. ♦ Wybrane techniki programowania dla systemu Windows 111 Type klasa = a.GetType(nazwaKlasy); if (klasa == null) MessageBox.Show( Nie znaleziono klasy + nazwaKlasy); else MessageBox.Show( Znaleziono klasę + nazwaKlasy); } Wykorzystaliśmy metodę Assembly.GetType, która pobiera łańcuch zawierający nazwę klasy, a zwraca jej referencję. W razie niepowodzenia zwracana jest wartość null. Ćwiczenie 5.11. Lista metod w klasie z biblioteki DLL Wyświetl listę metod klasy Helion.SysInfo z biblioteki SysInfo.dll. Kolejnym etapem testów jest sprawdzenie, czy klasa posiada metodę, którą chcemy wywołać. Dodajmy do metody z listingu 5.13 polecenia wyróżnione na listingu 5.14, które wyświetlają sygnatury dostępnych metod: Listing 5.14. Wyświetlanie listy metod private const string nazwaKlasy = Helion.SysInfo ; private void button3_Click(object sender, EventArgs e) { Assembly a=Assembly.LoadFrom(nazwaPlikuDLL); Type klasa = a.GetType(nazwaKlasy); if (klasa == null) MessageBox.Show( Nie znaleziono klasy + nazwaKlasy); else { string nazwyMetod = Sygnatury metod: ; MethodInfo[] metody = klasa.GetMethods(); foreach (MethodInfo metoda in metody) nazwyMetod += metoda.ToString() + ; MessageBox.Show( Znaleziono klasę + nazwaKlasy + + nazwyMetod); } } Powinniśmy uzyskać komunikat taki jak na rysunku 5.8. Na liście metod są metody publiczne, zadeklarowane przez nas w klasie SysInfo, oraz metody odziedziczone z klasy Object. Klasa MethodInfo pozwala na drobiazgowe zbadanie metod z klasy dzięki całej serii metod typu IsPublic, GetParameters, GetType itd. Pokazuje to kolejne ćwiczenie. Ćwiczenie 5.12. Weryfikacja obecności konkretnej metody w klasie z biblioteki DLL Sprawdź, czy w klasie Helion.SysInfo z biblioteki SysInfo.dll znajduje się statyczna me- toda Show nieprzyjmująca argumentów i niezwracająca wartości. Podobnie jak w przypadku klasy, w praktyce sprawdza się zazwyczaj tylko obecność konkretnej metody, którą chcemy wywołać. Dodajmy do formy jeszcze jeden przycisk, z którym zwiążemy metodę testującą obecność metody Show (listing 5.15). 112 Rysunek 5.8. Wszystkie metody publiczne klasy SysInfo Część II ♦ Platforma .NET 2.0 Listing 5.15. Sprawdzamy obecność metody Show w klasie Helion.SysInfo private void button4_Click(object sender, EventArgs e) { string nazwaMetody = Show ; Type zwracanaWartoscMetody = typeof(void); try { Assembly a = Assembly.LoadFrom(nazwaPlikuDLL); Type klasa = a.GetType(nazwaKlasy); if (klasa == null) throw new Exception( Nie znaleziono klasy + nazwaKlasy); MethodInfo metoda = klasa.GetMethod(nazwaMetody); if (metoda == null) throw new Exception( Nie znaleziono metody + nazwaMetody); if (!metoda.IsStatic) throw new Exception( Poszukiwana metoda powinna być statyczna ); if (metoda.ReturnType != zwracanaWartoscMetody) throw new Exception( Zły typ zwracanej wartości w + nazwaMetody); if (metoda.GetParameters().Length 0) throw new Exception( Zła liczba argumentów metody + nazwaMetody); MessageBox.Show( Znalazłem metodę ); } catch (Exception exc) { MessageBox.Show( Błąd: + exc.Message + . ); return; } } Metoda Type.GetMethod wymaga, aby pobierana w ten sposób metoda była nieprze- ciążona (jednoznaczna). Rozdział 5. ♦ Wybrane techniki programowania dla systemu Windows 113 Tak jak wykorzystaliśmy metodę Assembly.GetType do sprawdzenia występowania klasy w bibliotece DLL, tak teraz analogicznie skorzystaliśmy z metody Type.GetMethod do sprawdzenia występowania metody w klasie. Weryfikowanie obecności metody po- winno również obejmować sprawdzenie typu zwracanej przez nią wartości i pobieranych argumentów. Podobnie jak listę klas i metod, możemy także wyświetlić listę parame- trów wybranej metody. Niestety, metoda SysInfo nie zawiera żadnych argumentów, więc nie możemy się spodziewać ciekawego wyniku. Warto zatem wrócić do projektu biblioteki DLL i dodać do klasy Helion.SysInfo metodę o nazwie GetInfo (tym ra- zem niestatyczną), która takie argumenty będzie posiadać. Przykład znajduje się na li- stingu 5.16. Uzupełnijmy ją także metodą GetInfoBuilder, która różni się sposobem przekazywania łańcucha jako parametru (także widoczna na listingu 5.16). Pamiętajmy, aby po wprowadzeniu zmian przebudować projekt, naciskając klawisz F6. Listing 5.16. Ta metoda nie jest statyczna tylko dlatego, że potrzebujemy takiego przykładu public int GetInfo(out string informacje,bool czyWyswietlac) { informacje = Informacje o systemie: + Wersja systemu: + Environment.OSVersion + Wersja Microsoft .NET Framework: + Environment.Version + Nazwa komputera: + Environment.MachineName + Katalog systemowy: + Environment.SystemDirectory + ; if (czyWyswietlac) System.Windows.Forms.MessageBox.Show(informacje, Informacje o platformie .NET ); return Environment.Version.Major; } public int GetInfoBuilder(StringBuilder informacje, bool czyWyswietlac) { string s; int wynik = GetInfo(out s, czyWyswietlac); informacje.Append(s); return wynik; } Ćwiczenie 5.13. Lista argumentów wybranej metody Po załadowaniu biblioteki SysInfo.dll do pamięci odczytaj listę argumentów metody Helion.SysInfo.GetInfo. Zmodyfikujmy metodę z listingu 5.15 tak, aby zaprezentować informacje o metodzie GetInfo. Pokazuje to poniższy listing. Listing 5.17. Polecenia badające argumenty metody private void button4_Click(object sender, EventArgs e) { string nazwaMetody = GetInfo ; try 114 Część II ♦ Platforma .NET 2.0 { Assembly a = Assembly.LoadFrom(nazwaPlikuDLL); Type klasa = a.GetType(nazwaKlasy); if (klasa == null) throw new Exception( Nie znaleziono klasy + nazwaKlasy); MethodInfo metoda = klasa.GetMethod(nazwaMetody); if (metoda == null) throw new Exception( Nie znaleziono metody + nazwaMetody); ParameterInfo[] parametry=metoda.GetParameters(); string listaArgumentow= Lista argumentow: ; foreach(ParameterInfo parametr in parametry) listaArgumentow+= +parametr.Position+ . +parametr.ParameterType+ (cid:180) +parametr.Name+ ; string zwracanyTyp = Zwracany typ: + metoda.ReturnParameter; string statyczna = Czy statyczna: + ((metoda.IsStatic) ? tak : nie ); MessageBox.Show( Znalazłem metodę + metoda.Name + + listaArgumentow + (cid:180)zwracanyTyp + + statyczna); } catch (Exception exc) { MessageBox.Show( Błąd: + exc.Message + . ); return; } } Gdy teraz uruchomimy aplikację i wywołamy powyższą metodę, na ekranie zoba- czymy bardziej szczegółowe informacje o metodzie, podobne do tych z rysunku 5.9. Rysunek 5.9. Inspekcja metody Rozdział 5. ♦ Wybrane techniki programowania dla systemu Windows 115 Dzięki powyższym ćwiczeniom nauczyliśmy się dwóch rzeczy. Po pierwsze, jak od- czytać z biblioteki całą listę klas, następnie listę jej metod i parametrów wybranej metody. Dobrym podsumowaniem tego podejścia jest aplikacja AssemblyExplorer do- stępna w źródłach dołączonych do książki, która jest swojego rodzaju przeglądarką podzespołów, tj. plików .dll i .exe (rysunek 5.10). Jej działanie opiera się na technikach poznanych w powyższych ćwiczeniach. Rysunek 5.10. W dołączonych źródłach znajdują się projekty przeglądarki podzespołów Po drugie, umiemy sprawdzić, czy w bibliotece znajduje się konkretna, interesująca nas klasa z metodą o sygnaturze zgodnej z naszymi oczekiwaniami. Sprawdzenie obecności metody i weryfikacja jej sygnatury to pierwszy krok do jej uruchomienia, co zrobimy w kolejnym ćwiczeniu. Uruchomimy w nim metodę Helion.SysInfo.Show. Metoda ta jest statyczna, co oznacza, że nie musimy tworzyć obiektu, instancji klasy SysInfo, aby ją uruchomić. Ćwiczenie 5.14. Uruchamianie metody statycznej z klasy wczytanej z biblioteki DLL Uruchom statyczną metodę Helion.SysInfo.Show z biblioteki SysInfo.dll. W zasadzie wystarczy, jeżeli w listingu 5.15 polecenie MessageBox.Show( Znalazłem metodę ); zastąpimy poleceniem metoda.Invoke(null, null);. Wówczas po kliknięciu przycisku zobaczymy znajomy komunikat z informacjami o systemie. To będzie naj- lepszy dowód na to, że zdołaliśmy uruchomić metodę Show. Listing 5.18 zawiera pe- łen, ostateczny kod metody sprawdzającej obecność metody statycznej z biblioteki DLL, a następnie uruchamiający ją. 116 Część II ♦ Platforma .NET 2.0 Listing 5.18. Ostateczna wersja private void button5_Click(object sender, EventArgs e) { string nazwaKlasy = Helion.SysInfo ; string nazwaMetody = Show ; Type zwracanaWartoscMetody = typeof(void); try { Assembly a = Assembly.LoadFrom(nazwaPlikuDLL); Type klasa = a.GetType(nazwaKlasy); if (klasa == null) throw new Exception( Nie znaleziono klasy + nazwaKlasy); MethodInfo metoda = klasa.GetMethod(nazwaMetody); if (metoda == null) throw new Exception( Nie znaleziono metody + nazwaMetody); if (!metoda.IsStatic) throw new Exception( Poszukiwana metoda powinna być statyczna ); if (metoda.ReturnType != zwracanaWartoscMetody) throw new Exception( Zły typ zwracanej wartości w + nazwaMetody); if (metoda.GetParameters().Length 0) throw new Exception( Zła liczba argumentów metody + nazwaMetody); metoda.Invoke(null, null); } catch (Exception exc) { MessageBox.Show( Błąd: + exc.Message + . ); return; } } Komentarza wymagają argumenty metody Invoke. Użyliśmy prostszej z dwóch jej przeciążonych wersji. Pierwszym argumentem jest referencja do obiektu, na rzecz którego metoda ma być uruchomiona. Jednak w przypadku metod statycznych, a Show do nich należy, argument ten jest ignorowany. Drugi argument to zbiór parametrów. Metoda Show nie przyjmuje żadnych, dlatego i tu przekazaliśmy null. Ćwiczenie 5.15. Uruchamianie metody na rzecz instancji obiektu. Przekazywanie parametrów i odczytywanie zwracanej wartości Utwórz obiekt Helion.SysInfo z biblioteki SysInfo.dll i na jego rzecz uruchom metodę GetInfoBuilder. Jeżeli interesująca nas metoda nie jest metodą statyczną, przed jej uruchomieniem należy utworzyć obiekt — instancję klasy, w której jest ona zdefiniowana. Przećwiczmy to na metodzie GetInfoBuilder. Dodajmy do formy nowy przycisk i utwórzmy jego do- myślną metodę zdarzeniową. Listing 5.19 zawiera odpowiedni kod — wyróżnione zostały fragmenty zmienione względem kodu z listingu 5.18. Rozdział 5. ♦ Wybrane techniki programowania dla systemu Windows 117 Listing 5.19. Uruchamianie metod niestatycznych private void button6_Click(object sender, EventArgs e) { string nazwaKlasy = Helion.SysInfo ; string nazwaMetody = GetInfoBuilder ; Type zwracanaWartoscMetody = typeof(System.Int32); try { Assembly a = Assembly.LoadFrom(nazwaPlikuDLL); Type klasa = a.GetType(nazwaKlasy); if (klasa == null) throw new Exception( Nie znaleziono klasy + nazwaKlasy); MethodInfo metoda = klasa.GetMethod(nazwaMetody); if (metoda == null) throw new Exception( Nie znaleziono metody + nazwaMetody); if (metoda.ReturnType != zwracanaWartoscMetody) throw new Exception( Zły typ zwracanej wartości w + nazwaMetody); if (metoda.GetParameters().Length != 2) throw new Exception( Zła liczba argumentów metody + nazwaMetody); object obiektSysInfo=a.CreateInstance(nazwaKlasy); StringBuilder informacje=new StringBuilder(); object[] parametry=new object[2]; parametry[0]=informacje; parametry[1]=false; int zwroconaWartosc = (int)metoda.Invoke(obiektSysInfo, parametry); MessageBox.Show( Zwrócona wartość: + zwroconaWartosc + (główna wersja (cid:180)platformy .NET) Pobrany łańcuch z informacjami o systemie: + informacje); } catch (Exception exc) { MessageBox.Show( Błąd: + exc.Message + . ); return; } } Po tych kilku ćwiczeniach związanych z dynamicznym wczytywaniem bibliotek i ko- niecznym wówczas rozpoznawaniem typów Czytelnik może zadawać sobie pytanie, czy warto tak się z tym męczyć. Jakie korzyści dynamicznego ładowania biblioteki DLL uzasadniają wysiłek włożony w jego realizację? Czy nie łatwiej i bezpieczniej jest łączyć ją statycznie? Zazwyczaj tak, łatwiej i bezpieczniej jest wykorzystywać biblioteki DLL statycznie, tj. w sposób, jaki opisywało ćwiczenie 5.7. Jednak są też korzyści z dynamicznego łączenia bibliotek. Przede wszystkim mamy pełną kontrolę nad procesem ładowania i możemy sprawdzić, czy w bibliotece jest to, czego potrze- bujemy — co może być istotne w niektórych zastosowaniach. W przypadku statycz- nego ładowania bibliotek cały proces „podczepiania” biblioteki DLL odbywa się, za- nim zostanie uruchomiona metoda Program.Main, a więc programista nie ma na jego przebieg praktycznie żadnego wpływu i w żaden sposób nie może się zabezpieczyć przed brakiem biblioteki lub jej nieodpowiednią zawartością. Oczywiście są także przypadki, gdy inny niż dynamiczny sposób ładowania biblioteki nie jest możliwy, 118 Część II ♦ Platforma .NET 2.0 np. wspomniany wyżej eksplorator bibliotek DLL AssemblyExplorer, gdzie właściwą bibliotekę użytkownik wybiera za pomocą okna dialogowego już po uruchomieniu aplikacji. Należy jeszcze zwrócić uwagę na to, że podzespoły (assembly) to nie tylko biblioteki DLL. Podzespołem jest również każdy wykonywalny plik .exe zawierający kod po- średni (a więc każdy powstały w wyniku kompilacji C# lub innego języka dla plat- formy .NET) i z niego również mogą być pobrane klasy i wywołane ich metody. Mechanizm PInvoke i funkcje WinAPI Filozofia platformy .NET jest pod wieloma względami podobna do podejścia znanego z wirtualnej maszyny Javy — obie tworzą warstwę pośredniczącą między aplikacją a systemem operacyjnym, co umożliwia przenaszalność i zwiększenie bezpieczeństwa programów, obie dostarczają bibliotekę komponentów, co zmniejsza rozmiar plików programu. Różnią się jednak zasadniczo, jeżeli chodzi o podejście do macierzystego sys- temu. Java jest w zasadzie odizolowaną wyspą5, podczas gdy platforma .NET ułatwia wręcz odwołania do niezarządzanych bibliotek DLL. W tej części zaprezentuję kilka przykładów wywoływania funkcji niezarządzanych w kodzie C#. Służy do tego me- chanizm nazywany PInvoke (od ang. Platform Invoke6). W szczególności będziemy próbować uruchamiać funkcje z bibliotek systemowych, a więc funkcje WinAPI, które w różnych sytuacjach mogą być bardzo pomocne w rozwiązywaniu problemów pro- gramistycznych. Należy jednak być świadomym tego, że każde odwołanie do funkcji WinAPI czyni program nieprzenaszalnym — program nie odnajdzie tych funkcji w Linuksie. Zacznijmy od prostego ćwiczenia, a mianowicie od próby uruchomienia znajdującej się w bibliotece systemowej User32.dll funkcji MessageBeep, której rezultatem jest emisja jednego z predefiniowanych sygnałów dźwiękowych systemu Windows. W do- kumentacji WinAPI możemy znaleźć następującą jej definicję: BOOL MessageBeep( UINT uType // sound type ); Do poniższego przykładu użyliśmy funkcji WinAPI MessageBeep, żeby go jak najbardziej uprościć. Należy jednak być świadomym tego, że o ile w wersji 1.0 i 1.1 platformy był to jedyny sposób, aby zmusić komputer do zrobienia „biip”, to w wersji 2.0 dysponujemy klasą SystemSounds. Teraz ten sam efekt co z użyciem PInvoke można osiągnąć, wywołując metodę System.Media.SystemSounds.Beep.Play. 5 Co nie znaczy, że w Javie nie można uruchamiać programów spoza VJM, czy też przechwycić ich standardowego strumienia wyjścia i strumienia błędów. 6 Polski termin platforma .NET jest tłumaczeniem angielskiego .NET Framework. Niestety, także użyty tu termin angielski platform invoke może być tłumaczony jako wywołanie z platformy. Po polsku nie jest więc tak wyraźnie podkreślona różnica między warstwą systemową Windows (platform) i znajdującą się nad nią warstwą platformy .NET (framework). Rozdział 5. ♦ Wybrane techniki programowania dla systemu Windows 119 Ćwiczenie 5.16. Funkcja bez argumentów Uruchom dźwięk systemowy za pomocą funkcji WinAPI. 1. Tworzymy nowy projekt (Ctrl+Shift+N) typu Windows Forms Application. 2. Po utworzeniu projektu przechodzimy do edycji kodu z pliku Form1.cs. 3. Do sekcji zawierającej serię poleceń using dodajemy kolejne, umożliwiające dostęp do przestrzeni nazw, w której zdefiniowany jest atrybut DllImport: using System.Runtime.InteropServices; 4. Następnie wewnątrz klasy Form1 deklarujemy metodę statyczną z modyfikatorem extern, która poprzedzona jest atrybutem DllImport wskazującym na bibliotekę systemową User32.dll: [DllImport( User32.dll )] static extern bool MessageBeep(uint rodzajDzwieku); 5. Przechodzimy do widoku projektowania (F7) i na podglądzie formy umieszczamy przycisk Button z palety komponentów Common Controls. 6. Klikając go dwukrotnie, tworzymy domyślną metodę zdarzeniową i umieszczamy w niej polecenie wywołania metody MessageBeep z argumentem 0 (listing 5.20). Listing 5.20. Metoda zdarzeniowa związana z kliknięciem przycisku private void button1_Click(object sender, EventArgs e) { MessageBeep(0); } Funkcja WinAPI MessageBeep przyjmuje jako argument liczbę całkowitą bez znaku i zwraca wartość logiczną. Argument identyfikuje typ uruchamianego sygnału dźwię- kowego. Użyta przez nas wartość 0 oznacza sygnał typowy dla komunikatów infor- macyjnych (nie ostrzeżeń ani błędów). Może się oczywiście zdarzyć, że w używanym schemacie dźwięków ten sygnał jest wyłączony. Wówczas warto poeksperymentować, próbując używać różnych wartości argumentu tej funkcji. Będą one odpowiadały dźwię- kom określonym w Panelu sterowania, w aplecie Dźwięki i multimedia (rysunek 5.11). Warto na przykład wypróbować wartość 48 odpowiadającą stałej MB_ICONEXCLAMATION z WinAPI, a oznaczającą pozycję Wykrzyknik ze schematu dźwięków Windows. Aby wywołać funkcję MessageBeep z poziomu kodu C#, musieliśmy jej sygnaturę prze- tłumaczyć na język C#. W efekcie sygnatura miała następującą postać: static extern bool MessageBeep(uint rodzajDzwieku); To, na co należy przede wszystkim zwrócić uwagę, to fakt, że funkcja MessageBeep musi w wydaniu C# stać się metodą — w C# przecież nie ma funkcji niebędących skła- dowymi klas. Zdefiniowaliśmy ją zatem jako element klasy Form1, tzn. tej, z której jest i
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Visual C# 2008. Projektowanie aplikacji. Pierwsze starcie
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ą: