De beheerde client gebruiken voor Azure Mobile Apps

• Android
• Cordova
• JavaScript
• iOS
• Beheerd (Windows/Xamarin)

Overzicht

Deze handleiding laat zien hoe u algemene scenario's kunt uitvoeren met behulp van de beheerde clientbibliotheek voor Azure App Service Mobile Apps voor Windows- en Xamarin-apps. Als u geen tijd hebt Mobile Apps, kunt u het beste eerst de zelfstudie Azure Mobile Apps uitvoeren . 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's aan de serverzijde voor Mobile Apps.

Referentiedocumentatie

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

Ondersteunde platformen

Het .NET Platform ondersteunt de volgende platformen:

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

De verificatie van de serverstroom maakt gebruik van 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 apparaten van het type Watch of vergelijkbare beperkte apparaten.

Installatie en vereisten

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

Het bijbehorende type type clientzijde in C# is de volgende klasse:

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

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

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

De JsonPropertyAttribute wordt gebruikt voor het definiëren van de PropertyName-toewijzing tussen het clientveld en het tabelveld.

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

How to: Install the managed client SDK package (Het SDK-pakket voor beheerde client installeren)

Gebruik een van de volgende methoden om het SDK-pakket voor beheerde client te installeren Mobile Apps nuGet:

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

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

using Microsoft.WindowsAzure.MobileServices;

Notitie

Alle ondersteuningspakketten waarnaar wordt verwezen in uw Android-project, moeten dezelfde versie hebben. De SDK Xamarin.Android.Support.CustomTabs is afhankelijk van het Android-platform, dus als uw project nieuwere ondersteuningspakketten gebruikt, moet u dit pakket rechtstreeks met de vereiste versie installeren om conflicten te voorkomen.

Werken met foutopsporingssymbolen in Visual Studio

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

De client Mobile Apps maken

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

var client = new MobileServiceClient("MOBILE_APP_URL");

Vervang in de voorgaande code MOBILE_APP_URL door de URL van de back-end voor mobiele apps. Deze vindt u op de blade voor uw back-Azure Portal. Het MobileServiceClient-object moet een singleton zijn.

Werken met tabellen

De volgende sectie geeft informatie over het zoeken en ophalen van records en het wijzigen van de gegevens in de tabel. De volgende onderwerpen worden behandeld:

• Een tabelverwijzing maken
• Querygegevens
• Geretourneerde gegevens filteren
• Geretourneerde gegevens sorteren
• Gegevens retourneren op pagina's
• Specifieke kolommen selecteren
• Een record zoeken op id
• Omgaan met niet-getypte query's
• Gegevens invoegen
• Gegevens bijwerken
• Gegevens verwijderen
• Conflictoplossing en optimistische gelijktijdigheid
• Binding met een Windows Gebruikersinterface
• Het paginaformaat wijzigen

Een tabelverwijzing maken

Alle code die gegevens in een back-endtabel gebruikt of wijzigt, roept functies aan voor 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 getypeerd serialisatiemodel. Een niet-getypeerd serialisatiemodel wordt ook 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.

Hoe: Query's uitvoeren op gegevens uit uw mobiele app

In deze sectie wordt beschreven hoe u query's kunt uitvoeren op de back-end voor mobiele apps, die de volgende functionaliteit bevat:

• Geretourneerde gegevens filteren
• Geretourneerde gegevens sorteren
• Gegevens retourneren op pagina's
• Specifieke kolommen selecteren
• Gegevens op id ops zoeken

Notitie

Er wordt een servergestuurde paginagrootte afgedwongen om te voorkomen dat alle rijen worden geretourneerd. Paginering voorkomt dat standaardaanvragen voor grote gegevenssets de service negatief beïnvloeden. Als u meer dan 50 rijen wilt retourneren, gebruikt u de Skip methode en Take , zoals beschreven in Gegevens retourneren op pagina's.

Hoe: Geretourneerde gegevens filteren

De volgende code laat zien hoe u gegevens filtert door een component op Where te nemen in een query. Het retourneert alle items waarvan de todoTable eigenschap Complete gelijk is aan false. Met de functie Where wordt een rijfilterpredicaat toegepast op de query op 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 software voor berichtinspectie, zoals ontwikkelhulpprogramma's voor browsers 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 omgezet in een SQL query door de Server SDK:

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

De functie die wordt doorgegeven aan de Where methode 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 omgezet 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 -components:

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 eerste optie, het samenvoegen van meerdere predicaten in één query, is compacter en aanbevolen.

De Where component ondersteunt bewerkingen die worden vertaald in de OData-subset. Bewerkingen zijn onder andere:

• Relationele operators (==, !=, <, = <, >, >=),
• Rekenkundige operators (+, -, /, *, %)
• Getalprecisie (Math.Floor, Math.Ceiling),
• Tekenreeksfuncties (Length, Substring, Replace, IndexOf, StartsWith, EndsWith),
• Datumeigenschappen (Year, Month, Day, Hour, Minute, Second),
• Toegangseigenschappen van een object, en
• Expressies die een van deze bewerkingen combineren.

Als u overweegt wat de Server SDK ondersteunt, kunt u de OData v3-documentatie overwegen.

Hoe: Geretourneerde gegevens sorteren

De volgende code laat zien hoe u gegevens sorteert door een functie OrderBy of OrderByDescending op te geven in de query. Het retourneert items van todoTable gesorteerd op oplopend 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();

Hoe: Gegevens retourneren op pagina's

Standaard retourneert de back-end 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();

De volgende herziene query slaat de eerste drie resultaten over en retourneert de volgende drie resultaten. Deze query produceert de tweede pagina met gegevens, waarbij de paginagrootte 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 records die zouden zijn geretourneerd, waarbij eventuele paginerings-/limietclausules worden genegeerd:

query = query.IncludeTotalCount();

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

Notitie

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

[EnableQuery(MaxTop=1000)]

Hoe: Specifieke kolommen selecteren

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

// 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 ketenen. Elke keten-aanroep is van invloed op meer query's. 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();

How to: Look up data by ID

De lookupAsync-functie kan worden gebruikt om objecten uit de database met een bepaalde id op te zoeken.

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

How to: Execute untyped queries (Niet-getypte query's uitvoeren)

Wanneer u een query uitvoert met een niet-getypeerd 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 voor meer informatie over JToken en Newtonsoft Json.NET .

Hoe: Gegevens invoegen in een back-end voor mobiele apps

Alle clienttypen moeten een lid bevatten met de naam Id. 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 er geen unieke aangepaste id-waarde is opgenomen in de todoItem tijdens het invoegen, wordt er een GUID gegenereerd door de server. U kunt de gegenereerde id ophalen door het object te inspecteren nadat de aanroep is retourneert.

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 is 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-kolom van de tabel. Met een tekenreekswaarde kunnen toepassingen aangepaste waarden gebruiken, zoals e-mailadressen of gebruikersnamen voor de id. Tekenreeks-ID's bieden de volgende voordelen:

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

Wanneer een tekenreeks-id niet is ingesteld op een ingevoegde record, genereert de back-end van de mobiele app een unieke waarde voor de id. U kunt de guid.NewGuid-methode 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"));

How to: Modify data in a Mobile App backend (Gegevens wijzigen in een back-end voor mobiele apps)

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

await todoTable.UpdateAsync(todoItem);

Als u niet-getypeeerde gegevens wilt bijwerken, kunt u als Json.NET gebruiken:

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 id moet een veld worden opgegeven bij het maken van een update. De back-end gebruikt het veld id om te bepalen welke rij moet worden bijgewerkt. Het id veld kan worden verkregen van het resultaat van de aanroep InsertAsync . Er ArgumentException teert een als u een item probeert bij te werken zonder de waarde op te id geven.

How to: Delete data in a Mobile App backend (Gegevens verwijderen in een back-end voor mobiele apps)

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

await todoTable.DeleteAsync(todoItem);

Als u niet-getypeeerde gegevens wilt verwijderen, kunt u als Json.NET gebruiken:

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

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

How to: Use Optimistic Concurrency for conflict resolution (Optimistische gelijktijdigheid gebruiken voor conflictoplossing)

Twee of meer clients kunnen tegelijkertijd wijzigingen in hetzelfde item schrijven. Zonder conflictdetectie worden eventuele eerdere updates door de laatste schrijf schrijven overschreven. Bij optimistisch gelijktijdigheidsbeheer wordt ervan uitgegaan dat elke transactie kan worden commit en daarom geen resourcevergrendeling gebruikt. Voordat u een transactie gaat doen, controleert optimistisch gelijktijdigheidsbeheer of de gegevens niet door een andere transactie zijn gewijzigd. Als de gegevens zijn gewijzigd, wordt de transactie teruggedraaid.

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

Definieer een kolom in de tabelklasse voor de systeem-eigenschap version om optimistische gelijktijdigheid mogelijk te maken. Bijvoorbeeld:

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-getypeerd tabellen gebruiken, maken optimistische Version gelijktijdigheid mogelijk door de vlag op SystemProperties de 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 MobileServicePreconditionFailedException<T> u ook de uitzondering in uw code ondervangen bij het aanroepen van UpdateAsync. Los het conflict op door het juiste op de version bijgewerkte record toe te passen en UpdateAsync aan te roepen met de opgeloste record. De volgende code laat zien hoe u een schrijfconflict kunt oplossen nadat deze 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 Mobile Apps informatie.

Hoe: gegevens Mobile Apps verbinden met 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 verbindt met de bron van de lijst met een query voor onvolledige items. De MobileServiceCollection maakt een Mobile Apps-aware bindingverzameling.

// 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 met de naam 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 in Windows apps als volgt:

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, ToCollection gebruikt u de extensiemethoden op IMobileServiceTableQuery<T> en IMobileServiceTable<T>. Als u gegevens wilt laden, roept u aan LoadMoreItemsAsync().

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

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

Overweeg of uw tabel veel velden heeft, 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 in de gebruikersinterface moeten worden weergegeven.

De paginagrootte wijzigen

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

PullOptions pullOptions = new PullOptions
    {
        MaxPageSize = 100
    };

Ervan uitgaande dat u de gelijk PageSize aan of groter dan 100 binnen de server hebt gemaakt, retourneert een aanvraag maximaal 100 items.

Werken met offlinetabellen

Offlinetabellen gebruiken een lokale SQLite-opslag om gegevens op te slaan voor gebruik wanneer ze offline zijn. Alle tabelbewerkingen worden uitgevoerd op de lokale SQLite-opslag in plaats van het externe serveropslag. Als u een offlinetabel wilt maken, moet u eerst uw project voorbereiden:

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

2. (Optioneel) Installeer een Windows van de volgende SQLite-runtimepakketten ter ondersteuning van Windows apparaten:

   • Windows 8.1 Runtime:Installeer SQLite voor Windows 8.1.
   • Windows Phone 8.1:Installeer SQLite voor Windows Phone 8.1.
   • Universeel Windows-platformSQLite installeren voor de Universele Windows.

3. (Optioneel). Voor Windows-apparaten klikt u op VerwijzingenReferentie toevoegen..., vouwt u de Windows-map>Extensies> uit en schakel vervolgens de juiste SQLite voor Windows SDK in, samen met de Visual C++ 2013 Runtime voor Windows SDK. De SQLite SDK-namen verschillen enigszins per Windows platform.

Voordat een tabelverwijzing kan worden gemaakt, moet het 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);

Store-initialisatie wordt normaal gesproken onmiddellijk uitgevoerd nadat de client is gemaakt. Het 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 zeggen, het begint met een slash), wordt dat pad gebruikt. Als het pad niet volledig gekwalificeerd is, 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.

Een tabelverwijzing kan worden verkregen met behulp van de GetSyncTable<> methode :

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

U hoeft niet te verifiëren om een offline tabel te gebruiken. U hoeft zich alleen te verifiëren wanneer u communiceert met de back-endservice.

Een offlinetabel synchroniseren

Offlinetabellen worden niet standaard gesynchroniseerd met de back-end. Synchronisatie is opgesplitst in twee delen. U kunt wijzigingen afzonderlijk pushen van het downloaden van nieuwe items. Hier is 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. Met elke synchronisatiebewerking worden alle records opgehaald.

De SDK voert een impliciete uit voordat PushAsync() records worden binnenhalen.

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

Werken met een aangepaste API

Met een aangepaste API kunt u aangepaste eindpunten definiëren die serverfunctionaliteit beschikbaar stellen die niet is toe te voegen aan een invoeg-, update-, verwijder- of leesbewerking. Met behulp van een aangepaste API hebt u meer controle over berichten, waaronder het lezen en instellen van HTTP-berichtheaders en het definiëren van een andere berichttekstindeling 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 naar de completeAlle API op de back-end verzendt:

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

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

Met de methode InvokeApiAsync() wordt '/api/' voorbereid op de API die u wilt aanroepen, tenzij de API begint met een '/'. Bijvoorbeeld:

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

U kunt InvokeApiAsync gebruiken om elke WebAPI aan te roepen, met inbegrip van 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 biedt ondersteuning voor 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 voor tabellen instellen om de toegang voor specifieke bewerkingen te beperken tot alleen geverifieerde gebruikers. U kunt ook de identiteit van geverifieerde gebruikers gebruiken om autorisatieregels te implementeren in serverscripts. Zie de zelfstudie Verificatie toevoegen aan uw app voor meer informatie.

Er worden twee verificatiestromen ondersteund: door de client beheerdeen 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 maakt een uitgebreidere integratie mogelijk met apparaatspecifieke mogelijkheden, omdat deze afhankelijk is van providerspecifieke apparaatspecifieke SDK's.

Notitie

We raden u aan 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-Azure App Service verificatie/autorisatie in te schakelen. Volg de gedetailleerde instructies in de zelfstudie Verificatie toevoegen aan uw app voor meer informatie.

In deze sectie komen de volgende onderwerpen aan bod:

• Door client beheerde verificatie
• Door de server beheerde verificatie
• Caching verificatie-token maken

Door client beheerde verificatie

Uw app kan onafhankelijk contact opnemen met de id-provider en vervolgens het geretourneerde token tijdens de aanmelding met uw back-end verstrekken. Met deze clientstroom kunt u een gebruikerservaring voor een enkele aanmelding bieden of aanvullende gebruikersgegevens ophalen van de id-provider. Verificatie van clientstromen heeft de voorkeur boven het gebruik van een serverstroom, omdat de identiteitsprovider-SDK een systeemeigen UX-gevoel biedt en aanvullende aanpassingen mogelijk maakt.

Er worden voorbeelden gegeven voor de volgende clientstroomverificatiepatronen:

• 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 Azure Active Directory verificatie.

1. Configureer de back-AAD van uw mobiele app voor een AAD door de zelfstudie How to configure App Service for Active Directory login te volgen. Zorg ervoor dat u de optionele stap voor het registreren van een native clienttoepassing voltooit.

2. Open Visual Studio project in Visual Studio Xamarin Studio en voeg een verwijzing naar het Microsoft.IdentityModel.Clients.ActiveDirectory NuGet-pakket toe. Neem bij het zoeken versies van de voorlopige versie op.

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

   • 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 de 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 Geavanceerdonder Azure Active Directory Instellingen in de portal.

   • Vervang INSERT-CLIENT-ID-HERE door de client-id die u hebt gekopieerd uit de native 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 is als volgt:

     Windows:

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

     Xamarin.iOS

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

     Xamarin.Android

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

Eén Sign-On met een token van Facebook of Google

U kunt de clientstroom gebruiken zoals wordt 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 methode LoginAsync aan op de [MobileServiceClient] met de waarde MobileServiceAuthenticationProvider van uw provider. Met de volgende code wordt bijvoorbeeld een serverstroom aanmelding 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 OAuth-verificatiestroom door de aanmeldingspagina van de geselecteerde provider weer te geven. Zodra de id-provider retourneert, Azure App Service een App Service-verificatie-token. De loginAsync-methode retourneert een MobileServiceUser, die zowel de UserId van de geverifieerde gebruiker als het MobileServiceAuthenticationToken als JSON-webtoken (JWT) levert. Dit token kan worden opgeslagen in de cache en opnieuw worden gebruikt totdat het verloopt. Zie Het verificatie-token Caching 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 het retourneren van de webver authenticator afhandelen. In Android wordt dit afgehandeld in MainActivity.cs:

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

In iOS wordt dit afgehandeld in 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);
}

Caching verificatie-token maken

In sommige gevallen kan de aanroep van de aanmeldingsmethode worden vermeden na de eerste geslaagde verificatie door het verificatie-token van de provider op te slaan. Microsoft Store- en UWP-apps kunnen PasswordVault als volgt gebruiken om het huidige verificatie-token in de cache op te nemen 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 is de opgeslagen als het wachtwoord. Bij volgende start-ups kunt u PasswordVault controleren op referenties in de cache. In het volgende voorbeeld worden referenties in de cache gebruikt wanneer ze worden gevonden en wordt op andere wijze 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 referenties 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 Account-object . Zie het authStore.cs-codebestand in het voorbeeld van het delen van foto's in ContosoMoments voor een voorbeeld van het gebruik van deze API's.

Wanneer u door de client beheerde verificatie gebruikt, kunt u ook het toegangs token dat is verkregen van uw provider, zoals Facebook of Twitter, in de cache plaatsen. Dit token kan als volgt worden opgegeven om een nieuw verificatie-token aan te vragen bij 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

De volgende onderwerpen hebben betrekking op pushmeldingen:

• Registreren voor pushmeldingen
• Een sid van Microsoft Store-pakket verkrijgen
• Registreren met platformoverschrijdende sjablonen

Hoe: Registreren voor pushmeldingen

Met Mobile Apps-client kunt u zich registreren voor pushmeldingen met Azure Notification Hubs. Wanneer u zich registreert, krijgt u een handle die u verkrijgt via de platformspecifieke Push Notification Service (PNS). Vervolgens geeft u deze waarde samen met eventuele tags op wanneer u de registratie maakt. Met de volgende code wordt uw Windows-app geregistreerd voor pushmeldingen met 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 pusht naar WNS, moet u een Microsoft Store-pakket-SID verkrijgen. Zie Pushmeldingen toevoegen aan Windows app voor meer informatie over het registreren van apps, waaronder het registreren voor sjabloonregistraties.

Het aanvragen van tags van de client wordt niet ondersteund. Tagaanvragen worden op de stilzwijgend uit de registratie weggetrokken. 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 .

How to: Obtain a Microsoft Store package SID (Een Microsoft Store-pakket-SID verkrijgen)

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

Deze waarde verkrijgen:

1. Klik Visual Studio Solution Explorer met de rechtermuisknop op Microsoft Store app-project en klik op StoreApp>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 reserveren en 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 de Windows Ontwikkelaarscentrum met uw Microsoft-account. Klik Mijn apps op de app-registratie die u hebt gemaakt.
5. Klik opApp-beheerApp-identiteit> en schuif omlaag om uw pakket-SID te vinden.

Veel toepassingen van de pakket-SID behandelen deze als een URI. In dat geval moet u ms-app:// gebruiken als het schema. Noteer de versie van de pakket-SID die wordt gevormd door het samenvoegen van deze waarde als voorvoegsel.

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

• Xamarin.Android
• Xamarin.iOS

Hoe: Pushsjablonen registreren om platformoverschrijdende meldingen te verzenden

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

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

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

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. Als u tags wilt toevoegen aan installaties of sjablonen in installaties, zie [Werken met de .NET-back-endserver-SDK voor Azure Mobile Apps].

Als u meldingen wilt verzenden met behulp van deze geregistreerde sjablonen, raadpleegt u de Notification Hubs API's.

Diverse onderwerpen

Hoe: Fouten afhandelen

Wanneer er een fout optreedt in de back-end, wordt door de client-SDK een weergegeven 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 Mobile Apps Files Sample. Het Voorbeeld van LoggingHandler biedt een handler voor logboekregistratie van gemachtigden voor het registreren van de aanvragen die worden ingediend bij de back-end.

Hoe: Aanvraagheaders aanpassen

Ter ondersteuning van uw specifieke app-scenario moet u mogelijk de communicatie met de back-end voor mobiele apps aanpassen. U kunt bijvoorbeeld een aangepaste header toevoegen aan elke uitgaande aanvraag of zelfs statuscodes voor reacties wijzigen. U kunt een aangepaste DelegatingHandler gebruiken, 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;
    }
}