Udostępnij za pośrednictwem

Jak używać zarządzanego klienta usługi Azure Mobile Apps

  • Artykuł

Omówienie

W tym przewodniku przedstawiono sposób wykonywania typowych scenariuszy przy użyciu zarządzanej biblioteki klienta dla Azure App Service Mobile Apps dla Windows i aplikacji platformy Xamarin. Jeśli jesteś nowym użytkownikiem usługi Mobile Apps, rozważ najpierw ukończenie samouczka Szybki start Mobile Apps Azure . W tym przewodniku skupimy się na zestawie SDK zarządzanym po stronie klienta. Aby dowiedzieć się więcej o zestawach SDK po stronie serwera dla Mobile Apps, zobacz dokumentację dotyczącą zestawu .NET Server SDK lub zestawu SDKNode.js Server.

Dokumentacja referencyjna

Dokumentacja referencyjna zestawu SDK klienta znajduje się tutaj: Dokumentacja Mobile Apps platformy Azure dla platformy .NET. Kilka przykładów klientów można również znaleźć w repozytorium Azure-Samples GitHub przykładów.

Obsługiwane platformy

Platforma .NET obsługuje następujące platformy:

  • Wydania platformy Xamarin dla systemu Android dla interfejsów API od 19 do 24 (KitKat do Nougat)
  • Wydania platformy Xamarin dla systemu iOS w wersji 8.0 lub nowszej
  • Platforma uniwersalna systemu Windows
  • Windows Phone 8,1
  • Windows Phone 8.0 z wyjątkiem aplikacji Silverlight

Uwierzytelnianie "przepływu serwera" używa widoku WebView dla prezentowanego interfejsu użytkownika. Jeśli urządzenie nie może przedstawić interfejsu użytkownika aplikacji WebView, potrzebne są inne metody uwierzytelniania. W związku z tym ten zestaw SDK nie jest odpowiedni dla urządzeń typu Watch ani urządzeń z podobnymi ograniczeniami.

Instalacja i wymagania wstępne

Zakładamy, że projekt zaplecza aplikacji mobilnej został już utworzony i opublikowany, co zawiera co najmniej jedną tabelę. W kodzie używanym w tym temacie tabela ma TodoItem nazwę i ma następujące kolumny: Id, Texti Complete. Ta tabela jest tą samą tabelą utworzoną po ukończeniu przewodnika Szybki start Mobile Apps Azure.

Odpowiedni typ typ po stronie klienta w języku C# to następująca klasa:

public class TodoItem
{
    public string Id { get; set; }

    [JsonProperty(PropertyName = "text")]
    public string Text { get; set; }

    [JsonProperty(PropertyName = "complete")]
    public bool Complete { get; set; }
}

JsonPropertyAttribute służy do definiowania mapowania PropertyName między polem klienta a polem tabeli.

Aby dowiedzieć się, jak tworzyć tabele w Mobile Apps zaplecza, zobacz temat .NET Server SDK (Zestaw SDK serwera platformy .NET ) lub Node.js Server SDK (Zestaw SDK serwera programuNode.js Server). Jeśli utworzono zaplecza aplikacji mobilnej w Azure Portal przewodniku Szybki start, możesz również użyć ustawienia Łatwe tabele w Azure Portal.

Instaluj pakiet zestawu SDK klienta zarządzanego

Użyj jednej z następujących metod, aby zainstalować pakiet zestawu SDK klienta zarządzanego dla Mobile Apps z NuGet:

  • Visual Studio prawym przyciskiem myszy projekt, kliknij pozycję Zarządzaj pakietami NuGet, Microsoft.Azure.Mobile.Client wyszukaj pakiet, a następnie kliknij przycisk Zainstaluj.
  • Xamarin Studio Kliknij prawym przyciskiem myszy projekt, kliknij polecenie DodajDaj> NuGet pakiety, Microsoft.Azure.Mobile.Client wyszukaj pakiet, a następnie kliknij polecenie Dodaj pakiet.

W głównym pliku działania pamiętaj o dodaniu następującej instrukcji using :

using Microsoft.WindowsAzure.MobileServices;

Uwaga

Pamiętaj, że wszystkie pakiety dla pomocy technicznej, do których odwołuje się projekt systemu Android, muszą mieć tę samą wersję. Zestaw SDK jest Xamarin.Android.Support.CustomTabs zależny od platformy Android, więc jeśli projekt korzysta z nowszej wersji pakietów obsługi, należy zainstalować ten pakiet bezpośrednio z wymaganą wersją, aby uniknąć konfliktów.

Jak pracować z symbolami debugowania w Visual Studio

Symbole przestrzeni nazw Microsoft.Azure.Mobile są dostępne w witrynie SymbolSource. Zapoznaj się z instrukcjami dotyczącymi symbolsource, aby zintegrować usługę SymbolSource z Visual Studio.

Tworzenie Mobile Apps klienta

Poniższy kod tworzy obiekt MobileServiceClient , który jest używany do uzyskiwania dostępu do zaplecza aplikacji mobilnej.

var client = new MobileServiceClient("MOBILE_APP_URL");

W poprzednim kodzie zastąp MOBILE_APP_URL adresem URL zaplecza aplikacji mobilnej, które znajduje się w bloku zaplecza aplikacji mobilnej w Azure Portal. Obiekt MobileServiceClient powinien być pojedynczym obiektem.

Praca z tabelami

W poniższej sekcji opisano sposób wyszukiwania i pobierania rekordów oraz modyfikowania danych w tabeli. Omawiane są następujące tematy:

How to: Create a table reference (2. Tworzyć odwołanie do tabeli)

Cały kod, który uzyskuje dostęp do danych w tabeli zaplecza lub modyfikuje je, wywołuje funkcje w obiekcie MobileServiceTable . Uzyskaj odwołanie do tabeli, wywołując metodę GetTable w następujący sposób:

IMobileServiceTable<TodoItem> todoTable = client.GetTable<TodoItem>();

Zwrócony obiekt używa modelu serializacji typizowana. Obsługiwany jest również nietypowany model serializacji. Poniższy przykład tworzy odwołanie do nietypowej tabeli:

// Get an untyped table reference
IMobileServiceTable untypedTodoTable = client.GetTable("TodoItem");

W przypadku nietypowanych zapytań należy określić podstawowy ciąg zapytania OData.

How to: Query data from your Mobile App

W tej sekcji opisano sposób wydawania zapytań do zaplecza aplikacji mobilnej, które obejmuje następujące funkcje:

Uwaga

Rozmiar strony opartej na serwerze jest wymuszany, aby zapobiec zwracaniu wszystkich wierszy. Stronicowanie chroni domyślne żądania dotyczące dużych zestawów danych przed negatywnym wpływem na usługę. Aby zwrócić więcej niż 50 wierszy, użyj metody Skip i Take zgodnie z opisem w tece Zwracanie danych na stronach.

Jak filtrować zwrócone dane

Poniższy kod ilustruje sposób filtrowania danych przez uwzględnienie klauzuli Where w zapytaniu. Zwraca wszystkie elementy, z których todoTable właściwość Complete jest równa false. Funkcja Where stosuje predykat filtrowania wierszy do zapytania względem tabeli.

// This query filters out completed TodoItems and items without a timestamp.
List<TodoItem> items = await todoTable
    .Where(todoItem => todoItem.Complete == false)
    .ToListAsync();

Możesz wyświetlić adres URI żądania wysłanego do zaplecza przy użyciu oprogramowania do inspekcji komunikatów, takiego jak narzędzia deweloperskie przeglądarki lub program Fiddler. Jeśli przyjrzysz się URI żądania, zwróć uwagę, że ciąg zapytania został zmodyfikowany:

GET /tables/todoitem?$filter=(complete+eq+false) HTTP/1.1

To żądanie OData jest tłumaczone na zapytanie SQL przez zestaw SDK serwera:

SELECT *
    FROM TodoItem
    WHERE ISNULL(complete, 0) = 0

Funkcja przekazywana do metody Where może mieć dowolną liczbę warunków.

// This query filters out completed TodoItems where Text isn't null
List<TodoItem> items = await todoTable
    .Where(todoItem => todoItem.Complete == false && todoItem.Text != null)
    .ToListAsync();

Ten przykład zostanie przetłumaczony na zapytanie SQL przez zestaw SDK serwera:

SELECT *
    FROM TodoItem
    WHERE ISNULL(complete, 0) = 0
          AND ISNULL(text, 0) = 0

To zapytanie można również podzielić na wiele klauzul:

List<TodoItem> items = await todoTable
    .Where(todoItem => todoItem.Complete == false)
    .Where(todoItem => todoItem.Text != null)
    .ToListAsync();

Te dwie metody są równoważne i mogą być używane zamiennie. Pierwsza opcja — ujednania wielu predykatów w jednym zapytaniu — jest bardziej kompaktowa i zalecana.

Klauzula Where obsługuje operacje, które można przetłumaczyć na podzestaw OData. Operacje obejmują:

  • Operatory relacyjne (==, !=, <, <=, >, >=),
  • Operatory arytmetyczne (+, -, /, *, %)
  • Precyzja liczb (Math.Floor, Math.Ceiling),
  • Funkcje ciągów (Length, Substring, Replace, IndexOf, StartsWith, EndsWith),
  • Właściwości daty (Rok, Miesiąc, Dzień, Godzina, Minuta, Sekunda),
  • Uzyskiwanie dostępu do właściwości obiektu i
  • Wyrażenia łączące dowolną z tych operacji.

Rozważając obsługę zestawu SDK serwera, można rozważyć dokumentację OData v3.

How to: Sort returned data (3.03.2018: sortowanie

Poniższy kod ilustruje sposób sortowania danych przez uwzględnienia funkcji OrderBy lub OrderByDescending w zapytaniu. Zwraca elementy posortowane todoTable rosnąco według Text pola.

// Sort items in ascending order by Text field
MobileServiceTableQuery<TodoItem> query = todoTable
                .OrderBy(todoItem => todoItem.Text)
List<TodoItem> items = await query.ToListAsync();

// Sort items in descending order by Text field
MobileServiceTableQuery<TodoItem> query = todoTable
                .OrderByDescending(todoItem => todoItem.Text)
List<TodoItem> items = await query.ToListAsync();

How to: Return data in pages (Jak zwrócić dane na stronach)

Domyślnie zaplecza zwraca tylko pierwszych 50 wierszy. Liczbę zwracanych wierszy można zwiększyć, wywołując metodę Take . Użyj Take metody wraz z metodą Skip , aby zażądać określonej "strony" całkowitego zestawu danych zwróconego przez zapytanie. Następujące zapytanie, po wykonaniu, zwraca trzy pierwsze elementy w tabeli.

// Define a filtered query that returns the top 3 items.
MobileServiceTableQuery<TodoItem> query = todoTable.Take(3);
List<TodoItem> items = await query.ToListAsync();

Następujące poprawione zapytanie pomija pierwsze trzy wyniki i zwraca następne trzy wyniki. To zapytanie tworzy drugą "stronę" danych, gdzie rozmiar strony to trzy elementy.

// Define a filtered query that skips the top 3 items and returns the next 3 items.
MobileServiceTableQuery<TodoItem> query = todoTable.Skip(3).Take(3);
List<TodoItem> items = await query.ToListAsync();

Metoda IncludeTotalCount żąda łącznej liczby wszystkich rekordów, które zostałyby zwrócone, ignorując wszystkie określone klauzule stronicowania/limitu:

query = query.IncludeTotalCount();

W rzeczywistej aplikacji możesz używać zapytań podobnych do poprzedniego przykładu z kontrolką pager lub porównywalnym interfejsem użytkownika do nawigowania między stronami.

Uwaga

Aby zastąpić limit 50 wierszy w za zaplecza aplikacji mobilnej, należy również zastosować do publicznej metody GET wartość EnableQueryAttribute i określić zachowanie stronicowania. Po zastosowaniu do metody maksymalna liczba zwracanych wierszy jest ustawiana na 1000:

[EnableQuery(MaxTop=1000)]

How to: Select specific columns (Jak wybrać określone kolumny)

Możesz określić, który zestaw właściwości ma zostać uwzględniany w wynikach, dodając klauzulę Select do zapytania. Na przykład poniższy kod pokazuje, jak wybrać tylko jedno pole, a także jak wybrać i sformatować wiele pól:

// Select one field -- just the Text
MobileServiceTableQuery<TodoItem> query = todoTable
                .Select(todoItem => todoItem.Text);
List<string> items = await query.ToListAsync();

// Select multiple fields -- both Complete and Text info
MobileServiceTableQuery<TodoItem> query = todoTable
                .Select(todoItem => string.Format("{0} -- {1}",
                    todoItem.Text.PadRight(30), todoItem.Complete ?
                    "Now complete!" : "Incomplete!"));
List<string> items = await query.ToListAsync();

Wszystkie opisane do tej pory funkcje są addytywne, więc możemy je nadal ująć w łańcuch. Każde wywołanie łańcuchowe wpływa na większą część zapytania. Jeszcze jeden przykład:

MobileServiceTableQuery<TodoItem> query = todoTable
                .Where(todoItem => todoItem.Complete == false)
                .Select(todoItem => todoItem.Text)
                .Skip(3).
                .Take(3);
List<string> items = await query.ToListAsync();

How to: Look up data by ID

Funkcja LookupAsync może służyć do wyszukiwania obiektów z bazy danych o określonym identyfikatorze.

// This query filters out the item with the ID of 37BBF396-11F0-4B39-85C8-B319C729AF6D
TodoItem item = await todoTable.LookupAsync("37BBF396-11F0-4B39-85C8-B319C729AF6D");

How to: Execute untyped queries (3.0: Wykonywanie nietypowanych zapytań)

Podczas wykonywania zapytania przy użyciu nietypowego obiektu tabeli należy jawnie określić ciąg zapytania OData, wywołując readasync, jak w poniższym przykładzie:

// Lookup untyped data using OData
JToken untypedItems = await untypedTodoTable.ReadAsync("$filter=complete eq 0&$orderby=text");

Możesz uzyskać wartości JSON, których możesz użyć jak z torbą właściwości. Aby uzyskać więcej informacji o programach JToken i Newtonsoft Json.NET, zobacz witrynę Json.NET firmy.

Jak wstawić dane do zaplecza aplikacji mobilnej

Wszystkie typy klientów muszą zawierać członka o nazwie Id, który jest domyślnie ciągiem. Ten identyfikator jest wymagany do wykonywania operacji CRUD i synchronizacji w trybie offline. Poniższy kod ilustruje sposób użycia metody InsertAsync do wstawiania nowych wierszy do tabeli. Parametr zawiera dane do wstawienia jako obiekt .NET.

await todoTable.InsertAsync(todoItem);

Jeśli podczas wstawiania nie zostanie uwzględniona todoItem unikatowa wartość identyfikatora niestandardowego, serwer generuje identyfikator GUID. Wygenerowany identyfikator można pobrać, kontrolując obiekt po zwracaniu wywołania.

Aby wstawić nietypowane dane, możesz skorzystać z zalet Json.NET:

JObject jo = new JObject();
jo.Add("Text", "Hello World");
jo.Add("Complete", false);
var inserted = await table.InsertAsync(jo);

Oto przykład użycia adresu e-mail jako unikatowego identyfikatora ciągu:

JObject jo = new JObject();
jo.Add("id", "myemail@emaildomain.com");
jo.Add("Text", "Hello World");
jo.Add("Complete", false);
var inserted = await table.InsertAsync(jo);

Praca z wartościami identyfikatorów

Mobile Apps obsługuje unikatowe niestandardowe wartości ciągu dla kolumny id tabeli. Wartość ciągu umożliwia aplikacjom używanie dla identyfikatora wartości niestandardowych, takich jak adresy e-mail lub nazwy użytkowników. Identyfikatory ciągów zapewniają następujące korzyści:

  • Identyfikatory są generowane bez konieczności rundy w bazie danych.
  • Rekordy można łatwiej scalać z różnych tabel lub baz danych.
  • Wartości identyfikatorów można lepiej zintegrować z logiką aplikacji.

Jeśli wartość identyfikatora ciągu nie jest ustawiona dla wstawionego rekordu, zaplecza aplikacji mobilnej generuje unikatową wartość identyfikatora. Możesz użyć metody Guid.NewGuid , aby wygenerować własne wartości identyfikatorów na kliencie lub w za zaplecza.

JObject jo = new JObject();
jo.Add("id", Guid.NewGuid().ToString("N"));

How to: Modify data in a Mobile App backend (3.01.2.2017: modyfikowanie danych w zad

Poniższy kod ilustruje sposób użycia metody UpdateAsync w celu zaktualizowania istniejącego rekordu o ten sam identyfikator przy użyciu nowych informacji. Parametr zawiera dane do zaktualizowania jako obiekt .NET.

await todoTable.UpdateAsync(todoItem);

Aby zaktualizować nietypowane dane, możesz skorzystać z Json.NET w następujący sposób:

JObject jo = new JObject();
jo.Add("id", "37BBF396-11F0-4B39-85C8-B319C729AF6D");
jo.Add("Text", "Hello World");
jo.Add("Complete", false);
var inserted = await table.UpdateAsync(jo);

Podczas id tworzenia aktualizacji należy określić pole. Zaplecza używa pola do identyfikowania id wiersza do zaktualizowania. Pole id można uzyskać z wyniku wywołania InsertAsync . Jeśli ArgumentException spróbujesz zaktualizować element bez podaniem wartości, zostanie podniesiona wartość id .

How to: Delete data in a Mobile App backend (Jak usunąć dane z zaplecza aplikacji mobilnej)

Poniższy kod ilustruje sposób użycia metody DeleteAsync do usunięcia istniejącego wystąpienia. Wystąpienie jest identyfikowane przez pole id ustawione na .todoItem

await todoTable.DeleteAsync(todoItem);

Aby usunąć nietypowane dane, możesz skorzystać z Json.NET w następujący sposób:

JObject jo = new JObject();
jo.Add("id", "37BBF396-11F0-4B39-85C8-B319C729AF6D");
await table.DeleteAsync(jo);

Podczas żądania usunięcia należy określić identyfikator. Inne właściwości nie są przekazywane do usługi lub są ignorowane w usłudze. Wynikiem wywołania jest DeleteAsync zwykle null. Identyfikator do przekazania można uzyskać z wyniku wywołania InsertAsync . Element MobileServiceInvalidOperationException jest zgłaszany podczas próby usunięcia elementu bez określania id pola.

Jak używać optymistycznej współbieżności do rozwiązywania konfliktów

Co najmniej dwaj klienci mogą zapisywać zmiany w tym samym elementie w tym samym czasie. Bez wykrywania konfliktów ostatni zapis zastąpi poprzednie aktualizacje. Optymistyczna kontrola współbieżności zakłada, że każda transakcja może zostać zatwierdzoną i w związku z tym nie używa żadnego blokowania zasobów. Przed zatwierdzeniem transakcji optymistyczna kontrola współbieżności sprawdza, czy żadne inne transakcje nie zmodyfikują danych. Jeśli dane zostały zmodyfikowane, transakcja zatwierdzania zostanie wycofana.

Mobile Apps obsługuje optymistyczne version sterowanie współbieżnością, śledząc zmiany w poszczególnych elementach przy użyciu kolumny właściwości systemu zdefiniowanej dla każdej tabeli w zakładzie aplikacji mobilnej. Przy każdej aktualizacji rekordu Mobile Apps właściwość version dla tego rekordu na nową wartość. Podczas każdego żądania aktualizacji właściwość version rekordu dołączonego do żądania jest porównywana z taką samą właściwością rekordu na serwerze. Jeśli wersja przekazana wraz z żądaniem nie jest dopasowana do zaplecza, biblioteka klienta zgłasza wyjątek MobileServicePreconditionFailedException<T> . Typem dołączonym do wyjątku jest rekord z zaplecza zawierający wersję serwera rekordu. Aplikacja może następnie użyć tych informacji, aby zdecydować version , czy ponownie wykonać żądanie aktualizacji z poprawną wartością z zaplecza w celu zatwierdzenia zmian.

Zdefiniuj kolumnę w klasie tabeli dla właściwości version systemowej, aby włączyć optymistyczny współbieżność. Na przykład:

public class TodoItem
{
    public string Id { get; set; }

    [JsonProperty(PropertyName = "text")]
    public string Text { get; set; }

    [JsonProperty(PropertyName = "complete")]
    public bool Complete { get; set; }

    // *** Enable Optimistic Concurrency *** //
    [JsonProperty(PropertyName = "version")]
    public string Version { set; get; }
}

Aplikacje korzystające z nietypowanych tabel umożliwiają optymistyczny współbieżność Version , ustawiając flagę SystemProperties w tabeli w następujący sposób.

//Enable optimistic concurrency by retrieving version
todoTable.SystemProperties |= MobileServiceSystemProperties.Version;

Oprócz włączenia optymistycznej współbieżności należy MobileServicePreconditionFailedException<T> również przechwycić wyjątek w kodzie podczas wywoływania updateAsync. Rozwiąż konflikt, stosując poprawne do version zaktualizowanego rekordu i wywołując updateAsync z rozpoznanym rekordem. Poniższy kod pokazuje, jak rozwiązać konflikt zapisu po wykryciu:

private async void UpdateToDoItem(TodoItem item)
{
    MobileServicePreconditionFailedException<TodoItem> exception = null;

    try
    {
        //update at the remote table
        await todoTable.UpdateAsync(item);
    }
    catch (MobileServicePreconditionFailedException<TodoItem> writeException)
    {
        exception = writeException;
    }

    if (exception != null)
    {
        // Conflict detected, the item has changed since the last query
        // Resolve the conflict between the local and server item
        await ResolveConflict(item, exception.Item);
    }
}


private async Task ResolveConflict(TodoItem localItem, TodoItem serverItem)
{
    //Ask user to choose the resolution between versions
    MessageDialog msgDialog = new MessageDialog(
        String.Format("Server Text: \"{0}\" \nLocal Text: \"{1}\"\n",
        serverItem.Text, localItem.Text),
        "CONFLICT DETECTED - Select a resolution:");

    UICommand localBtn = new UICommand("Commit Local Text");
    UICommand ServerBtn = new UICommand("Leave Server Text");
    msgDialog.Commands.Add(localBtn);
    msgDialog.Commands.Add(ServerBtn);

    localBtn.Invoked = async (IUICommand command) =>
    {
        // To resolve the conflict, update the version of the item being committed. Otherwise, you will keep
        // catching a MobileServicePreConditionFailedException.
        localItem.Version = serverItem.Version;

        // Updating recursively here just in case another change happened while the user was making a decision
        UpdateToDoItem(localItem);
    };

    ServerBtn.Invoked = async (IUICommand command) =>
    {
        RefreshTodoItems();
    };

    await msgDialog.ShowAsync();
}

Aby uzyskać więcej informacji, zobacz temat Offline Data Sync in Azure Mobile Apps (Tryb offline na platformie Azure).

How to: Bind Mobile Apps data to a Windows user interface

W tej sekcji przedstawiono sposób wyświetlania zwracanych obiektów danych przy użyciu elementów interfejsu użytkownika w Windows aplikacji. Poniższy przykładowy kod jest wiązany ze źródłem listy za pomocą zapytania o niekompletne elementy. Kolekcja MobileServiceCollection tworzy kolekcję Mobile Apps z możliwością tworzenia powiązań.

// This query filters out completed TodoItems.
MobileServiceCollection<TodoItem, TodoItem> items = await todoTable
    .Where(todoItem => todoItem.Complete == false)
    .ToCollectionAsync();

// itemsControl is an IEnumerable that could be bound to a UI list control
IEnumerable itemsControl  = items;

// Bind this to a ListBox
ListBox lb = new ListBox();
lb.ItemsSource = items;

Niektóre kontrolki w zarządzanym środowisku uruchomieniowym obsługują interfejs o nazwie ISupportIncrementalLoading. Ten interfejs umożliwia kontrolkom żądanie dodatkowych danych podczas przewijania przez użytkownika. Ten interfejs jest wbudowaną obsługą uniwersalnych aplikacji Windows za pośrednictwem usługi MobileServiceIncrementalLoadingCollection, która automatycznie obsługuje wywołania z kontrolek. Użyj MobileServiceIncrementalLoadingCollection w Windows w następujący sposób:

MobileServiceIncrementalLoadingCollection<TodoItem,TodoItem> items;
items = todoTable.Where(todoItem => todoItem.Complete == false).ToIncrementalLoadingCollection();

ListBox lb = new ListBox();
lb.ItemsSource = items;

Aby użyć nowej kolekcji w Windows Phone 8 i "Silverlight", ToCollection użyj metod rozszerzeń w systemach IMobileServiceTableQuery<T> i IMobileServiceTable<T>. Aby załadować dane, wywołaj .LoadMoreItemsAsync()

MobileServiceCollection<TodoItem, TodoItem> items = todoTable.Where(todoItem => todoItem.Complete==false).ToCollection();
await items.LoadMoreItemsAsync();

Jeśli używasz kolekcji utworzonej przez wywołanie funkcji ToCollectionAsync lub ToCollection, otrzymasz kolekcję, która może być powiązana z kontrolkami interfejsu użytkownika. Ta kolekcja jest z podziałem na strony. Ponieważ kolekcja ładuje dane z sieci, ładowanie czasami kończy się niepowodzeniem. Aby obsłużyć takie błędy, zastąp metodę OnException w metodzie w MobileServiceIncrementalLoadingCollection celu obsługi wyjątków wynikających z wywołań metody LoadMoreItemsAsync.

Zastanów się, czy tabela zawiera wiele pól, ale chcesz wyświetlić tylko niektóre z nich w kontrolce. Możesz użyć wskazówek z poprzedniej sekcji "Wybieranie określonych kolumn", aby wybrać określone kolumny do wyświetlenia w interfejsie użytkownika.

Zmienianie rozmiaru strony

Usługa Azure Mobile Apps domyślnie zwraca maksymalnie 50 elementów na żądanie. Rozmiar stronicowania można zmienić, zwiększając maksymalny rozmiar strony na kliencie i serwerze. Aby zwiększyć żądany rozmiar strony, określ wartość w przypadku PullOptions korzystania z funkcji PullAsync():

PullOptions pullOptions = new PullOptions
    {
        MaxPageSize = 100
    };

Przy założeniu, że PageSize wartość jest równa lub większa niż 100 na serwerze, żądanie zwraca do 100 elementów.

Praca z tabelami trybu offline

Tabele trybu offline używają lokalnego magazynu SQLite do przechowywania danych do użycia w trybie offline. Wszystkie operacje na tabelach są wykonywane względem lokalnego magazynu SQLite zamiast magazynu serwera zdalnego. Aby utworzyć tabelę w trybie offline, najpierw przygotuj projekt:

  1. W Visual Studio > kliknij prawym przyciskiem myszy rozwiązanie Zarządzaj pakietami NuGet dla rozwiązania..., a następnie wyszukaj i zainstaluj pakiet NuGet Microsoft.Azure.Mobile.Client.SQLiteStore dla wszystkich projektów w rozwiązaniu.

  2. (Opcjonalnie) Aby obsługiwać Windows, zainstaluj jeden z następujących pakietów środowiska uruchomieniowego SQLite:

  3. (Opcjonalnie). > W przypadku Windows kliknij pozycjęOdwołaniaDeduj odwołanie..., rozwiń folder > rozszerzenia folderu Windows, a następnie włącz odpowiedni interfejs SQLite dla zestawu WINDOWS SDK wraz ze środowiskiem uruchomieniowym programu Visual C++ 2013 dla zestawu Windows SDK. Nazwy zestawu SQLite SDK różnią się nieznacznie w zależności Windows platformie.

Zanim będzie można utworzyć odwołanie do tabeli, należy przygotować magazyn lokalny:

var store = new MobileServiceSQLiteStore(Constants.OfflineDbPath);
store.DefineTable<TodoItem>();

//Initializes the SyncContext using the default IMobileServiceSyncHandler.
await this.client.SyncContext.InitializeAsync(store);

Inicjowanie magazynu jest zwykle wykonywane natychmiast po utworzeniu klienta. Ścieżka OfflineDbPath powinna być nazwą pliku odpowiednią do użycia na wszystkich platformach, które obsługujesz. Jeśli ścieżka jest w pełni kwalifikowaną ścieżką (to oznacza, że rozpoczyna się od ukośnika), ta ścieżka jest używana. Jeśli ścieżka nie jest w pełni kwalifikowana, plik zostanie umieszczony w lokalizacji specyficznej dla platformy.

  • W przypadku urządzeń z systemami iOS i Android ścieżka domyślna to folder "Pliki osobiste".
  • W Windows domyślną ścieżką jest folder "AppData" specyficzny dla aplikacji.

Odwołanie do tabeli można uzyskać przy użyciu GetSyncTable<> metody :

var table = client.GetSyncTable<TodoItem>();

Nie trzeba uwierzytelniać się, aby używać tabeli w trybie offline. Uwierzytelnianie jest konieczne tylko podczas komunikacji z usługą zaplecza.

Synchronizowanie tabeli w trybie offline

Tabele trybu offline nie są domyślnie synchronizowane z zapleczami. Synchronizacja jest podzielona na dwie części. Zmiany można wypychać niezależnie od pobierania nowych elementów. Oto typowa metoda synchronizacji:

public async Task SyncAsync()
{
    ReadOnlyCollection<MobileServiceTableOperationError> syncErrors = null;

    try
    {
        await this.client.SyncContext.PushAsync();

        await this.todoTable.PullAsync(
            //The first parameter is a query name that is used internally by the client SDK to implement incremental sync.
            //Use a different query name for each unique query in your program
            "allTodoItems",
            this.todoTable.CreateQuery());
    }
    catch (MobileServicePushFailedException exc)
    {
        if (exc.PushResult != null)
        {
            syncErrors = exc.PushResult.Errors;
        }
    }

    // Simple error/conflict handling. A real application would handle the various errors like network conditions,
    // server conflicts and others via the IMobileServiceSyncHandler.
    if (syncErrors != null)
    {
        foreach (var error in syncErrors)
        {
            if (error.OperationKind == MobileServiceTableOperationKind.Update && error.Result != null)
            {
                //Update failed, reverting to server's copy.
                await error.CancelAndUpdateItemAsync(error.Result);
            }
            else
            {
                // Discard local change.
                await error.CancelAndDiscardItemAsync();
            }

            Debug.WriteLine(@"Error executing sync operation. Item: {0} ({1}). Operation discarded.", error.TableName, error.Item["id"]);
        }
    }
}

Jeśli pierwszy argument funkcji ma wartość PullAsync null, synchronizacja przyrostowa nie jest używana. Każda operacja synchronizacji pobiera wszystkie rekordy.

Zestaw SDK wykonuje niejawną operację PushAsync() przed ściągnięciem rekordów.

Obsługa konfliktów odbywa się w metodzie PullAsync() . Możesz radzić sobie z konfliktami w taki sam sposób jak w przypadku tabel online. Konflikt jest wywoływany podczas wywoływania PullAsync() zamiast podczas wstawiania, aktualizowania lub usuwania. Jeśli dojdzie do wielu konfliktów, są one powiązane w jeden błąd MobileServicePushFailedException. Każdy błąd należy obsługiwać osobno.

Praca z niestandardowym interfejsem API

Niestandardowy interfejs API umożliwia definiowanie niestandardowych punktów końcowych, które uwidoczniają funkcje serwera, które nie są mapowe na operację wstawiania, aktualizowania, usuwania ani odczytywania. Za pomocą niestandardowego interfejsu API można mieć większą kontrolę nad komunikatami, w tym odczytywanie i ustawianie nagłówków komunikatów HTTP oraz definiowanie formatu treści komunikatu innego niż JSON.

Niestandardowy interfejs API jest wywoływany przez wywołanie jednej z metod InvokeApiAsync na kliencie. Na przykład poniższy wiersz kodu wysyła żądanie POST do interfejsu API completeAll na zakładzie:

var result = await client.InvokeApiAsync<MarkAllResult>("completeAll", System.Net.Http.HttpMethod.Post, null);

Ten formularz jest typem wywołania metody i wymaga, aby typ zwracany MarkAllResult był zdefiniowany. Obsługiwane są zarówno metody typowane, jak i nietypowane.

Metoda InvokeApiAsync() dołącza "/api/" do interfejsu API, który chcesz wywołać, chyba że interfejs API rozpoczyna się od "/". Na przykład:

  • InvokeApiAsync("completeAll",...) wywołuje /api/completeAll na za zaplecza
  • InvokeApiAsync("/.auth/me",...) Wywołuje /.auth/me na za zaplecza

Możesz użyć metody InvokeApiAsync, aby wywołać dowolny interfejs WebAPI, w tym te internetowe interfejsy API, które nie są zdefiniowane w usłudze Azure Mobile Apps. W przypadku użycia metody InvokeApiAsync() wraz z żądaniem są wysyłane odpowiednie nagłówki, w tym nagłówki uwierzytelniania.

Uwierzytelnianie użytkowników

Mobile Apps obsługuje uwierzytelnianie i autoryzowanie użytkowników aplikacji przy użyciu różnych zewnętrznych dostawców tożsamości: Facebook, Google, Konto Microsoft, Twitter i Azure Active Directory. Możesz ustawić uprawnienia do tabel, aby ograniczyć dostęp do określonych operacji tylko do uwierzytelnionych użytkowników. Możesz również użyć tożsamości uwierzytelnionych użytkowników, aby zaimplementować reguły autoryzacji w skryptach serwera. Aby uzyskać więcej informacji, zapoznaj się z samouczkiem Dodawanie uwierzytelniania do aplikacji.

Obsługiwane są dwa przepływy uwierzytelniania: zarządzany przez klientai zarządzany przez serwer . Przepływ zarządzany przez serwer zapewnia najprostsze środowisko uwierzytelniania, ponieważ opiera się na interfejsie uwierzytelniania internetowego dostawcy. Przepływ zarządzany przez klienta umożliwia głębszą integrację z możliwościami specyficznym dla urządzenia, ponieważ opiera się na zestawach SDK specyficznych dla określonego dostawcy dla urządzenia.

Uwaga

Zalecamy używanie przepływu zarządzanego przez klienta w aplikacjach produkcyjnych.

Aby skonfigurować uwierzytelnianie, musisz zarejestrować aplikację u co najmniej jednego dostawcy tożsamości. Dostawca tożsamości generuje identyfikator klienta i klucz tajny klienta dla aplikacji. Te wartości są następnie ustawiane w za zaplecza w celu włączenia Azure App Service uwierzytelniania/autoryzacji. Aby uzyskać więcej informacji, postępuj zgodnie ze szczegółowymi instrukcjami w samouczku Dodawanie uwierzytelniania do aplikacji.

Ta sekcja zawiera następujące tematy:

Uwierzytelnianie zarządzane przez klienta

Aplikacja może niezależnie skontaktować się z dostawcą tożsamości, a następnie podać zwrócony token podczas logowania za pomocą zaplecza. Ten przepływ klienta umożliwia zapewnienie użytkownikom logowania pojedynczego lub pobranie dodatkowych danych użytkownika od dostawcy tożsamości. Uwierzytelnianie przepływu klienta jest preferowane w przypadku przepływu serwera, ponieważ zestaw SDK dostawcy tożsamości zapewnia bardziej natywny interfejs użytkownika i umożliwia dodatkowe dostosowywanie.

Dostępne są przykłady następujących wzorców uwierzytelniania przepływu klienta:

Uwierzytelnianie użytkowników za pomocą Active Directory Authentication Library

Za pomocą interfejsu Active Directory Authentication Library (ADAL) można zainicjować uwierzytelnianie użytkownika od klienta przy użyciu Azure Active Directory uwierzytelniania.

  1. Skonfiguruj swoje zaplecza aplikacji mobilnej na AAD logowania, korzystając z samouczka How to configure App Service for Active Directory login (Jak skonfigurować logowanie do usługi Active Directory). Pamiętaj, aby wykonać opcjonalny krok rejestrowania natywnej aplikacji klienckiej.

  2. W Visual Studio lub Xamarin Studio otwórz projekt i dodaj odwołanie do Microsoft.IdentityModel.Clients.ActiveDirectory NuGet projektu. Podczas wyszukiwania uwzględnij wersje wstępne.

  3. Dodaj następujący kod do aplikacji zgodnie z używaną platformą. W każdym z nich należy wprowadzić następujące zamiany:

    • Zastąp pozycję INSERT-AUTHORITY-HERE nazwą dzierżawy, w której aprowizowana jest aplikacja. Powinien to być format https://login.microsoftonline.com/contoso.onmicrosoft.com. Tę wartość można skopiować z karty Domena w Azure Active Directory w Azure Portal.

    • Zastąp pozycję INSERT-RESOURCE-ID-HERE identyfikatorem klienta zaplecza aplikacji mobilnej. Identyfikator klienta można uzyskać z karty Zaawansowane w obszarze Azure Active Directory Ustawienia w portalu.

    • Zastąp pozycję INSERT-CLIENT-ID-HERE identyfikatorem klienta skopiowanym z natywnej aplikacji klienckiej.

    • Zastąp pozycję INSERT-REDIRECT-URI-HERE punktem końcowym /.auth/login/done witryny przy użyciu schematu HTTPS. Ta wartość powinna być podobna do .https://contoso.azurewebsites.net/.auth/login/done

      Kod wymagany dla każdej platformy:

      Windows:

      private MobileServiceUser user;
private async Task AuthenticateAsync()
{

   string authority = "INSERT-AUTHORITY-HERE";
   string resourceId = "INSERT-RESOURCE-ID-HERE";
   string clientId = "INSERT-CLIENT-ID-HERE";
   string redirectUri = "INSERT-REDIRECT-URI-HERE";
   while (user == null)
   {
       string message;
       try
       {
           AuthenticationContext ac = new AuthenticationContext(authority);
           AuthenticationResult ar = await ac.AcquireTokenAsync(resourceId, clientId,
               new Uri(redirectUri), new PlatformParameters(PromptBehavior.Auto, false) );
           JObject payload = new JObject();
           payload["access_token"] = ar.AccessToken;
           user = await App.MobileService.LoginAsync(
               MobileServiceAuthenticationProvider.WindowsAzureActiveDirectory, payload);
           message = string.Format("You are now logged in - {0}", user.UserId);
       }
       catch (InvalidOperationException)
       {
           message = "You must log in. Login Required";
       }
       var dialog = new MessageDialog(message);
       dialog.Commands.Add(new UICommand("OK"));
       await dialog.ShowAsync();
   }
}

      Xamarin.iOS

      private MobileServiceUser user;
private async Task AuthenticateAsync(UIViewController view)
{

   string authority = "INSERT-AUTHORITY-HERE";
   string resourceId = "INSERT-RESOURCE-ID-HERE";
   string clientId = "INSERT-CLIENT-ID-HERE";
   string redirectUri = "INSERT-REDIRECT-URI-HERE";
   try
   {
       AuthenticationContext ac = new AuthenticationContext(authority);
       AuthenticationResult ar = await ac.AcquireTokenAsync(resourceId, clientId,
           new Uri(redirectUri), new PlatformParameters(view));
       JObject payload = new JObject();
       payload["access_token"] = ar.AccessToken;
       user = await client.LoginAsync(
           MobileServiceAuthenticationProvider.WindowsAzureActiveDirectory, payload);
   }
   catch (Exception ex)
   {
       Console.Error.WriteLine(@"ERROR - AUTHENTICATION FAILED {0}", ex.Message);
   }
}

      Xamarin.Android

      private MobileServiceUser user;
private async Task AuthenticateAsync()
{

   string authority = "INSERT-AUTHORITY-HERE";
   string resourceId = "INSERT-RESOURCE-ID-HERE";
   string clientId = "INSERT-CLIENT-ID-HERE";
   string redirectUri = "INSERT-REDIRECT-URI-HERE";
   try
   {
       AuthenticationContext ac = new AuthenticationContext(authority);
       AuthenticationResult ar = await ac.AcquireTokenAsync(resourceId, clientId,
           new Uri(redirectUri), new PlatformParameters(this));
       JObject payload = new JObject();
       payload["access_token"] = ar.AccessToken;
       user = await client.LoginAsync(
           MobileServiceAuthenticationProvider.WindowsAzureActiveDirectory, payload);
   }
   catch (Exception ex)
   {
       AlertDialog.Builder builder = new AlertDialog.Builder(this);
       builder.SetMessage(ex.Message);
       builder.SetTitle("You must log in. Login Required");
       builder.Create().Show();
   }
}
protected override void OnActivityResult(int requestCode, Result resultCode, Intent data)
{

   base.OnActivityResult(requestCode, resultCode, data);
   AuthenticationAgentContinuationHelper.SetAuthenticationAgentContinuationEventArgs(requestCode, resultCode, data);
}

Pojedyncza Sign-On przy użyciu tokenu z usługi Facebook lub Google

Możesz użyć przepływu klienta, jak pokazano w tym fragmencie kodu dla serwisu Facebook lub Google.

var token = new JObject();
// Replace access_token_value with actual value of your access token obtained
// using the Facebook or Google SDK.
token.Add("access_token", "access_token_value");

private MobileServiceUser user;
private async Task AuthenticateAsync()
{
    while (user == null)
    {
        string message;
        try
        {
            // Change MobileServiceAuthenticationProvider.Facebook
            // to MobileServiceAuthenticationProvider.Google if using Google auth.
            user = await client.LoginAsync(MobileServiceAuthenticationProvider.Facebook, token);
            message = string.Format("You are now logged in - {0}", user.UserId);
        }
        catch (InvalidOperationException)
        {
            message = "You must log in. Login Required";
        }

        var dialog = new MessageDialog(message);
        dialog.Commands.Add(new UICommand("OK"));
        await dialog.ShowAsync();
    }
}

Uwierzytelnianie zarządzane przez serwer

Po zarejestrowaniu dostawcy tożsamości wywołaj metodę LoginAsync w [MobileServiceClient] przy użyciu wartości MobileServiceAuthenticationProvider dostawcy. Na przykład poniższy kod inicjuje logowanie do przepływu serwera przy użyciu usługi Facebook.

private MobileServiceUser user;
private async System.Threading.Tasks.Task Authenticate()
{
    while (user == null)
    {
        string message;
        try
        {
            user = await client
                .LoginAsync(MobileServiceAuthenticationProvider.Facebook);
            message =
                string.Format("You are now logged in - {0}", user.UserId);
        }
        catch (InvalidOperationException)
        {
            message = "You must log in. Login Required";
        }

        var dialog = new MessageDialog(message);
        dialog.Commands.Add(new UICommand("OK"));
        await dialog.ShowAsync();
    }
}

Jeśli używasz dostawcy tożsamości innego niż Facebook, zmień wartość mobileServiceAuthenticationProvider na wartość dostawcy.

W przepływie serwera Azure App Service przepływem uwierzytelniania OAuth, wyświetlając stronę logowania wybranego dostawcy. Po powrocie dostawcy tożsamości Azure App Service token App Service token uwierzytelniania. Metoda LoginAsync zwraca wartość MobileServiceUser, która dostarcza zarówno identyfikator użytkownika uwierzytelnionego użytkownika, jak i token MobileServiceAuthenticationToken jako token sieci Web JSON (JWT). Ten token można zapisać w pamięci podręcznej i ponownie go używać, dopóki nie wygaśnie. Aby uzyskać więcej informacji, zobacz Buforowanie tokenu uwierzytelniania.

W przypadku korzystania z platformy Xamarin (android lub iOS) używany jest element WebAuthenticator platformy Xamarin.Essentials. Należy przekazać domyślny kontekst (Android) lub UIViewController (iOS) do LoginAsync metody . Ponadto należy obsłużyć zwrot z internetowego wystawcy uwierzytelniań. W systemie Android jest to obsługiwane w programie MainActivity.cs:

public override void OnResume()
{
    base.OnResume();
    Xamarin.Essentials.Platform.OnResume();
}

W systemie iOS jest to obsługiwane w ramach appDelegate.cs":

public override bool OpenUrl(UIApplication app, NSUrl url, NSDictionary options)
{
    if (client.ResumeWithURL(app, url, options))
        return true;
    return base.OpenUrl(app, url, options);
}

Buforowanie tokenu uwierzytelniania

W niektórych przypadkach można uniknąć wywołania metody logowania po pierwszym pomyślnym uwierzytelnieniu przez zapisanie tokenu uwierzytelniania od dostawcy. Microsoft Store i platformy UWP mogą używać funkcji PasswordVault do buforowania bieżącego tokenu uwierzytelniania po pomyślnym zalogowaniu, w następujący sposób:

await client.LoginAsync(MobileServiceAuthenticationProvider.Facebook);

PasswordVault vault = new PasswordVault();
vault.Add(new PasswordCredential("Facebook", client.currentUser.UserId,
    client.currentUser.MobileServiceAuthenticationToken));

Wartość UserId jest przechowywana jako nazwa_użytkownika poświadczenia, a token jest przechowywany jako hasło. Podczas kolejnych startów możesz sprawdzić, czy w programie PasswordVault nie ma buforowanych poświadczeń. W poniższym przykładzie użyto poświadczeń buforowanych, gdy zostaną znalezione, a w przeciwnym razie spróbuje ponownie uwierzytelnić się za pomocą zaplecza:

// Try to retrieve stored credentials.
var creds = vault.FindAllByResource("Facebook").FirstOrDefault();
if (creds != null)
{
    // Create the current user from the stored credentials.
    client.currentUser = new MobileServiceUser(creds.UserName);
    client.currentUser.MobileServiceAuthenticationToken =
        vault.Retrieve("Facebook", creds.UserName).Password;
}
else
{
    // Regular login flow and cache the token as shown above.
}

Po wylogowania użytkownika należy również usunąć przechowywane poświadczenia w następujący sposób:

client.Logout();
vault.Remove(vault.Retrieve("Facebook", client.currentUser.UserId));

Aplikacje platformy Xamarin używają interfejsów API Xamarin.Auth do bezpiecznego przechowywania poświadczeń w obiekcie Account. Przykład użycia tych interfejsów API można znaleźć w pliku kodu AuthStore.cs w przykładzie udostępniania zdjęć ContosoMoments.

Korzystając z uwierzytelniania zarządzanego przez klienta, można również buforować token dostępu uzyskany od dostawcy, takiego jak Facebook lub Twitter. Ten token można dostarczyć w celu zażądania nowego tokenu uwierzytelniania z zaplecza w następujący sposób:

var token = new JObject();
// Replace <your_access_token_value> with actual value of your access token
token.Add("access_token", "<your_access_token_value>");

// Authenticate using the access token.
await client.LoginAsync(MobileServiceAuthenticationProvider.Facebook, token);

Powiadomienia wypychane

Następujące tematy obejmują powiadomienia wypychane:

Jak zarejestrować powiadomienia wypychane

Klient Mobile Apps umożliwia rejestrowanie powiadomień wypychanych w usłudze Azure Notification Hubs. Podczas rejestrowania uzyskujesz dojście, które uzyskujesz z usługi powiadomień wypychanych (PNS) specyficznej dla platformy. Następnie należy podać tę wartość wraz z dowolnymi tagami podczas tworzenia rejestracji. Poniższy kod rejestruje aplikację Windows powiadomień wypychanych w usłudze Windows Notification Service (WNS):

private async void InitNotificationsAsync()
{
    // Request a push notification channel.
    var channel = await PushNotificationChannelManager.CreatePushNotificationChannelForApplicationAsync();

    // Register for notifications using the new channel.
    await MobileService.GetPush().RegisterNativeAsync(channel.Uri, null);
}

W przypadku wypychania do usług WNS należy uzyskać identyfikator SID Microsoft Store WNS. Aby uzyskać więcej informacji na Windows, w tym na temat rejestrowania w celu rejestracji szablonów, zobacz Dodawanie powiadomień wypychanych do aplikacji.

Żądanie tagów od klienta nie jest obsługiwane. Żądania tagów są dyskretnie porzucane z rejestracji. Jeśli chcesz zarejestrować urządzenie przy użyciu tagów, utwórz niestandardowy interfejs API, który używa interfejsu API Notification Hubs api do przeprowadzenia rejestracji w Twoim imieniu. Wywołaj niestandardowy interfejs API zamiast RegisterNativeAsync() metody .

How to: Obtain a Microsoft Store package SID

Identyfikator SID pakietu jest wymagany do włączania powiadomień wypychanych w Microsoft Store aplikacji. Aby otrzymać identyfikator SID pakietu, zarejestruj aplikację w Microsoft Store.

Aby uzyskać tę wartość:

  1. W Visual Studio Eksplorator rozwiązań prawym przyciskiem myszy projekt aplikacji Microsoft Store kliknij pozycję SklepSkojarz> aplikację ze sklepem....
  2. W kreatorze kliknij przycisk Dalej, zaloguj się przy użyciu konto Microsoft, wpisz nazwę aplikacji w rezerwie nowej nazwy aplikacji, a następnie kliknij pozycję Rezerwuj.
  3. Po pomyślnym utworzeniu rejestracji aplikacji wybierz nazwę aplikacji, kliknij przycisk Dalej, a następnie kliknij pozycję Skojarz.
  4. Zaloguj się do witryny Windows Centrum deweloperów przy użyciu konta Microsoft. W Moje aplikacje kliknij utworzoną rejestrację aplikacji.
  5. Kliknij pozycję Zarządzanie aplikacją>Tożsamość aplikacji, a następnie przewiń w dół, aby znaleźć identyfikator SID pakietu.

Wiele zastosowań identyfikatora SID pakietu traktuje go jako identyfikator URI. W takim przypadku należy użyć identyfikatora ms-app:// jako schematu. Zanotuj wersję identyfikatora SID pakietu utworzonego przez ujednolicanie tej wartości jako prefiksu.

Aplikacje platformy Xamarin wymagają dodatkowego kodu, aby móc zarejestrować aplikację uruchamianą na platformach iOS lub Android. Aby uzyskać więcej informacji, zobacz temat dla swojej platformy:

Jak zarejestrować szablony wypychania do wysyłania powiadomień międzyplatformowych

Aby zarejestrować szablony, użyj RegisterAsync() metody z szablonami w następujący sposób:

JObject templates = myTemplates();
MobileService.GetPush().RegisterAsync(channel.Uri, templates);

Szablony powinny być typami JObject i mogą zawierać wiele szablonów w następującym formacie JSON:

public JObject myTemplates()
{
    // single template for Windows Notification Service toast
    var template = "<toast><visual><binding template=\"ToastText01\"><text id=\"1\">$(message)</text></binding></visual></toast>";

    var templates = new JObject
    {
        ["generic-message"] = new JObject
        {
            ["body"] = template,
            ["headers"] = new JObject
            {
                ["X-WNS-Type"] = "wns/toast"
            },
            ["tags"] = new JArray()
        },
        ["more-templates"] = new JObject {...}
    };
    return templates;
}

Metoda RegisterAsync() akceptuje również kafelki pomocnicze:

MobileService.GetPush().RegisterAsync(string channelUri, JObject templates, JObject secondaryTiles);

Wszystkie tagi są zdjęte podczas rejestracji w celu zabezpieczenia. Aby dodać tagi do instalacji lub szablonów w ramach instalacji, zobacz [Praca z zestawem SDK serwera zaplecza platformy .NET dla usługi Azure Mobile Apps].

Aby wysyłać powiadomienia przy użyciu tych zarejestrowanych szablonów, zapoznaj się z Notification Hubs API.

Różne tematy

Jak obsłużyć błędy

Gdy wystąpi błąd w za zaplecza, zestaw SDK klienta zgłasza błąd MobileServiceInvalidOperationException. W poniższym przykładzie pokazano, jak obsługiwać wyjątek zwracany przez zaplecza:

private async void InsertTodoItem(TodoItem todoItem)
{
    // This code inserts a new TodoItem into the database. When the operation completes
    // and App Service has assigned an Id, the item is added to the CollectionView
    try
    {
        await todoTable.InsertAsync(todoItem);
        items.Add(todoItem);
    }
    catch (MobileServiceInvalidOperationException e)
    {
        // Handle error
    }
}

Inny przykład obsługi warunków błędów można znaleźć w przykładzie Mobile Apps Files. Przykład LoggingHandler zawiera program obsługi delegata rejestrowania do rejestrowania żądań, które są dokonywane do zaplecza.

Jak dostosować nagłówki żądań

Aby obsługiwać określony scenariusz aplikacji, może być konieczne dostosowanie komunikacji z zaplecza aplikacji mobilnej. Na przykład możesz dodać niestandardowy nagłówek do każdego żądania wychodzącego, a nawet zmienić kody stanu odpowiedzi. Możesz użyć niestandardowego delegatinghandler, jak w poniższym przykładzie:

public async Task CallClientWithHandler()
{
    MobileServiceClient client = new MobileServiceClient("AppUrl", new MyHandler());
    IMobileServiceTable<TodoItem> todoTable = client.GetTable<TodoItem>();
    var newItem = new TodoItem { Text = "Hello world", Complete = false };
    await todoTable.InsertAsync(newItem);
}

public class MyHandler : DelegatingHandler
{
    protected override async Task<HttpResponseMessage>
        SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
    {
        // Change the request-side here based on the HttpRequestMessage
        request.Headers.Add("x-my-header", "my value");

        // Do the request
        var response = await base.SendAsync(request, cancellationToken);

        // Change the response-side here based on the HttpResponseMessage

        // Return the modified response
        return response;
    }
}