Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00434 008311 10495759 na godz. na dobę w sumie
.Net. Najpilniej strzeżone tajemnice - książka
.Net. Najpilniej strzeżone tajemnice - książka
Autor: Liczba stron: 192
Wydawca: Helion Język publikacji: polski
ISBN: 83-246-0173-2 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> .net - programowanie
Porównaj ceny (książka, ebook, audiobook).

Platforma .NET staje się coraz popularniejsza. Tysiące programistów na całym świecie doceniają jej doskonałe narzędzia programistyczne i tysiące stron wyczerpującej dokumentacji. Każdego dnia adepci sztuki programowania odkrywają nowe możliwości oferowane im przez .NET. Wiele z tych możliwości pozostaje jednak wciąż nie odkrytych. Sztuczki i furtki zaszyte przez twórców platformy .NET pozwalające na szybszą i sprawniejszą realizację projektów czekają na to, aby ktoś je zastosował w pracy. Jak dotrzeć do tych ukrytych cech? Skąd wziąć informacje o tym, co jeszcze można osiągnąć wykorzystują znane już narzędzia, na temat których napisano setki książek?

Dzięki książce '.NET. Najpilniej strzeżone tajemnice' poznasz te możliwości platformy .NET, których nie opisuje oficjalna dokumentacja. Znajdziesz w niej omówienie niezwykle cennych, ale mniej znanych funkcji Visual Studio i .NET Framework. Każda z tych funkcji może pomóc Ci podnieść wydajność procesu tworzenia oprogramowania oraz poprawić jakość swoich aplikacji. Dowiesz się, jak wykorzystać maksimum możliwości środowiska programistycznego, wykorzystasz nieznane funkcje GDI+ i ADO.NET i nauczysz się zasad programowania defensywnego, dzięki któremu znacznie ograniczysz liczbę błędów w swoich programach.

Wykorzystaj sekrety i skarby ukryte w platformie .NET.

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

Darmowy fragment publikacji:

IDZ DO IDZ DO PRZYK£ADOWY ROZDZIA£ PRZYK£ADOWY ROZDZIA£ SPIS TREŒCI SPIS TREŒCI KATALOG KSI¥¯EK KATALOG KSI¥¯EK KATALOG ONLINE KATALOG ONLINE ZAMÓW DRUKOWANY KATALOG ZAMÓW DRUKOWANY KATALOG TWÓJ KOSZYK TWÓJ KOSZYK DODAJ DO KOSZYKA DODAJ DO KOSZYKA CENNIK I INFORMACJE CENNIK I INFORMACJE ZAMÓW INFORMACJE ZAMÓW INFORMACJE O NOWOŒCIACH O NOWOŒCIACH ZAMÓW CENNIK ZAMÓW CENNIK CZYTELNIA CZYTELNIA FRAGMENTY KSI¥¯EK ONLINE FRAGMENTY KSI¥¯EK ONLINE Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel. (32)230-98-63 e-mail: helion@helion.pl .NET. Najpilniej strze¿one tajemnice Autor: Deborah Kurata T³umaczenie: Grzegorz Werner ISBN: 83-246-0173-2 Tytu³ orygina³u: Best Kept Secrets In .Net Format: B5, stron: 192 Platforma .NET staje siê coraz popularniejsza. Tysi¹ce programistów na ca³ym œwiecie doceniaj¹ jej doskona³e narzêdzia programistyczne i tysi¹ce stron wyczerpuj¹cej dokumentacji. Ka¿dego dnia adepci sztuki programowania odkrywaj¹ nowe mo¿liwoœci oferowane im przez .NET. Wiele z tych mo¿liwoœci pozostaje jednak wci¹¿ nie odkrytych. Sztuczki i furtki zaszyte przez twórców platformy .NET pozwalaj¹ce na szybsz¹ i sprawniejsz¹ realizacjê projektów czekaj¹ na to, aby ktoœ je zastosowa³ w pracy. Jak dotrzeæ do tych ukrytych cech? Sk¹d wzi¹æ informacje o tym, co jeszcze mo¿na osi¹gn¹æ wykorzystuj¹ znane ju¿ narzêdzia, na temat których napisano setki ksi¹¿ek? Dziêki ksi¹¿ce „.NET. Najpilniej strze¿one tajemnice” poznasz te mo¿liwoœci platformy .NET, których nie opisuje oficjalna dokumentacja. Znajdziesz w niej omówienie niezwykle cennych, ale mniej znanych funkcji Visual Studio i .NET Framework. Ka¿da z tych funkcji mo¿e pomóc Ci podnieœæ wydajnoœæ procesu tworzenia oprogramowania oraz poprawiæ jakoœæ swoich aplikacji. Dowiesz siê, jak wykorzystaæ maksimum mo¿liwoœci œrodowiska programistycznego, wykorzystasz nieznane funkcje GDI+ i ADO.NET i nauczysz siê zasad programowania defensywnego, dziêki któremu znacznie ograniczysz liczbê b³êdów w swoich programach. (cid:129) Zarz¹dzanie wyrywkami kodu w Visual Studio (cid:129) Dostosowywanie skrótów klawiaturowych (cid:129) Praca z kontrolkami Windows Forms (cid:129) Udoskonalone techniki rzutowania (cid:129) Stosowanie komentarzy XML (cid:129) Korzystanie z komponentu Microsoft Data Access Application Block (cid:129) Wyœwietlanie zestawów danych w formacie XML (cid:129) Zapobieganie nieautoryzowanemu dostêpowi do aplikacji (cid:129) Przeprowadzanie testów jednostkowych Wykorzystaj sekrety i skarby ukryte w platformie .NET Spis treści O autorce ......................................................................................... 7 O redaktorze technicznym ................................................................. 8 Wstęp .............................................................................................. 9 Rozdział 1. Ukryte skarby Visual Studio ............................................................ 13 Co zostanie opisane w tym rozdziale? ............................................................................ 13 Rozmieszczanie okien .................................................................................................... 14 Organizowanie urywków kodu ....................................................................................... 19 Zarządzanie listą zadań .................................................................................................. 21 Używanie klawiszy skrótu .............................................................................................. 35 Wykonywanie poleceń Visual Studio ............................................................................. 48 Dostęp do narzędzi zewnętrznych .................................................................................. 50 Co opisano w tym rozdziale? ......................................................................................... 51 Rozdział 2. Windows Forms .............................................................................. 53 Co zostanie opisane w tym rozdziale? ............................................................................ 53 Dokowanie kontrolek w celu uzyskania lepszego układu .............................................. 54 Kotwiczenie kontrolek ................................................................................................... 55 Wyrównywanie kontrolek .............................................................................................. 56 Edytowanie kontrolek przy użyciu klawiatury ............................................................... 58 Środkowanie formularza bez użycia kodu ...................................................................... 58 Iteracyjne przetwarzanie wszystkich kontrolek na formularzu ....................................... 58 Obsługa zdarzeń Enter i Leave ....................................................................................... 60 Korzystanie z właściwości DialogResult ......................................................................... 67 Rysowanie prostych linii ................................................................................................ 69 Dostosowywanie rozmiaru kontrolek do ich zawartości ................................................ 70 Wyświetlanie błędów sprawdzania poprawności przy użyciu kontrolki ErrorProvider ......71 Co opisano w tym rozdziale? ......................................................................................... 73 Rozdział 3. Tajniki kodowania ........................................................................... 75 Co zostanie opisane w tym rozdziale? ............................................................................ 75 Warunkowe operatory logiczne ...................................................................................... 76 Skrócone operatory przypisania ..................................................................................... 78 Zarządzanie łańcuchami przy użyciu klasy StringBuilder .............................................. 80 Deklarowanie zmiennych w pętli ................................................................................... 82 Ścisła konwersja typów danych ...................................................................................... 82 Ulepszone rzutowanie .................................................................................................... 85 6 .Net. Najpilniej strzeżone tajemnice Aliasy typów danych ...................................................................................................... 86 Wyrażenia regularne ....................................................................................................... 87 Przeciążanie procedur ..................................................................................................... 90 Przeciążanie operatorów ................................................................................................. 94 Eksploracja nieodkrytych regionów ............................................................................... 97 Komentarze XML .......................................................................................................... 98 Oznaczanie przestarzałego kodu .................................................................................. 101 Rozwijanie technik debugowania ................................................................................. 103 Co opisano w tym rozdziale? ....................................................................................... 113 Rozdział 4. ADO ............................................................................................. 115 Co zostanie opisane w tym rozdziale? .......................................................................... 115 Praca z bazami danych przy użyciu okna Server Explorer ........................................... 116 Zarządzanie procedurami składowanymi przy użyciu projektu bazodanowego ........... 126 Korzystanie z komponentu Microsoft Data Access Application Block ........................ 134 Konfigurowanie połączenia .......................................................................................... 136 Oglądanie zestawów danych w formacie XML ............................................................ 138 Filtrowanie zestawów danych przy użyciu widoków ................................................... 140 Konstruowanie „inteligentnych” zestawów danych z wykorzystaniem właściwości rozszerzonych .......................................................... 142 Co opisano w tym rozdziale? ....................................................................................... 147 Rozdział 5. Programowanie defensywne .......................................................... 149 Co zostanie opisane w tym rozdziale? .......................................................................... 149 Przewidywanie błędów ................................................................................................. 150 Wdrażanie metodologii projektowej ............................................................................. 150 Zapobieganie nieautoryzowanemu dostępowi do aplikacji .......................................... 155 Weryfikacja danych ...................................................................................................... 159 Przestrzeganie zalecanych praktyk programistycznych ................................................ 163 Zarządzanie błędami w aplikacji .................................................................................. 166 Opracowywanie mechanizmu powiadamiania ............................................................. 174 Wykonywanie testów jednostek ................................................................................... 176 Co opisano w tym rozdziale? ....................................................................................... 178 Skorowidz ..................................................................................... 179 Rozdział 3. Tajniki kodowania Jeśli programujesz już od jakiegoś czasu, zapewne wielokrotnie wykorzystujesz te same wzorce kodowania. Na przykład kod, który przetwarza zdarzenia kontrolki Toolbar, zwykle zawiera instrukcję Case; procedury zdarzeniowe zawierają standardowy blok Try Catch itd. Łatwo popaść w rutynę i koncentrować się na wykonywaniu bieżących zadań do tego stopnia, że brakuje czasu na wypróbowanie innych technik kodowania. Celem tego rozdziału jest przedstawienie kilku trików, dzięki którym kodowanie staje się łatwiejsze, produktywniejsze — po prostu lepsze. Do rozdziału dodano opis kilku technik debugowania — bo po co komu choćby najefektowniejszy, ale błędnie dzia- łający kod? Co zostanie opisane w tym rozdziale? W rozdziale tym przedstawione zostaną następujące tajniki kodowania: (cid:141) warunkowe operatory logiczne, (cid:141) skrócone operatory przypisania, (cid:141) zarządzanie łańcuchami przy użyciu klasy StringBuilder, (cid:141) deklarowanie zmiennych w pętli, (cid:141) ścisła konwersja typów danych, (cid:141) ulepszone rzutowanie, (cid:141) aliasy typów danych, (cid:141) wyrażenia regularne, (cid:141) przeciążanie procedur, (cid:141) przeciążanie operatorów, (cid:141) eksploracja nieodkrytych regionów, 76 .Net. Najpilniej strzeżone tajemnice (cid:141) komentarze XML, (cid:141) oznaczanie przestarzałego kodu, (cid:141) rozwijanie technik debugowania. Po przeczytaniu niniejszego rozdziału będziesz umiał zadziwić kolegów nowymi technikami kodowania. Przekonasz się, że techniki te zwiększą Twoją produktywność i ułatwią pisanie oraz konserwację kodu. Warunkowe operatory logiczne Operatory logiczne porównują dwa wyrażenia (typu prawda — fałsz) i zwracają wynik logiczny. Najczęściej używanymi operatorami logicznymi są iloczyn (And) i suma (Or). Aby wykonać operację w sytuacji, w której spełnione są dwa warunki, użyj operatora iloczynu logicznego (jeśli A jest prawdziwe oraz B jest prawdziwe, to…). Aby wykonać operację, gdy spełniony jest przynajmniej jeden spośród dwóch warunków, posłuż się operatorem sumy logicznej (jeśli A jest prawdziwe lub B jest prawdziwe, to…). Ściśle mówiąc, operator sumy logicznej bada dwa wyrażenia logiczne. Jeśli którekolwiek z nich jest prawdziwe (ma wartość True), operator zwraca True. Jeśli żadne z wyrażeń nie ma wartości True, operator zwraca False. Oto prosty przykład użycia operatora sumy logicznej: jeżeli miejsce przeznaczone na nazwę użytkownika lub hasło jest puste, kod powinien wyświetlić odpowiedni komunikat. W Visual Basicu operatorem sumy logicznej jest słowo Or: If sUserName = Or sPassword = Then MessageBox.Show( Musisz wprowadzić nazwę użytkownika i hasło ) End If W C# operatorem sumy logicznej jest znak |: if (sUserName == | sPassword == ) { MessageBox.Show( Musisz wprowadzić nazwę użytkownika i hasło ); } Operator iloczynu logicznego również bada dwa wyrażenia logiczne. W przypadku gdy oba są prawdziwe (mają wartość True), operator zwraca wartość True. Jeśli jednak jedno wyrażenie jest fałszywe albo też fałszywe są obydwa wyrażenia (mają wartość False), operator zwraca wartość False. Przykład użycia operatora iloczynu logicznego? — jeżeli kolekcja uporządkowanych elementów nie jest pusta oraz liczba elementów jest większa niż zero, można przypisać liczbę właściwości Text pola tekstowego. W Visual Basicu operatorem iloczynu logicznego jest słowo And: With m_dsOrder.Tables(Order.TN_OrderHeader).Rows(0) If Not .IsNull(Order.FN_ITEM_COUNT) And _ CType(.Item(Order.FN_ITEM_COUNT), Int32) 0 Then Rozdział 3. ♦ Tajniki kodowania 77 txtItemCount.Text = .Item(Order.FN_ITEM_COUNT).ToString End If End With W C# operatorem iloczynu logicznego jest znak : DataRow dr = m_dsOrder.Tables[Order.TN_OrderHeader].Rows[0]; If (!dr.IsNull(Order.FN_ITEM_COUNT) System.Convert.ToInt32(dr[Order.FN_ITEM_COUNT]) 0) { txtItemCount.Text = dr[Order.FN_ITEM_COUNT].ToString(); } Ups! Powyższy kod wygeneruje wyjątek, jeśli pole liczby elementów będzie puste. Zarówno w C#, jak i w VB operatory sumy oraz iloczynu logicznego wyznaczają wartość obu wyrażeń. Jeżeli nawet pole liczby elementów jest puste i pierwsze wyrażenie ma wartość False, zostanie zbadane również drugie wyrażenie, co spowoduje zgłoszenie wyjątku błędnego rzutowania (nie można rzutować wartości pustej na liczbę całkowitą). Aby zapobiec temu problemowi, należy skorzystać z warunkowych operatorów logicz- nych, nazywanych również operatorami „zwierającymi”. Operatory te najpierw badają wartość pierwszego wyrażenia, a następnie warunkowo wyznaczają wartość drugiego. W Visual Basicu operatorami „zwierającymi” są słowa AndAlso oraz OrElse. W tym przykładzie użyłbyś operatora AndAlso zamiast And, żeby zapobiec badaniu drugiego wyrażenia, jeśli pierwsze jest prawdziwe: With m_dsOrder.Tables(Order.TN_OrderHeader).Rows(0) If Not .IsNull(Order.FN_ITEM_COUNT) AndAlso _ CType(.Item(Order.FN_ITEM_COUNT), Int32) 0 Then txtItemCount.Text = .Item(Order.FN_ITEM_COUNT).ToString End If End With W C# operatorami „zwierającymi” są znaki oraz ||. W zaprezentowanym przykła- dzie używa się operatora zamiast i zapobiega badaniu drugiego wyrażenia, jeśli pierwsze jest prawdziwe: DataRow dr = m_dsOrder.Tables[Order.TN_OrderHeader].Rows[0]; If (!dr.IsNull(Order.FN_ITEM_COUNT) System.Convert.ToInt32(dr[Order.FN_ITEM_COUNT]) 0) { txtItemCount.Text = dr[Order.FN_ITEM_COUNT].ToString(); } Jest to pozornie niewielka zmiana (And na AndAlso lub na ), ale oferuje wiele korzyści. Nie tylko zwiększa wydajność, lecz także może zapobiegać błędom, takim jak niepra- widłowe rzutowanie. Operatory „zwierające” są warunkowymi wersjami operatorów logicznych. Wyznaczają wartość drugiego wyrażenia w następujących przypadkach: (cid:141) x AndAlso y zawsze wyznacza wartość wyrażenia x, a wartość y bada jedynie wtedy, gdy x jest prawdziwe (Visual Basic); 78 .Net. Najpilniej strzeżone tajemnice (cid:141) x OrElse y zawsze wyznacza wartość wyrażenia x, a wartość y bada jedynie wtedy, gdy x jest fałszywe (Visual Basic); (cid:141) x y zawsze wyznacza wartość wyrażenia x, a wartość y bada jedynie wtedy, gdy x jest prawdziwe (C#); (cid:141) x || y zawsze wyznacza wartość wyrażenia x, a wartość y bada jedynie wtedy, gdy x jest fałszywe (C#). Chcąc zwiększyć wydajność swoich aplikacji, powinieneś używać operatorów „zwie- rających” wszędzie, gdzie to możliwe. Operatory te skracają czas wykonywania pro- gramu, ponieważ mogą pomijać badanie drugiego wyrażenia w zależności od wartości pierwszego. Przejrzyj swoje programy i zastąp operatory logiczne „zwierającymi” wszędzie, gdzie to możliwe. Ponieważ operatory „zwierające” pomijają badanie drugiego wyrażenia, nie używaj ich w przypadkach, gdy drugie wyrażenie wywołuje funkcję, która musi zostać wykonana bez względu na wartość pierwszego wyrażenia. Operatory „zwierające” są szczególnie przydatne podczas pracy z polami bazy danych, gdyż w jednym wyrażeniu warunkowym możesz sprawdzić, czy pole nie jest puste, i zbadać, czy ma konkretną wartość. Pamiętaj o tym triku za każdym razem, gdy będziesz pisał And, Or, lub |. Skrócone operatory przypisania Zarówno w VB, jak i w C# operatorem przypisania jest znak równości (=). Znaku tego używasz wtedy, gdy chcesz przypisać zmiennej wartość pewnego wyrażenia. Aby na przykład obliczyć łączną liczbę produktów w zamówieniu, dodawałbyś kolejno zamawiane produkty do ogólnej sumy. Visual Basic: iOrderItemTotal = iOrderItemTotal + iQuantity C#: iOrderItemTotal = iOrderItemTotal + iQuantity; Możesz jednak oszczędzić sobie pisania, używając skróconej wersji operatora przypisania: +=. Operator ten dodaje wartość wyrażenia do wartości zmiennej i przypisuje wynik tej samej zmiennej. Visual Basic: iOrderItemTotal += iQuantity Rozdział 3. ♦ Tajniki kodowania 79 C#: iOrderItemTotal += iQuantity; Najczęściej używane skrócone operatory przypisania zgromadzono w tabeli 3.1. Tabela 3.1. Skrócone operatory przypisania Operator += -= *= /= = = Opis i przykład Dodaje wartość wyrażenia do wartości zmiennej i przypisuje wynik tej samej zmiennej. x += 4 Zwiększa wartość zmiennej x o 4 i przypisuje wynik zmiennej x. Odejmuje wartość wyrażenia od wartości zmiennej i przypisuje wynik tej samej zmiennej. x -= 3 Zmniejsza wartość zmiennej x o 3 i przypisuje wynik zmiennej x. Mnoży wartość wyrażenia przez wartość zmiennej i przypisuje wynik tej samej zmiennej. x *= 2 Mnoży zmienną x przez 2 i przypisuje wynik zmiennej x. Dzieli wartość zmiennej przez wartość wyrażenia i przypisuje wynik tej samej zmiennej. x /= 4 Dzieli zmienną x przez 4 i przypisuje wynik zmiennej x. Dzieli wartość zmiennej przez wartość wyrażenia i przypisuje zmiennej część całkowitą wyniku. x = 4 Dzieli zmienną x przez 4 i przypisuje wynik zmiennej x, odrzucając resztę z dzielenia. Łączy wyrażenie łańcuchowe ze zmienną łańcuchową i przypisuje wynik tej samej zmiennej. x = świecie Dołącza słowo „świecie” do łańcucha przechowywanego w zmiennej x i przypisuje wynik zmiennej x. Uwagi W C# operator += łączy również wyrażenia łańcuchowe. W VB, jeśli opcja Option Strict jest ustawiona na On, zmienna po lewej stronie (w tym przypadku x) musi być zadeklarowana jako Double. Jeśli opcja Option Strict jest ustawiona na Off, zmienna po lewej stronie zostanie niejawnie przekształcona w typ Double. Tylko VB. Jeśli opcja Option Strict jest ustawiona na On, zmienna musi być typu Byte, Short, Integer lub Long. Jeśli opcja Option Strict jest ustawiona na Off, zmienna zostanie przekształcona w typ Long. Tylko VB. W C# do łączenia łańcuchów używa się operatora +=. W C# operator = przypisuje zmiennej wynik iloczynu logicznego. Więcej informacji można znaleźć w pomocy Visual Studio. 80 .Net. Najpilniej strzeżone tajemnice Więcej informacji o niejawnych konwersjach oraz opcji Option Strict znajdziesz w dalszym podrozdziale „Ścisła konwersja typów danych”. Skrócone operatory przypisania oszczędzają pisania i są efektywniejsze, ponieważ zmienna (x w przykładach z tabeli 3.1) jest szacowana tylko raz. Zarządzanie łańcuchami przy użyciu klasy StringBuilder Łańcuchy są niezmienne. Innymi słowy, raz przypisanego łańcucha nie można zmienić. Kiedy dołączasz jeden łańcuch do drugiego, Visual Studio w rzeczywistości tworzy nowy łańcuch złożony z pierwotnego i dołączonego. Jeśli przypuszczasz, że opóźnia to wykonywanie programu, to masz rację. Łączenie łańcuchów jest zoptymalizowane, więc ograniczone operacje łączenia nie mają zauważalnego wpływu na wydajność aplikacji. Wpływ ten staje się odczuwalny, gdy łączysz wiele łańcuchów, na przykład podczas budowania strony ASP.NET albo treści komunikatu. Visual Basic: Dim sMessage As String = To jest komunikat sMessage = dla użytkownika sMessage = sUserName C#: string Message = To jest komunikat ; sMessage += dla użytkownika ; sMessage += sUserName; Wydawać by się mogło, że w powyższych przykładach tworzony jest łańcuch sMessage, do którego dołączane są kolejne łańcuchy, przez co zmienia się pierwotna zawartość łańcucha sMessage. W rzeczywistości dzieje się coś innego. W pierwszym wierszu przy- kładu tworzony jest łańcuch o zdefiniowanej treści („To jest komunikat”). Zarówno w drugim, jak i w trzecim wierszu łańcuch sMessage jest niszczony (oznaczany przez „odśmiecacz” jako przeznaczony do usunięcia), po czym tworzony jest nowy łańcuch sMessage złożony z pierwotnego i dołączonego. Jeśli łączenie łańcuchów odbywa się w jednej instrukcji, łańcuch nie jest niszczony między kolejnymi dołączeniami, więc wydajność programu nie zmniejsza się. Visual Basic: Dim sMessage As String = To jest komunikat dla użytkownika sUserName C#: string sMessage = To jest komunikat + dla użytkownika + sUserName; Rozdział 3. ♦ Tajniki kodowania 81 Jednakże podczas łączenia wielu długich łańcuchów albo budowania całej zawartości strony ASP.NET użycie pojedynczego przypisania może być niepraktyczne (albo nie- czytelne). Aby zminimalizować wpływ łączenia łańcuchów na wydajność aplikacji, możesz użyć klasy StringBuilder. Klasa ta tworzy obiekt przypominający łańcuch, który jednak może być modyfikowany. Kiedy dokonasz wszystkich żądanych zmian, możesz przekształcić zawartość obiektu StringBuilder w rzeczywisty łańcuch. Visual Basic: Imports System.Text Dim sbMessage As StringBuilder sbMessage = New StringBuilder( To jest komunikat ) sbMessage.Append( dla użytkownika ) sbMessage.Append(sUserName) Dim sMessage As String = sbMessage.ToString C#: using System.Text; StringBuilder sbMessage = new StringBuilder( To jest komunikat ); sbMessage.Append( dla użytkownika ); sbMessage.Append(sUserName); string sMessage = sbMessage.ToString(); Ten przykładowy kod tworzy instancję klasy StringBuilder. Potem używa metody Append klasy StringBuilder, aby dołączyć kolejne łańcuchy tekstu. Po połączeniu wszystkich łańcuchów metoda ToString przekształca obiekt StringBuilder w typ String. Klasa StringBuilder zawiera inne metody, takie jak Insert i Replace, które przeprowadzają różne operacje na łańcuchu. Klasa StringBuilder zapewnia efektywniejsze łączenie łańcuchów, ponieważ tworzy bufor na tyle duży, aby mógł pomieścić pierwotny łańcuch i zostawić miejsce na jego rozszerzanie. Jeśli jednak dołączane łańcuchy zajmą całe miejsce w buforze, trzeba będzie go powiększyć, a to spowoduje spadek wydajności. Żeby jeszcze bardziej zwiększyć wydajność, użyj metody EnsureCapacity klasy StringBuilder. Metoda ta umożliwia ustawienie rozmiaru bufora StringBuilder na przewidywaną długość końcowego łańcucha. Obiekt StringBuilder nie będzie musiał powiększać bufora, co pozwoli uniknąć spadku wydajności. Inicjalizowanie obiektu StringBuilder wymaga więcej czasu niż tworzenie łańcucha, więc nie ma sensu używać go w przypadku łączenia zaledwie kilku łańcuchów. Ogólnie mówiąc, punktem granicznym jest liczba pięć. Jeśli łączysz więcej niż pięć łańcuchów, StringBuilder zwykle bywa wydajniejszy. W sytuacji, w której obsługa łańcuchów w programie musi być jak najwydajniesza, jedyny sposób sprawdzenia, czy szybsze jest łączenie łańcuchów, czy też użycie obiektu StringBuilder, to przeprowadzenie testów wydajności. 82 .Net. Najpilniej strzeżone tajemnice Jeśli kiedykolwiek zauważysz wiele łączeń łańcuchów w swoim kodzie, rozważ użycie klasy StringBuilder w celu uzyskania większej wydajności. Deklarowanie zmiennych w pętli Niegdyś większość podręczników kodowania zalecała deklarowanie wszystkich zmien- nych metody na samym jej początku. Takie działanie może jednak powodować pro- blemy w przypadku zmiennych, które są definiowane tylko na użytek pętli i używane w innym miejscu metody. Obecnie zaleca się deklarować zmienne pętli jak najbliżej miejsca, w którym zostaną użyte. Najprostszym sposobem zadeklarowania zmiennej pętli jest zdefiniowanie jej w samym kodzie pętli. Możesz to zrobić w przypadku dowolnej pętli For lub For Each. Oto przykład pętli For Each w Visual Basicu: For Each ctrl As Control In pnl.Controls ... Next A oto pętla for w języku C#: for (int i = 1; i = 5; i++) { sResponse = i + sCustomerName; ... } Deklarując te zmienne w konstrukcji pętli, zyskujesz pewność, że nie zostaną one przy- padkowo użyte w innym miejscu metody. Ścisła konwersja typów danych Nie zawsze dane należą do typu, który jest potrzebny w programie. Przypuśćmy, że Twoja aplikacja pobiera liczbę całkowitą z bazy danych i ma wyświetlić ją w kontrolce TextBox. Właściwość Text kontrolki TextBox wymaga łańcucha, więc liczbę całkowitą trzeba najpierw przekształcić w łańcuch. Bywa też, że masz krótką liczbę całkowitą, a jakaś metoda wymaga długiej, więc konieczne jest jej przekształcenie. Niektóre konwersje w .NET są wykonywane automatycznie. Nazywamy je konwersjami niejawnymi, ponieważ nie musimy dokonywać ich jawnie w kodzie. Zarówno w VB, jak i w C# niejawnie wykonywane są konwersje rozszerzające. Za- chodzą one podczas przekształcania typu mniejszego w większy, zwykle bez utraty informacji. Na przykład, przekształcanie krótkiej liczby całkowitej w długą to konwersja rozszerzająca, obsługiwana automatycznie przez VB i C#. Rozdział 3. ♦ Tajniki kodowania 83 Visual Basic: Dim i As Int16 Dim j As Int32 i = 7 j = i C#: Int16 i; Int32 j; i = 7; j = i; Zwróć uwagę, że w obu tych przykładach niepotrzebne jest rzutowanie czy przekształ- canie typów. .NET obsługuje takie konwersje automatycznie. Do konwersji zawężających dochodzi podczas przekształcania typu większego w mniej- szy, na przykład długiej liczby całkowitej w krótką. Konwersje zawężające mogą prowadzić do utraty informacji, więc zwykle wymagają przekształcenia jawnego, co znaczy, że aplikacja musi definiować sposób konwersji. Visual Basic: Dim i As Int16 Dim j As Int32 j = 7 i = CType(j, Int16) C#: Int16 i; Int32 j; j = 7; i = (Int16)j; W powyższych przykładach kod VB używa funkcji CType, a kod C# — operatora kon- wersji, żeby jawnie przekształcić wartość na węższy typ danych. Jawna konwersja wymagana jest ponadto w trakcie przekształcania niespokrewnionych typów danych, na przykład liczb całkowitych w łańcuchy. Visual Basic: Dim x As Int32 txtUserName.Text = x.ToString C#: Int32 x; txtUserName.Text = x.ToString(); W tych przykładach wywołano metodę ToString, aby jawnie wykonać konwersję. 84 .Net. Najpilniej strzeżone tajemnice Domyślnie VB próbuje niejawnie przekształcać większość typów danych, wykonując konwersje zawężające a także konwersje między niespokrewnionymi typami. W zwy- kłych okolicznościach pokazane wcześniej przykłady VB nie wymagały jawnej kon- wersji. Ponieważ VB wykonuje je niejawnie, nie masz kontroli nad przekształcaniem typów. Może to prowadzić do błędów w programie. C# nie wykonuje niejawnie konwersji zawężających ani konwersji między niespo- krewnionymi typami danych. Dużo lepiej jest samodzielnie przekształcać typy danych. Możesz to wymusić, używając instrukcji Option Strict. Dodaj ją na początku każdego pliku kodu VB: Option Strict On Instrukcja Option Strict musi pojawiać się w kodzie przed wszystkimi pozostałymi. Kiedy opcja Strict jest ustawiona na On, będziesz musiał jawnie przekształcać lub rzutować typy danych w przypadku konwersji zawężających i konwersji między niespo- krewnionymi typami. Otrzymasz komunikat o błędzie składniowym, jeśli w kodzie znajdzie się którakolwiek z poniższych konstrukcji: (cid:141) konwersje zawężające bez operatora rzutowania; (cid:141) późne wiązanie (kiedy wynikiem wywołania metody jest typ Object, a nie konkretny typ danych, wywołanie nazywamy późno wiązanym); (cid:141) operacje na typie Object inne niż =, , TypeOf...Is oraz Is; (cid:141) pominięcie klauzuli As w deklaracji. Możesz ustawić opcję Strict na On dla całego projektu na zakładce Build okna dialo- gowego Property Pages (rysunek 3.1). Rysunek 3.1. Opcja Strict jest domyślnie wyłączona. Włącz ją w oknie dialogowym Property Pages, aby wymusić ścisłą konwersję typów (tylko Visual Basic) Rozdział 3. ♦ Tajniki kodowania 85 Jeśli używasz Visual Basica, możesz wymusić ścisłą konwersję typów w całym kodzie, dodając instrukcję Option Strict do każdego pliku kodu albo ustawiając opcję Option Strict we właściwościach każdego projektu. Ulepszone rzutowanie Konieczność rzutowania zachodzi wówczas, gdy masz zmienną, którą trzeba prze- kształcić w inny typ danych, jak to opisano w poprzednim podrozdziale. Ponieważ .NET Framework używa wielu wartości typu Object, często potrzebne jest rzutowanie typu Object na konkretny typ. W Visual Basicu najlepszym sposobem rzutowania typu Object na konkretny typ jest użycie instrukcji DirectCast: Private Sub txt_Enter(ByVal sender As Object, _ ByVal e As System.EventArgs) Handles txtUserName.Enter DirectCast(sender, TextBox).BackColor = Color.BlanchedAlmond End Sub W tym przykładzie instrukcja DirectCast rzutuje zmienną sender (typu Object) na typ TextBox, co pozwala uzyskać dostęp do właściwości kontrolki TextBox. Instrukcja DirectCast działa wydajniej niż CType podczas rzutowania obiektu na bardziej specyficzny typ, ponieważ nie używa funkcji pomocniczych wywoływanych w czasie działania programu. Instrukcji DirectCast możesz używać tylko w przypadku rzutowania typu na pokrew- ny, ale bardziej specyficzny typ, nazywany typem pochodnym. Możesz, na przykład, rzutować typ Control na TextBox, ponieważ TextBox wywodzi się z Control. Nie możesz użyć instrukcji DirectCast do przekształcenia liczby całkowitej w łańcuch, ponieważ typ String nie wywodzi się z typu Integer. Zawsze możesz używać jej do przekształ- cania typu Object w każdy inny typ, ponieważ wszystkie typy wywodzą się z typu Object. Operator DirectCast zgłasza wyjątek InvalidCastException, jeśli docelowy typ nie wywodzi się z przekształcanego. Choć w C# nie ma bezpośredniego odpowiednika instrukcji DirectCast, istnieje operator, który przekształca kompatybilne typy danych: private void txt_Enter(object sender, System.EventArgs e) { TextBox tb = sender as TextBox; tb.BackColor = Color.BlanchedAlmond; } 86 .Net. Najpilniej strzeżone tajemnice Operator as przypomina DirectCast, ale różni się od niego pod jednym ważnym wzglę- dem: nie zgłasza wyjątku, kiedy nie może przeprowadzić rzutowania, lecz zwraca wartość null. Operator as nie może rzutować na typy wartościowe, takie jak Int, lecz tylko na typy referencyjne. W nadchodzącej wersji Visual Studio 2005 Visual Basic prawdopodobnie będzie zawierać nowy operator równoważny operatorowi as języka C#. Obecnie nosi on nazwę TryCast. Operator ten próbuje rzutowania, a jeśli operacja się powiedzie, zwraca wartość przekształconą w żądany typ. Jeśli operacja się nie powiedzie, zwraca wartość Nothing. Aliasy typów danych Kolejnym tajnikiem kodowania jest używanie aliasów typów danych. Jeśli zamierzasz użyć jakiegoś typu, ale spodziewasz się, że w przyszłości będziesz musiał zastąpić go innym, zdefiniuj alias typu danych i posługuj się nim w pozostałej części kodu. Przypuśćmy, że chcesz użyć typu Int16, ale nie wykluczasz, że później zmienisz go na Int32. Zdefiniuj alias typu Int16 w opisany niżej sposób. Visual Basic: Imports ChangeableType = System.Int16 C# using ChangeableType = System.Int16; Następnie we wszystkich miejscach, w których użyłbyś typu Int16, zastąp go nowo zdefiniowanym aliasem. Visual Basic: Private m_iSomething As ChangeableType Debug.WriteLine(m_iSomething.GetTypeCode) C#: ChangeableType m_iSomething; Debug.WriteLine(m_iSomething.GetTypeCode); Jeśli później zdecydujesz się wykorzystać typ Int32, po prostu zmień alias, a w pozostałej części kodu będzie obowiązywał nowy typ. Visual Basic: Imports ChangeableType = System.Int32 C# using ChangeableType = System.Int32; Rozdział 3. ♦ Tajniki kodowania 87 Technikę tę najczęściej stosuje się w przypadkach, gdy nazwy pewnych klas są nieznane, ponieważ pisze je inny programista. Tworzysz więc namiastkę klasy, definiujesz alias nazwy klasy i możesz uruchomić swoją aplikację. Kiedy otrzymasz nową klasę, wystar- czy, że wstawisz ją w miejsce namiastki i zmienisz nazwę klasy w aliasie. Wyrażenia regularne Wyrażenie regularne to wzorzec, który pozwala sprawdzić, czy pewna wartość (zwykle łańcuch) odpowiada specyficznym kryteriom. Przy użyciu wyrażenia regularnego możesz na przykład sprawdzić, czy numer telefonu zawiera wyłącznie cyfry albo prawidłową kombinację cyfr, nawiasów i myślników. Jest to szczególnie przydatne podczas spraw- dzania poprawności danych wpisanych przez użytkownika. Wyrażenia regularne przydają się też do zastępowania lub usuwania części łańcucha, które pasują do pewnego wzorca, na przykład do usuwania wszystkich znaków specjalnych z łańcucha. Wyrażeń regularnych najlepiej uczyć się, wykorzystując przykłady. Dzięki temu po- znajesz ogólne zasady tworzenia wyrażeń regularnych i używania ich w kodzie. Warto też jednak zrozumieć, jak budować wyrażenia regularne przy użyciu odpowiedniej składni. W kolejnych punktach najpierw zostaną przedstawione przykłady zastosowania wy- rażeń regularnych w rzeczywistych aplikacjach, a następnie szczegółowe informacje o samodzielnym budowaniu takich wyrażeń. Używanie wyrażeń regularnych Jednym z najczęstszych zastosowań wyrażeń regularnych jest weryfikowanie danych wprowadzonych przez użytkownika. W poniższych podpunktach podano przykłady sprawdzania poprawności numerów PESEL, kodów pocztowych oraz numerów identy- fikacji podatkowej (NIP). Numery PESEL Zacznijmy od prostego przykładu: możesz użyć wyrażeń regularnych do sprawdzenia, czy łańcuch zawiera wyłącznie wartości liczbowe. Za pomocą tej techniki upewnisz się, czy numer PESEL wprowadzony przez użytkownika zawiera wyłącznie cyfry. Zamiast korzystać z wyrażeń regularnych, mógłbyś wykonać ten test za pomocą funkcji IsNumeric Visual Basica, która sprawdza, czy wyrażenie można przekształcić w liczbę. Aby wykorzystać tę funkcję z poziomu C#, dodaj referencję do biblioteki Microsoft.VisualBasic.dll. Chcąc sprawdzić, czy dany łańcuch zawiera tylko cyfry, użyj następującego wzorca: ^d+$ 88 .Net. Najpilniej strzeżone tajemnice Daszek (^) wskazuje, że dopasowywanie wzorca powinno rozpocząć się od pierwszego znaku łańcucha wpisanego przez użytkownika. Symbol d definiuje cyfrę (0–9). Znak plusa (+) wymaga, aby poprzedzający go znak pojawiał się jeden raz lub więcej razy; w tym przypadku oznacza to jedną cyfrę lub więcej cyfr. Znak dolara ($) wskazuje, że dopasowywanie wzorca powinno zakończyć się na ostatnim znaku łańcucha wpisanego przez użytkownika. Dodatkowe informacje o znakach używanych w wyrażeniach regu- larnych znajdziesz w tabeli 3.2 w dalszej części rozdziału. Przestrzeń nazw System.Text.RegularExpressions w .NET Framework oferuje zbiór funkcji, które pomagają w pracy z wyrażeniami regularnymi. Możesz wykorzystać te funkcje do dopasowywania wzorców i zastępowania znaków przy użyciu wyrażeń regu- larnych. Dzięki poniższym przykładom dowiesz się, jak sprawdzić, czy numer PESEL wpisany przez użytkownika zawiera wyłącznie cyfry. Visual Basic: Imports System.Text.RegularExpressions Dim sRegExPattern As String = ^d+$ Dim sTextToValidate As String = txtPesel.Text If Not Regex.IsMatch(sTextToValidate, sRegExPattern) Then epValidation.SetError(ctrl, Numer PESEL musi składać się wyłącznie z cyfr. ) End if C#: using System.Text.RegularExpressions; string sRegExPattern = @ ^d+$ ; string sTextToValidate = txtPesel.Text; if(!Regex.IsMatch(sTextToValidate, sRegExPattern)) { epValidation.SetError(ctrl, Numer PESEL musi składać się wyłącznie z cyfr. ); } Metoda IsMatch klasy Regex zwraca True, jeśli tekst pasuje do zdefiniowanego wzorca. Jeśli metoda IsMatch zwróci False, kontrolka ErrorProvider powiadamia użytkownika o błędzie (jeśli nie miałeś do czynienia z kontrolką ErrorProvider, zajrzyj do odpo- wiedniego podrozdziału w rozdziale 2.). Mógłbyś uogólnić kod w podanych przykła- dach tak, aby porównywać dowolny wzorzec wyrażenia regularnego (zdefiniowany w zmiennej sRegExPattern) z dowolnym łańcuchem (zdefiniowanym w zmiennej sTextToValidate). Zwróć uwagę na znak at (@) we wzorcu wyrażenia regularnego w kodzie C#. Zapo- biega on przetwarzaniu znaków specjalnych przez kompilator C#. Kody pocztowe Kolejnym, często spotykanym wzorcem, jest kod pocztowy w postaci xx-xxx. Opisana poniżej technika może przydać się nie tylko do weryfikowania kodów pocztowych, ale również innych wzorców liczbowych, takich jak numery klienta albo dostawcy. Rozdział 3. ♦ Tajniki kodowania 89 Aby sprawdzić, czy wpisany kod pocztowy składa się z dwóch cyfr, myślnika i trzech cyfr, użyj poniższego wzorca: ^d{2}-d{3}$ Wzorzec ten rozpoczyna dopasowywanie od początku łańcucha (^), dopasowuje dwie cyfry (d{2}), myślnik (-) i trzy cyfry (d{3}), i kończy dopasowywanie na końcu łań- cucha ($). Wykorzystując ten wzorzec w swojej aplikacji, zastosuj kod podobny do tego, który weryfikuje numery PESEL (zamieszczony w poprzednim punkcie) i podaj kod pocztowy jako wyrażenie regularne. Numery telefoniczne Aplikacja przetwarzająca informacje kontaktowe albo dane klientów lub pracowników powinna sprawdzać poprawność numerów telefonicznych. Kłopot z numerami telefo- nicznymi polega na tym, że użytkownicy nigdy nie są pewni, czy i gdzie mają wpisywać nawiasy, spacje, myślniki albo inne znaki specjalne. Zanim więc sprawdzisz popraw- ność numeru telefonicznego, musisz usunąć z niego wszystkie nadmiarowe znaki. Oto wyrażenie regularne dopasowujące standardowy numer telefoniczny (dwie cyfry numeru kierunkowego i siedem cyfr numeru lokalnego): ^d{9}$ Daszek (^) i znak dolara ($) określają, czy do wzorca pasuje cały łańcuch, a symbol d{9} wskazuje ciąg 9 cyfr. Przed sprawdzeniem poprawności numeru musisz usunąć z niego wszystkie znaki spe- cjalne wpisane przez użytkownika. Służy do tego metoda Replace klasy Regex. Kod, który usuwa znaki specjalne, a następnie sprawdza poprawność numeru, przypomina kod z poprzedniego przykładu, ale zawiera dodatkowy wiersz przeznaczony do zastą- pienia znaków. Visual Basic: Imports System.Text.RegularExpressions Dim sRegExPattern As String = ^d{9}$ Dim sTextToValidate As String = txtPhone.Text sTextToValidate = Regex.Replace(sTextToValidate, [^0-9] , ) If Not Regex.IsMatch(sTextToValidate, sRegExPattern) Then epValidation.SetError(ctrl, Numer telefoniczny musi zawierać 9 cyfr. ) End if C#: using System.Text.RegularExpressions; string sRegExPattern = @ ^d{9} ; string sTextToValidate = txtPhone.Text; sTextToValidate = Regex.Replace(sTextToValidate, [^0-9] , ); 90 .Net. Najpilniej strzeżone tajemnice if(!Regex.IsMatch(sTextToValidate, sRegExPattern)) { epValidation.SetError(ctrl, Numer telefoniczny musi zawierać 9 cyfr. ); } Powyższy kod używa metody Replace klasy Regex, aby każdy znak nienumeryczny, zdefiniowany jako nienależący do zakresu 0–9 ([^0-9]), zastąpić łańcuchem pustym. Powoduje to usunięcie wszystkich nadmiarowych znaków. Potem kod używa metod IsMatch, aby sprawdzić, czy wynikowy łańcuch pasuje do wzorca numeru telefonicznego. Budowanie wyrażeń regularnych Kiedy poznasz ogólne zasady użycia wyrażeń regularnych, łatwiej będzie Ci zrozumieć, jak budować własne. Większość znaków w wyrażeniu regularnym to zwykłe znaki. Niektóre są szczególnie istotne dla mechanizmu przetwarzającego wyrażenia regularne, więc trzeba je poprzedzać znakiem unikowym — lewym ukośnikiem () — w sposób zaprezentowany w tabeli 3.2. Wszystkie zwykłe znaki (bez znaku unikowego) pasują do samych siebie, z wyjątkiem znaków specjalnych zdefiniowanych w tabeli 3.3. Aby użyć znaków specjalnych, należy poprzedzić je znakiem unikowym. Na przykład, w celu dopasowania łańcucha (nnn) należy użyć wzorca ^(d{3})$. Rozpoczyna on dopasowywanie od początku łańcucha, dopasowuje lewy nawias okrągły, trzy cyfry oraz prawy nawias okrągły i kończy dopa- sowywanie na końcu łańcucha. Przeciążanie procedur To właściwie nie jest żaden sekret; jeśli programujesz, prawdopodobnie przeciążasz procedury. Jeśli nie, oto szybkie wprowadzenie. Przeciążanie polega na definiowaniu wielu procedur, konstruktorów albo właściwości, które mają takie same nazwy, ale inne sygnatury. Podstawowym celem przeciążania jest zaoferowanie wielu zbiorów parametrów, których można użyć do wykonania jakiejś operacji. Przypuśćmy, że klasa Customer ma metodę Retrieve. Załóżmy, że chcemy pobierać wszystkie kluczowe dane klientów w celu umieszczenia ich na liście rozwijanej, wszyst- kie kluczowe dane klientów z określonego regionu w celu umieszczenia ich na filtrowanej liście rozwijanej oraz wszystkie dane określonego klienta według jego identyfikatora. Moglibyśmy osiągnąć ten cel na kilka różnych sposobów: utworzyć trzy różne metody z różnymi nazwami, utworzyć jedną metodę z parametrami opcjonalnymi albo utworzyć trzy metody o takiej samej nazwie, ale różnych sygnaturach. Ta ostatnia technika wyko- rzystuje przeciążanie procedur (lub metod). Rozdział 3. ♦ Tajniki kodowania 91 Tabela 3.2. Znaki używane w wyrażeniach regularnych Znak Dopasowuje granicę słowa  B  d D e f s S v w W środek słowa znak cofania cyfry od 0 do 9 znak inny niż cyfra znak escape znak wysuwu strony znak nowego wiersza znak powrotu karetki spację znak inny niż spacja znak tabulacji znak tabulacji pionowej dowolny znak alfanumeryczny łącznie ze znakiem podkreślenia dowolny znak niealfanumeryczny Przykład na dopasowuje ciąg na znajdujący się na początku słowa, na przykład „Chodź tu natychmiast”. na dopasowuje ciąg na znajdujący się na końcu słowa, na przykład „Pierwsza zmiana”. na dopasowuje tylko całe słowo na, na przykład „Czas na zmianę”. Bna dopasowuje słowo na znajdujące się gdziekolwiek z wyjątkiem początku słowa, na przykład „To znajduje się w tym”.  reprezentuje znak cofania w zbiorze zdefiniowanym w nawiasie kwadratowym [] (zobacz tabela 3.3). Używa się go przede wszystkim we wzorcach zastępowania. d dopasowuje pierwszą cyfrę w łańcuchu, na przykład „444B Privet Drive”. D dopasowuje pierwszy znak inny niż cyfra w dowolnym miejscu łańcucha, na przykład „444B Privet Drive”. e reprezentuje znak escape w zbiorze zdefiniowanym w nawiasie kwadratowym [] (zobacz tabela 3.3). Używa się go przede wszystkim we wzorcach zastępowania. f reprezentuje znak wysuwu strony w zbiorze zdefiniowanym w nawiasie kwadratowym [] (zobacz tabela 3.3). Używa się go przede wszystkim we wzorcach zastępowania. reprezentuje znak nowego wiersza w zbiorze zdefiniowanym w nawiasie kwadratowym [] (zobacz tabela 3.3). Używa się go przede wszystkim we wzorcach zastępowania. reprezentuje znak powrotu karetki w zbiorze zdefiniowanym w nawiasie kwadratowym [] (zobacz tabela 3.3). Używa się go przede wszystkim we wzorcach zastępowania. s dopasowuje pierwszą spację, na przykład „444B Privet Drive”. S dopasowuje pierwszy znak inny niż spacja, na przykład „444B Privet Drive”. reprezentuje znak tabulacji w zbiorze zdefiniowanym w nawiasie kwadratowym [] (zobacz tabela 3.3). Używa się go przede wszystkim we wzorcach zastępowania. v reprezentuje znak tabulacji pionowej w zbiorze zdefiniowanym w nawiasie kwadratowym [] (zobacz tabela 3.3). Używa się go przede wszystkim we wzorcach zastępowania. w dopasowuje pierwszy znak alfanumeryczny lub znak podkreślenia, na przykład „444B Privet Drive”. W dopasowuje pierwszy znak niealfanumeryczny albo znak podkreślenia, na przykład „444B Privet Drive”. 92 .Net. Najpilniej strzeżone tajemnice Tabela 3.3. Znaki specjalne używane w wyrażeniach regularnych . [...] Znak Dopasowuje dowolny znak z wyjątkiem znaku nowego wiersza ( ) zbiór określonych znaków zbiór znaków innych niż określone zbiór określonych zakresów znaków [^... ] [a- bm-n] * + ? {n} {n,} {n,m} ^ $ a|b poprzedni znak zero lub większą ilość razy poprzedni znak jeden lub większą ilość razy poprzedni znak zero lub jeden raz poprzedni znak dokładnie n razy poprzedni znak n lub większą ilość razy poprzedni znak co najmniej n i najwyżej m razy wzorzec występujący na początku łańcucha wzorzec występujący na końcu łańcucha a lub b Przykład . dopasowuje dowolny znak, na przykład „444B Privet Drive”. Często używa się go, aby sprawdzić, czy użytkownik wpisał jakieś dane w polu. [ABC] dopasowuje pierwsze wystąpienie litery a, b lub c, na przykład „444B Privet Drive”. [^ABC] dopasowuje pierwsze wystąpienie litery innej niż a, b lub c, na przykład „444B Privet Drive”. [0-9a-kA-K] dopasowuje pierwsze wystąpienie jakiekolwiek cyfry z zakresu 0 – 9, małej litery z zakresu a – k lub wielkiej litery z zakresu A – K, na przykład „444B Privet Drive”. d* dopasowuje cały ciąg cyfr, na przykład „444B Privet Drive”. d* dopasowuje cały ciąg cyfr, na przykład „444B Privet Drive”. d? dopasowuje ciąg składający się z zera cyfr lub jednej cyfry, na przykład „444B Privet Drive”. d{2} dopasowuje ciąg składający się z dokładnie 2 cyfr, na przykład „444B Privet Drive”. d{2,} dopasowuje ciąg składający się z 2 lub większej ilości cyfr, na przykład „444B Privet Drive”. d{1,3} dopasowuje ciąg składający się z co najmniej 1 i najwyżej 3 cyfr, na przykład „444B Privet Drive”. ^4 dopasowuje cyfrę 4, jeśli występuje ona na początku łańcucha, na przykład „444B Privet Drive”. $Drive dopasowuje słowo Drive, jeśli występuje ono na końcu łańcucha, na przykład „444B Privet Drive”. P | Q dopasowuje P lub Q, na przykład „444B Privet Drive”. Nadanie wszystkim trzem metodom tej samej nazwy ułatwia ich wykorzystanie. Prze- ciążanie jest również lepsze od parametrów opcjonalnych, ponieważ sygnatury metod są jednoznaczne (poza tym parametry opcjonalne są niedostępne w C#). Korzystanie z przeciążania nie wymaga żadnych specjalnych technik ani słów kluczo- wych; wystarczy, że utworzysz dwie procedury lub większą ich ilość o tej samej nazwie i różnych zbiorach parametrów. Visual Basic: Public Function Retrieve() As DataSet Pobiera kluczowe dane wszystkich klientów End Function Public Function Retrieve(ByVal sRegion As String) As DataSet Pobiera kluczowe dane wszystkich klientów z określonego regionu End Function Rozdział 3. ♦ Tajniki kodowania 93 Public Function Retrieve(ByVal iCustomerID As Int32) As DataSet Pobiera wszystkie dane określonego klienta End Function C#: public DataSet Retrieve() { // Pobiera kluczowe dane wszystkich klientów } public DataSet Retrieve(String sRegion) { // Pobiera kluczowe dane wszystkich klientów z określonego regionu } public Retrieve(Int32 iCustomerID) { // Pobiera wszystkie dane określonego klienta } Każda z tych procedur ma inną sygnaturę. Pierwsza metoda nie przyjmuje żadnych parametrów, druga przyjmuje pojedynczy łańcuch, a trzecia liczbę całkowitą. Możesz zdefiniować dowolnie wiele przeciążonych procedur z różnymi kombinacjami typów parametrów. W niektórych przypadkach, jak w powyższym przykładzie, kod przeciążonych metod jest różny. Bywa jednak i tak, że metody są bardzo podobne — możesz wtedy umieścić wspólny kod w jednej metodzie i wywoływać ją z pozostałych metod z odpo- wiednimi parametrami. Kiedy wywołujesz przeciążoną metodę, środowisko uruchomieniowe wybiera odpo- wiednią wersję na podstawie parametrów określonych w wywołaniu. Jeśli na przykład wywołasz metodę Retrieve i przekażesz parametr w postaci liczby całkowitej, zostanie wykonana ta wersja metody Retrieve, która przyjmuje parametr całkowity. Przeciążanie rządzi się pewnymi regułami. Najbardziej oczywista jest ta, że procedury muszą mieć taką samą nazwę. Sygnatury metod (typy danych parametrów) muszą się różnić, ponieważ w przeciwnym razie środowisko uruchomieniowe nie mogłoby ustalić, którą wersję metody należy wykonać. Nie możesz na przykład napisać dwóch metod o nazwie Retrieve, z których każda przyjmuje pojedynczy parametr w postaci łańcucha. Do odróżniania metod nie możesz też wykorzystać: (cid:141) typu wartości zwracanej przez metodę, (cid:141) sposobu przekazywania parametrów — przez wartość (ByVal) albo przez referencję (ByRef). Przeciążanie procedur ułatwia pisanie i konserwację programów. Poza tym upraszcza sposób korzystania z metod. 94 .Net. Najpilniej strzeżone tajemnice Przyjrzyj się swoim programom i zastanów się, w których miejscach możesz wyko- rzystać przeciążanie. Dobrymi „kandydatami” są tu metody z parametrami opcjo- nalnymi a także procedury wykonujące podobne zadania, ale o innych zbiorach parametrów i różnych nazwach. Przeciążanie operatorów Przeciążanie operatorów to jedna z tych funkcji, które rzadko są potrzebne, ale jeśli już, to naprawdę. Obecnie przeciążanie operatorów jest dostępne tylko w C# (choć w nowym Visual Studio 2005 Visual Basic również ma je obsługiwać). Przeciążanie operatorów polega na definiowaniu operatorów, takich jak +, - i *, dla własnych typów danych. Pozwala to manipulować obiektami przy użyciu standardowych operatorów i ułatwia pracę z samodzielnie zdefiniowanymi typami danych. Rozważmy aplikację, która przetwarza ceny podane w walutach obcych. Typ danych Price pozwala przechowywać kwoty wyrażone w dowolnej walucie. Jeśli przeciążymy operatory matematyczne dla typu danych Price, będziemy mogli manipulować cenami w różnych walutach. Zważywszy na globalizację współczesnej gospodarki, taka funkcja byłaby bardzo przydatna. Typ danych Price to struktura złożona z kilku pól: public struct Price { public float Amount; public string CurrencyCode; public float ExchangeRateWRTUSD; } Pole Amount definiuje kwotę w zdefiniowanej walucie. Pole CurrencyCode to trzyliterowy kod waluty, na przykład USD (dolar amerykański), PLN (złoty) lub EUR (euro). W rzeczywistej aplikacji wystarczyłyby pola Amount i CurrencyCode. Program używałby pola CurrencyCode do wyszukania odpowiednich kursów wymiany w tabeli (jeśli aktual- ność informacji nie jest wymagana) albo pobrania ich z usługi (jeśli informacje muszą być aktualne). Jednakże pisanie kodu przeszukującego tabele albo łączącego się z usługą sieciową odciągnęłoby nas od tematu niniejszego podrozdziału: przeciążania operatorów. Dlatego do typu danych Price dodano trzecie pole, które określa kurs wymiany. Jak wiadomo, każda waluta ma pewien kurs wymiany w odniesieniu do każdej innej. Standardowy sposób manipulowania cenami wyrażonymi w różnych walutach polega na znalezieniu ich kursu wymiany, przekształceniu jednej waluty w drugą i wykonaniu operacji. Rozdział 3. ♦ Tajniki kodowania 95 Niestety, w przedstawionym niżej przykładzie nie można z góry określić, w jaką walutę trzeba będzie przekształcać poszczególne obiekty Price. Nie wystarczy więc zdefinio- wanie pojedynczego kursu wymiany dla typu danych Price; trzeba by przechowywać w nim kursy wymiany dla wszystkich możliwych walut. W takiej sytuacji lepiej jest zdefiniować walutę bazową. Typ danych Price ma poje- dyncze pole, które przechowuje kurs wymiany w odniesieniu do waluty bazowej. Apli- kacja przekształca każdą kwotę w walutę bazową, wykonuje operację, a następnie przekształca wynik z powrotem w żądaną walutę. W tym przykładzie wybrano dolara amerykańskiego, ale mogłaby to być każda inna waluta. Konstruktor typu danych Price ustawia wartości pól i umożliwia utworzenie obiektu Price z odpowiednimi danymi. public Price(float fAmount, string sCurrencyCode, float fExchangeRateWRTUSD) { this.Amount = fAmount; this.CurrencyCode = sCurrencyCode; this.ExchangeRateWRTUSD = fExchangeRateWRTUSD; } Przeciążanie operatorów matematycznych Aby umożliwić dodawanie cen, moglibyśmy zdefiniować metodę Add, która przyjmo- wałaby dwa obiekty Price. Bardziej intuicyjne byłoby jednak dodawanie dwóch cen przy użyciu operatora +. Właśnie do tego służy przeciążanie operatorów. Aby przeciążyć operator, należy zdefiniować statyczną metodę ze słowem kluczowym operator: public static Price operator +(Price p1, Price p2) { Price p3; if (p1.ExchangeRateWRTUSD == p2.ExchangeRateWRTUSD) { p3 = new Price(p1.Amount+p2.Amount, p1.CurrencyCode,p1.ExchangeRateWRTUSD); } else { float p1InUSD = p1.Amount * p1.ExchangeRateWRTUSD; float p2InUSD = p2.Amount * p2.ExchangeRateWRTUSD; float p3Converted = (p1InUSD + p2InUSD) / p1.ExchangeRateWRTUSD; p3 = new Price(p3Converted,p1.CurrencyCode,p1.ExchangeRateWRTUSD); } return p3; } Metoda najpierw porównuje dwa kursy wymiany. Jeśli są takie same, dodaje ceny. Jeśli się różnią, obie ceny są przekształcane w walutę bazową (USD) i dodawane, po czym wynik przekształcany jest z powrotem w walutę pierwszego obiektu Price. Na koniec metoda zwraca nowy obiekt Price, który zawiera sumę dwóch pierwotnych cen. 96 .Net. Najpilniej strzeżone tajemnice Przeciążonego operatora możesz używać w połączeniu ze swoim typem danych tak samo jak w połączeniu z typami podstawowymi. Po prostu dodaj dwa obiekty Price: Price keyboardPrice = new Price(40, PLN , (float).25); Price mousePrice = new Price(20, EUR , (float)1.25); Price Total = keyboardPrice + mousePrice; MessageBox.Show( Łączna cena zamówienia to: + Total.Amount.ToString()); Powyższy kod najpierw tworzy dwa obiekty Price, następnie dodaje je przy użyciu operatora + i wyświetla otrzymany wynik. Możesz napisać podobny kod w celu przeciążenia operatorów -, * lub + dla obiektów Price. Przeciążanie operatorów przypisania Operatorów przypisania, takich jak znak równości (=), nie można przeciążać. W razie przeciążenia operatorów matematycznych można jednak korzystać ze skróconych ope- ratorów przypisania, takich jak +=, -=, *= i /=. Price speakerPrice = new Price(30, PLN , (float).25); Price surCharge = new Price(5, PLN , (float).25); speakerPrice += surCharge; MessageBox.Show( Końcowa cena głośnika to: + speakerPrice.Amount.ToString()); Powyższy kod definiuje kwotę dopłaty i zwiększa cenę towaru o tę kwotę. Jeśli przeciążysz inne operatory matematyczne, będziesz mógł korzystać z tej techniki także w przypadku pozostałych skróconych operatorów przypisania. Przeciążanie operatorów porównania Możesz przeciążać również operatory porównania: równy (= w VB, == w C#), nierówny ( w VB, != w C#), mniejszy ( ), większy ( ), mniejszy lub równy ( =) oraz większy lub równy ( =). Kod, który przeciąża operator większości, zwraca wartości logiczne: True lub False. public static bool operator (Price p1, Price p2) { // Jeśli oba kursy wymiany są takie same, po prostu porównujemy kwoty if (p1.ExchangeRateWRTUSD == p2.ExchangeRateWRTUSD) { return (p1.Amount p2.Amount); } else { float p1InUSD = p1.Amount * p1.ExchangeRateWRTUSD; float p2InUSD = p2.Amount * p2.ExchangeRateWRTUSD; return (p1InUSD p2InUSD); } } Rozdział 3. ♦ Tajniki kodowania 97 Ten kod porównuje kursy wymiany. Jeśli są takie same, kod zwraca True w przypadku, gdy pierwsza kwota jest większa od drugiej. Jeśli kursy są różne, obie kwoty są prze- kształcane na walutę bazową i dopiero wtedy porównywane. Operatory porównania trzeba przeciążać parami. Jeśli przeciążysz operator ==, musisz również przeciążyć operator !=. Ponieważ w tym przykładzie przeciążyliśmy operator większości ( ), musimy przeciążyć operator mniejszości ( ). public static bool operator (Price p1, Price p2) { // Jeśli oba kursy wymiany są takie same, po prostu porównujemy kwoty if (p1.ExchangeRateWRTUSD == p2.ExchangeRateWRTUSD) { return (p1.Amount p2.Amount); } else { float p1InUSD = p1.Amount * p1.ExchangeRateWRTUSD; float p2InUSD = p2.Amount * p2.ExchangeRateWRTUSD; return (p1InUSD p2InUSD); } } Powyższy kod jest bardzo podobny do tego, który przeciąża operator większości. Nie można przeciążać warunkowych operatorów logicznych ( oraz ||). Przeciążanie operatorów pozwala na intuicyjne wykonywanie działań matematycznych oraz porównywanie obiektów. W Visual Studio 2005 funkcja ta ma zostać rozbudowana. Eksploracja nieodkrytych regionów Prawdopodobnie zauważyłeś zwinięte sekcje Windows Forms Designer generated code w kodzie Windows Forms. Takie sekcje noszą nazwę regionów. Regiony są pomocne przy organizacji kodu i ułatwiają pisanie oraz konserwację programów. Aby utworzyć region wokół fragmentu kodu, użyj słowa kluczowego Region. Visual Basic: #Region Metody prywatne Tutaj umieść dowolny kod #End Region C#: #region Metody prywatne // Tutaj umieść dowolny kod #endregion 98 .Net. Najpilniej strzeżone tajemnice W swoich plikach kodu możesz zdefiniować dowolną liczbę regionów. Możesz je rów- nież zagnieżdżać, tworząc regiony regionów. Przydaje się to, na przykład, do zdefinio- wania regionu Metody prywatne, a następnie oddzielnego regionu dla każdej metody. Chcąc, by przeszukiwane były zamknięte regiony, musisz zaznaczyć pole Search hidden text w oknie dialogowym Find. W przeciwnym razie zamknięte regiony zosta- ną pominięte. Jeśli podzielisz cały kod na regiony, będziesz mógł obejrzeć ogólną strukturę pliku kodu (rysunek 3.2). Rozwijanie i zwijanie odpowiednich regionów pomoże Ci skupić się na bieżącym zadaniu. Rysunek 3.2. Ogólny widok całego kodu zawartego w pliku. Rozwiń odpowiedni region, aby wyświetlić interesujący Cię kod Zdefiniuj regiony, aby ułatwić zarządzanie kodem zarówno sobie, jak i przyszłym pokole- niom konserwatorów programu. Komentarze XML C# oferuje programistom mechanizm dokumentowania kodu przy użyciu standardowych elementów XML. Dzięki temu mechanizmowi komentarze zyskują jednolity styl, a śro- dowisko programistyczne Visual Studio może wykorzystać je w funkcji IntelliSense. Programiści VB również mogą dokumentować swój kod przy użyciu XML, ale muszą wprowadzać komentarze ręcznie, a Visual Studio ich nie wykorzystuje (funkcja komen- towania XML w Visual Basicu ma być dostępna w Visual Studio 2005). Rozdział 3. ♦ Tajniki kodowania 99 Tworzenie komentarzy XML Komentarzy XML można używać w języku C# do dokumentowania klas, delegacji, interfejsów, pól, zdarzeń, właściwości lub metod. Aby utworzyć komentarz XML do pewnego elementu, przejdź do wiersza znajdującego się tuż nad definicją elementu w pliku kodu C# i wpisz trzy ukośniki (///). Kiedy wpiszesz trzeci ukośnik, automa- tycznie pojawią się komentarze XML: /// summary /// /// /summary /// param name= pnl /param private void AddEventHandlers(Control pnl) W elemencie summary możesz podać krótki opis klasy lub metody. Zwróć uwagę, że element param zawiera w atrybucie name parametr pobrany z sygnatury metody. Możesz dodać definicję parametru. Minimalny komentarz XML do metody mógłby wyglądać tak: /// summary /// Przetwarza wszystkie kontrolki na formularzu i ustawia procedury /// obsługa zdarzeń Enter i Leave dla każdej kontrolki TextBox. /// /summary /// param name= pnl Formularz albo dowolna kontrolka na formularzu. /param private void AddEventHandlers(Control pnl) Narzędzie do tworzenia komentarzy XML oferuje kilka dodatkowych elementów: (cid:141) example — pozwala podać przykład użycia metody albo innej składowej klasy; (cid:141) exception — pozwala określić wyjątki, które może zgłosić metoda; (cid:141) returns — pozwala określić wartość zwrotną metody. Pełne omówienie komentarzy XML w języku C# znajdziesz pod hasłem „XML Docu- mentation tutorial” w pomocy MSDN. Oglądanie komentarzy XML w IntelliSense Funkcja IntelliSense w Visual Studio używa komentarzy XML w szybkim podglądzie (Quick Info), na listach składowych (List Members) oraz w informacjach o parametrach (Parametr Info). Jeśli nawet nie znasz tych nazw, prawdopodobnie widziałeś już powyż- sze funkcje w działaniu. (cid:141) Quick Info — wyświetla deklarację oraz skrótowy opis każdego identyfikatora w kodzie. Przesuń wskaźnik myszy nad dowolny identyfikator albo kliknij przycisk Quick Info umieszczony na pasku narzędzi Text Editor, aby zobaczyć szybki podgląd identyfikatora (rysunek 3.3). Zauważ, że pojawia się w nim tekst komentarza XML zdefiniowany w poprzednim przykładzie. .Net. Najpilniej strzeżone tajemnice 100 Rysunek 3.3. Funkcja Quick Info to część IntelliSense, wyświetlająca krótkie informacje o identyfikatorach zawartych w kodzie. Opis identyfikatora pobierany jest z elementu summary komentarza XML (cid:141) List Members — wyświetla składowe konkretnego obiektu na liście rozwijanej. Kiedy wpiszesz nazwę obiektu i kropkę (.) albo klikniesz przycisk Member List umieszczony na pasku narzędzi Text Editor, pojawi się lista składowych. Zatrzymaj wskaźnik myszy nad wybraną pozycją tej listy, aby obejrzeć podgląd Quick Info (rysunek 3.4). Rysunek 3.4. Funkcja List Members również wykorzystuje komentarze XML (cid:141) Parameter Info — wyświetla informacje o parametrach metody. Pojawiają się one po wpisaniu nazwy metody i nawiasu albo po kliknięciu przycisku Parameter Info umieszczonego na pasku narzędzi Text Editor (rysunek 3.5). Możesz wygenerować zewnętrzny plik ze wszystkimi komentarzami XML zawartymi w projekcie. Wybierz z menu Project polecenie Properties, otwórz folder Configuration Properties i wybierz pozycję Build. Następnie wpisz nazwę pliku w polu XML Docu- mentation File pod węzłem Output. Kiedy zbudujesz projekt, wygenerowany zostanie plik XML. Kolejną korzyścią będzie to, że wszystkie dostępne publicznie typy i metody bez komentarza XML zostaną wymienione jako ostrzeżenia w oknie Task List (więcej informacji o pracy z oknem Task List znajdziesz w rozdziale 1.). Wygenerowany w ten sposób plik XML można przetwarzać przy użyciu zewnętrznych narzędzi, na przykład NDoc (http://sourcefor
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

.Net. Najpilniej strzeżone tajemnice
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ą: