Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00257 004327 12931791 na godz. na dobę w sumie
MVVM i XAML w Visual Studio 2015 - książka
MVVM i XAML w Visual Studio 2015 - książka
Autor: Liczba stron: 320
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-283-1018-6 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> visual studio - programowanie
Porównaj ceny (książka, ebook (-25%), audiobook).

Twórz doskonałe aplikacje zgodne ze wzorcem MVVM z użyciem języka XAML!

Aplikację można budować na wiele sposobów, z użyciem różnych narzędzi. Zawsze trzeba jednak pamiętać o tym, do czego ma ona służyć, kto będzie jej używał, na jakim sprzęcie i jak długi ma być jej cykl życiowy. Jeżeli projekt jest duży lub jego czas życia planowany jest na lata, warto od razu zadbać o to, aby architektura projektu ułatwiała współpracę wielu osób przy jego tworzeniu, późniejszą rozbudowę, testowanie najbardziej istotnych modułów i możliwość używania aplikacji w wersjach przeznaczonych dla różnych platform sprzętowych oraz systemów operacyjnych. Dobrym wyborem jest trójwarstwowy MVVM – wzorzec przeznaczony dla aplikacji WPF oraz tzw. aplikacji uniwersalnych, w których interfejs przygotowywany jest w języku XAML.

W środowisku Visual Studio 2015 możesz łatwo zbudować aplikację opartą na wzorcu MVVM i wyposażyć ją we wspaniały interfejs dzięki pomocy XAML. Z tej książki dowiesz się, jak mądrze zaprojektować strukturę Twojej aplikacji, co powinno znaleźć się w poszczególnych warstwach, jak związać interfejs z modelem, jak zdefiniować polecenia, własności i zachowania. Zobaczysz, jak testować kod. Poznasz także aplikacje uniwersalne dla Windows 8.1 oraz Windows 10. Krótko mówiąc, zdobędziesz solidną wiedzę o konstruowaniu znakomitych, łatwych w utrzymaniu aplikacji!

MVVM i XAML — Twoje przepustki do świata nowoczesnych aplikacji!

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

Darmowy fragment publikacji:

Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną, fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym powoduje naruszenie praw autorskich niniejszej publikacji. Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądź towarowymi ich właścicieli. Autor oraz Wydawnictwo HELION dołożyli wszelkich starań, by zawarte w tej książce informacje były kompletne i rzetelne. Nie biorą jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane z tym ewentualne naruszenie praw patentowych lub autorskich. Autor oraz Wydawnictwo HELION nie ponoszą również żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji zawartych w książce. Opieka redakcyjna: Ewelina Burska Projekt okładki: Studio Gravite/Olsztyn Obarek, Pokoński, Pazdrijowski, Zaprucki Materiały graficzne na okładce zostały wykorzystane za zgodą Shutterstock. Wydawnictwo HELION ul. Kościuszki 1c, 44-100 GLIWICE tel. 32 231 22 19, 32 230 98 63 e-mail: helion@helion.pl WWW: http://helion.pl (księgarnia internetowa, katalog książek) Drogi Czytelniku! Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres http://helion.pl/user/opinie/xamlmv Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję. Pliki z przykładami omawianymi w książce można znaleźć pod adresem: ftp://ftp.helion.pl/przyklady/xamlmv.zip ISBN: 978-83-283-1018-6 Copyright © Helion 2016 Printed in Poland. • Kup książkę • Poleć książkę • Oceń książkę • Księgarnia internetowa • Lubię to! » Nasza społeczność Spis treści Część I Wzorzec MVVM. Podstawy XAML .................................... 7 Rozdział 1. Szybkie wprowadzenie do XAML ....................................................... 9 Wzorzec widoku autonomicznego .................................................................................... 9 Tworzenie projektu ......................................................................................................... 10 Projektowanie interfejsu ................................................................................................. 11 Kilka uwag na temat kodu XAML opisującego interfejs okna ....................................... 15 Zdarzenia ........................................................................................................................ 16 Własności ....................................................................................................................... 20 Zapisywanie i odtwarzanie stanu aplikacji ..................................................................... 21 Rozdział 2. Wzorzec MVVM .............................................................................. 25 Model ............................................................................................................................. 25 Widok ............................................................................................................................. 26 Model widoku ................................................................................................................. 27 Rozdział 3. Implementacja modelu i model widoku ............................................ 29 Model ............................................................................................................................. 29 Warstwa dostępu do danych ........................................................................................... 30 Model widoku ................................................................................................................. 31 Alternatywne rozwiązania .............................................................................................. 33 Ratujemy widok ............................................................................................................. 35 Zadania ........................................................................................................................... 36 Rozdział 4. Wiązanie danych (data binding) ...................................................... 37 Instancja modelu widoku i kontekst danych ................................................................... 37 Alternatywne rozwiązanie .............................................................................................. 38 Wiązanie pozycji suwaków i koloru prostokąta ............................................................. 39 Zmiany w code-behind ................................................................................................... 40 Implementacja interfejsu INotifyPropertyChanged ........................................................ 41 Powiadomienia w alternatywnych modelach widoku ..................................................... 44 Interfejs INotifyDataErrorInfo ........................................................................................ 50 Klasa ObservedObject .................................................................................................... 50 Rozdział 5. Konwersja danych w wiązaniu ......................................................... 53 Prosta konwersja typów .................................................................................................. 53 Konwersja klas Color i SolidColorBrush ....................................................................... 55 Multibinding ................................................................................................................... 56 Poleć książkęKup książkę 4 MVVM i XAML w Visual Studio 2015 Wiązanie między kontrolkami ........................................................................................ 57 Konwersje „wbudowane” ............................................................................................... 60 Zadania ........................................................................................................................... 60 Rozdział 6. Polecenia (commands) ................................................................... 61 Interfejs ICommand ........................................................................................................ 61 Przycisk uruchamiający polecenie .................................................................................. 62 Sprawdzanie możliwości wykonania polecenia .............................................................. 65 Resetowanie stanu suwaków po naciśnięciu klawisza .................................................... 66 Klasa RelayCommand .................................................................................................... 67 Zdarzenia a polecenia ..................................................................................................... 69 Zamykanie okna ............................................................................................................. 71 Zadanie ........................................................................................................................... 72 Rozdział 7. Zachowania, własności zależności i własności doczepione ............... 73 Zachowania (behaviors) ................................................................................................. 73 Własność zależności (dependency property) .................................................................. 75 Własność doczepiona (attached property) i zachowanie doczepione (attached behavior) ....................................................................................................... 79 Zadania ........................................................................................................................... 81 Rozdział 8. Testy jednostkowe ......................................................................... 83 Testy jednostkowe w Visual Studio 2013 ....................................................................... 84 Projekt testów jednostkowych .................................................................................. 84 Przygotowania do tworzenia testów ......................................................................... 85 Pierwszy test jednostkowy ....................................................................................... 85 Testy jednostkowe w Visual Studio 2015 ....................................................................... 86 Uruchamianie testów ...................................................................................................... 88 Testy wielokrotne ........................................................................................................... 89 Dostęp do prywatnych pól testowanej klasy ................................................................... 90 Atrapy obiektów (mock objects) ..................................................................................... 92 Testowanie konwersji ..................................................................................................... 95 Testowanie wyjątków ..................................................................................................... 96 Rozdział 9. Powtórzenie ................................................................................... 99 Model ............................................................................................................................. 99 Prototyp widoku ........................................................................................................... 100 Model widoku ............................................................................................................... 102 Wiązanie ....................................................................................................................... 103 Konwerter ..................................................................................................................... 104 Wzorzec MVVM .......................................................................................................... 106 Zadania ......................................................................................................................... 107 Część II Zaawansowane zagadnienia budowania interfejsu w XAML ..................................................................... 109 Rozdział 10. Budowanie złożonych kontrolek .................................................... 111 Konfiguracja przycisku w podoknie Properties ............................................................ 111 Pędzle ........................................................................................................................... 115 Formatowanie tekstu na przycisku ............................................................................... 118 StackPanel — liniowe ułożenie elementów .................................................................. 119 Projektowanie własnych kontrolek ............................................................................... 121 Poleć książkęKup książkę Spis treści 5 Rozdział 11. Style ............................................................................................ 123 Siatka i wiele kontrolek ................................................................................................ 123 Zasoby okna ................................................................................................................. 125 Style .............................................................................................................................. 127 Wyzwalacze .................................................................................................................. 129 Zasoby aplikacji ............................................................................................................ 130 Rozdział 12. Transformacje i animacje .............................................................. 133 Transformacje kompozycji i renderowania ................................................................... 133 Uruchamianie transformacji w wyzwalaczu stylu ........................................................ 140 Animacje ...................................................................................................................... 142 Animacja w stylu .......................................................................................................... 144 Funkcje w animacji ....................................................................................................... 145 Animacja koloru ........................................................................................................... 147 Rozdział 13. Szablony kontrolek ....................................................................... 149 Rozdział 14. Zdarzenia trasowane (routed events) ............................................ 153 Pojedyncza kontrolka ................................................................................................... 153 Zagnieżdżanie przycisków ............................................................................................ 155 Kontrola przepływu zdarzeń trasowanych .................................................................... 156 Przerwanie kolejki ........................................................................................................ 158 Bulgotanie (bubbling) i tunelowanie (tunneling) .......................................................... 158 Dynamiczne tworzenie przycisków zagnieżdżonych .................................................... 160 Rozdział 15. Kolekcje w MVVM i XAML ............................................................ 163 Model ........................................................................................................................... 163 Przechowywanie danych w pliku XML ........................................................................ 167 Model widoku zadania .................................................................................................. 169 Kolekcja w modelu widoku .......................................................................................... 172 Prezentacja kolekcji w widoku. Szablon danych (data template) ................................. 175 Style elementów kontrolki ListBox .............................................................................. 177 Konwertery ................................................................................................................... 179 Zapisywanie danych przy zamknięciu okna ................................................................. 182 Modyfikacje kolekcji .................................................................................................... 184 Sortowanie .................................................................................................................... 190 Zadania ......................................................................................................................... 192 Rozdział 16. Okna dialogowe w MVVM ............................................................. 193 Klasa bazowa okna dialogowego .................................................................................. 194 Polecenia wykonywane przed wyświetleniem i po wyświetleniu okna dialogowego ...... 196 Okno dialogowe MessageBox ...................................................................................... 199 Warunkowe wyświetlenie okna dialogowego ............................................................... 203 Okna dialogowe wyboru pliku ...................................................................................... 205 Łańcuch okien dialogowych ......................................................................................... 209 Okna dialogowe z dowolną zawartością ....................................................................... 210 Zadania ......................................................................................................................... 214 Rozdział 17. Grafika kształtów w XAML ............................................................ 215 Model widoku ............................................................................................................... 216 Widok ........................................................................................................................... 217 Zmiana kształtu okna .................................................................................................... 222 Zadania ......................................................................................................................... 226 Poleć książkęKup książkę 6 MVVM i XAML w Visual Studio 2015 Rozdział 18. Aplikacja WPF w przeglądarce (XBAP) .......................................... 227 Część III Aplikacje uniwersalne (Universal Apps) ....................... 231 Rozdział 19. Kod współdzielony ........................................................................ 233 Projekt .......................................................................................................................... 234 Kod współdzielony: model i model widoku ................................................................. 235 Konwertery ................................................................................................................... 237 Zadanie ......................................................................................................................... 238 Rozdział 20. Warstwa widoku dla Windows 8.1 ................................................ 239 Widok ........................................................................................................................... 239 Logo aplikacji ............................................................................................................... 244 Zadanie ......................................................................................................................... 246 Rozdział 21. Cykl życia aplikacji i przechowywanie jej stanu ............................. 247 Cykl życia aplikacji ...................................................................................................... 247 Przechowywanie stanu ................................................................................................. 248 Zadanie ......................................................................................................................... 252 Rozdział 22. Kafelek ........................................................................................ 255 Rozdział 23. Tworzenie i testowanie pakietu AppX ............................................ 259 Rozdział 24. Warstwa widoku dla Windows Phone 8.1 ...................................... 265 Zadania ......................................................................................................................... 268 Rozdział 25. Kolekcje w aplikacji mobilnej ........................................................ 271 Dostęp do plików w katalogu lokalnym ....................................................................... 271 Współdzielony kod z warstwy widoku ......................................................................... 276 Lista zadań w widoku dla Windows Phone 8.1 ............................................................ 279 Zdarzenie CanExecuteChanged poleceń ....................................................................... 283 Zadanie ......................................................................................................................... 285 Rozdział 26. Pasek aplikacji (app bar) .............................................................. 287 Zadania ......................................................................................................................... 290 Rozdział 27. Okna dialogowe w aplikacjach Windows Phone ............................. 291 Standardowe okna dialogowe ....................................................................................... 291 Okna dialogowe z dowolną zawartością w Windows Phone ........................................ 301 Zadania ......................................................................................................................... 305 Rozdział 28. Aplikacje uniwersalne w Windows 10 ............................................ 307 Skorowidz .................................................................................. 315 Poleć książkęKup książkę Rozdzia(cid:228) 2. Wzorzec MVVM Opisany w poprzednim rozdziale projekt b(cid:266)dziemy teraz krok po kroku modyfikowa(cid:252) tak, (cid:298)eby jego architektura sta(cid:225)a si(cid:266) zgodna ze wzorcem MVVM. We wzorcu tym za- k(cid:225)ada si(cid:266) obecno(cid:286)(cid:252) trzech warstw: modelu, modelu widoku i widoku (rysunek 2.1). W naj- prostszym przypadku, takim jak w naszej aplikacji, poszczególne warstwy mog(cid:261) sk(cid:225)ada(cid:252) si(cid:266) tylko z jednej klasy, ale zwykle jest ich wi(cid:266)cej. Rysunek 2.1. Warstwy aplikacji we wzorcu MVVM (z lewej polska, a z prawej angielska terminologia) Model Funkcja warstwy modelu jest najbardziej intuicyjna — z grubsza odpowiada modelom w innych wzorcach projektowych, chocia(cid:298)by w klasycznej dwuwarstwowej architekturze model-widok lub we wzorcach MVC i MVP. Dobrym pomys(cid:225)em jest tworzenie tej war- stwy w metodologii projektowania domenowego (ang. domain-driven design, DDD). W wielkim uproszczeniu oznacza to, (cid:298)e projektujemy zbiór klas sk(cid:225)adaj(cid:261)cych si(cid:266) na model razem z ekspertem w dziedzinie, której program ma dotyczy(cid:252). Cz(cid:266)sto jest to klient lub osoba przez niego wskazana. Wówczas nale(cid:298)y uwa(cid:298)nie s(cid:225)ucha(cid:252) s(cid:225)ownictwa, jakiego ów ekspert u(cid:298)ywa, bo cz(cid:266)sto stosowane przez niego rzeczowniki s(cid:261) dobrymi Poleć książkęKup książkę 26 Cz(cid:246)(cid:264)(cid:232) I (cid:105) Wzorzec MVVM kandydatami na nazwy podstawowych klas modelu. Z kolei czasowniki towarzysz(cid:261)ce tym rzeczownikom b(cid:266)d(cid:261) prawdopodobnie nazwami kluczowych metod. Przy czym w DDD nie chodzi oczywi(cid:286)cie tylko o wybieranie nazw klas i metod, a przede wszystkim o ich zawarto(cid:286)(cid:252) i wyznaczenie relacji mi(cid:266)dzy klasami. Ma ona odzwierciedla(cid:252) relacje pojawiaj(cid:261)ce si(cid:266) w j(cid:266)zyku u(cid:298)ywanym przez eksperta. To oczywi(cid:286)cie trywializacja, ale dobrze oddaje ide(cid:266) DDD. Modele domenowe powinny by(cid:252) mo(cid:298)liwie proste i „lekkie”. Nie powinny korzysta(cid:252) z (cid:298)adnych konkretnych mechanizmów platformy .NET — najlepiej, gdyby jedyn(cid:261) u(cid:298)ywan(cid:261) w nich przestrzeni(cid:261) nazw by(cid:225)a przestrze(cid:276) System1. W tym podej(cid:286)ciu klasy modelu powinny stanowi(cid:252) tylko proste no(cid:286)niki danych przekazywanych z bazy danych lub innego (cid:296)ród(cid:225)a danych do wy(cid:298)szych warstw aplikacji. Klasy modelu nie mog(cid:261), i to jest bardzo wa(cid:298)ne, zna(cid:252) (cid:298)adnych szczegó(cid:225)ów dotycz(cid:261)cych owych wy(cid:298)szych warstw — powinny by(cid:252) ca(cid:225)kowicie autonomiczne. W takim podej(cid:286)ciu klasy modelu musz(cid:261) by(cid:252) bar- dzo proste, a tym samym (cid:225)atwe do testowania2. Klarowne s(cid:261) te(cid:298) relacje mi(cid:266)dzy nimi. Kluczowy w projektowaniu warstwy modelu jest podzia(cid:225) odpowiedzialno(cid:286)ci — nale(cid:298)y jasno ustali(cid:252), za co odpowiedzialna jest która klasa. Cz(cid:266)(cid:286)(cid:252) odpowiedzialno(cid:286)ci mo(cid:298)e, lub nawet powinna, by(cid:252) wydzielona do osobnych modu(cid:225)ów w warstwie modelu. Za zapis danych mo(cid:298)na uczyni(cid:252) odpowiedzialn(cid:261) podwarstw(cid:266) dost(cid:266)pu do danych (ang. data access layer, DAL), która na przyk(cid:225)ad w postaci klasy statycznej przyjmuje instan- cje klas domenowych i zapisuje ich stan. Podobnie logika modelu mo(cid:298)e by(cid:252) wydzie- lona do osobnego modu(cid:225)u tak zwanej logiki biznesowej (ang. buissness logic layer, BLL), która operuje na instancjach domenowych klas modelu. Widok Widok odpowiedzialny jest za kontakt z u(cid:298)ytkownikiem. W WPF, a tak(cid:298)e w aplikacjach Windows Phone i WinRT, widokiem jest kod XAML opisuj(cid:261)cy graficzny interfejs u(cid:298)ytkownika (ang. graphical user interface, GUI). Z widokiem zwi(cid:261)zana jest klasa okna, w której w poprzednim rozdziale umieszczali(cid:286)my metody zdarzeniowe. Tworzy ona tak zwany kod zaplecza widoku, czyli code-behind. Zgodnie z zaleceniami wzorca MVVM kod ten powinien by(cid:252) ograniczony do minimum, a najlepiej, (cid:298)eby go w ogóle nie by(cid:225)o. W tym sensie wzorzec MVVM ca(cid:225)kowicie odwraca wzorzec widoku auto- nomicznego. G(cid:225)ównym powodem unikania kodu C# w warstwie widoku, a przynajmniej w klasie okna, jest to, (cid:298)e kod ten, jako silnie zwi(cid:261)zany z kontrolkami, jest trudny do przetestowania. Ponadto zanurzenie logiki prezentacyjnej w widoku znacz(cid:261)co utrudnia wspó(cid:225)prac(cid:266) mi(cid:266)dzy projektantami interfejsu tworz(cid:261)cymi widok a programistami odpo- wiedzialnymi za ni(cid:298)sze warstwy aplikacji. Zmniejsza te(cid:298) elastyczno(cid:286)(cid:252) projektu, utrudniaj(cid:261)c tym samym jego zmiany. 1 Klasy tego typu nazywane s(cid:261) POCO, od ang. „plain-old” CRL objects. To popularne okre(cid:286)lenie w slangu programistów C#. 2 Testowanie klas POCO nie ma jednak sensu, je(cid:298)eli zawieraj(cid:261) one same w(cid:225)asno(cid:286)ci. Poleć książkęKup książkę Rozdzia(cid:228) 2. (cid:105) Wzorzec MVVM Model widoku 27 Model widoku jest abstrakcj(cid:261) widoku. Je(cid:298)eli mo(cid:298)emy sobie wyobrazi(cid:252) kilka wariantów graficznego interfejsu u(cid:298)ytkownika naszej aplikacji, dla ró(cid:298)nych (cid:286)rodowisk i platform, to model widoku w tych wszystkich przypadkach powinien pozostawa(cid:252) taki sam. My(cid:286)l(cid:261)c przez analogi(cid:266): mo(cid:298)emy sobie wyobrazi(cid:252) ró(cid:298)ne sto(cid:225)y, ró(cid:298)nej wielko(cid:286)ci i o ró(cid:298)nych kszta(cid:225)tach, z trzema lub czterema nogami. Nie zmienia to jednak definicji sto(cid:225)u jako miejsca, przy którym mo(cid:298)na usi(cid:261)(cid:286)(cid:252) i co(cid:286) na nim po(cid:225)o(cid:298)y(cid:252). Podobnie wiele mo(cid:298)e by(cid:252) projektów widoku. Ale model widoku musi by(cid:252) jak definicja sto(cid:225)u, jego zapisana idea — powinien by(cid:252) jak najprostszy, lecz kompletny. Powinien wobec tego zawiera(cid:252) tylko to, co konieczne do okre(cid:286)lenia, do czego widoki maj(cid:261) by(cid:252) u(cid:298)yte. Warto podj(cid:261)(cid:252) wysi(cid:225)ek, (cid:298)eby doprowadzi(cid:252) kod modelu widoku do jak najwy(cid:298)szego poziomu abstrakcji. Z po- wy(cid:298)szych górnolotnych rozwa(cid:298)a(cid:276) wynika, (cid:298)e najlepszym sprawdzianem poprawno(cid:286)ci modelu widoku s(cid:261) zmiany wprowadzane w widoku. Tych w trakcie rozwijania pro- jektu zwykle nie brakuje. Je(cid:298)eli model widoku jest dobrze zaprojektowany, takie zmia- ny widoku powinny si(cid:266) oby(cid:252) bez jego modyfikacji. Pami(cid:266)tajmy jednak, (cid:298)e (cid:650) jak wiele dobrych praktyk w informatyce (cid:650) jest to raczej cel, do którego d(cid:261)(cid:298)ymy, ni(cid:298) twarde wymaganie, stawiane osobie projektuj(cid:261)cej model widoku. Funkcj(cid:261) modelu widoku jest udost(cid:266)pnienie widokowi instancji klas z warstwy modelu (na rysunku 2.1 odpowiada to ruchowi do góry) oraz zmienianie stanu tych instancji w wyniku dzia(cid:225)a(cid:276) u(cid:298)ytkownika wykrytych w warstwie widoku (ruch w dó(cid:225)). W tym drugim przypadku model widoku odpowiedzialny jest mi(cid:266)dzy innymi za weryfikacj(cid:266) przekazywanych danych. Model widoku pe(cid:225)ni wi(cid:266)c rol(cid:266) po(cid:286)rednika mi(cid:266)dzy warstwami modelu i widoku, a jednocze(cid:286)nie adaptera dla przekazywanych danych. Owo po(cid:286)red- niczenie najcz(cid:266)(cid:286)ciej odbywa si(cid:266) w taki sposób, (cid:298)e obiekty modelu s(cid:261) prywatnymi polami modelu widoku. Model widoku udost(cid:266)pnia je lub ich cz(cid:266)(cid:286)ci w swoich w(cid:225)asno(cid:286)ciach, jest wobec tego (cid:286)wiadomy warstwy modelu, nie powinien by(cid:252) natomiast (cid:286)wiadomy warstwy widoku (cid:650) to widok powinien by(cid:252) (cid:286)wiadom modelu widoku. Po(cid:225)(cid:261)czenie mi(cid:266)dzy modelem widoku a widokiem jest zwykle bardzo „lu(cid:296)ne”. Oparte jest nie na odwo(cid:225)a- niach w kodzie C#, lecz na wi(cid:261)zaniach danych umieszczonych w kodzie XAML. To lu(cid:296)ne wi(cid:261)zanie u(cid:225)atwia niezale(cid:298)n(cid:261) prac(cid:266) nad widokiem i modelem widoku i znakomicie u(cid:225)atwia wprowadzanie zmian w poszczególnych warstwach, z ca(cid:225)kowitym ich prze- budowywaniem w(cid:225)(cid:261)cznie. Ta druga zaleta jest szczególnie warta docenienia, cho(cid:252) jest ona w wi(cid:266)kszym lub mniejszym stopniu zalet(cid:261) wszystkich wzorców z wyra(cid:296)nie roz- dzielonymi warstwami (modu(cid:225)ami). W modelu widoku zapisana jest ca(cid:225)a logika prezentacyjna okre(cid:286)laj(cid:261)ca procedury kon- taktu z u(cid:298)ytkownikiem z uwzgl(cid:266)dnieniem weryfikacji danych. Mimo tego pozostaje (cid:225)atwa do testowania, nie ma w niej bowiem odwo(cid:225)a(cid:276) do kontrolek ani za(cid:225)o(cid:298)onej bez- po(cid:286)redniej interakcji z u(cid:298)ytkownikiem. Doskonale zdaj(cid:246) sobie spraw(cid:246), (cid:276)e dla osób, które nie mia(cid:228)y jeszcze kontaktu ze wzorcem MVVM albo chocia(cid:276)by z MVP lub MVC, wi(cid:246)kszo(cid:264)(cid:232) powy(cid:276)szych zda(cid:254) o mode- lu widoku jest trudna do zrozumienia. Zadaniem kolejnych rozdzia(cid:228)ów z pierwszej cz(cid:246)(cid:264)ci ksi(cid:241)(cid:276)ki b(cid:246)dzie wyja(cid:264)nienie tego na konkretnym przyk(cid:228)adzie. Po przeczytaniu dalszych rozdzia(cid:228)ów warto wróci(cid:232) do niniejszego i przeczyta(cid:232) go jeszcze raz, w ca- (cid:228)o(cid:264)ci lub przynajmniej w cz(cid:246)(cid:264)ci dotycz(cid:241)cej modelu widoku. To powinno pomóc po- uk(cid:228)ada(cid:232) sobie w g(cid:228)owie wiedz(cid:246) o MVVM przedstawion(cid:241) w pierwszej cz(cid:246)(cid:264)ci. Poleć książkęKup książkę 28 Cz(cid:246)(cid:264)(cid:232) I (cid:105) Wzorzec MVVM W przypadku aplikacji KoloryWPF modelem mo(cid:298)e by(cid:252) prosta klasa opisuj(cid:261)ca kolor, zawieraj(cid:261)ca tylko trzy sk(cid:225)adowe typu byte. Odpowiedzialno(cid:286)(cid:252) za zapis stanu modelu pozostawimy osobnej klasie statycznej nale(cid:298)(cid:261)cej do warstwy modelu. Prostota naszej aplikacji spowoduje, (cid:298)e model widoku b(cid:266)dzie z pocz(cid:261)tku równie prosty i w istocie bardzo podobny do samego modelu. Z czasem dodamy do niego jednak elementy cha- rakterystyczne dla klas modelu widoku, mi(cid:266)dzy innymi polecenia i mechanizm po- wiadomie(cid:276). A poniewa(cid:298) podstawowym celem aplikacji jest mo(cid:298)liwo(cid:286)(cid:252) kontrolowania trzech sk(cid:225)adowych koloru, model widoku musi udost(cid:266)pnia(cid:252) w(cid:225)asno(cid:286)ci reprezentuj(cid:261)ce te sk(cid:225)adowe. Oprócz tego wyposa(cid:298)ymy go w metod(cid:266), któr(cid:261) potem przekszta(cid:225)cimy w tak zwane polecenie, umo(cid:298)liwiaj(cid:261)ce zapis stanu aplikacji (czyli de facto stanu modelu). To nie jest oczywi(cid:286)cie jedyna architektura, jak(cid:261) mo(cid:298)na sobie wyobrazi(cid:252) dla tej aplika- cji. Dobrym modelem mog(cid:225)aby by(cid:252) przecie(cid:298) klasa Properties.Settings stworzona przez Visual Studio w momencie okre(cid:286)lania ustawie(cid:276) aplikacji. Przy takim za(cid:225)o(cid:298)eniu naszym jedynym zadaniem pozostaje napisanie modelu widoku, który t(cid:266) klas(cid:266) udo- st(cid:266)pni(cid:225)by widokowi. Mo(cid:298)na równie(cid:298) rozwa(cid:298)y(cid:252) klas(cid:266) System.Windows.Media.Color, jako klas(cid:266) modelu, ale nie uwa(cid:298)am, (cid:298)eby korzystanie z klas przeznaczonych do budowa- nia interfejsu by(cid:225)o dobrym pomys(cid:225)em na tworzenie modelu. Dlatego pozostaniemy przy rozwi(cid:261)zaniu „kanonicznym”, lecz pami(cid:266)taj(cid:261)c, (cid:298)e wzorzec MVVM pozwala na pewne wariacje. Ostrzega(cid:225)em ju(cid:298), (cid:298)e aplikacja, któr(cid:261) od tego momentu b(cid:266)dziemy przebudowywa(cid:252), jest bardzo prosta. W kontek(cid:286)cie uczenia si(cid:266) wzorca MVVM to jest jednak moim zdaniem zaleta. Brak szczegó(cid:225)ów zwi(cid:261)zanych z bardziej skomplikowanym projektem pozwoli Czytelnikowi (cid:225)atwiej dostrzec istot(cid:266) wzorca. Poleć książkęKup książkę Skorowidz A animacja, 142, 143, 145, 146, 215 ColorAnimation, 147 w stylu, 144 z użyciem ramek kluczowych, 148 aplikacja AppX, Patrz: AppX cykl życia, 247, 248 dynamika, 16 interfejs, Patrz: interfejs język domyślny, 245 lista, 255 logo, 244, 245 mobilna, Patrz: aplikacja na urządzenia przenośne na smartfon, 247 na tablet, 247 na urządzenia przenośne, 247, 248, 271 dostęp do pamięci, 271 pasek, 287, 292, 295, 301 plik, Patrz: plik stan, 248 odtwarzanie, 21, 23 przywracanie, 251 resetowanie, 251 wstrzymywanie, 252 zapisywanie, 21, 23, 247, 249, 313 tworzenie, 10, 11 uniwersalna, 231, 234, 239, 279 Windows 10, 307 uruchamianie w przeglądarce, 227, 230 ustawienia lokalne, 249, 250 Windows Phone, 291 wstrzymywanie, 247, 248, 281 wznowienie, 247, 248 zamykanie, 183, 184, 247, 248, 313 zasoby, 130 app bar, Patrz: aplikacja pasek AppX, 259 instalowanie, 263 testowanie, 261, 262 tworzenie, 260 atrybut DataContext, 38 ExpectedException, 97 Fill, 20 Height, 15 Icon, 288 Label, 288 RelativePanel.AlignLeftWith, 311 RelativePanel.Below, 311 StringFormat, 278, 279 TargetType, 127 TextDecoration, 279 Title, 15 Width, 15 x:Class, 15 x:Name, 15 xmlns, 15 attached property, Patrz: własność doczepiona B behavior, Patrz: zachowanie biblioteka Microsoft.Expression.Interaction.dll, 73 Newtonsoft.JSON, 168 System.Windows.Interactivity.dll, 73 BLL, 26 bubbling, Patrz: bulgotanie buissness logic layer, Patrz: BLL bulgotanie, 158 Poleć książkęKup książkę 316 MVVM i XAML w Visual Studio 2015 C checkbox, Patrz: pole opcji code-behind, 26, 40, 61, 69, 76, 153, 188, 189 czas, 216, 217 D DAL, 26, 30 dane szablon, Patrz: szablon danych weryfikacja, 27 wiązanie, 37, 38, 39 data, 186, 188, 189, 216, 217 data access layer, Patrz: DAL data binding, Patrz: dane wiązanie data template, Patrz: szablon danych DDD, 25, 29, 100 domain-driven design, Patrz: DDD I interfejs, 166 ikona, 288 interfejs, 11, 172 ICommand, 61, 240 IComparable, 190 IComparer, 190 IDataErrorInfo, 50 IEnumerable, 166 ImultiValueConverter, 57 IMultiValueConverter, 56, 188 INotifyCollectionChanged, 174 INotifyDataErrorInfo, 50 INotifyPropertyChanged, 41, 42, 44, 50, 169, 171, 194, 216 IValueConverter, 53, 237 użytkownika graficzny, 26, 27 Internet of Things, Patrz: urządzenie IoT E K ekran element powitalny, 244, 245 wielkość, 311 AppBarButton, 288 DoubleAnimation, 143 MenuFlyout, 288 Page, 228 Setter, 127, 129, 312 emulator smartfona, 233 tabletu, 233, 243 uruchamianie, 243 etykieta, 288 formularz, 184, 186 funkcja przejścia, 145 wygładzania, 146 F G generic type, Patrz: typ parametryczny gradient, 115, 116 graphical user interface, Patrz: interfejs użytkownika graficzny GUI, Patrz: interfejs użytkownika graficzny kafelek, 255 aktualizowanie, 313 kolor tła, 255 logo, 255 rozmiar, 255 szablon, 256 wygląd, 255, 256 klasa App, 249, 251, 265, 313 Application, 249 ApplicationCommands, 69 ApplicationData, 249 Brush, 39 Brushes, 237 CommandBar, 288 CommandDialogBox, 293 CommandManager, 235 ContentDialog, 301, 303 DependencyObject, 75 EditingCommands, 69 EventTrigger, 69 FileIO, 271 FrameworkElement, 133, 194 Freezable, 216 Geometry, 216 Graphics, 215 konwersja, 55 List, 190 MainWindow, 41 MediaCommands, 69 MessageBox, 185 Poleć książkęKup książkę Skorowidz 317 MessageDialogBox, 298 modelu, 100 NavigationCommands, 69 NotificationDialogBox, 198, 293, 295 ObservedObject, 50 PrivateObject, 91, 92 RelayCommand, 67, 68, 102, 104, 185, 235 Shape, 215 SolidColorBrush, 20 statyczna, 93 StorageFile, 271 UIElement, 133, 194 Windows.Storage.KnownFolders, 271 XDocument, 272 kod XAML, 26, 111, 123, 239 zaplecza widoku, Patrz: code-behind kolekcja, 163 modyfikowanie, 184 w aplikacji mobilnej, 271 w modelu widoku, 172 zachowań, 74 konsola Xbox, 307 kontrolka, 111 DatePicker, 186, 189 definiowanie, 121 dziedzicząca po Shape, Patrz: kształt Ellipse, 215 Grid, 38, Patrz też: siatka Line, 215 ListBox, 177, 184, 289 Path, 215 projektowana przez użytkownika, 121, 234, 239 Rectangle, 215 rozmiar, 14 Slider, 12 styl, Patrz: styl szablon, Patrz: szablon kontrolki TextBlock, 176 wiązanie, 57 widoku, 101 WPF, 75 konwerter, 53, 54, 55, 57, 234, 276 AlternationConverter, 60 BooleanToVisibilityConverter, 60, 278 BoolToBrushConverter, 237 BoolToVisibilityConverter, 178 BorderGapMaskConverter, 60 ColorToSolidColorBrushConverter, 96 DataGridLengthConverter, 60 definiowanie, 179 JournalEntryListConverter, 60 JournalEntryUnifiedViewConverter, 60 MenuScrollingVisibilityConverter, 60 ProgressBarBrushConverter, 60 ProgressBarHighlightConverter, 60 testowanie, 83, 95 wbudowany, 60 ZoomPercentageConverter, 60 kształt, 215 L lista, 156, 177, 179 sortowanie, Patrz: sortowanie ListBox, Patrz: lista M manifest, 259 menedżer stanów wizualnych, 312 metoda CanExecute, 61, 65, 102, 103, 188, 240 Convert, 53, 56, 181 ConvertBack, 53, 56, 181 Execute, 61, 63, 102, 103 GetProperty, 91 OnCanExecuteChanged, 240 OnPropertyChanged, 103 OnSuspending, 251, 281 ScrollToBottom, 189 SetField, 91, 92 SetProperty, 91 ShowAsync, 303 Sort, 190 XDocument.Save, 271 mock object, Patrz: obiekt atrapa model, 106 pasywny, 193 testowanie, 83 tworzenie, 99 widoku, 27, 29, 44, 46, 53, 103, 106, 169, 188, 193, 216 instancja, 37 kolekcja, Patrz: kolekcja w modelu widoku testowanie, 83 tworzenie, 31, 33, 34, 35, 102 wiązanie widoku, 103, 104 multibinding, 56, 57, 279, 303 O obiekt atrapa, 92, 94 Windows.Storage.ApplicationData. Current.LocalFolder, 271 Poleć książkęKup książkę 318 MVVM i XAML w Visual Studio 2015 Windows.Storage.ApplicationData. Current.LocalSettings, 249 Windows.Storage.ApplicationData. Current.RoamingSettings, 249 wstrzykiwanie, 93 okno dialogowe, 193, 194, 196 łańcuch, 209 MessageBox, 199 w aplikacji Windows Phone, 291 wyboru pliku, 205 wyświetlenie warunkowe, 203 zawartość, 210, 301 pasek tytułu, 223 przesuwanie, 223 przezroczystość, 222 operator ., 40 ?, 40 dostępu, 40 P pasek aplikacji, Patrz: aplikacja pasek pędzel, 115, 215 LinearGradientBrush, 115, 116, 125 RadialGradientBrush, 116 SolidColorBrush, 237 plik App.config, 22 App.xaml.cs, 249, 251, 313 domyślny aplikacji, 11 JSON, 168 XML, 167, 168 pojemnik RelativePanel, 311 pole opcji, 69, 156 polecenie, 61 CommandAfter, 202 CommandBefore, 198, 202 Create IntelliTests, 88 Show, 198 uruchamianie, 62, 66 projekt aplikacji uniwersalnej, Patrz: aplikacja uniwersalna domyślny, 265 współdzielony, 234, 235, 237, 265, 276 projektowanie domenowe, Patrz: DDD przestrzeń nazw domyślna, 15 local, 13, 15 mc, 16 Microsoft.VisualStudio.TestTools.UnitTesting, 90 s, 186 System, 100 System.Windows, 186 System.Windows.Data, 53, 237 System.Windows.Input, 186 System.Windows.Media, 237 Windows.UI.Xaml.Data, 237 x, 15 przycisk, 111, 311 aktywny, 118 definiowanie, 121 tekst, 118 wygląd, 111, 119 zagnieżdżanie, 155, 160 R reguła DRY, 123 routed event, Patrz: zdarzenie trasowane S siatka, 38, 123 smartfona emulator, Patrz: emulator smartfona pędzel, 215 sortowanie, 190 splash screen, Patrz: ekran powitalny stos StackPanel, 134 styl, 127, 151 lokalizacja, 127, 130, 131 Surface Hub, 307 suwak, 16, 53 szablon danych, 175 kontrolki, 149, 150, 151 Ś ścieżka, 225 środowisko Blend, 148 projektowe Expression Blend, 16, 118 T tabletu emulator, Patrz: emulator tabletu test dostęp do pól testowanej klasy, 90 IntelliTest, 88 jednostkowy, 83, 95, 97 tworzenie, 85, 87, 88 uruchamianie, 88 Visual Studio 2013, 84, 86, 87 konwertera, 95 Poleć książkęKup książkę Skorowidz 319 wielokrotny, 89 wyjątku, 96 testowanie funkcjonalne, 9 tile, Patrz: kafelek transformacja animowana, Patrz: animacja CompositeTransform, 140 kompozycji, 134, 135, 137, 215 MatrixTransform, 140 obrotu, 220 renderowania, 135, 137 złożona, 140 tunelowanie, 159 tunneling, Patrz: tunelowanie typ ApplicationDataContainer, 249 byte, 53 Comparison, 190 DateTime, 216 DependencyProperty, 79 double, 53, 89 int, 89 konwersja, 53, 55 MessageDialogBoxButton, 298 parametryczny, 93 SuspendingDeferral, 252 U Universal Windows Platform, Patrz: UWP urządzenie IoT, 307 user control, Patrz: kontrolka projektowana przez użytkownika UWP, 307, 309 V Visual Studio, 255 Visual Studio 2010, 84 Visual Studio 2013, 173, 231, 233 Visual Studio 2015, 86, 87, 103, 173, 231, 233, 307, 309 W warstwa, 193 dostępu do danych, Patrz: DAL logiki biznesowej, Patrz: BLL modelu, 25, 26, 29 widoku, Patrz: widok dla Windows Phone 8.1, 265 wiązanie danych, Patrz: dane wiązanie widok, 26, 106, 186, 234 model, Patrz: model widoku tworzenie, 100 warstwa, Patrz: warstwa widoku Windows 10, 307 Windows 8.1, 233, 234, 242, 255 Windows Forms, 9 Windows Phone, 265, 291 Windows Phone 8.1, 234, 265 Windows Phone Runtime, 231 Windows Phone Store, 259 Windows Presentation Foundation, Patrz: WPF Windows Runtime, 231, 239, 282 Windows Store, 259 WinRT, Patrz: Windows Runtime wirtualizacja Hyper-V, 233 własność, 20 Angle, 143 Background, 115 Caption, 194 Center, 111 ColumnDefinitions, 123 Content, 111, 210 Current, 249 DataContext, 194 DateTime.Now, 188, 216 DialogBypassButton, 204 DialogResult, 212 doczepiona, 79, 311 Fill, 39, 215 Foreground, 112, 115 Height, 111 IsDialogBypassed, 203 IsEnabled, 178 LayoutTransform, 133, 134 Opacity, 222 OriginalSource, 159 Page.BottomAppBar, 288 RenderTransform, 133, 215 RowDefinitions, 123 SelectedIndex, 188, 289 Source, 159 Stroke, 215 StrokeThickness, 215 Visibility, 178 Width, 111 WindowContent, 210 WPF, 10 wyjątek ArgumentOutOfRangeException, 100 NotImplementedException, 96 NullReferrenceException, 40 testowanie, 96 wyzwalacz, 129 Poleć książkęKup książkę 320 MVVM i XAML w Visual Studio 2015 wzorzec MVC, 25 MVP, 25 MVVM, 25, 83, 99, 103, 106, 188, 193, 231, 233, 234 Z zachowanie, 73 definiowanie, 73 kolekcja, 74 zdarzenie, 16 bulgotanie, Patrz: bulgotanie CanExecuteChanged, 61, 235, 283 Click, 189 CollectionChanged, 174 kontrolki, 9 ., 40 ?, 40 Paint, 215 PreviewKeyDown, 159 PreviewMouseDown, 159 przekształcanie w polecenie, 69 RoutedEventArgs, 159 trasowane, 153 kontrola przepływu, 156 przerwanie sekwencji, 158 Window.Closed, 61 zegar, 216, 217, 227 analogowy, 218 tarcza, 222 znacznik, Patrz: element znak Poleć książkęKup książkę
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

MVVM i XAML w Visual Studio 2015
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ą: