Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00324 007133 12250238 na godz. na dobę w sumie
Wprowadzenie do WPF. Tworzenie aplikacji w WPF przy użyciu XAML i C# - ebook/pdf
Wprowadzenie do WPF. Tworzenie aplikacji w WPF przy użyciu XAML i C# - ebook/pdf
Autor: Liczba stron: 208
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-283-3699-5 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> .net - programowanie
Porównaj ceny (książka, ebook (-20%), audiobook).

Rozpocznij przygodę z programowaniem dla systemu Windows!

Technologia Windows Presentation Foundation firmy Microsoft to jedno z najlepszych rozwiązań do tworzenia aplikacji działających pod kontrolą systemu Windows. WPF integruje interfejs użytkownika, grafikę, multimedia i dokumenty oraz ułatwia implementację wzorców projektowych, które oddzielają warstwę logiczną od warstwy prezentacji. Dużą zaletą tej technologii jest możliwość kompozycji i adaptacji poszczególnych elementów, z których budowany jest interfejs.

Jeśli uczysz się programowania od niedawna i chcesz tworzyć aplikacje desktopowe przy użyciu technologii WPF, to jest to książka dla Ciebie! Z jej pomocą szybko rozpoczniesz pisanie programów. W ten sposób, tworząc kolejne aplikacje okienkowe, będziesz poznawać kluczowe możliwości tej platformy.

Podręcznik nie przedstawia wszystkich podstawowych funkcji zapewnianych przez WPF, ponieważ nie są one potrzebne na początkowym etapie nauki. Opracowanie prostej aplikacji o charakterze biznesowym nie wymaga wykorzystania grafiki 3D czy animacji, nieodzowna jest tu natomiast znajomość podstawowych kontrolek, paneli oraz kluczowych mechanizmów, takich jak wiązanie danych. I właśnie tego nauczysz się, pisząc z tą książką swoje pierwsze programy z użyciem WPF!

Sięgnij po doskonały przewodnik dla początkujących programistów!


Informacja dla Czytelnika: książka jest aktualna dla wersji Visual Studio 2017.

---
Anna Kempa jest autorką kursu Videopoint.pl oraz współautorką podręcznika Wstęp do programowania w C#. Łatwy podręcznik dla początkujących.

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

Darmowy fragment publikacji:

Autorka: Anna Kempa – pracownik naukowo-dydaktyczny Wydziału Informatyki i Komunikacji Uniwersytetu Ekonomicznego w Katowicach Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną, fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym powoduje naruszenie praw autorskich niniejszej publikacji. Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądź towarowymi ich właścicieli. Autor oraz Wydawnictwo HELION dołożyli wszelkich starań, by zawarte w tej książce informacje były kompletne i rzetelne. Nie biorą jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane z tym ewentualne naruszenie praw patentowych lub autorskich. Autor oraz Wydawnictwo HELION nie ponoszą również żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji zawartych w książce. Redaktor prowadzący: Małgorzata Kulik Projekt okładki: Jan Paluch Fotografia na okładce została wykorzystana za zgodą Shutterstock.com Wydawnictwo HELION ul. Kościuszki 1c, 44-100 GLIWICE tel. 32 231 22 19, 32 230 98 63 e-mail: helion@helion.pl WWW: http://helion.pl (księgarnia internetowa, katalog książek) Drogi Czytelniku! Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres http://helion.pl/user/opinie/jchata Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję. Kody źródłowe wybranych przykładów dostępne są pod adresem: ftp://ftp.helion.pl/przyklady/jchata.zip ISBN: 978-83-283-3272-0 Copyright © Helion 2017 Printed in Poland. • Kup książkę • Poleć książkę • Oceń książkę • Księgarnia internetowa • Lubię to! » Nasza społeczność Spis treści Wstęp .............................................................................................. 9 Dla kogo jest ta książka? .................................................................................................. 9 Jak czytać tę książkę? ..................................................................................................... 10 Zakres książki ................................................................................................................. 11 Rozdział 1. Przed przystąpieniem do zadań ....................................................... 13 1.1 Instalacja środowiska i uruchomienie aplikacji WPF ............................................... 13 1.2 Wymagany zakres znajomości języka C# ................................................................. 15 1.3 Podstawy WPF ......................................................................................................... 21 1.4 Podstawy XAML ...................................................................................................... 22 1.5 Sterowanie rozmiarem i pozycją elementów ............................................................ 29 Rozdział 2. Pierwsza aplikacja — Przywitanie ................................................... 33 2.1 Warstwa prezentacji, czyli jak ma wyglądać ............................................................ 33 2.2 Code-behind, czyli jak ma działać ............................................................................ 37 2.3 Zadania ..................................................................................................................... 40 2.4 Wskazówki do zadań ................................................................................................ 41 Rozdział 3. Podstawowe kontrolki .................................................................... 45 3.1 Kontrolki Label, TextBox, Button — aplikacja Kwadrat ......................................... 45 3.2 Kontrolki ComboBox i CheckBox — aplikacja Rysowanie kwadratu ..................... 48 3.3 Zadania ..................................................................................................................... 50 3.4 Wskazówki do zadań ................................................................................................ 51 Rozdział 4. Panele ........................................................................................... 53 4.1 Canvas ...................................................................................................................... 53 4.2 StackPanel ................................................................................................................ 54 4.3 WrapPanel ................................................................................................................ 56 4.4 DockPanel ................................................................................................................ 56 4.5 Grid ........................................................................................................................... 57 Rozdział 5. Wiązanie danych — aplikacja Produkt ............................................. 61 5.1 Testowanie wiązania danych .................................................................................... 61 5.2 Kod XAML .............................................................................................................. 63 5.3 Definicja klasy Produkt i code-behind ...................................................................... 65 5.4 Zadania ..................................................................................................................... 67 5.5 Wskazówki do zadań ................................................................................................ 68 Poleć książkęKup książkę 6 Wprowadzenie do WPF. Tworzenie aplikacji w WPF przy użyciu XAML i C# Rozdział 6. Wiązanie kolekcji danych — aplikacja Lista produktów ................... 71 6.1 Kod XAML .............................................................................................................. 71 6.2 Definicja klasy Produkt i code-behind ...................................................................... 72 6.3 Sortowanie wykazu ................................................................................................... 73 6.4 Formatowanie danych w wykazie ............................................................................. 74 6.5 Wyrównanie tekstu w kolumnie ............................................................................... 75 6.6 Filtrowanie danych ................................................................................................... 76 6.7 Edycja danych w nowym oknie ................................................................................ 78 6.8 Zadania ..................................................................................................................... 80 6.9 Wskazówki do zadań ................................................................................................ 81 Rozdział 7. Kontrolka DataGrid — aplikacja Edycja produktów .......................... 85 7.1 Kontrolka DataGrid z autogenerowaniem kolumn ................................................... 85 7.2 Definiowanie kolumn dla DataGrid .......................................................................... 88 7.3 Kolumna DataGridComboBoxColumn ..................................................................... 89 7.4 Wiązanie kontrolki DataGrid z dokumentem XML .................................................. 90 7.5 Zadania ..................................................................................................................... 93 7.6 Wskazówki do zadań ................................................................................................ 94 Rozdział 8. Menu — aplikacja Przeglądarka www ........................................... 101 8.1 Kod XAML ............................................................................................................ 101 8.2 Code-behind ........................................................................................................... 104 8.3 Zadania ................................................................................................................... 107 8.4 Wskazówki do zadań .............................................................................................. 108 Rozdział 9. Zakładki (TabControl) — aplikacja Odtwarzacz audio .................... 111 9.1 Kod XAML ............................................................................................................ 111 9.2 Code-behind ........................................................................................................... 113 9.3 Zadania ................................................................................................................... 116 9.4 Wskazówki do zadań .............................................................................................. 116 Rozdział 10. Zasoby, style i wyzwalacze ........................................................... 119 10.1 Zasoby binarne ..................................................................................................... 119 10.2 Zasoby logiczne .................................................................................................... 120 10.3 Style ...................................................................................................................... 126 10.4 Wyzwalacze .......................................................................................................... 131 Wyzwalacze właściwości ..................................................................................... 132 Wyzwalacze danych ............................................................................................. 132 Warunki logiczne w wyzwalaczach ...................................................................... 135 Rozdział 11. Szablony danych, konwertery i szablony kontrolek ......................... 137 11.1 Drzewo logiczne i drzewo prezentacji .................................................................. 137 11.2 Szablony danych — aplikacja Lista zadań ............................................................ 141 11.3 Konwertery wartości ............................................................................................. 145 11.4 Szablony kontrolek ............................................................................................... 147 11.5 Zadania ................................................................................................................. 150 11.6 Wskazówki do zadań ............................................................................................ 151 Rozdział 12. Walidacja danych ......................................................................... 153 12.1 Wbudowane mechanizmy walidacji ..................................................................... 153 12.2 Definiowanie własnych reguł walidacji ................................................................ 158 12.3 Wyrażenia regularne ............................................................................................. 160 12.4 Zadania ................................................................................................................. 167 12.5 Wskazówki do zadań ............................................................................................ 168 Poleć książkęKup książkę Spis treści 7 Rozdział 13. Wprowadzenie do wzorca projektowego MVVM ............................. 175 13.1 Model-View-ViewModel ..................................................................................... 176 13.2 Budujemy widok dla przykładowej aplikacji ........................................................ 177 13.3 Implementacja modelu .......................................................................................... 178 13.4 Implementacja modelu widoku ............................................................................. 181 13.5 Przed dalszą nauką MVVM .................................................................................. 183 Rozdział 14. Trochę teorii na temat WPF .......................................................... 187 14.1 Hierarchia klas WPF.............................................................................................. 187 14.2 Kontrolki ............................................................................................................... 189 Kontrolki z zawartością wpisywaną do właściwości Content.................................... 190 Kontrolki z zawartością Items.................................................................................... 194 Kontrolki tekstowe..................................................................................................... 197 Kontrolki zakresu....................................................................................................... 198 Pozostałe kontrolki .................................................................................................... 199 14.3 Kierunki dalszej nauki WPF.................................................................................... 200 Literatura ..................................................................................... 203 Skorowidz .................................................................................... 205 Poleć książkęKup książkę 8 Wprowadzenie do WPF. Tworzenie aplikacji w WPF przy użyciu XAML i C# Poleć książkęKup książkę Wstęp Windows Presentation Foundation (WPF) firmy Microsoft jest jedną z wiodących technologii do tworzenia desktopowych aplikacji dla systemu Windows. Integruje in- terfejs użytkownika, grafikę 2D i 3D, multimedia oraz dokumenty. Umożliwia definiowa- nie interfejsu użytkownika w deklaratywnym języku XAML, a także pozwala na łatwą implementację wzorców projektowych, które oddzielają warstwę logiczną od warstwy prezentacji. Ponieważ jest zbudowany na bazie Direct3D, aplikacje WPF korzystają z przyspieszenia sprzętowego. Znaczącym walorem WPF jest możliwość kompozycji i adaptacji poszczególnych elementów, z których budowany jest interfejs. Czy nauka tak zaawansowanego narzędzia jest trudna? Trud wkładany w naukę pro- gramowania (i wielu innych dziedzin) jest zazwyczaj stanem przejściowym, postrze- ganym jako doraźne, tymczasowe problemy, które mogą wystąpić na każdym etapie nauki. Wraz z nabywaniem doświadczenia każdy programista uświadamia sobie, że ewentualne trudności tkwią nie tyle w stopniu skomplikowania danego narzędzia, ile w dostępności odpowiednich materiałów, w tym dokumentacji i podręczników. Starsze pokolenie programistów ― które uczyło się programować jeszcze przed upowszechnie- niem internetu i przy ograniczonej ofercie podręczników w księgarniach — szczególnie docenia ten aspekt. Obecnie nie brakuje pomocy naukowych, a zróżnicowanie oferty pozwala na bardziej swobodny dobór źródeł dostosowanych do oczekiwań Czytelnika. Niniejszy podręcznik dedykowany jest osobom początkującym. Nie przedstawia wszystkich bazowych funk- cjonalności dostarczanych przez WPF. Główny akcent położony jest na podstawach, umożliwiających zbudowanie biznesowej aplikacji, bez animacji i grafiki 3D. Kolejną cechą książki jest jej zadaniowy charakter ― większość rozdziałów opisuje wykonanie konkretnej aplikacji. Dla kogo jest ta książka? Podręcznik jest przeznaczony dla osób początkujących, które niedawno rozpoczęły naukę programowania i znają podstawy C#. Nie wymaga znajomości Windows Forms ani innych rozwiązań służących do tworzenia interfejsu graficznego. Celem książki Poleć książkęKup książkę 10 Wprowadzenie do WPF. Tworzenie aplikacji w WPF przy użyciu XAML i C# jest ułatwienie pierwszych kroków w zakresie technologii WPF i języka XAML. Takie przygotowanie umożliwi Czytelnikowi samodzielne wykonanie prostych aplikacji bizne- sowych, a ponadto utoruje drogę do dalszej nauki WPF w oparciu o bardziej zawanso- wane źródła, w tym dokumentację techniczną. Wprowadzający charakter podręcznika pozwala polecać jego lekturę studentom i uczniom szkół średnich oraz wszystkim innym osobom, które mają powody i ochotę nauczyć się WPF i nie mają dużego doświadczenia informatycznego. Jak czytać tę książkę? Podręcznik został przygotowany raczej do pracy z WPF niż do czytania o WPF. Roz- dział 1. wprowadza w podstawowe zagadnienia dotyczące WPF i XAML, tak aby moż- liwie szybko można było przejść do praktycznego etapu nauki. Większość rozdziałów opisuje wykonanie kompletnych i niezależnych aplikacji. Tytułowe pytanie powinno zatem brzmieć: jak pracować z tą książką? Zalecane jest wykonywanie omawianych programów według podanych objaśnień. Kody programów można pobrać ze strony http://helion.pl/pobierz-przyklady/jchata/. Dostępne są w dwóch wersjach: do nauki oraz w postaci gotowych projektów1. Polecam korzystanie przede wszystkim z tej pierwszej wersji, przeznaczonej do nauki, która zawiera pliki tekstowe z fragmentami kodu opatrzone krótkimi komentarzami. Na podstawie wyjaśnień ujętych w treści podręcznika można z owych fragmentów, niczym z klocków, budować program. Jest to sposób znany z wielu poradników i podręczników software’owych, który do- brze sprawdza się w przypadku nauki takich technologii jak WPF. Budowanie aplikacji z przygotowanych „klocków” nie polega jednak na bezmyślnym używaniu opcji Kopiuj i Wklej. Praca taka wymaga analizy poszczególnych fragmentów kodu w oparciu o wyja- śnienia zawarte w podręczniku i w innych źródłach (zwłaszcza jeśli ktoś uczy się jedno- cześnie C#). Przesadne dążenie do zrozumienia od razu wszystkiego w każdym frag- mencie programu też nie jest wskazane. Wiele rzeczy będzie się powtarzać w kolejnych programach, w nowych odsłonach. Ponadto będą zadania do samodzielnego wykonania, różne modyfikacje, będzie wiele okazji do tego, aby przekonać się, czy dany mechanizm bądź konstrukcja są zrozumiałe. Jak wspomniałam kody programów dostępne są tak- że w postaci gotowych projektów, do których można zajrzeć w przypadku większych trudności z uruchomieniem swojej wersji programu. Na końcu większości rozdziałów znajdują się podrozdziały z zadaniami i wskazówkami. Czytelnik może samodzielnie pracować nad danym programem i w razie konieczności korzystać ze szczegółowych wskazówek i propozycji rozwiązań. Zachęcam Czytelnika do przeglądania dokumentacji technicznej w trakcie tych prac w celu bliższego poznania danej klasy, jej właściwości czy metod. 1 Wśród gotowych projektów nie ma programów dla zadań do samodzielnego wykonania. Dla takich zadań umieszczono w treści podręcznika jedynie wskazówki i szczegółowe wyjaśnienia. Poleć książkęKup książkę Wstęp 11 Zadaniowy charakter książki daje Czytelnikowi w trakcie pracy dużo okazji do satys- fakcji. Tworzone programy prezentują wizualne, od razu widoczne efekty. Zachęcam to kreatywności i doskonalenia danego programu według własnych upodobań z użyciem poznanych na danym etapie konstrukcji i mechanizmów. Opisy objaśniające wykonanie danego programu, gdyby patrzeć na nie „z boku”, to znaczy nie angażując się w proces tworzenia, mogą się wydać zbyt techniczne. Wynika to w dużej mierze ze specyfiki WPF (i innych zaawansowanych rozwiązań wspomagających tworzenie GUI), dla której trafne jest polskie przysłowie „diabeł tkwi w szczegółach”. Tworzenie interfejsu wymaga ustalenia wielu drobnych detali, których opisanie nie brzmi jak lektura do poczytania. Ponadto WPF ma trochę swoich „osobliwości”, do których należą m.in. właściwości dołączone, nazywane przez niektórych „magią WPF”. Proszę się nie obawiać — to wszystko ma swoje solidne uzasadnienie i ani się Czytelnik zorientuje, jak zacznie swobodnie używać tych i innych poznanych tu rozwiązań WPF. Podsumowując: po- wody do zadowolenia znajdzie Czytelnik przede wszystkim w wyniku naszej współ- pracy — w postaci działających programów uruchamianych na swoim komputerze, a na- stępnie samodzielnie modyfikowanych. Zakres książki W WPF wiele rzeczy można zrobić na kilka różnych sposobów. W tym podręczniku przedstawiam tylko wybrane sposoby. Wśród zastosowanych kryteriów wyboru moż- na wymienić popularność i jakość danego rozwiązania. Niemniej w niektórych przy- padkach, zwłaszcza na początku książki, uwzględniam stopień trudności, prezentując prostszy sposób. To ostatnie kryterium traci na znaczeniu wraz z zaawansowaniem nauki w kolejnych rozdziałach. Zaraz po zapoznaniu się z podstawami WPF opisanymi w roz- dziale 1. można przystąpić w rozdziale 2. do wykonania pierwszej prostej aplikacji, zawierającej dwa przyciski. Pierwsze programy będą tworzone w tak zwanym widoku autonomicznym (zbliżonym nieco do Windows Forms). Takie programowanie ma swoje wady, ujawniające się w bardziej złożonych projektach, do których zalicza się brak dostatecznej elastyczności czy utrudnienia dotyczące testowania aplikacji. Zaletą tego podejścia jest natomiast większa przystępność dla osób uczących się. Można wyko- rzystać tę zaletę i jeszcze przed wprowadzeniem bardziej zaawansowanych zagadnień omówić podstawowe elementy WPF, które są niezależne od stylu programowania. Program realizowany w rozdziale 3. będzie wymagał zdefiniowania większej liczby kontrolek, co zrodzi potrzebę bardziej uporządkowanego podejścia do planowania in- terfejsu. Odpowiedź na to zapotrzebowanie przynosi rozdział 4., opisujący standardowe panele, pozwalające zarządzać układem graficznym elementów. Zaraz później, w roz- dziale 5., Czytelnik dokona kolejnego ważnego kroku, mianowicie pozna wiązanie danych. Wówczas okaże się, że część mrówczej pracy wykonanej w rozdziale 3. może być zastąpiona przez ten nieoceniony mechanizm WPF. W dwóch kolejnych rozdziałach zostały przedstawione aplikacje wykorzystujące kontrolki przewidziane dla kolekcji danych — ListView i DataGrid. Rozdziały 8. i 9. prezentują możliwości kontrolek służą- cych do tworzenia menu oraz zakładek (Menu i TabControl) na przykładzie popularnych aplikacji — przeglądarki www i odtwarzacza audio. Rozdział 10. traktuje o ważnych zagadnieniach, takich jak zasoby, style i wyzwalacze, dzięki którym definiowanie in- terfejsu jest bardziej wygodne i profesjonalne. Bogate możliwości WPF w zakresie Poleć książkęKup książkę 12 Wprowadzenie do WPF. Tworzenie aplikacji w WPF przy użyciu XAML i C# kompozycji elementów interfejsu będzie można szerzej poznać w rozdziale 11., po- święconym przede wszystkim tematyce szablonów. Gdyby nie wiązanie danych, czyli specyficzny mechanizm WPF umożliwiający automatyczne aktualizacje danych, pod- ręcznik mógłby się w tym miejscu już zakończyć. Ale korzystanie w pełni z komfortu, jaki zapewnia to rozwiązanie, wymaga poznania sposobów wykonywania konwersji danych oraz ich walidacji. Konwertery zostały omówione w jednym z podrozdziałów rozdziału 11., natomiast walidacja danych ― w rozdziale 12. Rozdział kolejny zawiera wprowadzenie do wzorca projektowego MVVM, który opiera się na mechanizmie wią- zania danych i tak zwanych powiadomieniach. Zasady tego wzorca odbiegają od po- dejścia z zastosowaniem widoku autonomicznego. Wzorzec MVVM pozwala na bardziej konsekwentną separację logiki aplikacji i sposobu wyświetlenia danych, co wpływa na zwiększenie elastyczności programu i ułatwia jego testowanie. Rozdział 14., ostatni, zawiera uporządkowanie pewnych aspektów teoretycznych, głównie poprzez omówienie hierarchii klas WPF. Spoglądanie na diagramy dziedziczenia klas niczym na mapy pozwoli Czytelnikowi wyłonić to, co poznał w tym podręczniku podczas wykonywania zadań, oraz to, co pozostało mu do poznania. Podsumowując, zakres tej książki obejmuje: podstawy języka XAML (wykorzystywane- go w WPF do deklaratywnego opisania interfejsu), większość kontrolek (elementów wywodzących się z klasy Control) oraz wybrane elementy wywodzące się z klasy FrameworkElement. Czytelnik tej książki łatwo przyswoi mechanizmy i rozwiązania dostarczane przez WPF, takie jak wiązanie danych, wyzwalacze, konwertery, zasoby, style i szablony. Pozna także wybrane sposoby walidacji danych i podstawy wzorca projektowego MVVM. To wszystko, po dodaniu umiejętności w zakresie baz danych (będących poza tematem tego podręcznika), powinno przygotować Czytelnika do na- pisania aplikacji biznesowej. Gdyby porównać naukę WPF do zwiedzania jakiegoś większego miasta, to moglibyśmy powiedzieć, że ten podręcznik (jako przewodnik) proponuje uproszczoną trasę wy- cieczki po ciekawszych zakątkach miasta z pomięciem kilku ważnych miejsc, które po- leca podróżnikowi w przyszłości (w tym grafika 3D i animacje), oraz z pominięciem wielu mniejszych zakątków. Podręcznik ten należy zatem traktować jako pierwszą po- dróż i przetarcie szlaków. Mam nadzieję, że z jego pomocą będzie Czytelnikowi łatwiej zgłębiać zaawansowane możliwości WPF podczas dalszej nauki. Poleć książkęKup książkę Rozdział 5. Wiązanie danych — aplikacja Produkt Wiązanie danych w WPF jest mechanizmem, który ustanawia połączenie między dwiema właściwościami różnych obiektów. Jednym z ważniejszych zastosowań tego mechanizmu jest łączenie danych i wizualnych elementów interfejsu. Definiując wiązanie, należy określić źródło danych i cel wiązania. Źródłem danych może być obiekt, baza danych, zasób, XML ― właściwie „wszystko”. Natomiast celem powinna być właściwość zależna elementu WPF. Aby móc w pełni korzystać z automatyzmu, jaki dostarcza ten mechanizm, należy jeszcze uwzględnić kilka innych rozwiązań WPF, takich jak konwertery, walidacja danych, powiadomienia o zmianach czy wiązanie pole- ceń. Zagadnienia te zostaną przedstawione w dalszej części książki. Niemniej już teraz będzie można docenić wygodę wiązania danych. W niniejszym rozdziale w pierwszej kolejności przetestujemy wiązanie danych na prostym przykładzie z suwakiem, a następ- nie przystąpimy do wykonania aplikacji, w której zostanie ustanowione połączenie między polami tekstowymi a właściwościami obiektu klasy Produkt. Wykorzystamy umiejętności nabyte w poprzednim rozdziale i umieścimy kontrolki w oknie przy użyciu panelu. 5.1 Testowanie wiązania danych Wiązanie danych można wykonać w code-behind lub kodzie XAML. W tym przykładzie wykorzystamy ten drugi sposób. Otwórz nowy projekt WPF. W kodzie XAML ustaw atrybut Title= Test wiązania danych . Zmień także rozmiar okna aplikacji: Height= 200 Width= 550 . W oknie XAML podmień kod ze znacznikami Grid na następujący: StackPanel Slider x:Name= rozmiarTekstu Minimum= 10 Value= 15 Maximum= 45 / TextBlock FontSize= {Binding Path=Value, ElementName=rozmiarTekstu} Testujemy wiązanie danych /TextBlock /StackPanel Poleć książkęKup książkę 62 Wprowadzenie do WPF. Tworzenie aplikacji w WPF przy użyciu XAML i C# Programik ten można już uruchomić. Dzięki wiązaniu danych nie potrzebujemy ob- sługiwać zdarzenia dla zmiany wartości suwaka. Po uruchomieniu programu możemy przesuwać suwak i w ten sposób zwiększać lub zmniejszać rozmiar czcionki tekstu, jaki się wyświetla poniżej suwaka (rysunek 5.1). Rysunek 5.1. Testowanie wiązania danych z użyciem suwaka Suwak stanowi źródło dla omawianego wiązania danych. Natomiast blok tekstu jest celem tego wiązania. Zatem po obu stronach wiązania w tym przypadku są jakieś elementy WPF. Omówmy dokładnie przedstawiony kod XAML. W znaczniku Slider zdefiniowany jest suwak. Kontrolka ta ma więcej właściwości, tu zostały wykorzystane następujące: war- tość minimalna (Minimum), wartość aktualna (Value) oraz wartość maksymalna (Maximum). Znacznik TextBlock definiuje blok tekstu. Bez wiązania danych definicja tego elementu mogłaby wyglądać przykładowo tak: TextBlock FontSize= 15 Testujemy wiązanie danych /TextBlock Albo w zapisie równoważnym tak: TextBlock FontSize= 15 Text= Testujemy wiązanie danych / Skupmy się zatem na tym, co różni ten prosty zapis, podobny do wielu innych pre- zentowanych wcześniej w tej książce, od zapisu uwzględniającego wiązanie. Spójrzmy na kod: TextBlock FontSize= {Binding Path=Value, ElementName=rozmiarTekstu} Zamiast konkretnej wartości dla atrybutu FontSize przypisane jest wyrażenie w klam- rach. Wiązanie dwóch elementów w kodzie XAML realizowane jest za pomocą spe- cjalnego rozszerzenia znaczników Binding. Definiując wiązanie, po lewej stronie znaku przypisania określamy cel wiązania, tu jest to właściwość FontSize (rozmiar tekstu). Natomiast po prawej stronie znaku przypisania umieszcza się źródło wiązania. W klam- rach oprócz słowa Binding widzimy dwie właściwości: ElementName, która wskazuje źródło wiązania, oraz Path, która wskazuje właściwość obiektu źródłowego. Poleć książkęKup książkę Rozdział 5.  Wiązanie danych — aplikacja Produkt 63 Warto nadmienić, że można użyć alternatywnego rozszerzenia znaczników poprzez przekazanie obiektu Path do konstruktora. Dzięki temu znacznik otwierający TextBlock możemy zapisać także w następujący sposób: TextBlock FontSize= {Binding Value, ElementName=rozmiarTekstu} Jak widać, nie ma tu jawnego przypisania wartości do właściwości Path. Można także inaczej wykonać samo wiązanie w kodzie XAML ― używając Binding jako elementu XAML, jak w przykładzie: TextBlock TextBlock.FontSize Binding Path= Value ElementName= rozmiarTekstu / /TextBlock.FontSize Testujemy wiązanie danych /TextBlock Po „rozgrzewce” z suwakiem, która pozwoliła Czytelnikowi poznać istotę mechanizmu wiązania danych, przejdziemy w dalszej części rozdziału do pracy nad tworzeniem aplikacji Produkt. Zaczniemy od kodu XAML. 5.2 Kod XAML Nierzadko mamy do czynienia z przypadkiem, w którym kilka różnych kontrolek jest wiązanych z tym samym obiektem źródłowym (ale z różnymi jego właściwościami). W takich sytuacjach można skorzystać z kontekstu danych, który umożliwia podanie źródła danych w jednym miejscu, w elemencie nadrzędnym. Definicja kontekstu wy- konywana za pomocą właściwości DataContext może być umieszczona w kodzie XAML lub code-behind. W tym i w dwóch kolejnych rozdziałach użyjemy tego drugiego sposobu. Otwórz nowy projekt WPF. W kodzie XAML ustaw atrybut Title= Produkt . Zmień także rozmiar okna aplikacji: Height= 220 Width= 350 . W oknie XAML podmień kod ze znacznikami Grid i /Grid na następujący: Grid x:Name= gridProdukt Grid.RowDefinitions RowDefinition Height= Auto / RowDefinition Height= Auto / RowDefinition Height= Auto / RowDefinition Height= Auto / RowDefinition Height= Auto / /Grid.RowDefinitions Grid.ColumnDefinitions ColumnDefinition Width= Auto / ColumnDefinition Width= * / /Grid.ColumnDefinitions Poleć książkęKup książkę 64 Wprowadzenie do WPF. Tworzenie aplikacji w WPF przy użyciu XAML i C# Label Content= Symbol: Grid.Row= 0 Grid.Column= 0 Margin= 5 / TextBox Grid.Row= 0 Grid.Column= 1 Margin= 5 Text= {Binding Symbol} / Label Content= Nazwa: Grid.Row= 1 Grid.Column= 0 Margin= 5 / TextBox Grid.Row= 1 Grid.Column= 1 Margin= 5 Text= {Binding Nazwa} / Label Content= Liczba sztuk: Grid.Row= 2 Grid.Column= 0 Margin= 5 / TextBox Grid.Row= 2 Grid.Column= 1 Margin= 5 Text= {Binding LiczbaSztuk} / Label Content= Magazyn: Grid.Row= 3 Grid.Column= 0 Margin= 5 / TextBox Grid.Row= 3 Grid.Column= 1 Margin= 5 Text= {Binding Magazyn} / Button x:Name= btnPotwierdz Grid.Row= 5 Grid.Column= 0 Grid.ColumnSpan= 2 Margin= 4 MinWidth= 120 HorizontalAlignment= Center Content= Potwierdź Click= btnPotwierdz_Click / /Grid Panel składa się z 5 wierszy i 2 kolumn, przy czym w ostatnim wierszu, w którym defi- niowany jest przycisk Potwierdź, dwie kolumny zostały połączone (poprzez ustawienie właściwości Grid.ColumnSpan= 2 ). Dla pól tekstowych atrybut Text ma przypisaną wartość, umożliwiającą wiązanie z poszczególnymi właściwościami klasy (klasę Produkt wykonamy w kolejnym podrozdziale). I tak przykładowo pole tekstowe, w którym będzie wpisywany symbol produktu, ma dla tego atrybutu wartość: Text= {Binding Symbol} , co oznacza, że zostanie powiązane z właściwością Symbol. Wykorzystano tu zapis pozwalający pominąć jawne przypisanie właściwości Path. Można by użyć także alternatywnego zapisu: Text= {Binding Path= Symbol} . Należy zwrócić uwagę na to, że panel Grid ma tu swoją nazwę — x:Name= gridProdukt . Ta nazwa zostanie wy- korzystana w code-behind do przypisania kontekstu dla wiązania danych. Wewnątrz pa- nelu tylko jeden element ma nadaną nazwę — przycisk Potwierdź (btnPotwierdz). Dzięki wiązaniu danych nie ma potrzeby używać nazw pozostałych elementów w code-behind. Dla przedstawionego kodu XAML otrzymamy okno w widoku Design, jak na rysunku 5.2. Rysunek 5.2. Panel Grid aplikacji Produkt Poleć książkęKup książkę Rozdział 5.  Wiązanie danych — aplikacja Produkt 65 5.3 Definicja klasy Produkt i code-behind W dalszym kroku stworzymy nową klasę w osobnym pliku1. Plik nazwijmy Produkt.cs. Należy tam umieścić kod klasy: class Produkt { public string Symbol { get; set; } public string Nazwa { get; set; } public int LiczbaSztuk { get; set; } public string Magazyn { get; set; } public Produkt(string sym, string naz, int lszt, string mag) { Symbol = sym; Nazwa = naz; LiczbaSztuk = lszt; Magazyn = mag; } public override string ToString() { return String.Format( {0} {1} {2} {3} , Symbol, Nazwa, LiczbaSztuk, Magazyn); } } Kod klasy jest prosty, zawiera cztery publiczne właściwości opisujące produkt, kon- struktor oraz metodę ToString, zwracającą informacje o produkcie. W pliku MainWindow.xaml.cs należy podmienić kod klasy MainWindow na następujący: public partial class MainWindow : Window { private Produkt p1 = null; public MainWindow() { InitializeComponent(); PrzygotujWiazanie(); } private void PrzygotujWiazanie() { p1 = new Produkt( DZ-10 , długopis żelowy , 132, Katowice 1 ); gridProdukt.DataContext = p1; } } 1 Aby dodać nowy plik w projekcie, należy kliknąć nazwę projektu w oknie Solution Explorer, a następnie po naciśnięciu prawego klawisza myszy wybrać opcję Add/Class. Poleć książkęKup książkę 66 Wprowadzenie do WPF. Tworzenie aplikacji w WPF przy użyciu XAML i C# W metodzie PrzygotujWiazanie tworzony jest obiekt klasy Produkt i ustawiany jest kontekst dla wiązania danych. Wiązanie będzie realizowane z kontrolkami tego panelu, którym przypisano (w kodzie XAML) rozszerzenie znaczników Binding, np. Text= {Binding Symbol} . Została nam już tylko ostatnia rzecz do wykonania w tym programie, mianowicie de- finicja metody obsługującej zdarzenie kliknięcia przycisku Potwierdź. Kliknij w tym celu dwa razy lewym klawiszem myszy ten przycisk w widoku Design i wpisz kod metody: private void btnPotwierdz_Click(object sender, RoutedEventArgs e) { string tekst = String.Format( {0}{1}{2} , Wprowadzono dane: , Environment.NewLine, p1.ToString()); MessageBox.Show(tekst); } Ponieważ nigdzie nie zapisujemy danych, metodę tę wykorzystamy jedynie do tego, aby wyświetlić informacje o produkcie. Program można już uruchomić. Wstępnie poja- wiają się dane dla produktu, można je dowolnie zmienić, a następnie kliknąć przycisk Potwierdź (rysunek 5.3). Rysunek 5.3. Testowanie aplikacji Produkt W programie nie wykonaliśmy walidacji, czyli sprawdzania poprawności danych, jakie wprowadza użytkownik. Mimo to pewne możliwości program w tym zakresie posiada. Popatrzmy na rysunek 5.4. Po wpisaniu tekstu XXX w polu Liczba sztuk i kliknięciu do- wolnego innego pola (lub przycisku) obramowanie tego pola zmienia kolor na czerwony. Rysunek 5.4. Walidacja pola tekstowego Poleć książkęKup książkę Rozdział 5.  Wiązanie danych — aplikacja Produkt 67 Nie jest możliwa konwersja tekstu XXX do danej typu int, czyli typu właściwości LiczbaSztuk (z klasy Produkt) połączonej z tą kontrolką. Wyświetlenie czerwonej ramki pola tekstowego zapewnia domyślny szablon2, nie zapewnia on jednak stosownego ko- munikatu. Ponadto nie mamy obecnie możliwości sprawdzania poprawności formatu danych. Przykładowo wiedząc, że symbol produktu składa się z sekwencji dużych liter, łącznika oraz kilku cyfr, moglibyśmy sprawdzić, czy użytkownik wpisał poprawny sym- bol. Istnieje kilka sposobów przeprowadzenia takiej walidacji danych, wybrane z nich zostaną opisane w rozdziale 12. 5.4 Zadania W pierwszym zadaniu należy dowiązać kilka kontrolek do jednej. Drugi program będzie wymagał zmiany sposobu aktualizacji kontrolki. Natomiast ostatnie zadanie wymaga użycia właściwości służącej do formatowania danej użytej w wiązaniu. Zadanie 5.1 Program testujący wiązanie danych z rozdziału 5.1 rozwiń o dwie nowe kontrolki, które mają podlegać wiązaniu: listę rozwijaną z listą kilku kolorów oraz pole tekstowe do wpi- sywania tekstu. Program ma wyświetlać zadany tekst w wybranym kolorze dla okre- ślonego rozmiaru (rysunek 5.5). Rysunek 5.5. Przykładowe działanie programu Zadanie 5.2 Wykonaj nową wersję programu z poprzedniego zadania, zmieniając element docelowy z TextBlock na TextBox. Po zmianie i uruchomieniu program będzie wyglądał bardzo podobnie, ale będzie widoczna zmiana w działaniu, a mianowicie będzie można zmienić element docelowy wiązania. Efekt tej zmiany jest jednak widoczny dopiero po zmianie fokusu (aktywacji innej kontrolki). Wykonaj taką wersję programu, aby zmiana w kie- runku od celu do źródła wiązania była natychmiastowa (podobnie jak to ma miejsce w drugą stronę). 2 Szablony zostaną przedstawione w rozdziale 11. Poleć książkęKup książkę 68 Wprowadzenie do WPF. Tworzenie aplikacji w WPF przy użyciu XAML i C# Zadanie 5.3 Uzupełnij program z poprzedniego zadania o nowy element — TextBlock, w którym będzie się wyświetlać aktualna liczba znaków tekstu umieszczonego w polu Tekst. W polu tym zaraz za liczbą znaków ma się wyświetlić tekst „znaków (znaki/znak)”. Wykorzystaj w tym celu właściwość StringFormat klasy Binding. Przykładowy efekt działania programu przedstawia rysunek 5.6. Rysunek 5.6. Przykładowe działanie programu 5.5 Wskazówki do zadań Wskazówki zawierają dość szczegółowe wyjaśniania i przykładowe propozycje roz- wiązania. Wskazówki do zadania 5.1 W programie mają być trzy kontrolki źródłowe: suwak dla rozmiaru czcionki, lista roz- wijana dla koloru czcionki i pole tekstowe do wpisywania tekstu, a także jedna kontrolka dla celu wiązania — blok tekstu. Należałoby jeszcze dodać trzy kontrolki z etykietą opisującą trzy źródłowe komponenty. W szczegółach zmiany względem bazowego pro- gramu wyglądałyby następująco: należy powiększyć nieco rozmiar okna, dodać nowe kontrolki, które zalecam ułożyć w panelu Grid mającym 4 wiersze i 2 kolumny, a ostatni element (TextBlock) powinien zajmować obie kolumny w ostatnim wierszu. Przykład użycia listy rozwijanej (ComboBox) został opisany w podrozdziale 3.2. Wpisz do listy an- gielskie nazwy kolorów (np. Black, Red, Green)3. Przykładowa realizacja wiązania danych w definicji znacznika TextBlock mogłaby wyglądać tak: TextBlock Grid.Row = 3 Grid.Column = 0 Grid.ColumnSpan= 2 Margin= 5 FontSize= {Binding Path=Value, ElementName=rozmiarTekstu} Text= {Binding Path=Text, ElementName=txtTekst} Foreground= {Binding Path=SelectedItem.Content, ElementName=cmbKolor} / 3 W jednym z dalszych rozdziałów dowiesz się, jak wykonać wiązanie danych z użyciem konwerterów wartości (wówczas nazwy kolorów będą mogły być polskie). Poleć książkęKup książkę Rozdział 5.  Wiązanie danych — aplikacja Produkt 69 Wskazówki do zadania 5.2 Możemy wykorzystać kod XAML znacznika TextBlock podany we wskazówkach do poprzedniego zadania. W pierwszej kolejności należy podmienić znacznik TextBlock na TextBox, zostawiając pozostałe ustawienia. To już wystarczy do testowania działania w domyślnym trybie aktualizacji. Zmiana elementu docelowego jest aktualizowana w elemencie źródłowym dopiero po utracie fokusu w kontrolce docelowej (czyli spra- wieniu, że kontrolka ta przestaje być aktywna). Po przeprowadzeniu testu można przejść do wykonania drugiej części zadania, mianowicie zmiany domyślnego sposobu aktualizacji elementu źródłowego. W wykonanych dotąd w tym rozdziale programach aktualizacja danych następowała od obiektu źródłowego do obiektu docelowego, ale może przebiegać także w drugim kierunku. W klasie Binding jest właściwość Mode, która przyjmuje jedną z wartości typu wyliczeniowego BindingMode. Typ ten zawiera pięć elementów4, wśród których są OneWay i TwoWay. Tryb OneWay oznacza, że element docelowy jest aktualizowany przy każdej zmianie źródła, natomiast tryb TwoWay oznacza aktualizację obustronną (od źródła do celu i od celu do źródła). Większość kontrolek ma domyślnie przypisany tryb OneWay, ale takie kontrolki jak TextBox, umożliwiające edycję danych, mają ustawiony domyśl- nie tryb TwoWay. W przypadku gdy aktualizacja następuje w kierunku od celu do źródła, można ją wy- konać na trzy sposoby: natychmiast, po utracie fokusu lub po jawnym wywołaniu metody aktualizującej źródło. Decyduje o tym właściwość UpdateSourceTrigger, której można przypisać wartość typu wyliczeniowego UpdateSourceTrigger. Wśród elementów tego typu są wartości5: PropertyChanged (natychmiastowa aktualizacja celu na pod- stawie źródła) i LostFocus (źródło jest aktualizowane po utracie fokusu). Domyślnym ustawieniem sposobu aktualizacji celu dla kontrolki TextBox jest LostFocus. Na pod- stawie przytoczonych informacji widzimy, że zmiana w naszym programie będzie niewielka. Wystarczy dodać do wyrażenia Binding przypisanie odpowiedniej wartości dla właściwości UpdateSourceTrigger. Definicja wiązania dla właściwości Text będzie wyglądać następująco: Text= {Binding Path=Text, ElementName=txtTekst, UpdateSourceTrigger= PropertyChanged} Wskazówki do zadania 5.3 Dodaj w panelu Grid nowy wiersz, a następnie dotychczasową lokalizację dla ostatniej kontrolki (TextBox) przenieś do nowego ostatniego wiersza (Grid.Row = 4 ). W wierszu powyższym dodaj w lewej kolumnie etykietę z opisem Długość, a w prawej kolumnie zdefiniuj element TextBlock według wzoru: 4 Wartości typu wyliczeniowego BindingMode („BindingMode Enumeration”): https://msdn.microsoft.com/en-us/library/system.windows.data.bindingmode(v=vs.110).aspx. 5 Wartości typu wyliczeniowego UpdateSourceTrigger („UpdateSourceTrigger Enumeration”): https://msdn.microsoft.com/en-us/library/system.windows.data.updatesourcetrigger(v=vs.110).aspx. Poleć książkęKup książkę 70 Wprowadzenie do WPF. Tworzenie aplikacji w WPF przy użyciu XAML i C# TextBlock Grid.Row = 3 Grid.Column = 1 HorizontalAlignment= Left Margin= 5,11,0,5 Text= {Binding StringFormat={}{0} znaków (znaki/znak), Path=Text.Length, ElementName=txtTekst} / Jeżeli wartość, do której określono wiązanie, ma być wyświetlona w innej postaci niż domyślna, można użyć właściwości StringFormat z klasy Binding. Jak wspomniałam w podrozdziale 1.4 na temat podstaw XAML, ujęcie wartości atrybutu w nawiasy klamrowe {} oznacza, że stanowi ona rozszerzenie znaczników. Jeśli na początku tekstu określającego wartość właściwości chcemy użyć nawiasu klamrowego jako zwykłego literału znakowego, nie traktowanego jako rozszerzenie znaczników, musimy przed nim (po znaku przypisania) użyć pustej pary nawiasów klamrowych. I tak jest właśnie w prezentowanym przykładzie: StringFormat={}{0} znaków (znaki/znak). Pusta para nawiasów klamrowych po znaku przypisania byłaby zbędna, gdyby wartość dla wła- ściwości StringFormat zaczynała się od innego znaku niż klamra. Na przykład przete- stuj taki wariant: StringFormat=liczba znków: {0}. Puste klamry byłyby zbędne także w przypadku, gdybyśmy użyli Binding jako elementu XAML. Wówczas kod znacznika dla bloku tekstu mógłby wyglądać tak: TextBlock Grid.Row = 3 Grid.Column = 1 HorizontalAlignment= Left Margin= 5,11,0,5 TextBlock.Text Binding Path= Text.Length ElementName= txtTekst Binding.StringFormat {0} znaków (znaki/znak) /Binding.StringFormat /Binding /TextBlock.Text /TextBlock Kod taki byłby jednak dłuższy i z tego powodu zazwyczaj wybierany jest ten pierwszy wariant. Zwróć uwagę, że choć definiowana tu kontrolka jest powiązana bezpośrednio tylko z jednym polem tekstowym, to efekt zmian w postaci aktualnej liczby znaków widzimy także wówczas, gdy użytkownik zmienia tekst w drugim polu tekstowym, co jest kon- sekwencją tego, że oba pola tekstowe są ze sobą powiązane. Właściwość StringFormat, którą wykorzystaliśmy w tym zadaniu, stanowi jedną z moż- liwości WPF w zakresie definiowania formatu wyświetlanej wartości dla wiązanych danych. W dalszej części książki (w rozdziale 11.) omówię inne możliwości, a mia- nowicie szablony danych i konwertery. Poleć książkęKup książkę Skorowidz A autonomiczny widok, 175 code-behind, 21, 25, 27 C D DataGrid, 85 autogenerowanie kolumn, 85 definiowanie kolumn, 88, 94 kolumna z listą rozwijaną, 89 wiązanie z XML, 90 diagram dziedziczenia klas WPF, 21, 187 dokument XML, 22, 90 dokumentacja MSDN, 20 drzewo logiczne, 21, 137 prezentacji, 21, 137 wizualne, patrz prezentacji dyrektywa using, 20 dziedziczenie stylu, 172 właściwości zależnych, 130 E element główny (XML), 22 Window (XAML), 25 element, patrz także kontrolka Ellipse, 148 Image, 52, 94, 110, 120 Rectangle, 48, 133 TextBlock, 61, 62, 75, 191 etykieta, 45 F filtrowanie, 76 fokus, 69 format Pack URI, 94 formatowanie, 74 H hierarchia klas WPF, 187 I instalacja środowiska, 13 interfejs, 18 ICommand, 182, 183 ICollectionView, 93, 97 IDataErrorInfo, 156, 171 INotifyDataErrorInfo, 158 INotifyPropertyChanged, 180 IValueConverter, 145 jednostka px, 35 język C#, 15 XAML, 22, 23 XML, 22 J K klasa Application, 28 ApplicationCommands, 109 Binding, 61, 69 Brushes, 42 ContentElement, 188 ContentPresenter, 148, 149 Control, 188, 189 Poleć książkęKup książkę 206 Wprowadzenie do WPF. Tworzenie aplikacji w WPF przy użyciu XAML i C# klasa DataErrorValidationRule, 156 DataTrigger, 132 DependencyObject, 188 DispatcherObject, 188 DispatcherTimer, 114 FrameworkContentElement, 188 FrameworkElement, 188 Freezable, 188 MainWindow, 27 MultiDataTrigger, 135 MultiTrigger, 135 Object, 188 ObservableCollection, 72, 185 OpenFileDialog, 96 Regex, 160 Selector, 194 Setter, 126, 127 Trigger, 132 UIElement, 188 UIElement3D, 188 ValidationResult, 159, 160 ValidationRule, 159 Visual, 188 Visual3D, 188 Window, 27 XElement, 92 kolory w WPF, 42 komentarze w XAML, 24 kontekst danych, 63 kontrolka, 189 Button, 45 Calendar, 199 CheckBox, 48 ComboBox, 48, 49 ContextMenu, 109, 195 DataGrid, 85 DatePicker, 200 Expander, 97, 99 GroupBox, 192 Label, 45 ListBox, 141 ListView, 71 Menu, 101, 195 MenuItem, 109 PasswordBox, 199 ProgressBar, 111, 112 RadioButton, 51, 55 RepeatButton, 192 Ribbon, 195 RichTextBox, 197, 198 ScrollBar, 198 ScrollViewer, 193 Separator, 199 Slider, 61, 117 StatusBar, 196 TabControl, 111 TextBox, 45, 108, 197 ToolBar, 102, 103 ToolTip, 110 TreeView, 110 WebBrowser, 102, 103, 106 konwertery typów, 147 wartości, 145 korzeń dokumentu XML, 22 kształty, 189 elipsa, 148 kwadrat, patrz prostokąt prostokąt, 48, 133 L lista rozwijana, 49 w DataGrid, 89 ListView, 71 filtrowanie, 76 formatowanie, 74 sortowanie, 73 wyrównanie, 75 M mechanizmy walidacji, 153 metoda CanExecute, 182 Convert, 145 ConvertBack, 145 Close, 79 Execute, 182 GoBack, 105 GoForward, 105 IndexOf, 77, 78 IsMatch, 164 MessageBox.Show, 38, 81, 181 Navigate, 105 Open, 113, 115 Pause, 114, 115 Play, 114, 115 Show, 78 ShowDialog, 80 Stop, 114, 115 ToString, 65 TryParse, 47 Validate, 159 Microsoft Blend, 26, 150 Model, 176, 178 MSDN, 20 MVVM, Model-View-ViewModel, 175, 183 Poleć książkęKup książkę Skorowidz 207 O obrazek, 52, 94, 110, 120 obsługa zdarzenia kliknięcia, 47, 49, 104 zmiany w polu tekstowym, 47 odtwarzacz audio, 111 okno aplikacji WPF, 33 dialogowe własne, 80 MessageBox, 38, 81, 181 OpenFileDialog, 96, 113, 115 SaveFileDialog, 104 P panel Canvas, 53 DockPanel, 56 Grid, 57 StackPanel, 54 WrapPanel, 56 pasek postępu, 112, 198 piksel, 35 polecenie, 178, 182, 184 powiadomienia o zmianach, 180 pozycja elementów, 29 przeglądarka, 101 przestrzeń nazw, 20 przeźroczystość, 41 przycisk, 34, 192 Button, 45 CheckBox, 48 RadioButton, 51, 55 RepeatButton, 192 R reguły walidacji, 158 rozmiar elementów, 29 rozszerzenia znaczników, 28 rysunek, patrz obrazek S scalanie komórek w Grid, 59 selektory, 194 siatka, 59 słowa kluczowe XAML, 26 sortowanie, 73 struktura Color, 42 style, 126 suwak, 62, 116 szablony danych, 141 kontrolek, 147 T tryb wiązania danych OneWay, 69 TwoWay, 69 U układ okien aplikacji, 34 uruchomienie aplikacji, 14 View, 176 ViewModel, 177 V W walidacja danych, 153 pola tekstowego, 66 w DataGrid, 170, 171, 173 wyrażenia regularne, 160 warstwa prezentacji, 33 wiązanie danych, 61 kolekcji danych, 71 widok, 176, 177 własne reguły walidacji, 158 właściwości, 16 automatyczne, 17 dołączane, 21, 54, 131 zależne, 21, 130 właściwość AlternatingRowBackground, 87 AlternationCount, 88 Background, 75 CanGoBack, 105 CanGoForward, 105 CellTemplate, 145 Command, 109, 182 ContainerStyle, 98 Content, 190 DataContext, 63, 65, 83 DialogResult, 80 DisplayMemberBinding, 71, 72 ElementName, 62, 63 ElementStyle, 129, 172 Error, 156 Fill, 48 Poleć książkęKup książkę 208 Wprowadzenie do WPF. Tworzenie aplikacji w WPF przy użyciu XAML i C# właściwość Filter, 77 FlowDirection, 32 FontSize, 36 Foreground, 75 Grid.Column, 59 Grid.ColumnSpan, 59, 60 Grid.Row, 59 Grid.RowSpan, 59, 60 GridLinesVisibility, 87 GroupDescriptions, 93, 97 GroupName, 51 Header, 71, 88, 99, 102, 110, 111, 192 Height, 29 HorizontalAlignment, 30 HorizontalContentAlignment, 31 Icon, 108, 110 Interval, 114 IsCheckable, 102, 103 IsChecked, 102, 103, 133 IsEnabled, 41, 46, 112 IsExpanded, 110 ItemHeight, 56 ItemsSource, 73, 171 ItemWidth, 56 LastChildFill, 56, 57 Margin, 29 MaxHeight, 29 MaxWidth, 29 MinHeight, 29 MinWidth, 29 Mode, 69 Name, 27 NaturalDuration, 113, 115 Opacity, 41, 43, 49 Orientation, 55, 56 Padding, 29 Path, 62, 63 RelativeSource, 134 RowDetailsTemplate, 95 SelectedIndex, 49 SelectedItem, 79, 96, 194 SortDescriptions, 74 Source, 52, 94, 120 StringFormat, 68, 70 Stroke, 48 TabStripPlacement, 112 TargetType, 128 Template, 141 TextWrapping, 95, 102, 197 ToolTip, 110, 154 Triggers, 151 UpdateSourceTrigger, 69 ValidatesOnDataErrors, 157, 158 Validation.ErrorTemplate, 155 ValidationRules, 159 VerticalAlignment, 30 VerticalContentAlignment, 31 Visibility, 51 Width, 29 ZIndex, 54 WPF, Windows Presentation Foundation, 9, 187 wyrażenia regularne, 160 wyrównywanie, 30, 31 tekstu w ListView, 75 wyzwalacze 131 danych, 131, 132 warunki logiczne, 135 właściwości, 131 zdarzeń, 131 wzorce projektowe, 175 wzorzec MVVM, 175 XAML, 22, 23 XML, 22 X Z zakładki, 111 zasięg zasobu, 122 zasoby binarne, 119 logiczne, 120 statyczne i dynamiczne, 124 zdarzenie CanExecuteChanged, 182 Checked, 51, 102, 103, 112 Click, 38 KeyUp, 105, 106 MouseDoubleClick, 78 MouseEnter, 39 MouseLeave, 39 Navigated, 106 Navigating, 106 PropertyChanged, 180 TextChanged, 47 Tick, 114 zmiana właściwości zasobu, 120 znacznik 22 otwierający, 22 rozszerzenia znaczników, 28 zamykający, 22 Poleć książkęKup książkę
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Wprowadzenie do WPF. Tworzenie aplikacji w WPF przy użyciu XAML i C#
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ą: