Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00374 009606 11232647 na godz. na dobę w sumie
Programowanie aplikacji dla Sklepu Windows w C# - ebook/pdf
Programowanie aplikacji dla Sklepu Windows w C# - ebook/pdf
Autor: , Liczba stron:
Wydawca: Promise Język publikacji: polski
ISBN: 978-83-7541-218-5 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie
Porównaj ceny (książka, ebook, audiobook).

Ten praktyczny poradnik pozwoli każdemu deweloperowi .NET zainteresowanemu tworzeniem aplikacji dla tabletów przejść krok po kroku proces budowania aplikacji typu Sklepu Windows. Pokazuje, jak posługiwać się językiem projektowania Modern UI dla systemu Windows 8.1 i mechanizmami WinRT 8.1.1 na przykładzie tworzenia biznesowej aplikacji mobilnej przy użyciu języka C#.
W trakcie projektowania aplikacji użyte zostaną te same szczegóły systemowe i specyfikacje, które dotyczą aplikacji komercyjnych, takie jak trwałość, usługi tła oraz funkcje udostępniania i wyszukiwania systemu Windows 8. Pokazane zostanie projektowanie kodu, dołączanie produktów open source i tworzenie pakietu dystrybucyjnego dla Sklepu Windows.
• Budowanie interfejsu użytkownika przy użyciu XAML oraz wzorca Model/View/View-Model
• Istota asynchronicznego przetwarzania i ponowne poznanie wątków i równoległości
• Przechowywanie danych i ustawień systemu za pomocą SQLite
• Stosowanie paska aplikacji dla poleceń i ustawień
• Prezentowanie powiadomień jako aktualizacji kafelka, etykiet lub wyskakujących komunikatów
• Wizualizacja lokalizacji i aktywności na mapach
• Włączanie udostępniania danych i równoległego działania aplikacji w interfejsie użytkownika
• Implementacja wykonywania zadań w tle
Matt Baxter-Reynolds jest niezależnym konsultantem w dziedzinie programowania, szkoleniowcem i autorem mieszkającym w Wielkiej Brytanii. Jego preferowaną metodą komu-nikacji z podobnie myślącymi osobami jest Twitter: @mbrit.
Iris Classon ma tytuł MVP w dziedzinie C#. Publikuje w witrynie Pluralsight i jest szeroko znana jako wykładowca i bloger. Uzyskała kilikanaście certyfikatów w dziedzinie pro-jektowania .NET, specjalizując się w tworzeniu aplikacji klienckich i programowania Windows Phone.

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

Darmowy fragment publikacji:

Programowanie aplikacji dla Sklepu Windows w języku C# Matt Baxter-Reynolds i Iris Classon przekład: Natalia Chounlamany Krzysztof Kapustka APN Promise Warszawa 2014 ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Programowanie aplikacji dla Sklepu Windows w języku C# © 2014 APN PROMISE Sp. z o. o. Authorized translation of English edition of Programming Windows Store Apps with C# ISBN 978-1-449-32085-0 Copyright © 2014 Matt Baxter-Reynolds. All rights reserved. This translation is published and sold by permission of O’Reilly Media, Inc., which owns or controls of all rights to publish and sell the same. APN PROMISE SA, biuro: ul. Kryniczna 2, 03-934 Warszawa tel. +48 22 35 51 600, fax +48 22 35 51 699 e-mail: mspress@promise.pl Wszystkie prawa zastrzeżone. Żadna część niniejszej książki nie może być powielana ani roz- powszechniana w jakiejkolwiek formie i w jakikolwiek sposób (elektroniczny, mechaniczny), włącznie z fotokopiowaniem, nagrywaniem na taśmy lub przy użyciu innych systemów bez pisemnej zgody wydawcy. Nutshell Handbook, logo Nutshell Handbook oraz logo O’Reilly są zarejestrowanymi znakami towarowymi O’Reilly Media, Inc. Programming Windows Store Apps with C#, ilustracja z okładki i powiązane elementy są znakami towarowymi O’Reilly Media, Inc. Wszystkie inne nazwy handlowe i towarowe występujące w niniejszej publikacji mogą być znakami towarowymi zastrzeżonymi lub nazwami zastrzeżonymi odpowiednich firm odnośnych właścicieli. Przykłady firm, produktów, osób i wydarzeń opisane w niniejszej książce są fikcyjne i nie odnoszą się do żadnych konkretnych firm, produktów, osób i wydarzeń. Ewentualne podobień- stwo do jakiejkolwiek rzeczywistej firmy, organizacji, produktu, nazwy domeny, adresu poczty elektronicznej, logo, osoby, miejsca lub zdarzenia jest przypadkowe i niezamierzone. APN PROMISE SA dołożyła wszelkich starań, aby zapewnić najwyższą jakość tej publikacji. Jednakże nikomu nie udziela się rękojmi ani gwarancji. APN PROMISE SA nie jest w żadnym wypadku odpowiedzialna za jakiekolwiek szkody będące następstwem korzystania z informacji zawartych w niniejszej publikacji, nawet jeśli APN PROMISE została powiadomiona o możliwości wystąpienia szkód. ISBN: 978-83-7541-152-2 Przekład: Natalia Chounlamany, Krzysztof Kapustka Redakcja: Marek Włodarz Korekta: Ewa Swędrowska Projekt okładki: Randy Comer Ilustracje: Rebecca Demarest Skład i łamanie: MAWart Marek Włodarz ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Spis treści Przedmowa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ix 1 Przejście z platformy .NET (cz.1) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 Dlaczego WinRT? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 Fundamentalne różnice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 Cele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 Nowe szablony projektów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 Metadane WinRT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 Ustawienia projektu i dodawanie odwołań. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 Budowanie podstawowego interfejsu użytkownika . . . . . . . . . . . . . . . . . . . . . . . . . . 12 Warianty UI. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 Podstawowe zasady analizowania kodu XAML . . . . . . . . . . . . . . . . . . . . . . . . . . 15 Budowanie podstawowej strony . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 Implementowanie wzorca MVVM. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 WPF a Silverlight. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 Struktura MVVM a odwrócenie sterowania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 Tworzenie modelu widoku i uruchamianie aplikacji. . . . . . . . . . . . . . . . . . . . . . 40 2 Przejście z platformy .NET (cz. 2). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49 Odwrócenie sterowania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49 Instalowanie biblioteki TinyIoC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50 Inicjalizowanie domyślnych ustawień IoC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51 Wprowadzenie do asynchroniczności . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56 Implementacja asynchroniczności na platformie WinRT . . . . . . . . . . . . . . . . . 57 Wywoływanie serwera . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63 Budowanie proxy usług . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63 Budowanie metody rejestracji . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66 Uzupełnienie strony do wywoływania funkcji rejestracji na serwerze . . . . . . 70 Logowanie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72 Budowanie proxy usługi logowania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72 Budowanie strony logowania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74 Wskaźniki zajętości . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79 Pozycjonowanie wskaźnika. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80 Wyświetlanie wskaźnika . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81 ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== iii 3 Lokalne dane trwałe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87 SQLite oraz sqlite-net. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88 Korzystanie z programu SQLite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89 Wprowadzenie do mapowania obiektowo-relacyjnego . . . . . . . . . . . . . . . . . . . 90 Stosowanie komponentu Micro-ORM w bibliotece sqlite-net. . . . . . . . . . . . . 91 Przechowywanie ustawień. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93 Klasa SettingItem. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94 Integracja z biblioteką sqlite-net . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95 Tworzenie w bazie danych tabeli reprezentującej klasę SettingItem . . . . . . .100 Odczytywanie i zapisywanie wartości . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .101 Modyfikowanie klasy LogonPageViewModel . . . . . . . . . . . . . . . . . . . . . . . . . . .102 Przechowywanie danych lokalnie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .105 Lokalna pamięć podręczna . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .106 Mapowanie danych JSON do obiektów bazodanowych. . . . . . . . . . . . . . . . . .106 Tworzenie raportów testowych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .108 Konfigurowanie bazy danych użytkownika . . . . . . . . . . . . . . . . . . . . . . . . . . . . .108 Tworzenie strony ReportsPage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .111 Stosowanie szablonów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .112 Budowanie lokalnej pamięci podręcznej. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .115 Aktualizowanie pamięci podręcznej. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .118 Zwracanie raportów z serwera . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .119 Właściwość Items . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .121 4 Pasek aplikacji . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125 Dodawanie prostego paska aplikacji. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126 Rozpoczęcie pracy z paskiem aplikacji . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .127 Zachowanie paska aplikacji. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .130 Pasek aplikacji z siatką w trybie pojedynczego zaznaczenia. . . . . . . . . . . . . . .132 Pasek aplikacji z siatką w trybie wielokrotnego zaznaczenia . . . . . . . . . . . . . .132 Rozszerzona implementacja paska aplikacji. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .134 Wyświetlanie paska aplikacji w wyniku wielokrotnego zaznaczenia. . . . . . .134 Testowanie interakcji za pomocą gestów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .140 Wyświetlanie paska aplikacji po kliknięciu prawym przyciskiem myszy . . .141 Prezentowanie opcji kontekstowych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .143 Obrazy na pasku aplikacji . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .147 Metoda bazująca na symbolach. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .147 Wykorzystywanie obrazów. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .153 iv | Spis treści ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== 5 Powiadomienia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161 Powiadomienia lokalne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .162 Włączanie i wyłączanie powiadomień . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .162 Szablony XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .162 Powiadomienia wyskakujące . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .164 Znaczniki . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .175 Kafelki. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .177 Inne funkcje powiadamiania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .184 Powiadomienia wypychane. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .185 Proces komunikacji z usługą WNS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .186 Obsługa kont użytkowników . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .188 Pozyskiwanie identyfikatora URI powiadomienia. . . . . . . . . . . . . . . . . . . . . . .189 Wysyłanie powiadomień do usługi WNS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .191 Wskazówki dotyczące rozwiązywania problemów . . . . . . . . . . . . . . . . . . . . . . .200 6 Praca z plikami . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201 Selektor plików. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .201 Skojarzenia plików. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .204 Uruchamianie aplikacji . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .205 Obsługa zdarzenia uruchomienia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .207 Dostęp do plików w trybie piaskownicy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .209 Przechodzenie po folderze i kopiowanie plików. . . . . . . . . . . . . . . . . . . . . . . . .211 Pliki mobilne. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .214 Wiele urządzeń. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .216 Konfigurowanie aplikacji klienckiej do zdalnego debugowania . . . . . . . . . . .216 Synchronizowanie plików . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .217 Ustawienia mobilne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .219 Wykorzystywanie plików w projekcie StreetFoo . . . . . . . . . . . . . . . . . . . . . . . . . . .219 Pobieranie obrazów do użycia w raportach . . . . . . . . . . . . . . . . . . . . . . . . . . . . .220 Zastosowanie nowej klasy ReportViewItem . . . . . . . . . . . . . . . . . . . . . . . . . . . .221 Implementacja klasy ReportImageCacheManager . . . . . . . . . . . . . . . . . . . . . .226 7 Udostępnianie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233 Udostępnianie danych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .234 Podstawowe funkcje udostępniania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .234 Żądania ściągnięcia/Odroczenia. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .243 Rejestrowanie aplikacji jako udziału docelowego udostępniania . . . . . . . . . . . . .245 Udostępnianie tekstu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .246 Udostępnianie tekstu (i rozwiązywanie problemów) . . . . . . . . . . . . . . . . . . . .248 Długotrwałe operacje. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .260 Udostępnianie obrazów. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .263 ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Spis treści | v Szybkie łącza . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .267 8 Wyszukiwanie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269 Implementowanie funkcji wyszukiwania. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .270 Tworzenie strony wyników wyszukiwania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .270 Tworzenie klasy SearchResultsPageViewModel . . . . . . . . . . . . . . . . . . . . . . . . .271 Implementowanie operacji wyszukiwania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .275 Udoskonalenia funkcji wyszukiwania. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .290 Tekst zastępczy. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .290 Sugestie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .291 Zapamiętanie kontekstu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .298 Korzystanie z kontrolki SearchBox. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .301 Inne zalecenia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .306 9 Ustawienia. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307 Dodawanie opcji . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .307 Standardowe opcje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .307 Dodawanie opcji niestandardowych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .308 Implementowanie wysuwanego okna ustawień. . . . . . . . . . . . . . . . . . . . . . . . . . . . .311 Budowanie panelu ustawień. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .311 Budowanie komponentu MySettingsFlyout . . . . . . . . . . . . . . . . . . . . . . . . . . . .315 Budowanie ekranu pomocy. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .317 Tworzenie panelu pomocy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .318 Obsługa zdarzenia naciśnięcia klawisza F1. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .320 Renderowanie znaczników . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .321 10 Lokalizacja. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 327 Tworzenie pojedynczego widoku . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .327 Tworzenie modelu widoku. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .328 Tworzenie widoku. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .331 Przechodzenie do widoku. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .335 Pozyskiwanie bieżącej lokalizacji. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .339 Korzystanie z symulatora . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .344 Integrowanie map . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .345 Dodawanie kontrolki Bing Maps. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .346 Obsługiwanie wejścia przy użyciu widoku . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .348 Pakowanie punktów w celu wyświetlenia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .349 Pokazywanie punktów na mapie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .353 Przechodzenie do aplikacji Mapy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .356 11 Korzystanie z aparatu. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 361 Wykonywanie zdjęć. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .362 vi | Spis treści ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Tworzenie strony EditReportPage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .363 Tworzenie modelu widoku EditReportPageViewModel . . . . . . . . . . . . . . . . .364 Zapisywanie i anulowanie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .371 Dodawanie opcji New. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .373 Obsługa plików tymczasowych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .374 Modyfikowanie manifestu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .375 Wykonywanie zdjęć . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .375 Implementowanie zapisu. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .379 Weryfikowanie i zapisywanie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .379 Dostosowywanie rozmiaru zdjęć. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .382 12 Responsywność projektu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 387 Uaktualnianie widoku siatki . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .389 Klasa VisualStateManager. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .389 Tworzenie widoku MyListView. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .391 Modyfikowanie paska aplikacji . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .393 Uaktualnianie pojedynczych widoków . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .395 Dodawanie przycisku More do paska aplikacji. . . . . . . . . . . . . . . . . . . . . . . . . .398 Obsługiwanie widoków niewspierających 320-pikselowej szerokości . . . . . . . .404 13 Zasoby i lokalizacja aplikacji . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 405 Pliki .pri . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .405 Dodawanie ciągów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .408 Lokalizowanie ciągów. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .411 Domyślne ustawienia regionalne projektu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .411 Lokalizowanie ciągów w XAML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .412 Konwencje. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .416 Modyfikowanie pozostałych właściwości . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .417 Jawne wczytywanie ciągów. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .417 Lokalizowanie obrazów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .420 Obrazy zależne od języka . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .420 Obrazy zależne od rozdzielczości DPI. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .423 14 Zadania w tle oraz cykl życia aplikacji. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 427 Cykl życia aplikacji . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .428 API zadań w tle. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .430 Przydział użycia procesora . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .430 Wyzwalacze i warunki . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .432 Model wykonawczy. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .434 ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Spis treści | vii Implementowanie zadania synchronizacji w tle . . . . . . . . . . . . . . . . . . . . . . . . . . . .435 Budowanie fasady . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .442 Debugowanie zadania. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .445 Rozwiązywanie problemów z zadaniami w tle. . . . . . . . . . . . . . . . . . . . . . . . . . .447 Ograniczenia czasu uruchamiania. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .447 Implementowanie synchronizacji . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .453 Wysyłanie zmian . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .454 Pozyskiwanie nowych zadań do wykonania. . . . . . . . . . . . . . . . . . . . . . . . . . . . .459 Powiadamianie aplikacji z poziomu zadań w tle . . . . . . . . . . . . . . . . . . . . . . . . .464 Umieszczanie aplikacji na ekranie blokady. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .465 15 Pobieranie lokalne i dystrybucja. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 469 Korzystanie z zestawu Windows App Certification Kit . . . . . . . . . . . . . . . . . . . . .472 Dystrybucja poprzez pobieranie lokalne. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .473 Włączanie pobierania lokalnego w Windows 8. . . . . . . . . . . . . . . . . . . . . . . . . .474 Instalowanie aplikacji . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .475 Dystrybucja poprzez Sklep Windows . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .476 A Kryptografia i tworzenie skrótów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 479 SSL. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .479 Bezpieczeństwo urządzeń . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .479 SQLite. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .480 Tworzenie skrótów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .481 Generowanie danych losowych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .484 Szyfrowanie symetryczne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .485 B Podstawy testowania jednostkowego aplikacji dla Sklepu Windows . 489 Testowanie jednostkowe dla początkujących. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .489 Tworzenie projektu testu. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .490 Testowanie RegisterServiceProxy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .491 Uruchamianie środowiska wykonawczego i obsługa metod async. . . . . . . . . . . .492 Testowanie modeli widoku . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .494 Indeks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 497 O autorach. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 509 viii | Spis treści ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Przedmowa Branża komputerowa nieustannie się zmienia. Sprzedaż komputerów PC powoli spada, natomiast wzrasta sprzedaż urządzeń nowej generacji – tabletów i smartfonów. Zmianę tę łatwo zrozumieć, bowiem komputery nie są już dłużej wykorzystywane do pracy – komputery wykorzystywane są obecnie do życia, które na całe szczęście nie polega jedynie na wykonywaniu pracy. Ogromny sukces komercyjny urządzeń nowej generacji sugeruje akceptację tej zmiany przez znaczną większość społeczeństwa, jednak dla takich fi rm jak Microsoft tworzy ona spory problem. Komputery PC przez następne 20 lat nie będą już tak ważne, jak to miało miejsce przez ostatnie dwie dekady. Systemy Windows 8.1 i Windows RT są pierwszą podjętą przez Microsoft próbą rozwiązania tego problemu, poprzez uczynienie systemu operacyjnego Windows ”bardziej przyjaznego” tabletom. Microsoft dokonał tego, wprowadzając nowy interfejs użytkownika o  nazwie Modern UI. Interfejs ten jest monochroniczny (tj. wykonujemy w nim jedną rzecz na raz), podczas gdy normalny okienkowy system operacyjny jest polichroniczny (kilka rzeczy na raz). Został on również zoptymalizowany pod obsługę dotykiem. Poza utworzeniem nowego interfejsu użytkownika, Microsoft wprowadził również nowy interfejs programowania aplikacji o nazwie Windows Runtime (WinRT) oraz nowy model wykonywania i pakowania aplikacji, nazywany aplikacjami dla Sklepu Windows. O konstruowaniu aplikacji dla Sklepu Windows porozmawiamy szczegółowo w rozdziale 2. W niniejszej książce systemy Windows 8.1 i Windows 8.1.1 RT traktowane są na równi. Innymi słowy, wszystkie wykonywane przez nas czynności będą działać na obu wspo- mnianych wersjach tego systemu. Wszystko, co zrobimy w tej książce, będzie też miało zastosowanie do aplikacji rozprowadzanych przy użyciu Sklepu Windows. W większości przypadków cały kod będziemy tworzyć sami, przy czym od czasu do czasu będziemy posługiwać się produktami zewnętrznymi. Wszystkie one, z wyjątkiem komponentu Bing Maps omawianego w rozdziale 11, są produktami otwarto źródłowymi, którymi możemy się swobodnie posługiwać. Zatem zaczynajmy! Na początek powiemy sobie więcej na temat aplikacji, którą zbudujemy. ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== ix Potencjalni odbiorcy Pisząc tę książkę staraliśmy się stworzyć pewną opowieść. W miarę jej czytania pozwoli Ci ona rozwinąć Twoje umiejętności tworzenia oprogramowania w środowisku .NET do poziomu, w którym będziesz mógł tworzyć aplikacje dla Sklepu Windows. Założyli- śmy w tej książce, że większość czytelników pracuje na co dzień przy rozwijaniu aplikacji sieciowych, lecz zostali oni poproszeni o zapoznanie się z procesem tworzenia aplikacji przeznaczonych na tablety z systemem operacyjnym fi rmy Microsoft . Niektórzy czytelnicy będą mieć zapewne jakieś doświadczenie w tworzeniu tradycyj- nych aplikacji Windows, wykorzystując przy tym technologie Silverlight i/lub Windows Presentation Foundation (WPF). Książka ta nie skupia się na tworzeniu kodu XAML, choć zawiera ona wystarczającą liczbę przykładów, by móc biegle opanować ten język. Powiemy sobie nieco więcej na temat tworzonej w tej książce aplikacji, byś mógł upew- nić się, że książka ta będzie dla Ciebie właściwa. Aplikacja ta zawiera w sobie wszystkie standardowe funkcje, jakie można zazwyczaj znaleźć w aplikacjach biznesowych (ang. line-of-business, LOB). W czasie pisania tej książki tablety Windows nie zdążyły się jeszcze dobrze przyjąć na rynku, dlatego też omawiane w niej elementy będą miały zastosowanie do prawdziwych aplikacji działających na systemach Windows Mobile, Android i iOS, które mieliśmy okazję budować przez ostatnie 10 lat. Mimo że  budowana przez nas aplikacja będzie aplikacją biznesową, wszystko, co zobaczymy i wykonamy, będzie miało również zastosowanie do zwykłych aplikacji konsumenckich. Aplikacja Jak już wspomnieliśmy, w książce tej zajmiemy się budową aplikacji biznesowej, nie zaś aplikacji konsumenckiej. Różnica pomiędzy nimi polega na tym, że w przypadku aplikacji konsumenckiej do- stawca oprogramowania nie jest zazwyczaj ściśle związany z klientem końcowym. Klient znajduje aplikację poprzez pośrednie rekomendacje i/lub z poziomu katalogu sklepu z aplikacjami. W aplikacjach biznesowych stosuje się pewne proaktywne zabiegi mar- ketingowe oraz podejmuje czynności tworzące relacje, mając na celu powiązanie klienta z dostawcą przy pomocy jakiejś komercyjnej oferty. Z technicznego punktu widzenia pomiędzy tymi aplikacjami nie ma jednak żadnej większej różnicy. Szczególnym przykładem w tej książce jest aplikacja dedykowana ”serwisowi terenowe- mu”. Jest to klasyczna aplikacja przeznaczona do pracy mobilnej. Do naszych obowiązków należy sprawowanie kontroli nad działaniami pracowników. Wysyłamy ich w teren w celu wykonania jakieś pracy – może to być coś konkretnego (”idź tam i napraw to”) lub też coś reaktywnego (np. ktoś ”patroluje” jakiś obszar i zgłasza ewentualne problemy). x | Przedmowa ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Aplikacja, którą zbudujemy – o nazwie StreetFoo – będzie stanowić połączenie tych dwóch ostatnich przykładów. Utworzyliśmy prosty serwer hostowany na platformie AppHarbor, który będzie służył jako usługa wewnętrzna dla naszej aplikacji. Po zalogowaniu się w aplikacji użytkownik pobierze z serwera zestaw ”zawierających problemy raportów”. Każdy raport będzie czymś, co wymaga podjęcia jakichś działań – w naszym przykładzie chodzi o usunięcie graffi ti, ale mogłoby to być cokolwiek innego. Cała koncepcja aplikacji opiera się na tym, że jej użytkownik albo naprawi istniejący problem, albo zgłosi w niej jakiś nowy problem. Zaktualizowane lub nowe problemy są następnie przesyłane na serwer. Tak wygląda podstawowa funkcjonalność naszej aplikacji. Dodatkowo przyjrzymy się kilku innym rzeczom, takim jak wykonywanie zdjęć oraz pozyskiwanie bieżącej lokaliza- cji, wykorzystując przy tym wszystkie specjalne funkcje oferowane przez Windows 8.1/ Windows 8.1.1 RT, takie jak udostępnianie, widok przyciągania, wyszukiwanie, itd. Rozdziały W rozdziałach 1 i 2 zbudujmy sobie odpowiedni grunt, który pozwoli nam przenieść się ze świata .NET do świata WinRT. Rozdział 1, Przejście z platformy .NET (Część 1) Rozdział ten wyjaśnia różnice pomiędzy .NET i powiązanymi z nim technologiami (w szczególności WPF) a środowiskiem Windows Runtime (WinRT). Budujemy w nim prosty interfejs użytkownika i implementujemy w nim wzorzec MVVM. Rozdział 2, Przejście z platformy .NET (Część 2) W tym rozdziale rozbudowujemy interfejs użytkownika z rozdziału 1, by był on bar- dziej użyteczny. Poruszamy tu kwestię odwoływania się do serwera w celu utworzenia nowego konta użytkownika, jak również szczegółowo przyglądamy się asynchronicz- ności – prawdopodobnie najważniejszej rzeczy, jakiej nauczymy się w czasie tworzenia naszej aplikacji dla Sklepu Windows. Pozostałe rozdziały tej książki skupiają się już na konkretnych obszarach dostępnego API. Rozdział 3, Lokalne dane trwałe Rozdział ten omawia bazę danych SQLite. Temat ten poruszamy już na tym etapie, dlatego że obecnie bez posiadania jakiegoś trwałego magazynu praktycznie nie jest możliwe zbudowanie jakiejkolwiek przydatnej aplikacji. Choć korzystając z odpo- wiednich API możemy przechowywać informacje na dysku, to SQLite jest de facto standardową relacyjną bazą danych wykorzystywaną w dzisiejszych rozwiązaniach mobilnych. Z tego względu posłużymy się nią w naszej aplikacji. ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== | xi Rozdział 4, Pasek aplikacji W rozdziale tym prezentujemy pierwszą z nowych, dostępnych w systemie Win- dows 8.1 funkcji: pasek aplikacji. Paski aplikacji są małymi panelami, które wyskakując w górnej i dolnej części ekranu dają nam dostęp do różnych opcji i zakładek (pasek aplikacji w pewnym stopniu zastępuje paski narzędziowe). Przyjrzymy się, w jaki sposób możemy zbudować pasek aplikacji oraz jak możemy utworzyć nasze własne obrazki do wykorzystania na przyciskach. Rozdział 5, Powiadomienia Rozdział ten w całości poświęcony jest powiadomieniom. Powiadomienia w aplika- cjach dla Sklepu Windows mogą być wykorzystywane do aktualizowania kafelków na ekranie startowym, dodawania do nich znaczków oraz do wyświetlania tzw. powia- domień wyskakujących (pojawiają się one w prawej dolnej części ekranu). Powiado- mienia możemy tworzyć i wyświetlać lokalnie lub też tworzyć je na serwerze i wysyłać na wszystkie połączone urządzenia, wykorzystując do tego usługi Windows Push Notifi cation Services (WNS). W rozdziale tym przyjrzymy się obu tym sposobom. Rozdział 6, Praca z plikami W tym miejscu przyjrzymy się szczegółowo pracy z plikami. Planując tę książkę nie zamierzaliśmy tworzyć tego rozdziału, jako że temat ten zawsze jest wyczerpująco oma- wiany przez społeczność, gdy tylko pojawia się jakaś nowa platforma. Zamieściliśmy go jednak ze względu na obsługę obrazów. Każdy śledzony w aplikacji raport będzie zawierał dokładnie jeden obraz. Zamiast przechowywać je w bazie SQLite, co byłoby dość niepraktyczne, będziemy zapisywać je na dysku. Rozdział 7, Udostępnianie W tym miejscu skupimy się na funkcji udostępniania w Windows 8.1. Udostępnianie zdecydowanie wyróżnia strategię fi rmy Microsoft dotyczącą tabletów na tle pozostałych platform. Większość platform oddziela od siebie aplikacje, utrudniając im wzajemne współdzielenie danych. Windows 8.1 dysponuje deklaratywnym modelem udostęp- niania danych, w którym aplikacja wskazuje typy danych, jakie będzie udostępniać. Dane te mogą być później odczytane przez inną aplikację obsługującą ten model udostępniania. W rozdziale tym omówimy kwestie zarówno udostępniania danych, jak również ich konsumpcji przez pozostałe aplikacje. Rozdział 8, Wyszukiwanie Rozdział ten dotyczyć będzie funkcji wyszukiwania w systemie Windows 8.1. Funk- cja wyszukiwania, choć w różnych wariantach, implementowana jest w zasadzie we wszystkich aplikacjach. W systemie Windows 8.1 uzyskujemy do niej dostęp z poziomu panelu funkcji lub przy wykorzystaniu kontrolki SearchBox. My skupimy xii | Przedmowa ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== się tu na implementowaniu funkcji wyszukiwania, która pozwoli nam odnajdywać nasze raporty dotyczące problemów. Rozdział 9, Ustawienia W tym rozdziale dokonamy podsumowania funkcji specyfi cznych dla systemu Win- dows 8.1, omawiając przy tym panel ustawień. Jak wskazuje jego nazwa – panel usta- wień jest miejscem, w którym programiści mogą umieszczać ustawienia aplikacji. Jest to również powszechnie stosowane miejsce do zamieszczania łączy prowadzących do informacji na temat wsparcia technicznego oraz związanych z zasadami prywat- ności. W rozdziale tym wykorzystamy kontrolkę SettingsFlyout w celu załadowania i wyrenderowania tekstu sformatowanego metodą Markdown. Rozdział 10, Lokalizacja Na tym etapie zajmiemy się pozyskiwaniem bieżącej lokalizacji urządzenia. Większość mobilnych aplikacji fi rmowych wymaga takiej funkcjonalności, ponieważ często za- chodzi potrzeba posiadania pewnych ”dowodów” dokonania określonej czynności. Lokalizacja użytkownika może zostać również wykorzystana przy opracowywaniu nowych danych. W rozdziale tym zajmiemy się prostym pozyskiwaniem informacji o lokalizacji urządzenia, jak również posłużymy się kontrolką Bing Maps w celu wy- świetlenia w naszej aplikacji mapy. Rozdział 11, Korzystanie z aparatu W tym rozdziale nauczymy się korzystać z aparatu urządzenia. W mobilnych aplika- cjach biznesowych często konieczne jest gromadzenie pewnych dowodów zdjęciowych dotyczących wykonanej pracy (na przykład, jeśli ktoś ma za zadanie naprawić zlew, powinien on wykonać jego zdjęcie zarówno przed, jak i po jego naprawie). Przyjrzymy się tu, w jaki sposób możemy tworzyć nowe raporty dotyczące problemów, rozpoczy- nając od wykonywania zdjęć aparatem. Rozdział 12, Responsywność projektu Rozdział ten nauczy nas sposobu tworzenia responsywnych projektów, dzięki czemu interfejs użytkownika naszych aplikacji będzie mógł automatycznie dostosowywać się do ich bieżącej szerokości, obsługując nawet najmniejszy, 320-pikselowy rozmiar widoku, nazywany również ”trybem przyciągnięcia”. Kolejną funkcją wprowadzoną w Windows 8.1, która wyróżnia ten system na tle innych platform, jest możliwość uruchamiania aplikacji obok siebie. Innymi słowy, jedna aplikacja może zajmować cienki pasek po lewej lub po prawej stronie ekranu, podczas gdy kolejna zajmować będzie jego całą pozostałą przestrzeń. Jedynym problemem jest to, że dla takiego trybu działania aplikacji musimy zbudować całkowicie nowy interfejs użytkownika. Tak naprawdę nie jest to wcale takie trudne, gdyż wykorzystywany przez nas wzorzec ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== | xiii MVVM wykonuje dla nas sporą część tej pracy. W rozdziale tym wyposażymy naszą aplikację w zdolność dostosowywania się do różnych rozmiarów wielkości. Rozdział 13, Zasoby i lokalizacja aplikacji W tym rozdziale przyjrzymy się bliżej zasobom oraz porozmawiamy o lokalizowaniu naszej aplikacji. Zanim dotrzesz do tego tematu, będziesz już znał kilka sposobów pracy z zasobami, dlatego część tego rozdziału poświęcimy na omówienie rzeczy, którymi nie zajmowaliśmy się zbyt szczegółowo. Następnie przedyskutujemy pra- widłowy sposób lokalizowania naszej aplikacji (tj. implementowania w niej obsługi wielu różnych języków). Rozdział 14, Zadania w tle i cykl życia aplikacji Rozdział ten omawia zadania w tle, czyli specjalny mechanizm wydzielania z aplikacji funkcji, które będą uruchamiane przez Windows w ustalonym harmonogramie. Podob- nie jak na innych platformach, Windows stara się ograniczyć działanie naszej aplikacji, w przypadku gdy nie jest ona uruchomiona na pierwszym planie. Porozmawiamy tu o szczegółach implementacji zadań w tle, skupiając się na wykorzystaniu ich do po- bierania nowych raportów oraz wysyłania wprowadzonych lokalnie zmian na serwer. Rozdział 15, Pobieranie lokalne i dystrybucja W tym rozdziale szczegółowo porozmawiamy o pakowaniu i dystrybuowaniu naszych aplikacji przy użyciu Sklepu Windows. Zobaczymy, w jaki sposób wykorzystujemy na- sze licencje dewelopera w celu utworzenia pakietów pobierania lokalnego dla testowania wewnętrznego, jak również omówimy sobie poprawne wykorzystywanie tej funkcji w przedsiębiorstwie (pobieranie lokalne jest procesem, w którym dystrybuujemy nasze aplikacje do prywatnych odbiorców, zamiast udostępniać je publicznie w Skle- pie Windows). Powiemy tu sobie również o regułach, jakie muszą zostać spełnione, by nasza aplikacja została dopuszczona przez Microsoft do dystrybucji w ramach Sklepu Windows. Książka zawiera ponadto dwa dodatki: Dodatek A, Kryptografi a i tworzenie skrótów Dodatek ten omawia pewne wymagania związane z kryptografi ą i tworzeniem skró- tów, o których powinniśmy wiedzieć, przy czym nie nawiązuje on w żaden sposób do głównej treści tej książki. Dodatek B, Podstawy testowania jednostkowego aplikacji dla Sklepu Windows W tym dodatku przyglądamy się sposobom testowania naszego kodu przy użyciu oferowanych przez Visual Studio projektów testów jednostkowych. Skorzystamy tu z kontenerów odwrócenia sterowania, które budowaliśmy i wykorzystywaliśmy w przykładach tej książki. xiv | Przedmowa ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== I to wszystko! Po przeczytaniu całego materiału powinieneś być w stanie budować w pełni funkcjonalne aplikacje dla Sklepu Windows. Wymagania wstępne Jedyną rzeczą, której będziesz potrzebować do rozpoczęcia pracy, jest środowisko Visual Studio 2013. Wszystko, co będzie Ci potrzebne do budowy aplikacji dla Sklepu Windows, jest już zawarte w tej wersji Visual Studio. To, z której edycji będziesz korzystać, nie ma tu żadnego znaczenia. My co prawda korzystaliśmy z edycji Professional, ale wszystko przetestowaliśmy również w edycji Express. Jeśli zechcesz umieścić swoje aplikacje w Sklepie Windows, będzie Ci potrzebne konto dewelopera. Żaden z naszych przykładów w tej książce nie wymaga od Ciebie zakupu takiego konta. Wystarczy, że utworzysz sobie bezpłatne konto, co umożliwi Ci pozyskanie licencji dewelopera pozwalającej na lokalne wdrażanie dowolnych zbudowanych przez Ciebie aplikacji. Kod źródłowy Kod źródłowy dla tej książki dostępny jest w witrynie GitHub. Najprostszym sposobem pracy z tym kodem jest pobranie całego repozytorium na lokalny dysk. Każdy rozdział prezentowany jest w osobnym folderze, a każdy z nich zawiera kod aplikacji znajdującej się w takim samym stanie, w jakim znajdowała się ona na końcu danego rozdziału (na przykład, folder Chapter8 zawiera wszystko od rozdziału 2 aż do rozdziału 8 włącznie; folder Chapter9 zawiera wszystko to, co znajduje się w folderze Chapter8, oraz całą pracę, którą wykonaliśmy w rozdziale 9). W niektórych przypadkach udostępniony do pobrania kod może zawierać więcej zmian, niż tylko te, które zostały dokonane w tej książce. Jeśli nie jesteś zaznajomiony z działaniem systemu git lub witryny GitHub, skorzystaj z zamieszczonego poniżej krótkiego szkolenia. Korzystanie z systemu git W tej części poznasz podstawy dotyczące instalacji i obsługi systemu git, które pozwolą Ci pozyskać kod z repozytorium. Nie mamy tu zamiaru pokazywać sposobów wyko- rzystywania systemu git jako systemu kontroli wersji – informacje na ten temat można znaleźć w serwisie GitHub. Na początek potrzebny Ci będzie klient git. Możesz go pobrać z ofi cjalnej witryny tego projektu. ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== | xv Po zakończeniu pobierania przeprowadź instalację uzyskanego pakietu. Instalator zainstaluje zarówno klienta w wersji dla wiersza poleceń, jak i klienta z inter- fejsem grafi cznym. Wiele osób korzysta z wersji grafi cznej, przy czym my korzystaliśmy z klienta git dla wiersza poleceń. Jeśli chcesz jedynie pozyskać kod dołączony do tej książki, to najłatwiej Ci będzie posłużyć się klientem grafi cznym. Aby uruchomić grafi cznego klienta git w systemie Windows 8.1, przejdź do ekranu Start wciskając klawisz Windows. Znajdując się na ekranie startowym, wpisz git. Po chwili otrzymasz dwie opcje: Git Bash oraz Git GUI. Otwórz klienta Git GUI i wybierz opcję Clone Existing Repository (Sklonuj istniejące repozytorium). Będziesz musiał skopiować i wkleić ścieżkę do repozytorium z witryny GitHub. Aby tego dokonać, otwórz w przeglądarce poniższy adres: htt ps://github.com/mbrit/ ProgrammingWindowsStoreApps. Na stronie tej, w sekcji ”Quick setup”, znajdziesz właściwy adres URL repozytorium. Adres ten musisz skopiować do schowka. Powinien on wyglądać mniej więcej tak: htt ps://github.com/mbrit/ProgrammingWindowsStoreApps.git. Ilustruje to rysunek P-1. Rysunek P-1. Obszar strony GitHub prezentujący właściwy adres URL repozytorium Wróć do klienta i wklej w nim skopiowaną ścieżkę do pola Source Location (Lokalizacja źródłowa). Następnie w polu Target Directory (Katalog docelowy) podaj ścieżkę do do- wolnie wybranego przez siebie folderu lokalnego, podobnie jak na rysunku P-2. Rysunek P-2. Konfi guracja operacji klonowania xvi | Przedmowa ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Kliknij przycisk Clone (Sklonuj) i poczekaj na pobranie repozytorium na Twój komputer. Po zakończeniu tego procesu będziesz mógł otworzyć w Visual Studio zawarte w poszcze- gólnych folderach pliki rozwiązań. Kontakt z autorami Najlepszym sposobem nawiązania kontaktu z Matt em jest jego Twitt er (@mbrit). Alternatywnie możesz też odwiedzić jego witrynę. Iris Classon dostępna jest zarówno na Twitt erze (@irisclasson), jak i poprzez jej własną stronę. Zaczynamy! I to wszystko. Powinieneś już być gotowy do rozpoczęcia budowy aplikacji dla Sklepu Windows. Konwencje stosowane w tej książce W niniejszej książce wykorzystywane są następujące konwencje typografi czne: Zwykły tekst Wskazuje tytuły, opcje i przyciski menu oraz skróty klawiszowe (takie jak Alt i Ctrl). Kursywa Wskazuje nowe terminy, adresy URL, adresy e-mail, nazwy plików i ich rozszerzenia, ścieżki, katalogi i narzędzia systemu Unix. Stała szerokość Wskazuje polecenia, opcje, przełączniki, zmienne, atrybuty, klucze, funkcje, typy, klasy, przestrzenie nazw, metody, moduły, właściwości, parametry, wartości, obiekty, zdarzenia, metody obsługi zdarzeń, znaczniki XML, makra, zawartości plików lub otrzymane z poleceń wyjście. Stała szerokość i kursywa Komentarz wewnątrz kodu. Stała szerokość z pogrubieniem Wskazuje składnię poleceń lub inny tekst, który powinien zostać wpisany przez użyt- kownika dokładnie tak, jak został przedstawiony. Stała szerokość z pogrubieniem i kursywą Wskazuje tekst, który powinien zostać zastąpiony wartościami podanymi przez użytkownika. ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== | xvii Ta ikona określa ogólną uwagę. Ta ikona określa wskazówkę lub radę. Ta ikona wskazuje ostrzeżenie lub konieczność zachowania ostrożności. Korzystanie z przykładowego kodu Książka ta ma za zadanie pomóc Ci w wykonaniu Twojej pracy. W ogólnym przypadku, jeśli zawiera ona przykładowy kod, możesz wykorzystać go w swoich programach oraz w swojej dokumentacji. Nie musisz pytać nas o zgodę na jego wykorzystanie, chyba że reprodukujesz większą część naszego kodu. Na przykład, napisanie programu, który wykorzystuje kilka fragmentów kodu z tej książki, nie wymaga uzyskania od nas zgody. Sprzedaż lub dystrybucja płyt CD z przykładami z książek O’Reilly wymaga uzyskania takiej zgody. Udzielanie odpowiedzi na pytanie poprzez wskazanie tytułu tej książki i wstawienie kodu danego przykładu nie wymaga uzyskania zgody. Zawieranie większej ilości przykładowego kodu z tej książki w dokumentacji produktu czytelnika wymaga uzyskania od nas zgody. Doceniamy (ale nie wymagamy) stosowanie atrybucji uwzględniającej tytuł, autorów, wydawcę i numer ISBN tej książki. Na przykład: ”Programowanie aplikacji dla Sklepu Windows w języku C#, Matt Baxter-Reynolds i Iris Classon (O’Reilly/APN Promise). Copyright 2014 Matt hew Baxter-Reynolds, 978-83-7541-152-2”. Jeśli masz wątpliwości, czy wykorzystanie przez Ciebie naszych przykładów nie na- ruszy powyższych postanowień, zapytaj nas o to pod adresem permissions@oreilly.com. Jak się z nami skontaktować Wszelkie uwagi i pytania dotyczące tej książki prosimy kierować bezpośrednio do jej wydawcy: O’Reilly Media, Inc. 1005 Gravenstein Highway North Sebastopol, CA 95472 800-998-9938 (w Stanach Zjednoczonych lub Kanadzie) 707-829-0515 (międzynarodowo lub lokalnie) 707-829-0104 (faks) xviii | Przedmowa ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Dla książki tej stworzyliśmy specjalną stronę, na której zamieściliśmy erratę, przykłady oraz wszelkie dodatkowe informacje. Strona ta jest dostępna pod adresem: htt p://oreil.ly/prog-win-store-apps-csharp Jakiekolwiek komentarze lub pytania techniczne prosimy kierować na adres: bookquestions@oreilly.com Więcej informacji na temat naszych książek, kursów i konferencji oraz wszelkie aktualności można znaleźć na stronie htt p://www.oreilly.com. Znajdź nas na Facebooku: htt p://facebook.com/oreilly Obserwuj nas na Twitt erze: htt p://twitt er.com/oreillymedia Oglądaj nas na YouTube: htt p://www.youtube.com/oreillymedia Podziękowania Dziękujemy naszym recenzentom technicznym, którymi są Oren Novotny, Stefan Turalski, Matt Fitchett oraz Nathan Jepson. Bez nich ta książka nie mogłaby powstać. Gdyby nie Twitt er, książka ta nie byłaby tak dobra i kompletna. Twitt er jest prawdopo- dobnie najlepszym źródłem zasobów do nauki dla osób związanych z branżą komputero- wą, jakie kiedykolwiek powstało. Niniejsza książka zawiera w sobie sporo cennych porad, z których jednak najważniejszą jest: jeśli jesteś profesjonalnym twórcą oprogramowania i nie korzystasz z Twitt era, lepiej zacznij to robić. Poniżej znajduje się lista naszych przyjaciół na Twitt erze, którzy wspierali nas w opra- cowywaniu tej książki, zaoszczędzili nam wiele godzin pracy, poddali nam mnóstwo nowych pomysłów i wyrazili wiele cennych opinii: • Alex Papadimoulis (@apapadimoulis) • Casey Muratori (@cmuratori) • Chris Field (@mrcfi eld) • Chris Hardy (@chrisntr ) • Craig Murphy (@camurphy) • Daniel Plaisted (@dsplaisted) • David Kean (@davkean) • Duncan Smart (@duncansmart) • Edward Behan (@edwardbehan) • Filip Skakun (@xyzzer) • Frank Krueger (@praeclarum) • Gill Cleeren (@gillcleeren) ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== | xix Iris Classon (@irisclasson) Jamie Mutt on (@jcmm33) Joel Hammond-Turner (@rammesses) Jose Fajardo (@josefajardo) • Ginny Caughey (@gcaughey) • Haris Custo (@hariscusto) • Hermit Dave (@hermitdave) • • • • • Keith Patt on (@kpatt on) • Kendall Miller (@kendallmiller) • Liam Westley (@westleyl) • Mark Tepper (@binaerforceone) • Matt Hidinger (@matt hidinger) • Matt hieu GD (@tewmgd) • Mike Harper (@mikejharper) • Nic Wise (@fastchiken) • Peter Provost (@pprovost) • Ross Dargan (@rossdargan) • Tim Heuer (@timheuer) • Tomas McGuinness (@tomasmcguinness) Na koniec dziękujemy Rachel Roumeliotis, Marii Gulick, Melanie Yarbrough oraz całej reszcie zespołu O’Reilly za ich ciężką pracę i cierpliwość podczas opracowywania tej książki. xx | Przedmowa ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Rozdział 1 Przejście z platformy .NET (cz.1) W tym i kolejnym rozdziale pokażemy, jak wykorzystać znajomość technologii .NET do rozpoczęcia pracy z platformą WinRT i budowania aplikacji dla Sklepu Windows (Windows Store). Pierwsze dwa rozdziały, w odróżnieniu od pozostałych rozdziałów, które koncentrują się na wybranych możliwościach interfejsu API, zawierają omówienie wielu różnych zagadnień. Zrozumienie tych podstawowych funkcji oraz zależności między nimi jest konieczne do skutecznego przejścia na platformę WinRT. W sprzeczności z dotychczasową polityką fi rmy Microsoft środowisko WinRT nie jest następnikiem platformy .NET i stanowi przejaw rewolucyjnej zmiany strategii, na jaką zdecydowały się zespoły odpowiedzialne za interfejs API systemu Windows. Technologia ta została opublikowana w czasach szybkiej ewolucji w świecie oprogramowania. Era komputerów PC, która pozwoliła fi rmie Microsoft osiągnąć przewagę na rynku, powoli dobiega końca. Dlaczego WinRT? Powstanie technologii WinRT zbiegło się w czasie z opublikowaniem przez fi rmę Microsoft dwóch nowych wersji systemu Windows: Windows 8 oraz Windows RT, co stanowi raczej przypadek niż wynik zaplanowanej strategii. Platforma WinRT ma na celu zlikwidowanie ograniczeń związanych z pisaniem macierzystego oprogramowania dla systemu Windows. Do pisania aplikacji macierzystych w systemie Windows służy interfejs Win32, który jest bardzo stary i nie jest zorientowany obiektowo. Oprócz Win32 dostępna jest także technologia COM, czyli zorientowany obiektowo system podrzędny, który umożliwia podłączanie (i odłączanie) komponentów do systemu Windows. Technologia ta może być zupełnie nieznana osobom, które stosunkowo niedawno zainteresowały się pisa- niem oprogramowania dla systemu Windows lub korzystają z platformy .NET. Nawet programiści, którzy kiedyś często korzystali z tego rozwiązania, z reguły porzucili je lata temu i do pisania oprogramowania dla systemów operacyjnych Windows wykorzystują obecnie platformę .NET. ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== 1 .NET przypomina bardziej technologię Java niż Win32 czy COM i stanowi bibliotekę oraz środowisko wykonania, które ma ułatwić rozwijanie oprogramowania dla systemu Windows. Platforma .NET jest nazywana środowiskiem ”kodu zarządzanego”, ponieważ środo- wisko uruchamiania przejmuje dużą część odpowiedzialności za zarzadzanie wykonaniem kodu. Natomiast aplikacje Win32 są ”niezarządzane”. Platforma .NET została wprowa- dzona z myślą o budowaniu witryn sieci Web w technologii ASP.NET lub aplikacji macie- rzystych przy użyciu technologii Windows Forms (na razie zignorujemy usługi systemu Windows i skoncentrujemy się na technologiach związanych z interfejsem użytkownika). Wspomniane technologie rozwijania interfejsów użytkownika ulegały przez lata różnym zmianom, ale główną zaletą platformy .NET pozostała łatwość, z jaką programiści mogą realizować własne cele. Wchodząca w skład pakietu .NET biblioteka Base Class Library (BCL) zapewniła łatwy, zorientowany obiektowo dostęp do funkcji systemu operacyjnego Windows (np. System.IO.FileStream), a także klasy usprawniające pracę programistów (np. System.Collections.Generic.List). Ten zestaw funkcji jest szczególnie istotny, ponieważ duża część biblioteki BCL odwołuje się do interfejsu Win32 i w ten sposób zapewnia dostęp do funkcji systemu operacyjnego. Poza biblioteką BCL środowisko uruchomieniowe CLR oferuje takie funkcje, jak Garbage Collection, które zdejmują z programisty ciężar zarzadzania pamięcią i innymi istotnymi aspektami. Fundamentalne różnice Problem polega na tym, że technologiom WinRT oraz .NET przyświeca zupełnie inna fi lozofi a. Inspiracją dla technologii .NET była Java i zarządzanie pamięcią przy użyciu funkcji Garbage Collection, co skutkuje częściową utratą kontroli nad systemem. Java nie została zaprojektowana z myślą o programistach rozwijających systemy operacyjne (takich jak zespół Windows Division w fi rmie Microsoft , nazywany także zespołem WinDiv) lub twórcach złożonych produktów, takich Offi ce. Java (a w konsekwencji także technologia .NET) jest zbyt abstrakcyjna, zbyt ”magiczna”, aby mogła być wykorzystywana do budowania tego typu oprogramowania. Jednak większość z nas nie rozwija ”tego typu oprogramowania”, lecz zajmuje się tworzeniem niewielkich aplikacji w ramach niedużego budżetu. W takiej sytuacji ograniczenia wynikające z pracy w środowisku wykonania takim jak CLR są mniej odczuwalne. Programiści .NET, którzy decydują się na przejście do środowiska WinRT, muszą pamiętać o tych fundamentalnych różnicach. Choć musimy zaznaczyć, że mimo iż rozu- miemy argumenty przemawiające za odejściem od fi lozofi i platformy .NET i powrotem do technologii COM, nie do końca zgadamy się z tą decyzją. Możliwość budowania aplikacji dla Sklepu Windows przy użyciu technologii .NET pozwoliłaby uniknąć wielu 2 | Rozdział 1: Przejście z platformy .NET (cz.1) ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== trudności wynikających z zastosowania technologii COM. Jednak musimy pogodzić się z rzeczywistością. W tym rozdziale przyjęliśmy założenie, że czytelnik posiada przynajmniej podstawową znajomość technologii .NET oraz najnowszych rozwiązań, takich jak .NET Framework v3.5. Będziemy często stosować typy generyczne. Zaprezentujemy także fragmenty kodu LINQ, jednak będziemy objaśniać ich działanie. Do lektury książki nie jest potrzebna znajomość biblioteki Task Parallel Library (TPL), którą będziemy często wykorzystywać. Wystarczy umiejętność pisania profesjonalnego kodu na platformie .NET. Wielu programistów .NET posiada pewne doświadczenie w rozwijaniu aplikacji ASP. NET, w związku z tym przyjęliśmy założenie, że większość czytelników preferuje tę metodę rozwijania interfejsu użytkownika. Do budowania interfejsu aplikacji dla Sklepu Windows wykorzystywać będziemy technologię XAML, która zostanie omówiona w dalszej części książki. Do tego samego celu można również użyć technologii Silverlight bądź Windows Presentation Foundation (WPF), ale przyjęliśmy założenie, że czytelnik nie ma doświad- czenia w stosowaniu żadnej z tych metod. Cele W dwóch kolejnych rozdziałach przedstawimy proces budowania aplikacji dla Sklepu Windows z interfejsem użytkownika oraz pewną funkcją biznesową wymagającą nawiąza- nia połączenia z serwerem. Ponadto udowodnimy, że możliwe jest zbudowanie biblioteki testów jednostkowych (ang. unit test) dla tego typu aplikacji: • Zbudujemy nowy projekt aplikacji dla Sklepu Windows w środowisku Visual Stu- dio 2012 po to, aby zaprezentować nowe szablony projektów oraz wyjaśnić różnice między plikami wyjściowymi generowanymi dla nowych projektów aplikacji dla Sklepu Windows oraz dla starszych typów projektów .NET. • Dodamy do projektu nową stronę XAML i jednocześnie przedstawimy zagadnienia związane z budowaniem infrastruktury zgodnej z wzorcem projektowym Model/ Widok/Model widoku (Model/View/View-Model – MVVM), który zostanie omó- wiony w dalszej części rozdziału. Dodatkowo pokażemy, jak wspierać paradygmat odwrócenia sterowania, który również zostanie przedstawiony w dalszej części roz- działu. Kod będzie zawierał wywołania metod ogólnie dostępnego serwera, aczkol- wiek zaczniemy od zasymulowania tych wywołań. • Zbudujemy test jednostkowy dla modelu widoku tylko po to, aby pokazać, że jest to możliwe. ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Cele | 3 • Po udowodnieniu, iż model może być testowany, zaimplementujemy prawdziwą ko- munikację z serwerem. Na zakończenie będziemy mogli przetestować całą aplikację i przekonać się, że działa ona prawidłowo. Nowe szablony projektów Warto zacząć od uświadomienia sobie, że w aplikacjach Sklepu Windows wykorzystywana jest okrojona, ograniczona wersja platformy .NET nazywana .NETCore. Nie pierwszy raz fi rma Microsoft zdecydowała się na stworzenie podzbioru technologii .NET – inny przykład stanowi platforma .NET Compact Framework zastosowana w systemie Win- dows CE lub platforma Client Profi le wprowadzona w wersji v3.5 i ”zoptymalizowana” z myślą o aplikacjach klienckich. Analogicznie zbiór narzędzi dla systemu Windows Phone 8 stanowi okrojoną wersję bibliotek Silverlight, które z kolei stanowią okrojoną wersję technologii WPF. Proces ”okrajania” bardziej zaawansowanych wersji ma na celu ograniczenie operacji, które mogą być wykonywane przez programistów. Firma Microsoft decyduje się na takie rozwiązanie z kilku przyczyn. Po pierwsze, pozwala ono na dodatkowe zabezpieczenie interfejsu API poprzez usunięcie potencjalnych punktów ataku. Po drugie, prowadzi ono do osiągnięcia ”lepszych efektów końcowych”. Innymi słowy, fi rma Microsoft kontroluje interfejs API w taki sposób, aby uniemożliwić programistom budowanie oprogramowania, które wpływałoby negatywnie na wizerunek produktu Windows 8. Zależność tę można zilustrować na przykładzie czasu pracy baterii, który jest bardzo istotny w przypadku uruchomienia systemu Windows 8 na tablecie. Zasadniczo, im dłuższy czas pracy baterii, tym bardziej zadowoleni są użytkownicy. Jeśli fi rma Microsoft zaprojektuje interfejs API w taki sposób, aby utrudnić programistom budowanie rozwią- zań, które znacznie podnoszą zużycie baterii, zdaniem użytkowników czas pracy baterii będzie dłuższy i w konsekwencji będą oni rekomendowali system Windows 8 jako system operacyjny dla tabletów. Problem ten zostanie zilustrowany na przykładzie zadań w tle omówionych w rozdziale 14. Podsumowując, możemy uzyskiwać dostęp tylko do tych funkcji, które zostały dodane do platformy .NETCore. Nawet gdybyśmy mogli pominąć to ograniczenie, nie byłoby to zalecane, ponieważ aplikacja prawdopodobnie nie otrzymałaby certyfi katu potrzebnego do opublikowania jej w Sklepie Windows (do tego zagadnienia powrócimy w rozdziale 15). 4 | Rozdział 1: Przejście z platformy .NET (cz.1) ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Metadane WinRT Jedną z ogromnych zalet platformy .NET był od samego początku poziom szczegółowości systemu metadanych (używając pojęcia metadane w tym kontekście, mamy po prostu na myśli opis struktury wszystkich typów oraz ich elementów członkowskich). Każdy zestaw .NET mógł zawierać niezwykle dokładny opis. Natomiast biblioteki DLL sys- temu Windows DLL zawierały bardzo niewiele metadanych, zazwyczaj jedynie tabelę EXPORTS z listą funkcji do wywołania. Biblioteki COM oferowały
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Programowanie aplikacji dla Sklepu Windows w 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ą: