De beheerde client gebruiken voor Azure Mobile Apps

• Android
• Córdoba
• JavaScript
• Ios
• Beheerd (Windows/Xamarin)

Overzicht

Deze handleiding laat zien hoe u algemene scenario's uitvoert met behulp van de beheerde clientbibliotheek voor Azure App Service Mobile Apps voor Windows- en Xamarin-apps. Als u nieuw bent met Mobile Apps, overweeg dan eerst de quickstart Azure Mobile Apps handleiding af te ronden. In deze handleiding richten we ons op de beheerde SDK aan de clientzijde. Zie de documentatie voor de .NET Server SDK of de Node.js Server SDK voor meer informatie over de SDK aan de serverzijde voor Mobile Apps.

Referentiedocumentatie

De referentiedocumentatie voor de client-SDK bevindt zich hier: Azure Mobile Apps .NET-clientreferenties. U kunt ook verschillende clientvoorbeelden vinden in de Azure-Samples GitHub-opslagplaats.

Ondersteunde platforms

Het .NET Platform ondersteunt de volgende platforms:

• Xamarin Android-releases voor API 19 tot en met 24 (KitKat tot en met Nougat)
• Xamarin iOS-releases voor iOS-versies 8.0 en hoger
• Het Universele Windows-platform
• Windows Phone 8.1
• Windows Phone 8.0, met uitzondering van Silverlight-toepassingen

De authenticatie in server-flow gebruikt een WebView voor de gepresenteerde gebruikersinterface. Als het apparaat geen WebView-gebruikersinterface kan presenteren, zijn er andere verificatiemethoden nodig. Deze SDK is dus niet geschikt voor watch-type of vergelijkbare beperkte apparaten.

Installatie en vereisten

We gaan ervan uit dat u uw back-endproject voor mobiele apps al hebt gemaakt en gepubliceerd, dat ten minste één tabel bevat. In de code die in dit onderwerp wordt gebruikt, heeft de tabel de naam TodoItem en de volgende kolommen: Id, Texten Complete. Deze tabel is dezelfde tabel die is gemaakt wanneer u de quickstart voor Azure Mobile Apps voltooit.

Het overeenkomstige getypte client-side type in C# is de volgende class:

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 wordt gebruikt om de koppeling van PropertyName tussen het clientveld en het tabelveld te definiëren.

Zie het onderwerp .NET Server SDK of het onderwerpNode.js Server SDK voor meer informatie over het maken van tabellen in de back-end van Mobile Apps. Als u de back-end van uw mobiele app in Azure Portal hebt gemaakt met behulp van de quickstart, kunt u ook de instelling Eenvoudige tabellen in Azure Portal gebruiken.

Procedure: Het SDK-pakket van de beheerde client installeren

Gebruik een van de volgende methoden om het SDK-pakket voor beheerde clients voor Mobile Apps te installeren vanuit NuGet:

• Visual Studio Klik met de rechtermuisknop op uw project, klik op NuGet-pakketten beheren, zoek naar het Microsoft.Azure.Mobile.Client pakket en klik vervolgens op Installeren.
• Xamarin Studio Klik met de rechtermuisknop op uw project, klik opNuGet-pakketten>, zoek naar het Microsoft.Azure.Mobile.Client pakket en klik vervolgens op Pakket toevoegen.

Vergeet niet om in het hoofdactiviteitsbestand de volgende using-instructie toe te voegen:

using Microsoft.WindowsAzure.MobileServices;

Opmerking

Houd er rekening mee dat alle ondersteuningspakketten waarnaar wordt verwezen in uw Android-project dezelfde versie moeten hebben. De SDK heeft Xamarin.Android.Support.CustomTabs afhankelijkheid voor het Android-platform, dus als uw project nieuwere ondersteuningspakketten gebruikt, moet u dit pakket rechtstreeks met de vereiste versie installeren om conflicten te voorkomen.

Procedure: Werken met foutopsporingssymbolen in Visual Studio

De symbolen voor de microsoft.Azure.Mobile-naamruimte zijn beschikbaar op SymbolSource. Raadpleeg de SymbolSource-instructies voor het integreren van SymbolSource met Visual Studio.

De Mobile Apps-client maken

Met de volgende code wordt het MobileServiceClient--object gemaakt dat wordt gebruikt voor toegang tot de back-end van uw mobiele app.

var client = new MobileServiceClient("MOBILE_APP_URL");

Vervang MOBILE_APP_URL in de voorgaande code door de URL van de back-end van uw mobiele app, die u vindt op het blad voor de back-end van uw mobiele app in de Azure Portal. Het MobileServiceClient-object moet een singleton zijn.

Werken met tabellen

In de volgende sectie wordt beschreven hoe u records kunt zoeken en ophalen en de gegevens in de tabel kunt wijzigen. De volgende onderwerpen worden behandeld:

• Een tabelreferentie maken
• Gegevens opvragen
• Filter teruggegeven gegevens
• geretourneerde gegevens sorteren
• Gegevens weergeven op pagina's
• Specifieke kolommen selecteren
• Een record opzoeken op id
• Omgaan met niet-getypte query's
• Gegevens invoegen
• Gegevens bijwerken
• Gegevens verwijderen
• Conflictoplossing en optimistische gelijklopendheid
• Binding aan een Windows-gebruikersinterface
• Het paginaformaat wijzigen

Procedure: Een tabelreferentie maken

Alle code die gegevens in een back-endtabel opent of wijzigt, roept functies aan op het MobileServiceTable-object. Haal als volgt een verwijzing naar de tabel op door de methode GetTable aan te roepen:

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

Het geretourneerde object maakt gebruik van het getypeerde serialisatiemodel. Er wordt ook een niet-getypeerd serialisatiemodel ondersteund. In het volgende voorbeeld wordt een verwijzing naar een niet-getypte tabel gemaakt:

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

In niet-getypte query's moet u de onderliggende OData-queryreeks opgeven.

Procedure: Gegevens opvragen uit uw mobiele app

In deze sectie wordt beschreven hoe u query's verzendt naar de back-end van de mobiele app, die de volgende functionaliteit bevat:

• Filter teruggegeven gegevens
• geretourneerde gegevens sorteren
• Gegevens weergeven op pagina's
• Specifieke kolommen selecteren
• Gegevens opzoeken op id

Opmerking

Een servergestuurd paginaformaat wordt afgedwongen om te voorkomen dat alle rijen worden geretourneerd. Paginering voorkomt dat standaardaanvragen voor grote gegevenssets een negatieve invloed hebben op de service. Als u meer dan 50 rijen wilt retourneren, gebruikt u de methode Skip en Take, zoals beschreven in Retourgegevens op pagina's.

Procedure: Geretourneerde gegevens filteren

De volgende code illustreert hoe u gegevens filtert door een Where component op te nemen in een query. Alle items worden geretourneerd uit todoTable waarvan de eigenschap Complete gelijk is aan false. De functie Where past een rijfilterpredicaat toe op de query op basis van de tabel.

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

U kunt de URI bekijken van de aanvraag die naar de back-end is verzonden met behulp van berichtinspectiesoftware, zoals hulpprogramma's voor browserontwikkelaars of Fiddler-. Als u de aanvraag-URI bekijkt, ziet u dat de queryreeks is gewijzigd:

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

Deze OData-aanvraag wordt vertaald in een SQL-query door de Server SDK:

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

De functie die wordt doorgegeven aan de methode Where kan een willekeurig aantal voorwaarden hebben.

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

Dit voorbeeld wordt vertaald in een SQL-query door de Server SDK:

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

Deze query kan ook worden gesplitst in meerdere componenten:

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

De twee methoden zijn gelijkwaardig en kunnen door elkaar worden gebruikt. De vorige optie, van het samenvoegen van meerdere predicaten in één query, is compacter en aanbevolen.

De Where-clausule ondersteunt bewerkingen die kunnen worden vertaald naar de OData-subset. De bewerkingen omvatten onder andere:

• Relationele operatoren (==, !=, <, <= >, >=),
• Rekenkundige operatoren (+, -, /, *, %),
• Getalprecisie (Math.Floor, Math.Ceiling),
• Tekenreeksfuncties (Lengte, Subtekenreeks, Vervangen, IndexOf, StartsWith, EndsWith),
• Datumeigenschappen (Jaar, Maand, Dag, Uur, Minuut, Seconde),
• Toegangseigenschappen van een object en
• Expressies die een van deze bewerkingen combineren.

Wanneer u overweegt wat de Server SDK ondersteunt, kunt u de documentatie voor OData v3 overwegen.

Procedure: Geretourneerde gegevens sorteren

De volgende code laat zien hoe u gegevens sorteert door een OrderBy of OrderByDescending functie in de query op te nemen. Het retourneert items uit todoTable oplopend gesorteerd op het Text veld.

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

Handleiding: Gegevens weergeven op pagina's

De back-end retourneert standaard alleen de eerste 50 rijen. U kunt het aantal geretourneerde rijen verhogen door de methode Take aan te roepen. Gebruik Take samen met de methode Skip om een specifieke pagina aan te vragen van de totale gegevensset die door de query wordt geretourneerd. De volgende query retourneert, wanneer deze wordt uitgevoerd, de drie belangrijkste items in de tabel.

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

Met de volgende herziene query worden de eerste drie resultaten overgeslagen en worden de volgende drie resultaten geretourneerd. Deze query produceert de tweede pagina met gegevens, waarbij het paginaformaat drie items is.

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

De methode IncludeTotalCount vraagt het totale aantal aan voor alle de records die zouden zijn geretourneerd, waarbij alle opgegeven paging-/limietclausules worden genegeerd:

query = query.IncludeTotalCount();

In een echte app kunt u query's gebruiken die vergelijkbaar zijn met het voorgaande voorbeeld met een pager-besturingselement of vergelijkbare gebruikersinterface om tussen pagina's te navigeren.

Opmerking

Als u de limiet van 50 rijen in een back-end van mobiele apps wilt overschrijven, moet u ook de EnableQueryAttribute- toepassen op de openbare GET-methode en het wisselgedrag opgeven. Wanneer deze wordt toegepast op de methode, stelt het volgende het maximum aantal geretourneerde rijen in op 1000:

[EnableQuery(MaxTop=1000)]

Hoe te: Specifieke kolommen selecteren

U kunt opgeven welke set eigenschappen u wilt opnemen in de resultaten door een Select clausule aan uw query toe te voegen. De volgende code laat bijvoorbeeld zien hoe u slechts één veld selecteert en ook hoe u meerdere velden selecteert en opmaken:

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

Alle functies die tot nu toe worden beschreven, zijn additief, zodat we ze kunnen blijven koppelen. Elke gekoppelde aanroep beïnvloedt meer van de query. Nog een voorbeeld:

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

Procedure: Gegevens opzoeken op id

De functie LookupAsync kan worden gebruikt om objecten uit de database op te zoeken met een bepaalde 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");

Zo voert u niet-getypte queries uit

Wanneer u een query uitvoert met behulp van een niet-getypt tabelobject, moet u expliciet de OData-queryreeks opgeven door ReadAsync-aan te roepen, zoals in het volgende voorbeeld:

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

U krijgt JSON-waarden terug die u kunt gebruiken als een eigenschappentas. Zie de Json.NET-site voor meer informatie over JToken en Newtonsoft Json.NET.

Hoe te handelen: Gegevens invoegen in een backend voor mobiele apps

Alle clienttypen moeten een lid met de naam idbevatten. Dit is standaard een tekenreeks. Deze id- is vereist voor het uitvoeren van CRUD-bewerkingen en voor offlinesynchronisatie. De volgende code laat zien hoe u de methode InsertAsync gebruikt om nieuwe rijen in een tabel in te voegen. De parameter bevat de gegevens die moeten worden ingevoegd als een .NET-object.

await todoTable.InsertAsync(todoItem);

Als een unieke aangepaste id-waarde niet is opgenomen in de todoItem tijdens een invoeging, wordt er een GUID gegenereerd door de server. U kunt de gegenereerde id ophalen door het object te inspecteren nadat de aanroep is geretourneerd.

Als u niet-getypte gegevens wilt invoegen, kunt u profiteren van Json.NET:

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

Hier volgt een voorbeeld van het gebruik van een e-mailadres als een unieke tekenreeks-id:

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

Werken met id-waarden

Mobile Apps ondersteunt unieke aangepaste tekenreekswaarden voor de -id van de tabel kolom. Met een tekenreekswaarde kunnen toepassingen aangepaste waarden gebruiken, zoals e-mailadressen of gebruikersnamen voor de id. String-ID's bieden u de volgende voordelen:

• Id's worden gegenereerd zonder een retour naar de database te maken.
• Records zijn eenvoudiger samen te voegen vanuit verschillende tabellen of databases.
• Id's kunnen beter worden geïntegreerd met de logica van een toepassing.

Wanneer een tekenreeks-id-waarde niet is ingesteld op een ingevoegde record, genereert de back-end van de mobiele app een unieke waarde voor de id. U kunt de methode Guid.NewGuid gebruiken om uw eigen id-waarden te genereren op de client of in de back-end.

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

Procedure: Gegevens wijzigen in een back-end voor mobiele apps

De volgende code illustreert hoe u de methode UpdateAsync gebruikt om een bestaande record bij te werken met dezelfde id met nieuwe informatie. De parameter bevat de gegevens die moeten worden bijgewerkt als een .NET-object.

await todoTable.UpdateAsync(todoItem);

Als u niet-getypte gegevens wilt bijwerken , kunt u als volgt profiteren van Json.NET:

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

Er moet een id veld worden opgegeven bij het maken van een update. De back-end gebruikt het id veld om te bepalen welke rij moet worden bijgewerkt. Het id veld kan worden verkregen uit het resultaat van de InsertAsync aanroep. Er wordt een ArgumentException gegenereerd als u een item probeert bij te werken zonder de id waarde op te geven.

Procedure: Gegevens verwijderen in een back-end voor mobiele apps

De volgende code illustreert hoe u de methode DeleteAsync gebruikt om een bestaand exemplaar te verwijderen. Het exemplaar wordt geïdentificeerd door het id veld dat is ingesteld op de todoItem.

await todoTable.DeleteAsync(todoItem);

Als u niet-getypte gegevens wilt verwijderen, kunt u als volgt profiteren van Json.NET:

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

Wanneer u een verwijderaanvraag indient, moet er een id worden opgegeven. Andere eigenschappen worden niet doorgegeven aan de service of worden genegeerd bij de service. Het resultaat van een DeleteAsync oproep wordt meestal null. De id die moet worden doorgegeven, kan worden verkregen uit het resultaat van de InsertAsync-aanroep. Er wordt een MobileServiceInvalidOperationException gegenereerd wanneer u een item probeert te verwijderen zonder het id veld op te geven.

Stappenplan: Optimistische gelijktijdigheid gebruiken voor conflictoplossing

Twee of meer clients kunnen tegelijkertijd wijzigingen naar hetzelfde item schrijven. Zonder conflictdetectie overschrijft de laatste schrijfbewerking eventuele eerdere updates. optimistisch gelijktijdigheidsbeheer ervan uitgaat dat elke transactie kan worden doorgevoerd en daarom geen resourcevergrendeling gebruikt. Voordat u een transactie doorvoert, controleert optimistisch gelijktijdigheidsbeheer of er geen andere transactie de gegevens heeft gewijzigd. Als de gegevens zijn gewijzigd, wordt de doorvoertransactie teruggedraaid.

Mobile Apps biedt ondersteuning voor optimistisch gelijktijdigheidsbeheer door wijzigingen in elk item bij te houden met behulp van de kolom version systeemeigenschap die is gedefinieerd voor elke tabel in de back-end van uw mobiele app. Telkens wanneer een record wordt bijgewerkt, stelt Mobile Apps de eigenschap version voor die record in op een nieuwe waarde. Tijdens elke updateaanvraag wordt de eigenschap version van de record die bij de aanvraag is opgenomen, vergeleken met dezelfde eigenschap voor de record op de server. Als de versie die is doorgegeven met de aanvraag niet overeenkomt met de back-end, genereert de clientbibliotheek een MobileServicePreconditionFailedException<T> uitzondering. Het type dat is opgenomen met de uitzondering is het record uit de backend met de serverversie van het record. De toepassing kan deze informatie vervolgens gebruiken om te bepalen of de updateaanvraag opnieuw moet worden uitgevoerd met de juiste version waarde van de back-end om wijzigingen door te voeren.

Definieer een kolom in de tabelklasse voor de systeemeigenschap version om optimistische gelijktijdigheid mogelijk te maken. Voorbeeld:

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

Toepassingen die niet-getypte tabellen gebruiken, maken optimistische gelijktijdigheid mogelijk door de vlag Version op de SystemProperties van de tabel als volgt in te stellen.

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

Naast het inschakelen van optimistische gelijktijdigheid moet u ook de MobileServicePreconditionFailedException<T> uitzondering in uw code ondervangen bij het aanroepen van UpdateAsync-. Los het conflict op door de juiste version toe te passen op de bijgewerkte record en aan te roepen UpdateAsync- met de opgeloste record. De volgende code laat zien hoe u een schrijfconflict kunt oplossen nadat dit is gedetecteerd:

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

Zie het onderwerp Offline data sync in Azure Mobile Apps voor meer informatie.

Procedure: Mobiele Apps-gegevens koppelen aan een Windows-gebruikersinterface

In deze sectie ziet u hoe u geretourneerde gegevensobjecten kunt weergeven met behulp van UI-elementen in een Windows-app. De volgende voorbeeldcode wordt gekoppeld aan de bron van de lijst met een query voor onvolledige items. De MobileServiceCollection maakt een bindingsverzameling voor mobiele 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;

Sommige besturingselementen in de beheerde runtime ondersteunen een interface genaamd ISupportIncrementalLoading. Met deze interface kunnen besturingselementen extra gegevens aanvragen wanneer de gebruiker schuift. Er is ingebouwde ondersteuning voor deze interface voor universele Windows-apps via MobileServiceIncrementalLoadingCollection, waarmee de aanroepen van de besturingselementen automatisch worden verwerkt. Gebruik MobileServiceIncrementalLoadingCollection als volgt in Windows-apps:

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

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

Als u de nieuwe verzameling wilt gebruiken in Windows Phone 8- en Silverlight-apps, gebruikt u de ToCollection-extensiemethoden op IMobileServiceTableQuery<T> en IMobileServiceTable<T>. Als u gegevens wilt laden, roept u LoadMoreItemsAsync()aan.

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

Wanneer u de verzameling gebruikt die is gemaakt door ToCollectionAsync of ToCollectionaan te roepen, krijgt u een verzameling die kan worden gebonden aan ui-besturingselementen. Deze verzameling is pagingbewust. Omdat de verzameling gegevens uit het netwerk laadt, mislukt het laden soms. Als u dergelijke fouten wilt afhandelen, overschrijft u de OnException methode op MobileServiceIncrementalLoadingCollection om uitzonderingen af te handelen die het gevolg zijn van aanroepen naar LoadMoreItemsAsync.

Overweeg of uw tabel veel velden bevat, maar u alleen enkele velden in uw besturingselement wilt weergeven. U kunt de richtlijnen in de vorige sectie "Specifieke kolommen selecteren" gebruiken om specifieke kolommen te selecteren die moeten worden weergegeven in de gebruikersinterface.

Het paginaformaat wijzigen

Azure Mobile Apps retourneert standaard maximaal 50 items per aanvraag. U kunt de paginagrootte wijzigen door de maximale paginagrootte op zowel de client als de server te vergroten. Als u het aangevraagde paginaformaat wilt vergroten, geeft u PullOptions op wanneer u PullAsync()gebruikt:

PullOptions pullOptions = new PullOptions
    {
        MaxPageSize = 100
    };

Uitgaande van het feit dat u binnen de server een waarde van 100 of meer bereikt met de PageSize, retourneert een verzoek maximaal 100 items.

Werken met offlinetabellen

Offlinetabellen gebruiken een lokaal SQLite-archief om gegevens op te slaan voor gebruik wanneer ze offline zijn. Alle tabelbewerkingen worden uitgevoerd op basis van het lokale SQLite-archief in plaats van het externe serverarchief. Als u een offlinetabel wilt maken, bereidt u eerst uw project voor:

1. Klik in Visual Studio met de rechtermuisknop op de oplossing >NuGet-pakketten voor oplossing beheren..., zoek en installeer vervolgens het Microsoft.Azure.Mobile.Client.SQLiteStore NuGet-pakket voor alle projecten in de oplossing.

2. (Optioneel) Installeer een van de volgende SQLite Runtime-pakketten om Windows-apparaten te ondersteunen:

   • Windows 8.1 Runtime: Installeer SQLite voor Windows 8.1.
   • Windows Phone 8.1: Installeer SQLite voor Windows Phone 8.1.
   • Universeel Windows-platform Installeer SQLite voor universal Windows.

3. (Optioneel). Voor Windows-apparaten klikt u op Verwijzingen>naar verwijzing toevoegen..., vouwt u de Extensies van de > uit en schakelt u vervolgens de juiste SQLite voor Windows SDK in, samen met de Visual C++ 2013 Runtime voor Windows SDK. De SQLite SDK-namen verschillen enigszins met elk Windows-platform.

Voordat u een tabelreferentie kunt maken, moet de lokale opslag worden voorbereid.

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

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

De initialisatie van de winkel wordt normaal gesproken onmiddellijk uitgevoerd nadat de client is aangemaakt. De OfflineDbPath- moet een bestandsnaam zijn die geschikt is voor gebruik op alle platforms die u ondersteunt. Als het pad een volledig gekwalificeerd pad is (dat wil gezegd, begint het met een slash), wordt dat pad gebruikt. Als het pad niet volledig is gekwalificeerd, wordt het bestand op een platformspecifieke locatie geplaatst.

• Voor iOS- en Android-apparaten is het standaardpad de map Persoonlijke bestanden.
• Voor Windows-apparaten is het standaardpad de toepassingsspecifieke map AppData.

U kunt een tabelreferentie verkrijgen met behulp van de methode GetSyncTable<>:

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

U hoeft zich niet te verifiëren voor het gebruik van een offlinetabel. U hoeft alleen te verifiëren wanneer u communiceert met de back-endservice.

Een offlinetabel synchroniseren

Offlinetabellen worden niet standaard gesynchroniseerd met de back-end. Synchronisatie wordt gesplitst in twee delen. U kunt wijzigingen afzonderlijk pushen van het downloaden van nieuwe items. Hier volgt een typische synchronisatiemethode:

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

Als het eerste argument voor PullAsync null is, wordt incrementele synchronisatie niet gebruikt. Elke synchronisatiebewerking haalt alle records op.

De SDK voert eerst impliciet een PushAsync() uit voordat het records ophaalt.

Conflictafhandeling vindt plaats op een PullAsync() methode. U kunt conflicten op dezelfde manier afhandelen als onlinetabellen. Het conflict wordt veroorzaakt wanneer PullAsync() wordt aangeroepen in plaats van tijdens het invoegen, bijwerken of verwijderen. Als er meerdere conflicten optreden, worden ze gebundeld in één MobileServicePushFailedException. Elke fout afzonderlijk afhandelen.

Werken met een aangepaste API

Met een aangepaste API kunt u aangepaste eindpunten definiëren die serverfunctionaliteit beschikbaar maken die niet is toegewezen aan een invoeg-, update-, verwijder- of leesbewerking. Met behulp van een aangepaste API kunt u meer controle hebben over berichten, waaronder het lezen en instellen van HTTP-berichtkoppen en het definiëren van een andere indeling voor de berichttekst dan JSON.

U roept een aangepaste API aan door een van de InvokeApiAsync- methoden op de client aan te roepen. Met de volgende coderegel wordt bijvoorbeeld een POST-aanvraag verzonden naar de completeAll-API op de back-end:

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

Dit formulier is een getypte methode-aanroep en vereist dat de MarkAllResult retourtype is gedefinieerd. Zowel getypte als niet-getypte methoden worden ondersteund.

Met de methode InvokeApiAsync() wordt '/api/' voorafgegaan aan de API die u wilt aanroepen, tenzij de API begint met een '/'. Voorbeeld:

• InvokeApiAsync("completeAll",...) roept /api/completeAll aan op de backend
• InvokeApiAsync("/.auth/me",...) roept /.auth/me aan op de backend

U kunt InvokeApiAsync gebruiken om webAPI's aan te roepen, inclusief web-API's die niet zijn gedefinieerd met Azure Mobile Apps. Wanneer u InvokeApiAsync() gebruikt, worden de juiste headers, inclusief verificatieheaders, verzonden met de aanvraag.

Gebruikers verifiëren

Mobile Apps ondersteunt het verifiëren en autoriseren van app-gebruikers met behulp van verschillende externe id-providers: Facebook, Google, Microsoft-account, Twitter en Azure Active Directory. U kunt machtigingen instellen voor tabellen om de toegang voor specifieke bewerkingen te beperken tot alleen geverifieerde gebruikers. U kunt ook de identiteit van geverifieerde gebruikers gebruiken om autorisatieregels in serverscripts te implementeren. Zie de zelfstudie Verificatie toevoegen aan uw appvoor meer informatie.

Er worden twee verificatiestromen ondersteund: door de client beheerde en door de server beheerde stroom. De door de server beheerde stroom biedt de eenvoudigste verificatie-ervaring, omdat deze afhankelijk is van de webverificatieinterface van de provider. De door de client beheerde stroom biedt een diepere integratie met apparaatspecifieke mogelijkheden, omdat deze afhankelijk is van providerspecifieke apparaatspecifieke SDK's.

Opmerking

U wordt aangeraden een door de client beheerde stroom te gebruiken in uw productie-apps.

Als u verificatie wilt instellen, moet u uw app registreren bij een of meer id-providers. De id-provider genereert een client-id en een clientgeheim voor uw app. Deze waarden worden vervolgens ingesteld in uw back-end om Verificatie/autorisatie van Azure App Service in te schakelen. Voor meer informatie, volg de gedetailleerde instructies in de handleiding Verificatie toevoegen aan uw app.

De volgende onderwerpen worden behandeld in deze sectie:

• door client beheerde verificatie
• door de server beheerde verificatie
• het verificatietoken in de cache opslaan

Door client beheerde verificatie

Uw app kan onafhankelijk contact opnemen met de id-provider en vervolgens het geretourneerde token opgeven tijdens de aanmelding met uw back-end. Met deze clientstroom kunt u eenmalige aanmelding bieden voor gebruikers of aanvullende gebruikersgegevens ophalen van de id-provider. Clientflow-authenticatie heeft de voorkeur boven het gebruik van een serverflow omdat de SDK van de identiteitsprovider een gebruikerservaring biedt die aanvoelt als een systeemeigen applicatie en extra mogelijkheden voor aanpassing biedt.

Er worden voorbeelden gegeven voor de volgende verificatiepatronen voor clientstromen:

• Active Directory Authentication Library
• Facebook of Google

Gebruikers verifiëren met de Active Directory Authentication Library

U kunt de Active Directory Authentication Library (ADAL) gebruiken om gebruikersverificatie van de client te initiëren met behulp van Azure Active Directory-verificatie.

1. Configureer de back-end van uw mobiele app voor AAD-aanmelding door de zelfstudie App Service configureren voor Active Directory-aanmelding te volgen. Zorg ervoor dat u de optionele stap voor het registreren van een systeemeigen clienttoepassing voltooit.

2. Open uw project in Visual Studio of Xamarin Studio en voeg een verwijzing toe naar het Microsoft.IdentityModel.Clients.ActiveDirectory NuGet-pakket. Voeg bij het zoeken ook voorlopige versies toe.

3. Voeg de volgende code toe aan uw toepassing, afhankelijk van het platform dat u gebruikt. Breng in elk daarvan de volgende vervangingen aan:

   • Vervang INSERT-AUTHORITY-HERE door de naam van de tenant waarin u uw toepassing hebt ingericht. De indeling moet zijn https://login.microsoftonline.com/contoso.onmicrosoft.com. Deze waarde kan worden gekopieerd van het tabblad Domein in uw Azure Active Directory in Azure Portal.

   • Vervang INSERT-RESOURCE-ID-HERE door de client-id voor de back-end van uw mobiele app. U kunt de client-id verkrijgen op het tabblad Geavanceerd onder Azure Active Directory-instellingen in de portal.

   • Vervang INSERT-CLIENT-ID-HERE door de client-id die u hebt gekopieerd uit de systeemeigen clienttoepassing.

   • Vervang INSERT-REDIRECT-URI-HERE door het eindpunt /.auth/login/done van uw site met behulp van het HTTPS-schema. Deze waarde moet vergelijkbaar zijn met https://contoso.azurewebsites.net/.auth/login/done.

     De code die nodig is voor elk platform, volgt:

     Ramen:

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

Enkelvoudige Sign-On met een token van Facebook of Google gebruiken

U kunt de clientstroom gebruiken zoals weergegeven in dit fragment voor Facebook of 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();
    }
}

Door de server beheerde verificatie

Nadat u uw id-provider hebt geregistreerd, roept u de LoginAsync-methode aan op de [MobileServiceClient] met de waarde MobileServiceAuthenticationProvider van uw provider. Met de volgende code wordt bijvoorbeeld een aanmelding voor een serverstroom gestart met behulp van 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();
    }
}

Als u een andere id-provider dan Facebook gebruikt, wijzigt u de waarde van MobileServiceAuthenticationProvider in de waarde voor uw provider.

In een serverstroom beheert Azure App Service de OAuth-verificatiestroom door de aanmeldingspagina van de geselecteerde provider weer te geven. Zodra de id-provider wordt geretourneerd, genereert Azure App Service een App Service-verificatietoken. De LoginAsync-methode retourneert een MobileServiceUser, die zowel de UserId van de geverifieerde gebruiker als het MobileServiceAuthenticationToken als een JSON-webtoken (JWT) levert. Dit token kan in de cache worden opgeslagen en opnieuw worden gebruikt totdat het verloopt. Zie Het verificatietoken in de cache opslaanvoor meer informatie.

Wanneer u Xamarin (Android of iOS) gebruikt, wordt Xamarin.Essentials WebAuthenticator gebruikt. U moet de standaardcontext (Android) of UIViewController (iOS) doorgeven aan de LoginAsync methode. Bovendien moet u de retour van de webauthentator afhandelen. In Android wordt dit verwerkt in MainActivity.cs:

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

In iOS wordt dit verwerkt binnen 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);
}

Het verificatietoken opslaan in de cache

In sommige gevallen kan de aanroep van de aanmeldingsmethode worden vermeden na de eerste geslaagde verificatie door het verificatietoken van de provider op te slaan. Microsoft Store- en UWP-apps kunnen als volgt PasswordVault- gebruiken om het huidige verificatietoken in de cache op te slaan na een geslaagde aanmelding:

await client.LoginAsync(MobileServiceAuthenticationProvider.Facebook);

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

De waarde UserId wordt opgeslagen als de gebruikersnaam van de referentie, en het token wordt opgeslagen als het wachtwoord. Bij volgende opstartbeurten kunt u de PasswordVault controleren voor in de cache opgeslagen referenties. In het volgende voorbeeld worden referenties in de cache gebruikt wanneer ze worden gevonden, en anders wordt opnieuw geprobeerd te verifiëren met de back-end.

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

Wanneer u een gebruiker afmeldt, moet u ook de opgeslagen referentie als volgt verwijderen:

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

Xamarin-apps gebruiken de Xamarin.Auth-API's om referenties veilig op te slaan in een accountobject . Zie het codebestand AuthStore.cs in het voorbeeld van het delen van foto's van ContosoMoments voor een voorbeeld van het gebruik van deze API's.

Wanneer u door de client beheerde verificatie gebruikt, kunt u ook het toegangstoken dat is verkregen van uw provider, zoals Facebook of Twitter, in de cache opslaan. Dit token kan als volgt worden opgegeven om een nieuw verificatietoken aan te vragen vanuit de back-end:

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

Pushmeldingen

In de volgende onderwerpen worden pushmeldingen behandeld:

• Registreren voor pushmeldingen
• Een MICROSOFT Store-pakket-SID verkrijgen
• Registreren met platformoverschrijdende sjablonen

Procedure: Registreren voor pushmeldingen

Met de Mobile Apps-client kunt u zich registreren voor pushmeldingen bij Azure Notification Hubs. Wanneer u zich registreert, verkrijgt u een ingang die u verkrijgt van de platformspecifieke Push Notification Service (PNS). Vervolgens geeft u deze waarde op, samen met eventuele tags wanneer u de registratie maakt. Met de volgende code wordt uw Windows-app geregistreerd voor pushmeldingen met de 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);
}

Als u naar WNS pusht, moet u een Microsoft Store-pakket-SID verkrijgen. Zie Pushmeldingen toevoegen aan uw app voor meer informatie over Windows-apps, waaronder het registreren voor sjabloonregistraties.

Het aanvragen van tags van de client wordt niet ondersteund. Tagaanvragen worden op de achtergrond verwijderd uit de registratie. Als u uw apparaat wilt registreren met tags, maakt u een aangepaste API die gebruikmaakt van de Notification Hubs-API om de registratie namens u uit te voeren. Roep de aangepaste API aan in plaats van de RegisterNativeAsync() methode.

Procedure: Een SID voor een Microsoft Store-pakket verkrijgen

Er is een pakket-SID nodig voor het inschakelen van pushmeldingen in Microsoft Store-apps. Als u een pakket-SID wilt ontvangen, moet u uw toepassing registreren bij de Microsoft Store.

Ga als volgt te werk om deze waarde te verkrijgen:

1. Klik in Visual Studio Solution Explorer met de rechtermuisknop op het Microsoft Store-app-project en klik op Store-app>koppelen aan de Store....
2. Klik in de wizard op Volgende, meld u aan met uw Microsoft-account, typ een naam voor uw app in Een nieuwe app-naam reserverenen klik vervolgens op reserveren.
3. Nadat de app-registratie is gemaakt, selecteert u de naam van de app, klikt u op Volgende en vervolgens op Koppelen.
4. Meld u aan bij het Windows-ontwikkelaarscentrum met uw Microsoft-account. Klik onder Mijn apps op de app-registratie die u hebt gemaakt.
5. Klik op App-beheer>App-identiteit, en scroll dan omlaag om uw Package SID te vinden.

Veel toepassingen van de pakket-SID behandelen deze als een URI, in welk geval u ms-app:// als het schema moet gebruiken. Noteer de versie van de pakket-SID die is gevormd door deze waarde samen te voegen als voorvoegsel.

Voor Xamarin-apps is extra code vereist om een app te kunnen registreren die wordt uitgevoerd op de iOS- of Android-platforms. Zie het onderwerp voor uw platform voor meer informatie:

• Xamarin.Android
• Xamarin.iOS

Procedure: Pushsjablonen registreren om platformoverschrijdende meldingen te verzenden

Als u sjablonen wilt registreren, gebruikt u de RegisterAsync() methode als volgt bij de sjablonen:

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

Uw sjablonen moeten typen zijn JObject en kunnen meerdere sjablonen bevatten in de volgende JSON-indeling:

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

De methode RegisterAsync() accepteert ook secundaire tegels:

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

Alle tags worden verwijderd tijdens de registratie voor beveiliging. Zie [Werken met de .NET-back-endserver-SDK voor Azure Mobile Apps] als u tags wilt toevoegen aan installaties of sjablonen binnen installaties.

Raadpleeg de Notification Hubs-API's om meldingen te verzenden die gebruikmaken van deze geregistreerde sjablonen.

Diverse onderwerpen

Hoe te: Fouten afhandelen

Wanneer er een fout optreedt in de back-end, genereert de client-SDK een MobileServiceInvalidOperationException. In het volgende voorbeeld ziet u hoe u een uitzondering verwerkt die wordt geretourneerd door de 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
    }
}

Een ander voorbeeld van het omgaan met foutvoorwaarden vindt u in het voorbeeld van mobile apps-bestanden. Het voorbeeld van LoggingHandler biedt een handler voor gemachtigden voor logboekregistratie om de aanvragen die worden gedaan in de back-end te registreren.

Hoe te: Aanvraagheaders aanpassen

Ter ondersteuning van uw specifieke app-scenario moet u mogelijk de communicatie aanpassen met de back-end van de mobiele app. U kunt bijvoorbeeld een aangepaste header toevoegen aan elke uitgaande aanvraag of zelfs statuscodes voor antwoorden wijzigen. U kunt een aangepaste DelegatingHandlergebruiken, zoals in het volgende voorbeeld:

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