Jak používat spravovaného klienta pro Azure Mobile Apps

  • Článek
  • 28 min ke čtení

Přehled

V této příručce se dozvíte, jak provádět běžné scénáře pomocí spravované klientské knihovny pro Azure App Service Mobile Apps pro aplikace pro Windows a Xamarin. Pokud s Mobile Apps začínáte, měli byste zvážit, jak nejprve vyplníte kurz Azure Mobile Apps rychlý Start . V tomto průvodci se zaměříme na spravovanou sadu SDK na straně klienta. Další informace o sadách SDK na straně serveru pro Mobile Apps naleznete v dokumentaci k sadě SDK serveru .NET nebo sadě SDK serveruNode.js.

Referenční dokumentace

Referenční dokumentace k sadě Client SDK se nachází tady: odkazy na klienta Azure Mobile Apps .NET. Několik ukázek klientů můžete najít také v úložišti GitHub Azure-Samples.

Podporované platformy

Platforma .NET podporuje následující platformy:

  • Verze Xamarin Androidu pro rozhraní API 19 až 24 (KitKat až nougat)
  • Verze Xamarin iOS pro iOS verze 8,0 a novější
  • Univerzální platforma Windows
  • Windows Phone 8.1
  • Windows Phone 8,0 s výjimkou aplikací Silverlight

Ověřování "Server-Flow" používá pro prezentované uživatelské rozhraní WebView. Pokud zařízení není schopné prezentovat uživatelské rozhraní WebView, vyžadují se další metody ověřování. Tato sada SDK není vhodná pro zařízení s omezením typu kukátka nebo podobně.

Nastavení a předpoklady

Předpokládáme, že už jste vytvořili a publikovali projekt back-endu mobilní aplikace, který obsahuje alespoň jednu tabulku. V kódu použitém v tomto tématu je tabulka pojmenována TodoItem a obsahuje následující sloupce: Id , Text , a Complete . Tato tabulka je stejná jako tabulka vytvořená při dokončení rychlého startu Azure Mobile Apps.

Odpovídající typový typ na straně klienta v jazyce C# je následující třída:

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 se používá k definování mapování PropertyName mezi polem klient a polem tabulky.

Informace o vytváření tabulek v back-endu Mobile Apps najdete v tématu věnovaném sadě SDK serveru .NET nebo v tématu sada SDK proNode.js Server. Pokud jste v Azure Portal vytvořili back-end mobilní aplikace pomocí rychlého startu, můžete také použít nastavení jednoduché tabulky v Azure Portal.

Postupy: instalace balíčku spravovaného klienta sady SDK

K instalaci balíčku spravovaného klienta sady SDK pro Mobile Apps z NuGetpoužijte jednu z následujících metod:

  • Visual Studio Klikněte pravým tlačítkem na projekt, klikněte na Spravovat balíčky NuGet , vyhledejte Microsoft.Azure.Mobile.Client balíček a pak klikněte na nainstalovat.
  • Xamarin Studio Klikněte pravým tlačítkem na projekt, klikněte na Přidat > Přidat balíčky NuGet , vyhledejte Microsoft.Azure.Mobile.Client balíček a pak klikněte na Přidat balíček.

V souboru hlavní aktivity nezapomeňte přidat následující příkaz using :

using Microsoft.WindowsAzure.MobileServices;

Poznámka

Upozorňujeme, že všechny balíčky podporu odkazované ve vašem projektu Android musí mít stejnou verzi. Sada SDK má Xamarin.Android.Support.CustomTabs závislost na platformě Android, takže pokud váš projekt používá novější balíčky podpory, je nutné nainstalovat tento balíček s požadovanou verzí přímo, aby nedocházelo ke konfliktům.

Postupy: práce s symboly ladění v aplikaci Visual Studio

V SymbolSourcejsou k dispozici symboly pro obor názvů Microsoft. Azure. Mobile. Informace o integraci SymbolSource se sadou Visual Studio najdete v pokynech k SymbolSource .

Vytvoření klienta Mobile Apps

Následující kód vytvoří objekt MobileServiceClient , který se používá pro přístup k back-endu mobilní aplikace.

var client = new MobileServiceClient("MOBILE_APP_URL");

V předchozím kódu nahraďte MOBILE_APP_URL adresu URL back-endu mobilní aplikace, který najdete v okně pro back-end mobilní aplikace v Azure Portal. Objekt MobileServiceClient by měl být typu singleton.

Práce s tabulkami

Následující část popisuje, jak vyhledat a načíst záznamy a upravit data v tabulce. Jsou pokrytá následující témata:

Postupy: Vytvoření odkazu na tabulku

Veškerý kód, který přistupuje k datům v back-endové tabulce a upravuje je, volá funkce MobileServiceTable objektu. Získejte odkaz na tabulku voláním metody GetTable následujícím způsobem:

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

Vrácený objekt používá typový serializace model. Podporuje se taky Netypový serializace model. Následující příklad [vytvoří odkaz na netypové tabulky]:

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

V netypových dotazech je nutné zadat podkladový řetězec dotazu OData.

Postupy: dotazování dat z mobilní aplikace

Tato část popisuje, jak vydávat dotazy do back-endu mobilní aplikace, který obsahuje následující funkce:

Poznámka

Je využívána velikost stránky řízená serverem, aby se zabránilo vrácení všech řádků. Stránkování udržuje výchozí požadavky na velké datové sady z negativního vlivu na službu. Chcete-li vrátit více než 50 řádků, Skip použijte Take metodu a, jak je popsáno v tématu návratová data na stránkách.

Postupy: filtrování vrácených dat

Následující kód ilustruje, jak filtrovat data zahrnutím Where klauzule do dotazu. Vrátí všechny položky, todoTable jejichž Complete vlastnost je rovna false . Funkce [WHERE] aplikuje predikát filtru řádku na dotaz na tabulku.

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

Identifikátor URI žádosti odeslané do back-endu můžete zobrazit pomocí softwaru pro kontrolu zpráv, například nástrojů pro vývojáře a Fiddler. Pokud se podíváte na požadavek s identifikátorem URI, Všimněte si, že je upraven řetězec dotazu:

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

Tento požadavek OData se převede na dotaz SQL ze serverové sady SDK:

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

Funkce, která je předána Where metodě, může mít libovolný počet podmínek.

// 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();

Tento příklad by byl přeložen na dotaz SQL pomocí sady SDK serveru:

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

Tento dotaz může být také rozdělen do více klauzulí:

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

Tyto dvě metody jsou ekvivalentní a dají se použít zaměnitelné. Předchozí možnost — zřetězení více predikátů v jednom dotazu — je kompaktnější a doporučuje se.

WhereKlauzule podporuje operace, které budou přeloženy do podmnožiny OData. Operace zahrnují:

  • Relační operátory (= =,! =, <, <=, >, >=),
  • Aritmetické operátory (+,-,/, *,%),
  • Přesnost čísel (Math. Floor, Math. strop),
  • Řetězcové funkce (délka, podřetězec, Replace, IndexOf, StartsWith, EndsWith),
  • Vlastnosti data (rok, měsíc, den, hodina, minuta, sekundy),
  • Přístup k vlastnostem objektu a
  • Výrazy kombinující některé z těchto operací.

Při zvažování, co podporuje sada SDK serveru, můžete zvážit [dokumentaci k OData V3].

Postupy: řazení vrácených dat

Následující kód ilustruje, jak řadit data zahrnutím funkce OrderBy nebo OrderByDescending do dotazu. Vrátí položky ze todoTable vzestupného řazení podle Text pole.

// 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();

Postupy: vrácení dat na stránkách

Ve výchozím nastavení back-end vrátí jenom prvních 50 řádků. Počet vrácených řádků můžete zvýšit voláním metody [přijmout] . Použijte Take spolu s metodou [Skip] pro vyžádání konkrétní "stránky" celkové datové sady vrácené dotazem. Následující dotaz po provedení vrátí první tři položky v tabulce.

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

Následující revidovaný dotaz přeskočí první tři výsledky a vrátí další tři výsledky. Tento dotaz vytvoří druhou "stránku" dat, kde je velikost stránky tři položky.

// 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 požaduje celkový počet všech záznamů, které by byly vráceny, ignorování všech zadaných klauzulí stránkování a omezení:

query = query.IncludeTotalCount();

V reálné aplikaci můžete použít dotazy podobné předchozím příkladům pomocí ovládacího prvku stránkování nebo srovnatelného uživatelského rozhraní pro navigaci mezi stránkami.

Poznámka

Chcete-li v back-endu mobilní aplikace přepsat 50 – limit řádku, je nutné také použít EnableQueryAttribute na metodu public get a určit chování stránkování. Při použití na metodu nastaví následující nastavení maximální počet vrácených řádků na 1000:

[EnableQuery(MaxTop=1000)]

Postupy: Výběr konkrétních sloupců

Přidáním klauzule [Select] do dotazu můžete určit, kterou sadu vlastností zahrnout do výsledků. Například následující kód ukazuje, jak vybrat pouze jedno pole a také jak vybrat a formátovat více polí:

// 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();

Všechny funkce popsané v této míře jsou doplňkové, takže je můžeme dál zřetězit. Každé zřetězené volání má vliv na více dotazů. Jeden další příklad:

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

Postupy: vyhledávání dat podle ID

Funkci LookupAsync lze použít k vyhledání objektů z databáze pomocí konkrétního ID.

// 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");

Postupy: spuštění netypových dotazů

Při provádění dotazu pomocí netypového objektu tabulky je nutné explicitně zadat řetězec dotazu OData voláním ReadAsync, jak je uvedeno v následujícím příkladu:

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

Vrátíte se zpátky hodnoty JSON, které můžete použít jako kontejner objektů a dat. Další informace o JToken a Newtonsoft Json.NET najdete na webu JSON.NET .

Postupy: vkládání dat do back-endu mobilní aplikace

Všechny typy klientů musí obsahovat člen s názvem ID , který je ve výchozím nastavení řetězec. Toto ID je vyžadováno k provádění operací CRUD a pro offline synchronizaci. Následující kód ilustruje použití metody InsertAsync k vložení nových řádků do tabulky. Parametr obsahuje data, která mají být vložena jako objekt rozhraní .NET.

await todoTable.InsertAsync(todoItem);

Pokud během vložení není v průběhu vkládání zahrnutá jedinečná hodnota vlastního ID todoItem , vygeneruje se na serveru identifikátor GUID. Vygenerované ID můžete načíst tak, že zkontrolujete objekt po návratu volání.

Chcete-li vložit netypové údaje, můžete využít výhod Json.NET:

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

Tady je příklad použití e-mailové adresy jako jedinečného ID řetězce:

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);

Práce s hodnotami ID

Mobile Apps podporuje jedinečné vlastní hodnoty řetězce pro sloupec ID tabulky. Řetězcová hodnota umožňuje aplikacím používat vlastní hodnoty, jako jsou e-mailové adresy nebo uživatelská jména pro ID. ID řetězců poskytují následující výhody:

  • ID jsou generována bez odeslání odezvy do databáze.
  • Záznamy je snazší sloučit z různých tabulek nebo databází.
  • Hodnoty ID se můžou integrovat lépe díky logice aplikace.

Pokud u vloženého záznamu není nastavená hodnota ID řetězce, back-end mobilní aplikace vygeneruje pro ID jedinečnou hodnotu. Pomocí metody GUID. NewGuid můžete vygenerovat vlastní hodnoty ID, a to buď v klientovi, nebo v back-endu.

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

Postupy: Změna dat v back-endu mobilní aplikace

Následující kód ilustruje použití metody UpdateAsync k aktualizaci existujícího záznamu se stejným ID s novými informacemi. Parametr obsahuje data, která mají být aktualizována jako objekt .NET.

await todoTable.UpdateAsync(todoItem);

Chcete-li aktualizovat netypové údaje, můžete využít výhod JSON.NET následujícím způsobem:

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);

idPři provádění aktualizace je třeba zadat pole. Back-end používá id pole k identifikaci řádku, který se má aktualizovat. idPole lze získat z výsledku InsertAsync volání. ArgumentExceptionJe vyvolána, pokud se pokusíte aktualizovat položku bez zadání id hodnoty.

Postupy: odstranění dat v back-endu mobilní aplikace

Následující kód ilustruje použití metody DeleteAsync k odstranění existující instance. Instance je identifikována id polem nastaveným na todoItem .

await todoTable.DeleteAsync(todoItem);

K odstranění netypových dat můžete využít výhod Json.NET následujícím způsobem:

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

Při provádění žádosti o odstranění je nutné zadat ID. Do služby se nepředaly další vlastnosti nebo se ve službě ignorují. Výsledek DeleteAsync volání je obvykle null . ID, které se má předat, lze získat z výsledku InsertAsync volání. MobileServiceInvalidOperationExceptionVýjimka je vyvolána, pokud se pokusíte odstranit položku bez zadání id pole.

Postupy: použití optimistického řízení souběžnosti pro řešení konfliktů

Dva nebo více klientů může současně zapisovat změny stejné položky. Bez zjištění konfliktů by poslední zápis přepsal všechny předchozí aktualizace. Optimistické řízení souběžnosti předpokládá, že každá transakce se může potvrdit, a proto nepoužívá žádné uzamykání prostředků. Před potvrzením transakce ověří optimistické řízení souběžnosti, že žádná jiná transakce data nezměnila. Pokud byla data změněna, transakce potvrzení se vrátí zpět.

Mobile Apps podporuje optimistické řízení souběžnosti tím, že sleduje změny každé položky pomocí version sloupce vlastnost systému, který je definovaný pro každou tabulku v back-endu mobilní aplikace. Pokaždé, když se aktualizuje záznam, Mobile Apps nastaví version vlastnost pro tento záznam na novou hodnotu. Během každé žádosti o aktualizaci se version vlastnost záznamu zahrnutého spolu s požadavkem porovnává se stejnou vlastností záznamu na serveru. Pokud se verze předaná s požadavkem neshoduje s back-end, Klientská knihovna vyvolá MobileServicePreconditionFailedException<T> výjimku. Typ zahrnutý s výjimkou je záznam z back-endu, který obsahuje verzi daného záznamu na serverech. Aplikace pak může tyto informace použít k rozhodnutí, jestli se má znovu spustit žádost o aktualizaci se správnou version hodnotou z back-endu pro potvrzení změn.

Definujte sloupec třídy Table pro version vlastnost System, aby se povolila Optimistická souběžnost. Příklad:

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; }
}

Aplikace používající netypové tabulky umožňují optimistickou souběžnost nastavením Version příznaku v SystemProperties tabulce následujícím způsobem.

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

Kromě povolení optimistické souběžnosti musíte také zachytit MobileServicePreconditionFailedException<T> výjimku v kódu při volání UpdateAsync. Vyřešte konflikt tím, že použijete správný version záznam na aktualizovaný záznam a zavoláte UpdateAsync s vyřešeným záznamem. Následující kód ukazuje, jak vyřešit konflikt zápisu, jakmile byl zjištěn:

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();
}

Další informace najdete v tématu [synchronizace offline dat v Azure Mobile Apps] .

Postupy: vázání dat Mobile Apps k uživatelskému rozhraní systému Windows

V této části se dozvíte, jak zobrazit vrácené datové objekty pomocí prvků uživatelského rozhraní v aplikaci pro Windows. Následující příklad kódu se váže ke zdroji seznamu s dotazem na nedokončené položky. MobileServiceCollection vytvoří kolekci vazeb s podporou Mobile Apps.

// 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;

Některé ovládací prvky ve spravovaném modulu runtime podporují rozhraní s názvem ISupportIncrementalLoading. Toto rozhraní umožňuje ovládacím prvkům požádat o další data, když se uživatel posune. K dispozici je integrovaná podpora pro toto rozhraní pro univerzální aplikace pro Windows přes MobileServiceIncrementalLoadingCollection, která automaticky zpracovává volání z ovládacích prvků. MobileServiceIncrementalLoadingCollectionV aplikacích pro Windows použijte následující postup:

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

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

Chcete-li použít novou kolekci v aplikacích Windows Phone 8 a Silverlight, použijte ToCollection metody rozšíření v systémech IMobileServiceTableQuery<T> a IMobileServiceTable<T> . Chcete-li načíst data, zavolejte LoadMoreItemsAsync() .

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

Použijete-li kolekci vytvořenou voláním ToCollectionAsync nebo ToCollection , získáte kolekci, která může být svázána s ovládacími prvky uživatelského rozhraní. Tato kolekce je s podporou stránkování. Vzhledem k tomu, že kolekce načítá data ze sítě, načítání se někdy nezdařilo. Chcete-li tyto chyby zpracovat, přepište OnException metodu na MobileServiceIncrementalLoadingCollection pro zpracování výjimek vyplývajících z volání LoadMoreItemsAsync .

Vezměte v úvahu, jestli má tabulka mnoho polí, ale chcete zobrazit jenom některé z nich v ovládacím prvku. Pomocí pokynů v předchozí částivyberte konkrétní sloupcemůžete vybrat konkrétní sloupce, které se zobrazí v uživatelském rozhraní.

Změnit velikost stránky

Služba Azure Mobile Apps ve výchozím nastavení vrací maximálně 50 položek na jednu žádost. Velikost stránkování můžete změnit zvětšením maximální velikosti stránky na straně klienta i serveru. Chcete-li zvětšit požadovanou velikost stránky, zadejte, kdy se má PullOptions použít PullAsync() :

PullOptions pullOptions = new PullOptions
    {
        MaxPageSize = 100
    };

Za předpokladu, že jste PageSize v rámci serveru vytvořili větší nebo rovnou 100, vrátí požadavek až 100 položek.

Práce s offline tabulkami

Offline tabulky používají místní úložiště SQLite k ukládání dat pro použití v režimu offline. Všechny operace tabulky se provádí v rámci místního úložiště SQLite místo z úložiště vzdáleného serveru. Chcete-li vytvořit offline tabulku, připravte si nejprve projekt:

  1. V aplikaci Visual Studio klikněte pravým tlačítkem na řešení > _ * spravovat balíčky NuGet pro řešení... * *, vyhledejte a nainstalujte balíček NuGet Microsoft. Azure. Mobile. Client. SQLiteStore pro všechny projekty v řešení.

  2. Volitelné Pro podporu zařízení s Windows nainstalujte jeden z následujících balíčků za běhu programu SQLite:

  3. (Volitelné). V případě zařízení s Windows klikněte na odkazy > Přidat odkaz... , rozbalíte rozšíření složky Windows > a pak pro sadu Windows 2013 Runtime pro Windows SDK povolíte příslušnou Visual C++ SQLite . Názvy sady SDK SQLite se mírně liší u jednotlivých platforem Windows.

Aby bylo možné vytvořit odkaz na tabulku, je nutné připravit místní úložiště:

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

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

Inicializace úložiště se obvykle provádí ihned po vytvoření klienta. OfflineDbPath by měl být název souboru vhodný pro použití na všech platformách, které podporujete. Pokud je cesta plně kvalifikovanou cestou (to znamená, že začíná lomítkem), pak se tato cesta použije. Pokud cesta není plně kvalifikovaná, soubor se umístí do umístění specifického pro danou platformu.

  • Pro zařízení s iOS a Androidem je výchozí cesta složka osobní soubory.
  • Pro zařízení s Windows je výchozí cesta složka "data specifická pro aplikaci".

Odkaz na tabulku lze získat pomocí GetSyncTable<> metody:

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

Nemusíte ověřovat, aby bylo možné používat offline tabulku. Musíte ověřovat jenom při komunikaci se službou back-end.

Synchronizace offline tabulky

Ve výchozím nastavení nejsou offline tabulky synchronizovány s back-end. Synchronizace je rozdělena do dvou částí. Změny se dají doručovat nezávisle na stažení nových položek. Tady je typická metoda synchronizace:

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"]);
        }
    }
}

Pokud první argument má PullAsync hodnotu null, přírůstková synchronizace se nepoužije. Každá operace synchronizace načte všechny záznamy.

Sada SDK provede implicitní PushAsync() před přijetím záznamů.

Ke zpracování konfliktů dochází v PullAsync() metodě. Konflikty můžete řešit stejným způsobem jako online tabulky. Konflikt je vytvořen, pokud PullAsync() je volán místo během vložení, aktualizace nebo odstranění. Pokud dojde k více konfliktům, jsou rozčleněny do jediného MobileServicePushFailedException. Každou chybu zpracujte samostatně.

Práce s vlastním rozhraním API

Vlastní rozhraní API umožňuje definovat vlastní koncové body, které zveřejňují funkci serveru, která není namapována na operaci vložení, aktualizace, odstranění nebo čtení. Pomocí vlastního rozhraní API můžete mít větší kontrolu nad zasíláním zpráv, včetně čtení a nastavování hlaviček zpráv HTTP a definování formátu textu zprávy, který je jiný než JSON.

Zavoláte vlastní rozhraní API voláním jedné z metod InvokeApiAsync na straně klienta. Například následující řádek kódu odešle požadavek POST rozhraní completeAll API na back-end:

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

Tento formulář je typové volání metody a vyžaduje, aby byl definován návratový typ MarkAllResult . Podporují se typové i netypové metody.

Metoda InvokeApiAsync () přiřadí "/API/" do rozhraní API, které chcete volat, pokud rozhraní API nezačíná znakem "/". Příklad:

  • InvokeApiAsync("completeAll",...) zavolá/api/completeAll do back-endu.
  • InvokeApiAsync("/.auth/me",...) zavolá/.auth/me do back-endu.

InvokeApiAsync můžete použít k volání libovolných WebAPI, včetně těchto rozhraní WebApi, která nejsou definovaná pomocí Azure Mobile Apps. Při použití InvokeApiAsync () se s požadavkem odesílají příslušné hlavičky, včetně ověřovacích hlaviček.

Ověřování uživatelů

Mobile Apps podporuje ověřování a autorizaci uživatelů aplikací pomocí různých externích zprostředkovatelů identity: Facebook, Google, účet Microsoft, Twitter a Azure Active Directory. Můžete nastavit oprávnění pro tabulky a omezit tak přístup pro konkrétní operace jenom na ověřené uživatele. Identitu ověřených uživatelů můžete použít taky k implementaci autorizačních pravidel ve skriptech serveru. Další informace najdete v kurzu Přidání ověřování do aplikace.

Podporovány jsou dva toky ověřování: tok spravovaný klientem a serverem . Tok spravovaný serverem nabízí nejjednodušší možnosti ověřování, protože spoléhá na rozhraní webového ověřování poskytovatele. Tok spravovaný klientem umožňuje hlubší integraci s funkcemi specifickými pro konkrétní zařízení, protože spoléhá na sady SDK specifické pro konkrétní zařízení.

Poznámka

V produkčních aplikacích doporučujeme použít tok spravovaný klientem.

Pokud chcete nastavit ověřování, musíte aplikaci zaregistrovat s jedním nebo více zprostředkovateli identity. Zprostředkovatel identity vygeneruje ID klienta a tajný klíč klienta pro vaši aplikaci. Tyto hodnoty se pak nastaví v back-endu, aby povolovaly Azure App Service ověřování a autorizaci. Pokud chcete získat další informace, postupujte podle podrobných pokynů v kurzu Přidání ověřování do aplikace.

Tato část pojednává o následujících tématech:

Ověřování spravované klientem

Vaše aplikace může nezávisle kontaktovat poskytovatele identity a pak poskytnout vrácený token během přihlašování k back-endu. Tento tok klienta vám umožní poskytnout uživatelům jednotné přihlašování nebo načíst další uživatelská data od poskytovatele identity. Ověřování toku klienta se upřednostňuje při používání toku serveru, protože sada SDK zprostředkovatele identity poskytuje více nativních možností uživatelského rozhraní a umožňuje další přizpůsobení.

Příklady jsou k dispozici pro následující vzory ověřování klientského toku:

Ověřování uživatelů pomocí Active Directory Authentication Library

K zahájení ověřování uživatelů z klienta pomocí ověřování Azure Active Directory můžete použít Active Directory Authentication Library (ADAL).

  1. Nakonfigurujte back-end mobilní aplikace pro přihlášení AAD pomocí pokynů v článku Postup konfigurace App Service pro přihlášení ke službě Active Directory . Ujistěte se, že jste dokončili volitelný krok registrace nativní klientské aplikace.

  2. V aplikaci Visual Studio nebo Xamarin Studio otevřete projekt a přidejte odkaz na Microsoft.IdentityModel.Clients.ActiveDirectory balíček NuGet. Při hledání zahrnout předběžné verze verzí.

  3. Přidejte do své aplikace následující kód podle používané platformy. V každém z nich proveďte následující náhrady:

    • V části pro vložení autority nahraďte název tenanta, ve kterém jste aplikaci zřídili. Formát by měl být https://login.microsoftonline.com/contoso.onmicrosoft.com . Tuto hodnotu lze zkopírovat z karty doména v Azure Active Directory Azure Portal.

    • Pro back-end mobilní aplikace nahraďte INSERT-Resource-ID – tady ID klienta. ID klienta můžete získat z karty Upřesnit v části Nastavení Azure Active Directory na portálu.

    • Pomocí ID klienta, které jste zkopírovali z nativní klientské aplikace, nahraďte INSERT-Client-ID .

    • Pomocí schématu HTTPS nahraďte text INSERT-redirect-URI – tady s koncovým bodem /.auth/Login/Done vašeho webu. Tato hodnota by měla být podobná https://contoso.azurewebsites.net/.auth/login/done .

      Kód potřebný pro každou platformu je následující:

      Systému

      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);
}

Jeden Sign-On používající token z Facebooku nebo Google

Můžete použít tok klienta, jak je znázorněno v tomto fragmentu pro Facebook nebo 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();
    }
}

Ověřování spravované serverem

Po zaregistrování poskytovatele identity volejte metodu LoginAsync na [MobileServiceClient] s hodnotou MobileServiceAuthenticationProvider vašeho poskytovatele. Následující kód například inicializuje přihlášení k serveru pomocí služby 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();
    }
}

Pokud používáte jiného poskytovatele identity než Facebook, změňte hodnotu MobileServiceAuthenticationProvider na hodnotu pro vašeho poskytovatele.

V toku serveru Azure App Service spravuje tok ověřování OAuth zobrazením přihlašovací stránky vybraného zprostředkovatele. Jakmile se zprostředkovatel identity vrátí, Azure App Service vygeneruje ověřovací token App Service. Metoda LoginAsync vrací hodnotu MobileServiceUser, která poskytuje [ID uživatele] ověřeného uživatele i MobileServiceAuthenticationTokenjako webový token JSON (Jwt). Tento token se může uložit do mezipaměti a znovu požívat do vypršení platnosti. Další informace najdete v tématu ukládání ověřovacího tokenu do mezipaměti.

Při použití Xamarin (Android nebo iOS) se používá webověřovatel Xamarin. Essentials. Do metody musíte předat výchozí kontext (Android) nebo UIViewController (iOS) LoginAsync . Kromě toho je nutné zpracovat návrat z webové ověřovací služby. V Androidu se tato akce zpracovává v rámci MainActivity.cs :

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

V systému iOS se zpracovává v 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);
}

Ukládání ověřovacího tokenu do mezipaměti

V některých případech se volání metody Login může vyhnout po prvním úspěšném ověření uložením ověřovacího tokenu od poskytovatele. Aplikace Microsoft Store a UWP můžou používat PasswordVault k ukládání aktuálního ověřovacího tokenu do mezipaměti po úspěšném přihlášení, a to následujícím způsobem:

await client.LoginAsync(MobileServiceAuthenticationProvider.Facebook);

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

Hodnota ID uživatele je uložená jako uživatelské jméno přihlašovacích údajů a token je uložený jako heslo. Při dalších spuštěních se můžete podívat na přihlašovací údaje PasswordVault pro ukládání do mezipaměti. Následující příklad používá při jejich nalezení přihlašovací údaje uložené v mezipaměti a v opačném případě se pokusí znovu ověřit pomocí back-endu:

// 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.
}

Když odhlásíte uživatele, musíte taky odebrat uložené přihlašovací údaje následujícím způsobem:

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

Aplikace Xamarin používají rozhraní API Xamarin. auth k bezpečnému ukládání přihlašovacích údajů do objektu účtu . Příklad použití těchto rozhraní API naleznete v souboru kódu AuthStore.cs v ukázce sdílení fotek ContosoMoments.

Když použijete ověřování spravované klientem, můžete také ukládat do mezipaměti přístupový token získaný od poskytovatele, jako je Facebook nebo Twitter. Tento token lze zadat pro vyžádání nového ověřovacího tokenu z back-endu následujícím způsobem:

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);

Nabízená oznámení

Nabízená oznámení jsou pokrytá v následujících tématech:

Postupy: registrace nabízených oznámení

Klient Mobile Apps umožňuje registrovat nabízená oznámení pomocí Azure Notification Hubs. Při registraci získáte popisovač, který získáte ze služby nabízených oznámení specifických pro konkrétní platformu (PNS). Po vytvoření registrace pak tuto hodnotu zadejte spolu s jakýmikoli značkami. Následující kód zaregistruje aplikaci pro Windows pro nabízená oznámení pomocí služby oznamování systému Windows (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);
}

Pokud předáváte do WNS, musíte získat Microsoft Store SID balíčku. Další informace o aplikacích pro Windows, včetně toho, jak se zaregistrovat k registraci šablon, najdete v tématu [Přidání nabízených oznámení do vaší aplikace].

Vyžadování značek od klienta není podporováno. Požadavky na značky se tiše odcházejí z registrace. Pokud chcete zařízení zaregistrovat pomocí značek, vytvořte vlastní rozhraní API, které používá rozhraní Notification Hubs API k provedení registrace vaším jménem. Místo metody zavolejte vlastní rozhraní API RegisterNativeAsync() .

Postupy: získání identifikátoru SID balíčku Microsoft Store

K povolení nabízených oznámení v aplikacích Microsoft Store se vyžaduje SID balíčku. Pokud chcete získat identifikátor SID balíčku, Zaregistrujte svoji aplikaci pomocí Microsoft Store.

Tuto hodnotu můžete získat takto:

  1. V aplikaci Visual Studio Průzkumník řešení klikněte pravým tlačítkem na projekt Microsoft Store aplikace a klikněte na Store > přidružit aplikaci k obchodu....
  2. V průvodci klikněte na Další , přihlaste se pomocí svého účet Microsoft, zadejte název vaší aplikace do pole rezervovat nový název aplikace a pak klikněte na rezervovat.
  3. Po úspěšném vytvoření registrace aplikace vyberte název aplikace, klikněte na Další a pak klikněte na přidružit.
  4. Přihlaste se k webu [Windows Dev Center] pomocí svého účtu Microsoft. V části Moje aplikace klikněte na registraci aplikace, kterou jste vytvořili.
  5. Klikněte App management na možnost > Identita aplikace správy aplikací a potom přejděte dolů k vyhledání identifikátoru SID balíčku.

Mnohé použití identifikátoru SID balíčku považuje za identifikátor URI. v takovém případě je třeba použít aplikaci MS-App:// jako schéma. Poznamenejte si verzi vašeho balíčku SID vytvořenou zřetězením této hodnoty jako předpony.

Aplikace Xamarin vyžadují nějaký další kód, který by mohl Registrovat aplikaci běžící na platformách iOS nebo Android. Další informace najdete v tématu věnovaném vaší platformě:

Postupy: Registrace šablon nabízených oznámení pro odesílání oznámení pro různé platformy

Chcete-li registrovat šablony, použijte RegisterAsync() metodu se šablonami následujícím způsobem:

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

Vaše šablony by měly být JObject typy a mohou obsahovat více šablon v následujícím formátu 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 () také přijímá sekundární dlaždice:

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

Všechny značky jsou během registrace odstraněny pro zabezpečení. Chcete-li přidat značky do instalací nebo šablon v rámci instalací, přečtěte si téma [práce s back-end serverem .NET SDK pro Azure Mobile Apps].

Pokud chcete odesílat oznámení s těmito registrovanými šablonami, přečtěte si téma rozhraní API pro Notification Hubs.

Různá témata

Postupy: zpracování chyb

Pokud dojde k chybě v back-endu, klientská sada SDK vyvolá MobileServiceInvalidOperationException . Následující příklad ukazuje, jak zpracovat výjimku vrácenou back-end:

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
    }
}

Další příklad práce s chybovými stavy najdete v [ukázce Mobile Apps Files]. Příklad LoggingHandler poskytuje obslužnou rutinu delegáta protokolování pro protokolování požadavků do back-endu.

Postupy: přizpůsobení hlaviček požadavku

Aby bylo možné podporovat konkrétní scénář aplikace, může být nutné přizpůsobit komunikaci s back-endu mobilní aplikace. Například můžete chtít přidat vlastní hlavičku do každého odchozího požadavku nebo dokonce změnit stavové kódy odpovědí. Můžete použít vlastní DelegatingHandler, jak je znázorněno v následujícím příkladu:

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;
    }
}