De beheerde client gebruiken voor Azure Mobile AppsHow to use the managed client for Azure Mobile Apps

Notitie

Visual Studio App Center investeert in nieuwe en geïntegreerde services centraal staat in de ontwikkeling van mobiele Apps.Visual Studio App Center is investing in new and integrated services central to mobile app development. Ontwikkelaars kunnen gebruikmaken van bouwen, Test en verdelen services voor het instellen van de pijplijn voor continue integratie en levering.Developers can use Build, Test and Distribute services to set up Continuous Integration and Delivery pipeline. Zodra de app is geïmplementeerd, ontwikkelaars controleren de status en het gebruik van het gebruik van de app de Analytics en Diagnostics -services en Communiceer met gebruikers met behulp van de Push de service.Once the app is deployed, developers can monitor the status and usage of their app using the Analytics and Diagnostics services, and engage with users using the Push service. Ontwikkelaars kunnen ook gebruikmaken van Auth om hun gebruikers te verifiëren en gegevens service behouden en synchroniseren van app-gegevens in de cloud.Developers can also leverage Auth to authenticate their users and Data service to persist and sync app data in the cloud. Bekijk App Center vandaag nog.Check out App Center today.

OverzichtOverview

Deze handleiding wordt beschreven hoe u algemene scenario's met behulp van de beheerde-clientbibliotheek voor Azure App Service Mobile Apps voor Windows en Xamarin-apps uitvoert.This guide shows you how to perform common scenarios using the managed client library for Azure App Service Mobile Apps for Windows and Xamarin apps. Als u niet bekend bent met Mobile Apps, moet u overwegen eerst voltooien van de Azure Mobile Apps quickstart zelfstudie.If you are new to Mobile Apps, you should consider first completing the Azure Mobile Apps quickstart tutorial. In deze handleiding, we ons richten op de beheerde client-side-SDK.In this guide, we focus on the client-side managed SDK. Voor meer informatie over de server-side SDK's voor Mobile Apps, Zie de documentatie voor de .NET Server SDK or the Node.js Server SDK.To learn more about the server-side SDKs for Mobile Apps, see the documentation for the .NET Server SDK or the Node.js Server SDK.

ReferentiedocumentatieReference documentation

De referentiedocumentatie voor de client SDK bevindt zich hier: Naslaginformatie over Azure Mobile Apps .NET client.The reference documentation for the client SDK is located here: Azure Mobile Apps .NET client reference. U vindt hier ook enkele voorbeelden van de client in de Azure-Samples-GitHub-opslagplaats.You can also find several client samples in the Azure-Samples GitHub repository.

Ondersteunde PlatformsSupported Platforms

Het .NET-Platform ondersteunt de volgende platforms:The .NET Platform supports the following platforms:

  • Xamarin Android-versies voor API 19 tot en met 24 (KitKat via Nougat)Xamarin Android releases for API 19 through 24 (KitKat through Nougat)
  • Xamarin iOS-versies voor iOS 8.0 en hogerXamarin iOS releases for iOS versions 8.0 and later
  • Universeel Windows-platformUniversal Windows Platform
  • Windows Phone 8.1Windows Phone 8.1
  • Windows Phone 8.0, met uitzondering van Silverlight-toepassingenWindows Phone 8.0 except for Silverlight applications

De verificatie 'server-stroom' gebruikmaakt van een webweergave voor de gebruikersinterface weergegeven.The "server-flow" authentication uses a WebView for the presented UI. Als het apparaat niet kan zijn om weer te geven van een UI WebView, zijn andere methoden voor verificatie nodig.If the device is not able to present a WebView UI, then other methods of authentication are needed. Deze SDK is dus niet geschikt is voor controle van het type of op dezelfde manier beperkte apparaten.This SDK is thus not suitable for Watch-type or similarly restricted devices.

Installatie en vereistenSetup and Prerequisites

Gaan we ervan uit dat u hebt al gemaakt en gepubliceerd uw Mobile App back-end-project, waaronder ten minste één tabel.We assume that you have already created and published your Mobile App backend project, which includes at least one table. In de code die wordt gebruikt in dit onderwerp, de tabel met de naam TodoItem en heeft de volgende kolommen: Id, Text, en Complete.In the code used in this topic, the table is named TodoItem and it has the following columns: Id, Text, and Complete. Deze tabel is dezelfde tabel gemaakt na voltooiing van de Azure Mobile Apps quickstart.This table is the same table created when you complete the Azure Mobile Apps quickstart.

Het bijbehorende getypte client-side '-type in C# is de volgende klasse:The corresponding typed client-side type in C# is the following 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; }
}

De JsonPropertyAttribute wordt gebruikt voor het definiëren van de PropertyName toewijzing tussen de velden van de client en de tabel.The JsonPropertyAttribute is used to define the PropertyName mapping between the client field and the table field.

Zie voor meer informatie over het maken van tabellen in uw back-end van Mobile Apps, de .NET Server SDK onderwerp or the Node.js Server SDK topic.To learn how to create tables in your Mobile Apps backend, see the .NET Server SDK topic or the Node.js Server SDK topic. Als u de back-end van uw mobiele App in Azure portal met behulp van de Quick Start hebt gemaakt, kunt u ook gebruiken de eenvoudige tabellen instellen in de Azure Portal.If you created your Mobile App backend in the Azure portal using the QuickStart, you can also use the Easy tables setting in the Azure portal.

Procedure: De beheerde client-SDK-pakket installerenHow to: Install the managed client SDK package

Gebruik een van de volgende methoden voor het installeren van de beheerde client-SDK-pakket voor mobiele Apps van NuGet:Use one of the following methods to install the managed client SDK package for Mobile Apps from NuGet:

  • Visual Studio met de rechtermuisknop op uw project, klikt u op NuGet-pakketten beheren, zoek de Microsoft.Azure.Mobile.Client pakket en klik vervolgens op installeren.Visual Studio Right-click your project, click Manage NuGet Packages, search for the Microsoft.Azure.Mobile.Client package, then click Install.
  • Xamarin Studio met de rechtermuisknop op uw project, klikt u op toevoegen > NuGet-pakketten toevoegen, zoek de Microsoft.Azure.Mobile.Client verpakt en klik vervolgens op pakket toevoegen .Xamarin Studio Right-click your project, click Add > Add NuGet Packages, search for the Microsoft.Azure.Mobile.Client package, and then click Add Package.

In het bestand van uw belangrijkste activiteit, vergeet niet om toe te voegen van de volgende met behulp van instructie:In your main activity file, remember to add the following using statement:

using Microsoft.WindowsAzure.MobileServices;

Notitie

Alle ondersteuningspakketten waarnaar wordt verwezen in uw Android-project, moeten dezelfde versie hebben.Please note that all the support packages referenced in your Android project must have the same version. De SDK heeft Xamarin.Android.Support.CustomTabs afhankelijkheid voor Android-platform, dus als uw project gebruikmaakt van nieuwere ondersteuning u pakketten moet dit pakket installeren met de vereiste versie rechtstreeks op het voorkomen van conflicten.The SDK has Xamarin.Android.Support.CustomTabs dependency for Android platform, so if your project uses newer support packages you need to install this package with required version directly to avoid conflicts.

Procedures: Werken met foutopsporingssymbolen in Visual StudioHow to: Work with debug symbols in Visual Studio

De symbolen voor de naamruimte Microsoft.Azure.Mobile zijn beschikbaar op SymbolSource . Refer to the SymbolSource instructions SymbolSource integreren met Visual Studio.The symbols for the Microsoft.Azure.Mobile namespace are available on SymbolSource. Refer to the SymbolSource instructions to integrate SymbolSource with Visual Studio.

De Mobile Apps-client makenCreate the Mobile Apps client

De volgende code maakt de MobileServiceClient -object dat wordt gebruikt voor toegang tot de back-end van uw mobiele App.The following code creates the MobileServiceClient object that is used to access your Mobile App backend.

var client = new MobileServiceClient("MOBILE_APP_URL");

Vervang in de bovenstaande code MOBILE_APP_URL met de URL van de back-end van de mobiele App, die is gevonden in de blade voor uw mobiele App back-end in de Azure Portal.In the preceding code, replace MOBILE_APP_URL with the URL of the Mobile App backend, which is found in the blade for your Mobile App backend in the Azure portal. Het object MobileServiceClient moet een singleton.The MobileServiceClient object should be a singleton.

Werken met tabellenWork with Tables

De volgende sectie wordt uitgelegd hoe om te zoeken en records ophalen en de gegevens in de tabel wijzigen.The following section details how to search and retrieve records and modify the data within the table. De volgende onderwerpen komen aan bod:The following topics are covered:

Procedures: Maken van een tabelverwijzingHow to: Create a table reference

De code die toegang heeft tot of wijzigt u gegevens in de endtabel van een back-roept functies aan op de MobileServiceTable object.All the code that accesses or modifies data in a backend table calls functions on the MobileServiceTable object. Een verwijzing naar de tabel ophalen door het aanroepen van de GetTable methode, als volgt te werk:Obtain a reference to the table by calling the GetTable method, as follows:

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

Het geretourneerde object maakt gebruik van het type serialisatie-model.The returned object uses the typed serialization model. Een niet-getypeerde serialisatie-model wordt ook ondersteund.An untyped serialization model is also supported. Het volgende voorbeeld Hiermee maakt u een verwijzing naar een niet-getypeerde tabel:The following example creates a reference to an untyped table:

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

Niet-getypeerde query's, moet u de onderliggende OData-query-tekenreeks opgeven.In untyped queries, you must specify the underlying OData query string.

Procedures: Gegevens van uw mobiele App op te vragenHow to: Query data from your Mobile App

In deze sectie wordt beschreven hoe u query's uitgeven aan de backend voor mobiele Apps, waaronder de volgende functionaliteit:This section describes how to issue queries to the Mobile App backend, which includes the following functionality:

Notitie

Het formaat van een server gebaseerde pagina wordt afgedwongen om te voorkomen dat alle rijen worden geretourneerd.A server-driven page size is enforced to prevent all rows from being returned. Wisselbestand zorgt ervoor dat standaard aanvragen voor grote gegevenssets niet een negatieve invloed op de service.Paging keeps default requests for large data sets from negatively impacting the service. Als u wilt meer dan 50 rijen retourneren, gebruikt u de Skip en Take methode, zoals beschreven in als resultaat de gegevens op pagina's.To return more than 50 rows, use the Skip and Take method, as described in Return data in pages.

Procedures: Geretourneerde gegevens filterenHow to: Filter returned data

De volgende code laat zien hoe u gegevens filteren door een Where -component in een query.The following code illustrates how to filter data by including a Where clause in a query. Deze retourneert alle items uit todoTable waarvan Complete eigenschap is gelijk aan false.It returns all items from todoTable whose Complete property is equal to false. De waar functie is van toepassing een rij predicaat om de query op de tabel te filteren.The Where function applies a row filtering predicate to the query against the table.

// 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 van de aanvraag verzonden naar de back-end met behulp van bericht inspectie software, zoals browser ontwikkelhulpprogramma's weergeven of Fiddler.You can view the URI of the request sent to the backend by using message inspection software, such as browser developer tools or Fiddler. Als u de aanvraag-URI bekijkt, ziet u dat de queryreeks wordt gewijzigd:If you look at the request URI, notice that the query string is modified:

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

Deze OData-aanvraag wordt omgezet in een SQL-query door de SDK-Server:This OData request is translated into an SQL query by the Server SDK:

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

De functie die wordt doorgegeven aan de Where methode een willekeurig aantal voorwaarden kan hebben.The function that is passed to the Where method can have an arbitrary number of conditions.

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

In dit voorbeeld zou worden vertaald naar een SQL-query door de SDK-Server:This example would be translated into an SQL query by the Server SDK:

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

Deze query kan ook worden gesplitst in meerdere componenten:This query can also be split into multiple clauses:

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

De twee methoden zijn gelijkwaardig en door elkaar kunnen worden gebruikt.The two methods are equivalent and may be used interchangeably. De eerste optie—van het samenvoegen van meerdere predicaten in één query—compacter en aanbevolen is.The former option—of concatenating multiple predicates in one query—is more compact and recommended.

De Where component biedt ondersteuning voor bewerkingen die worden vertaald naar de subset OData.The Where clause supports operations that be translated into the OData subset. Bewerkingen zijn onder meer:Operations include:

  • Relationele operators (==,! =, <, < =, >, > =),Relational operators (==, !=, <, <=, >, >=),
  • Rekenkundige operators (+, -, /, *, %),Arithmetic operators (+, -, /, *, %),
  • Number precisie (Math.Floor, Math.Ceiling)Number precision (Math.Floor, Math.Ceiling),
  • Tekenreeksfuncties (lengte, subtekenreeks, vervangen, IndexOf, StartsWith, EndsWith),String functions (Length, Substring, Replace, IndexOf, StartsWith, EndsWith),
  • Datumeigenschappen van (jaar, maand, dag, uur, minuut, seconde)Date properties (Year, Month, Day, Hour, Minute, Second),
  • Toegang tot de eigenschappen van een object, enAccess properties of an object, and
  • Expressies combineren van elk van deze bewerkingen.Expressions combining any of these operations.

Wanneer u overweegt wat de SDK-Server ondersteunt, kunt u overwegen de OData v3-documentatie.When considering what the Server SDK supports, you can consider the OData v3 Documentation.

Procedures: Geretourneerde gegevens sorterenHow to: Sort returned data

De volgende code laat zien hoe u gegevens sorteren door op te nemen een OrderBy of OrderByDescending functie in de query.The following code illustrates how to sort data by including an OrderBy or OrderByDescending function in the query. Het resultaat van items uit todoTable door oplopend gesorteerd de Text veld.It returns items from todoTable sorted ascending by the Text field.

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

Procedures: Als resultaat de gegevens op pagina 'sHow to: Return data in pages

De back-end retourneert standaard alleen de eerste 50 rijen.By default, the backend returns only the first 50 rows. U kunt het aantal geretourneerde rijen verhogen door het aanroepen van de nemen methode.You can increase the number of returned rows by calling the Take method. Gebruik Take samen met de Skip methode om aan te vragen van een specifieke "page" van de totale gegevensset die wordt geretourneerd door de query.Use Take along with the Skip method to request a specific "page" of the total dataset returned by the query. De volgende query, wanneer uitgevoerd, retourneert de bovenste drie items in de tabel.The following query, when executed, returns the top three items in the table.

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

De volgende gewijzigde query wordt de eerste drie resultaten overgeslagen en worden de volgende drie resultaten geretourneerd.The following revised query skips the first three results and returns the next three results. Deze query levert de tweede "page" van gegevens, waarbij de paginagrootte van de drie items is.This query produces the second "page" of data, where the page size is three items.

// 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 IncludeTotalCount methode vraagt het totale aantal voor alle de records die zou zijn geretourneerd, wordt een wisselbestand/limit-component opgegeven genegeerd:The IncludeTotalCount method requests the total count for all the records that would have been returned, ignoring any paging/limit clause specified:

query = query.IncludeTotalCount();

In een echte wereld-app, kunt u query's die vergelijkbaar is met het voorgaande voorbeeld met een semafoon besturingselement of een vergelijkbare UI navigeren tussen pagina's.In a real world app, you can use queries similar to the preceding example with a pager control or comparable UI to navigate between pages.

Notitie

Als u wilt overschrijven de limiet van 50-rijen in een back-end van de mobiele App, moet u ook toepassen de EnableQueryAttribute openbaar methode GET en geef het gedrag van het wisselbestand.To override the 50-row limit in a Mobile App backend, you must also apply the EnableQueryAttribute to the public GET method and specify the paging behavior. Wanneer toegepast op de methode, wordt het volgende stelt het maximum aantal rijen geretourneerd naar 1000:When applied to the method, the following sets the maximum returned rows to 1000:

[EnableQuery(MaxTop=1000)]

Procedures: Specifieke kolommen selecterenHow to: Select specific columns

U kunt opgeven welke set eigenschappen om op te nemen in de resultaten door toe te voegen een Selecteren component aan uw query.You can specify which set of properties to include in the results by adding a Select clause to your query. Bijvoorbeeld, toont de volgende code hoe u slechts één veld selecteert en ook hoe u kunt selecteren en formatteren van meerdere velden:For example, the following code shows how to select just one field and also how to select and format multiple fields:

// 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 beschreven tot nu toe zijn additief, zodat we kunnen houden chaining ze.All the functions described so far are additive, so we can keep chaining them. Elke aanroep van de keten is van invloed op meer van de query.Each chained call affects more of the query. Een meer voorbeeld:One more example:

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

Procedures: Gegevens per-ID opzoekenHow to: Look up data by ID

De LookupAsync functie kan worden gebruikt om te controleren of objecten uit de database met een bepaalde ID.The LookupAsync function can be used to look up objects from the database with a particular 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");

Procedures: Niet-getypeerde query's uitvoerenHow to: Execute untyped queries

Bij het uitvoeren van een tabelobject niet-getypeerde met een query uitvoeren, moet u expliciet de OData-query-tekenreeks opgeven door het aanroepen van ReadAsync, zoals in het volgende voorbeeld:When executing a query using an untyped table object, you must explicitly specify the OData query string by calling ReadAsync, as in the following example:

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

U krijgt terug JSON-waarden die u, zoals een eigenschappenverzameling gebruiken kunt.You get back JSON values that you can use like a property bag. Zie voor meer informatie over JToken en Newtonsoft Json.NET de Json.NET site.For more information on JToken and Newtonsoft Json.NET, see the Json.NET site.

Procedures: Gegevens invoegen in een mobiele App back-endHow to: Insert data into a Mobile App backend

Alle clienttypen moeten een lid met de naam bevatten Id, dit is standaard een tekenreeks.All client types must contain a member named Id, which is by default a string. Dit Id CRUD-bewerkingen uit te voeren is vereist en voor het offline synchroniseren. De volgende code laat zien hoe u de InsertAsync methode voor het invoegen van nieuwe rijen in een tabel.This Id is required to perform CRUD operations and for offline sync. The following code illustrates how to use the InsertAsync method to insert new rows into a table. De parameter bevat de gegevens moet worden ingevoegd als een .NET-object.The parameter contains the data to be inserted as a .NET object.

await todoTable.InsertAsync(todoItem);

Als een unieke aangepaste ID-waarde niet is opgenomen in de todoItem tijdens een insert-, een GUID wordt gegenereerd door de server.If a unique custom ID value is not included in the todoItem during an insert, a GUID is generated by the server. U kunt de gegenereerde Id ophalen door het inspecteren van het object nadat de aanroep retourneert.You can retrieve the generated Id by inspecting the object after the call returns.

Voor het invoegen van niet-getypeerde gegevens, kunt u profiteren van Json.NET:To insert untyped data, you may take advantage of 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 met behulp van een e-mailadres als een unieke tekenreeks-id:Here is an example using an email address as a unique string 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 de id-waardenWorking with ID values

Mobile Apps biedt ondersteuning voor unieke tekenreeks van aangepaste waarden van de tabel id kolom.Mobile Apps supports unique custom string values for the table's id column. Een string-waarde zorgt ervoor dat toepassingen gebruiken van aangepaste waarden, zoals e-mailadressen of gebruikersnamen voor de ID.A string value allows applications to use custom values such as email addresses or user names for the ID. Tekenreeks-id's bieden u de volgende voordelen:String IDs provide you with the following benefits:

  • Id's worden gegenereerd zonder een retour naar de database.IDs are generated without making a round trip to the database.
  • Records zijn gemakkelijker te samenvoegen uit andere tabellen of databases.Records are easier to merge from different tables or databases.
  • Id-waarden kunnen beter integreren met de logica van een toepassing.IDs values can integrate better with an application's logic.

Als een tekenreeks-ID-waarde niet is ingesteld op een record ingevoegd, de mobiele App back-end wordt gegenereerd voor een unieke waarde voor de ID.When a string ID value is not set on an inserted record, the Mobile App backend generates a unique value for the ID. U kunt de Guid.NewGuid methode voor het genereren van uw eigen id-waarden, op de client of in de back-end.You can use the Guid.NewGuid method to generate your own ID values, either on the client or in the backend.

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

Procedures: Gegevens in een back-end van Mobile App wijzigenHow to: Modify data in a Mobile App backend

De volgende code laat zien hoe u de UpdateAsync methode voor het bijwerken van een bestaande record met dezelfde ID met nieuwe gegevens.The following code illustrates how to use the UpdateAsync method to update an existing record with the same ID with new information. De parameter bevat de gegevens moeten worden bijgewerkt als een .NET-object.The parameter contains the data to be updated as a .NET object.

await todoTable.UpdateAsync(todoItem);

Voor het bijwerken van niet-getypeerde gegevens, u kunt profiteren van Json.NET als volgt:To update untyped data, you may take advantage of Json.NET as follows:

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

Een id veld moet worden opgegeven bij het maken van een update.An id field must be specified when making an update. De back-end maakt gebruik van de id veld om te bepalen welke rij bij te werken.The backend uses the id field to identify which row to update. De id veld kan worden opgehaald uit het resultaat van de InsertAsync aanroepen.The id field can be obtained from the result of the InsertAsync call. Een ArgumentException treedt op als u probeert een item bijwerken zonder op te geven de id waarde.An ArgumentException is raised if you try to update an item without providing the id value.

Procedures: Gegevens in een back-end van Mobile App verwijderenHow to: Delete data in a Mobile App backend

De volgende code laat zien hoe u de DeleteAsync methode voor het verwijderen van een bestaand exemplaar.The following code illustrates how to use the DeleteAsync method to delete an existing instance. Het exemplaar wordt geïdentificeerd door de id veld is ingesteld op de todoItem.The instance is identified by the id field set on the todoItem.

await todoTable.DeleteAsync(todoItem);

Niet-getypeerde om gegevens te verwijderen, kunt u profiteren van Json.NET als volgt:To delete untyped data, you may take advantage of Json.NET as follows:

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

Wanneer u een delete-aanvraag, moet een ID worden opgegeven.When you make a delete request, an ID must be specified. Andere eigenschappen worden niet doorgegeven aan de service of in de service worden genegeerd.Other properties are not passed to the service or are ignored at the service. Het resultaat van een DeleteAsync -aanroep is meestal null.The result of a DeleteAsync call is usually null. De ID op om door te geven, kan worden opgehaald van het resultaat van de InsertAsync aanroepen.The ID to pass in can be obtained from the result of the InsertAsync call. Een MobileServiceInvalidOperationException wordt gegenereerd wanneer u probeert te verwijderen van een item zonder op te geven de id veld.A MobileServiceInvalidOperationException is thrown when you try to delete an item without specifying the id field.

Procedures: Optimistische gelijktijdigheid gebruiken voor conflictoplossingHow to: Use Optimistic Concurrency for conflict resolution

Twee of meer clients kunnen schrijven naar hetzelfde item op hetzelfde moment.Two or more clients may write changes to the same item at the same time. Zonder opsporing van conflicten, zou de laatste schrijfbewerking overschrijven alle voorgaande updates.Without conflict detection, the last write would overwrite any previous updates. Optimistisch gelijktijdigheidbeheer wordt ervan uitgegaan dat elke transactie kan worden doorgevoerd en daarom geen van een resource vergrendelen gebruikmaakt.Optimistic concurrency control assumes that each transaction can commit and therefore does not use any resource locking. Voordat het doorvoeren van een transactie Optimistisch gelijktijdigheidbeheer controleert of er geen andere transactie heeft de gegevens worden gewijzigd.Before committing a transaction, optimistic concurrency control verifies that no other transaction has modified the data. Als de gegevens is gewijzigd, de committing transactie teruggedraaid.If the data has been modified, the committing transaction is rolled back.

Mobile Apps biedt ondersteuning voor Optimistisch gelijktijdigheidbeheer door het bijhouden van wijzigingen in elk item met behulp van de version systeemkolom eigenschap die is gedefinieerd voor elke tabel in de back-end van uw mobiele App.Mobile Apps supports optimistic concurrency control by tracking changes to each item using the version system property column that is defined for each table in your Mobile App backend. Telkens wanneer een record wordt bijgewerkt, Mobile Apps-stelt de version eigenschap voor die record in een nieuwe waarde.Each time a record is updated, Mobile Apps sets the version property for that record to a new value. Tijdens de aanvraag voor elke update de version eigenschap van de record die is opgenomen in de aanvraag wordt vergeleken met de dezelfde eigenschap van de record op de server.During each update request, the version property of the record included with the request is compared to the same property for the record on the server. Als de versie die is doorgegeven met de aanvraag komt niet overeen met de back-end, wordt de clientbibliotheek leidt tot een MobileServicePreconditionFailedException<T> uitzondering.If the version passed with the request does not match the backend, then the client library raises a MobileServicePreconditionFailedException<T> exception. Het type dat is opgenomen in de uitzondering is de record van de back-end die de servers-versie van de record.The type included with the exception is the record from the backend containing the servers version of the record. De toepassing kan deze informatie vervolgens gebruiken om te bepalen of voor het uitvoeren van de updateaanvraag opnieuw uit met de juiste version waarde van de back-end wijzigingen wilt doorvoeren.The application can then use this information to decide whether to execute the update request again with the correct version value from the backend to commit changes.

Een kolom definiëren voor de tabel-klasse voor de version systeemeigenschap om in te schakelen van optimistische gelijktijdigheid.Define a column on the table class for the version system property to enable optimistic concurrency. Bijvoorbeeld:For example:

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 gebruikmaken van niet-getypeerde tabellen optimistische gelijktijdigheid inschakelen door in te stellen de Version markering waarmee wordt aangegeven op de SystemProperties van de tabel als volgt te werk.Applications using untyped tables enable optimistic concurrency by setting the Version flag on the SystemProperties of the table as follows.

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

Naast het inschakelen van optimistische gelijktijdigheid moet u ook moet catch de MobileServicePreconditionFailedException<T> uitzondering in uw code bij het aanroepen van UpdateAsync.In addition to enabling optimistic concurrency, you must also catch the MobileServicePreconditionFailedException<T> exception in your code when calling UpdateAsync. Los het conflict op door het toepassen van de juiste version naar de bijgewerkte record en roep UpdateAsync met de record opgelost.Resolve the conflict by applying the correct version to the updated record and call UpdateAsync with the resolved record. De volgende code laat zien hoe om op te lossen een schrijfconflict eenmaal is gedetecteerd:The following code shows how to resolve a write conflict once detected:

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 voor meer informatie de Offlinesynchronisatie van gegevens in Azure Mobile Apps onderwerp.For more information, see the Offline Data Sync in Azure Mobile Apps topic.

Procedures: Mobile Apps-gegevens binden aan een Windows-gebruikersinterfaceHow to: Bind Mobile Apps data to a Windows user interface

Deze sectie wordt beschreven hoe objecten van geretourneerde gegevens met behulp van UI-elementen in een Windows-app kunt weergeven.This section shows how to display returned data objects using UI elements in a Windows app. De volgende voorbeeldcode koppelt aan de bron van de lijst met een query voor onvolledige items.The following example code binds to the source of the list with a query for incomplete items. De MobileServiceCollection maakt een verzameling met mobiele Apps-bewuste binding.The MobileServiceCollection creates a Mobile Apps-aware binding collection.

// 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 ondersteunt een interface met de naam ISupportIncrementalLoading.Some controls in the managed runtime support an interface called ISupportIncrementalLoading. Deze interface kunt besturingselementen voor het aanvragen van extra gegevens wanneer de gebruiker.This interface allows controls to request extra data when the user scrolls. Er is ingebouwde ondersteuning voor deze interface voor universele Windows-apps via MobileServiceIncrementalLoadingCollection, die verwerkt automatisch de aanroepen van de besturingselementen.There is built-in support for this interface for universal Windows apps via MobileServiceIncrementalLoadingCollection, which automatically handles the calls from the controls. Gebruik MobileServiceIncrementalLoadingCollection in Windows-apps als volgt te werk:Use MobileServiceIncrementalLoadingCollection in Windows apps as follows:

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

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

Als u de nieuwe verzameling op Windows Phone 8- en 'Silverlight' apps, gebruikt de ToCollection uitbreidingsmethoden op IMobileServiceTableQuery<T> en IMobileServiceTable<T>.To use the new collection on Windows Phone 8 and "Silverlight" apps, use the ToCollection extension methods on IMobileServiceTableQuery<T> and IMobileServiceTable<T>. Aanroepen om gegevens te laden, LoadMoreItemsAsync().To load data, call LoadMoreItemsAsync().

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

Bij het gebruik van de verzameling die zijn gemaakt door het aanroepen van ToCollectionAsync of ToCollection, krijgt u een verzameling die kan worden gebonden aan een UI-besturingselementen.When you use the collection created by calling ToCollectionAsync or ToCollection, you get a collection that can be bound to UI controls. Deze verzameling is wisselbestand-bewust.This collection is paging-aware. Omdat de verzameling is het laden van gegevens vanaf het netwerk, mislukt het laden van soms.Since the collection is loading data from the network, loading sometimes fails. Voor het afhandelen van dergelijke fouten, overschrijven de OnException methode voor MobileServiceIncrementalLoadingCollection voor het afhandelen van uitzonderingen die voortvloeien uit aanroepen naar LoadMoreItemsAsync.To handle such failures, override the OnException method on MobileServiceIncrementalLoadingCollection to handle exceptions resulting from calls to LoadMoreItemsAsync.

Als uw tabel veel velden heeft, maar u wilt alleen enkele ervan weer te geven in uw overwegen.Consider if your table has many fields but you only want to display some of them in your control. U kunt de richtlijnen in de voorgaande sectie "specifieke kolommen selecteren' om specifieke kolommen om weer te geven in de gebruikersinterface te selecteren.You may use the guidance in the preceding section "Select specific columns" to select specific columns to display in the UI.

De grootte van de pagina wijzigenChange the Page size

Azure Mobile Apps retourneert een maximum van 50 items per aanvraag standaard.Azure Mobile Apps returns a maximum of 50 items per request by default. U kunt de grootte van het wisselbestand wijzigen door de maximale grootte van de client en de server.You can change the paging size by increasing the maximum page size on both the client and server. Als u wilt de aangevraagde pagina vergroten, geef PullOptions bij het gebruik van PullAsync():To increase the requested page size, specify PullOptions when using PullAsync():

PullOptions pullOptions = new PullOptions
    {
        MaxPageSize = 100
    };

Ervan uitgaande dat u hebt aangebracht de PageSize gelijk aan of groter zijn dan 100 in de server, een aanvraag tot 100 items geretourneerd.Assuming you have made the PageSize equal to or greater than 100 within the server, a request returns up to 100 items.

Werken met Offline tabellenWork with Offline Tables

Offline tabellen gebruik een lokale gegevens van de SQLite-archief op te slaan voor gebruik wanneer u offline bent.Offline tables use a local SQLite store to store data for use when offline. Alle tabel bewerkingen worden uitgevoerd op basis van de lokale SQLite opslaan in plaats van de externe server-store.All table operations are done against the local SQLite store instead of the remote server store. Als u wilt een offline-tabel maken, moet u eerst uw project voorbereiden:To create an offline table, first prepare your project:

  1. In Visual Studio met de rechtermuisknop op de oplossing > NuGet-pakketten beheren voor oplossing... , zoek en installeer de Microsoft.Azure.Mobile.Client.SQLiteStore NuGet-pakket voor alle projecten in de oplossing.In Visual Studio, right-click the solution > Manage NuGet Packages for Solution..., then search for and install the Microsoft.Azure.Mobile.Client.SQLiteStore NuGet package for all projects in the solution.

  2. (Optioneel) Ter ondersteuning van Windows-apparaten, moet u een van de volgende pakketten van de SQLite-runtime installeren:(Optional) To support Windows devices, install one of the following SQLite runtime packages:

  3. (Optioneel).(Optional). Voor Windows-apparaten, klikt u op verwijzingen > verwijzing toevoegen... , vouw de Windows map > extensies, schakelt u de juiste SQLite voor Windows SDK samen met de Visual C++ 2013-Runtime voor Windows SDK.For Windows devices, click References > Add Reference..., expand the Windows folder > Extensions, then enable the appropriate SQLite for Windows SDK along with the Visual C++ 2013 Runtime for Windows SDK. De namen van de SQLite SDK verschillen met elke Windows-platform.The SQLite SDK names vary slightly with each Windows platform.

Voordat een tabelverwijzing kan worden gemaakt, kan het lokale archief moet worden voorbereid:Before a table reference can be created, the local store must be prepared:

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

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

Store-initialisatie is normaal uitgevoerd onmiddellijk nadat de client wordt gemaakt.Store initialization is normally done immediately after the client is created. De OfflineDbPath moet een bestandsnaam geschikt zijn voor gebruik op alle platformen die u ondersteunt.The OfflineDbPath should be a filename suitable for use on all platforms that you support. Als het pad een volledig gekwalificeerde pad is (dat wil zeggen, het begint al met een slash), wordt het opgegeven pad gebruikt.If the path is a fully qualified path (that is, it starts with a slash), then that path is used. Als het pad is niet volledig gekwalificeerd, wordt het bestand geplaatst op een platform-specifieke locatie.If the path is not fully qualified, the file is placed in a platform-specific location.

  • Voor iOS en Android-apparaten is het standaardpad naar de map 'Persoonlijke Files'.For iOS and Android devices, the default path is the "Personal Files" folder.
  • Voor Windows-apparaten is het standaardpad naar de map van de "AppData" toepassingsspecifieke.For Windows devices, the default path is the application-specific "AppData" folder.

Een tabelverwijzing kan worden verkregen met behulp van de GetSyncTable<> methode:A table reference can be obtained using the GetSyncTable<> method:

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

U hoeft niet te verifiëren voor het gebruik van een offline-tabel.You do not need to authenticate to use an offline table. U hoeft alleen te verifiëren wanneer u met de back-endservice communiceert.You only need to authenticate when you are communicating with the backend service.

Synchroniseren van een Offline-tabelSyncing an Offline Table

Offline tabellen zijn niet gesynchroniseerd met de back-end standaard.Offline tables are not synchronized with the backend by default. Synchronisatie wordt gesplitst in twee delen.Synchronization is split into two pieces. U kunt wijzigingen afzonderlijk forceren van het downloaden van nieuwe items.You can push changes separately from downloading new items. Hier volgt een typische synchronisatiemethode:Here is a typical sync method:

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, en vervolgens incrementele synchronisatie wordt niet gebruikt.If the first argument to PullAsync is null, then incremental sync is not used. Elke synchronisatiebewerking haalt u alle records.Each sync operation retrieves all records.

De SDK voert een impliciete PushAsync() voordat u records.The SDK performs an implicit PushAsync() before pulling records.

Conflict verwerking wordt uitgevoerd op een PullAsync() methode.Conflict handling happens on a PullAsync() method. U kunt omgaan met conflicten op dezelfde manier als online-tabellen.You can deal with conflicts in the same way as online tables. Het conflict wordt gemaakt wanneer PullAsync() heet in plaats van tijdens het invoegen, bijwerken of verwijderen.The conflict is produced when PullAsync() is called instead of during the insert, update, or delete. Als meerdere conflicten optreden, worden ze in een enkele MobileServicePushFailedException gebundeld.If multiple conflicts happen, they are bundled into a single MobileServicePushFailedException. Elke fout afzonderlijk afhandelen.Handle each failure separately.

Werken met een aangepaste APIWork with a custom API

Een aangepaste API kunt u aangepaste eindpunten die beschikbaar maken van server-functionaliteit die niet worden toegewezen aan een invoegen, bijwerken, verwijderen of leesbewerking definiëren.A custom API enables you to define custom endpoints that expose server functionality that does not map to an insert, update, delete, or read operation. Met behulp van een aangepaste API, kunt u hebben meer controle over berichten, zoals lezen en HTTP-bericht headers instellen en definiëren van een indeling van de hoofdtekst van bericht dan JSON.By using a custom API, you can have more control over messaging, including reading and setting HTTP message headers and defining a message body format other than JSON.

U een aangepaste API oproept door het aanroepen van een van de InvokeApiAsync methoden op de client.You call a custom API by calling one of the InvokeApiAsync methods on the client. De volgende regel code verzendt bijvoorbeeld een POST-aanvraag naar de completeAll API op de back-end:For example, the following line of code sends a POST request to the completeAll API on the backend:

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

Dit formulier is een getypeerde methodeaanroep en vereist dat de MarkAllResult retourneren type is gedefinieerd.This form is a typed method call and requires that the MarkAllResult return type is defined. Getypte en niet-getypeerde methoden worden ondersteund.Both typed and untyped methods are supported.

De methode InvokeApiAsync() voegt toe '/ api /' aan de API die u aanroepen wilt, tenzij de API met begint een slash (/).The InvokeApiAsync() method prepends '/api/' to the API that you wish to call unless the API starts with a '/'. Bijvoorbeeld:For example:

  • InvokeApiAsync("completeAll",...) /api/completeAll wordt op de back-endInvokeApiAsync("completeAll",...) calls /api/completeAll on the backend
  • InvokeApiAsync("/.auth/me",...) /.auth/me wordt op de back-endInvokeApiAsync("/.auth/me",...) calls /.auth/me on the backend

U kunt InvokeApiAsync gebruiken om aan te roepen een WebAPI, met inbegrip van deze WebAPIs die niet zijn gedefinieerd met Azure Mobile Apps.You can use InvokeApiAsync to call any WebAPI, including those WebAPIs that are not defined with Azure Mobile Apps. Wanneer u InvokeApiAsync() gebruikt, worden de juiste headers, met inbegrip van verificatieheaders, verzonden met de aanvraag.When you use InvokeApiAsync(), the appropriate headers, including authentication headers, are sent with the request.

Verificatie van gebruikersAuthenticate users

Mobile Apps biedt ondersteuning voor verificatie en autorisatie van app-gebruikers met behulp van verschillende externe id-providers: Facebook, Google, Microsoft-Account, Twitter en Azure Active Directory.Mobile Apps supports authenticating and authorizing app users using various external identity providers: Facebook, Google, Microsoft Account, Twitter, and Azure Active Directory. U kunt machtigingen instellen voor tabellen toegang voor specifieke bewerkingen alleen geverifieerde gebruikers te beperken.You can set permissions on tables to restrict access for specific operations to only authenticated users. U kunt ook de identiteit van de geverifieerde gebruikers gebruiken voor het implementeren van autorisatieregels in server-scripts.You can also use the identity of authenticated users to implement authorization rules in server scripts. Zie de zelfstudie Verificatie toevoegen aan uw app voor meer informatie.For more information, see the tutorial Add authentication to your app.

Twee verificatiestromen worden ondersteund: client beheerd en server beheerd stroom.Two authentication flows are supported: client-managed and server-managed flow. De server beheerd stroom bevat de meest eenvoudige verificatie-ervaring, afhankelijk van de provider de webinterface voor verificatie.The server-managed flow provides the simplest authentication experience, as it relies on the provider's web authentication interface. De stroom client beheerd kunt diepere integratie met de apparaat-specifieke mogelijkheden zoals deze is afhankelijk van de provider-specifieke apparaat-specifieke SDK's.The client-managed flow allows for deeper integration with device-specific capabilities as it relies on provider-specific device-specific SDKs.

Notitie

We raden het gebruik van een stroom softwareclient worden beheerd in uw productie-apps.We recommend using a client-managed flow in your production apps.

Als u verificatie instelt, moet u uw app registreren bij een of meer id-providers.To set up authentication, you must register your app with one or more identity providers. De id-provider wordt gegenereerd voor een client-ID en een clientgeheim voor uw app.The identity provider generates a client ID and a client secret for your app. Deze waarden zijn wordt ingesteld in uw back-end op Azure App Service-verificatie/autorisatie inschakelen.These values are then set in your backend to enable Azure App Service authentication/authorization. Voor meer informatie, volgt u de gedetailleerde instructies in de zelfstudie Verificatie toevoegen aan uw app.For more information, follow the detailed instructions in the tutorial Add authentication to your app.

De volgende onderwerpen worden besproken in deze sectie:The following topics are covered in this section:

Verificatie-client worden beheerdClient-managed authentication

Uw app kunt afzonderlijk contact opnemen met de id-provider en geef vervolgens het geretourneerde token tijdens het aanmelden met uw back-end.Your app can independently contact the identity provider and then provide the returned token during login with your backend. Met deze clientstroom kunt u voor een eenmalige aanmelding voor gebruikers of aanvullende gebruikersgegevens ophalen van de id-provider.This client flow enables you to provide a single sign-on experience for users or to retrieve additional user data from the identity provider. Clientverificatie voor flow heeft de voorkeur voor het gebruik van een stroom server als de id-provider SDK een meer systeemeigen UX uiterlijk biedt en kunt u extra aanpassingen.Client flow authentication is preferred to using a server flow as the identity provider SDK provides a more native UX feel and allows for additional customization.

Voorbeelden zijn beschikbaar voor de volgende patronen van de client-flow-verificatie:Examples are provided for the following client-flow authentication patterns:

Verificatie van gebruikers met de Active Directory-VerificatiebibliotheekAuthenticate users with the Active Directory Authentication Library

U kunt de Active Directory Authentication Library (ADAL) te initiëren gebruikersverificatie van de client met behulp van Azure Active Directory-verificatie gebruiken.You can use the Active Directory Authentication Library (ADAL) to initiate user authentication from the client using Azure Active Directory authentication.

  1. Uw mobiele app back-end voor AAD-aanmelding configureren door de App Service configureren voor Active Directory-aanmelding zelfstudie.Configure your mobile app backend for AAD sign-on by following the How to configure App Service for Active Directory login tutorial. Zorg ervoor dat u de optionele stap voor het registreren van een systeemeigen clienttoepassing.Make sure to complete the optional step of registering a native client application.

  2. Open uw project in Visual Studio of Xamarin Studio, en voeg een verwijzing naar de Microsoft.IdentityModel.Clients.ActiveDirectory NuGet-pakket.In Visual Studio or Xamarin Studio, open your project and add a reference to the Microsoft.IdentityModel.Clients.ActiveDirectory NuGet package. Wanneer u zoekt, neemt u voorlopige versies.When searching, include pre-release versions.

  3. Voeg de volgende code aan uw toepassing, op basis van het platform dat u gebruikt.Add the following code to your application, according to the platform you are using. In elk, moet u de volgende vervangingen:In each, make the following replacements:

    • Vervang INSERT-instantie-HERE met de naam van de tenant waarin u uw toepassing hebt ingericht.Replace INSERT-AUTHORITY-HERE with the name of the tenant in which you provisioned your application. De indeling moet https://login.microsoftonline.com/contoso.onmicrosoft.com.The format should be https://login.microsoftonline.com/contoso.onmicrosoft.com. Deze waarde kan worden gekopieerd vanaf het tabblad domein in uw Azure Active Directory in de Azure Portal.This value can be copied from the Domain tab in your Azure Active Directory in the Azure portal.

    • Vervang INSERT-RESOURCE-ID-HERE met de client-ID voor de back-end van uw mobiele app.Replace INSERT-RESOURCE-ID-HERE with the client ID for your mobile app backend. U vindt de client-ID van de Geavanceerd tabblad onder Azure Active Directory-instellingen in de portal.You can obtain the client ID from the Advanced tab under Azure Active Directory Settings in the portal.

    • Vervang INSERT-CLIENT-ID-HERE met de client-ID die u hebt gekopieerd uit de toepassing native client.Replace INSERT-CLIENT-ID-HERE with the client ID you copied from the native client application.

    • Vervang INSERT-OMLEIDINGS-URI-HERE met van uw site /.auth/login/done eindpunt, met behulp van het HTTPS-schema.Replace INSERT-REDIRECT-URI-HERE with your site's /.auth/login/done endpoint, using the HTTPS scheme. Deze waarde moet zijn vergelijkbaar met https://contoso.azurewebsites.net/.auth/login/done .This value should be similar to https://contoso.azurewebsites.net/.auth/login/done.

      Hier volgt de code die nodig zijn voor elk platform:The code needed for each platform follows:

      Windows: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.iOSXamarin.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.AndroidXamarin.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);
      }
      

Eenmalige aanmelding met een token van Facebook of GoogleSingle Sign-On using a token from Facebook or Google

U kunt de stroom kunt gebruiken, zoals wordt weergegeven in dit fragment voor Facebook of Google.You can use the client flow as shown in this snippet for Facebook or 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();
    }
}

Beheerde server-verificatieServer-managed authentication

Wanneer u uw id-provider hebt geregistreerd, aanroepen de LoginAsync methode voor het [MobileServiceClient] met de MobileServiceAuthenticationProvider waarde van de provider.Once you have registered your identity provider, call the LoginAsync method on the [MobileServiceClient] with the MobileServiceAuthenticationProvider value of your provider. Bijvoorbeeld, initieert de volgende code een server flow aanmelden via Facebook.For example, the following code initiates a server flow sign-in by using 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 id-provider dan Facebook gebruikt, wijzigt u de waarde van MobileServiceAuthenticationProvider naar de waarde voor de provider.If you are using an identity provider other than Facebook, change the value of MobileServiceAuthenticationProvider to the value for your provider.

In een stroom server beheert Azure App Service de OAuth-verificatie-stroom door de aanmeldingspagina van de geselecteerde provider weer te geven.In a server flow, Azure App Service manages the OAuth authentication flow by displaying the sign-in page of the selected provider. Zodra de id-provider retourneert, Azure App Service genereert een App Service-verificatietoken.Once the identity provider returns, Azure App Service generates an App Service authentication token. De LoginAsync methode retourneert een MobileServiceUser, waarmee u zowel de UserId van de geverifieerde gebruiker en de MobileServiceAuthenticationToken, als een JSON webtoken (JWT).The LoginAsync method returns a MobileServiceUser, which provides both the UserId of the authenticated user and the MobileServiceAuthenticationToken, as a JSON web token (JWT). Dit token kan worden opgeslagen in de cache en opnieuw worden gebruikt totdat het verloopt.This token can be cached and reused until it expires. Zie voor meer informatie, Caching het verificatietoken.For more information, see Caching the authentication token.

Het verificatietoken opslaan in cacheCaching the authentication token

In sommige gevallen kan de aanroep naar de aanmeldingsmethode na de eerste authenticatie worden vermeden door op te slaan van het verificatietoken van de provider.In some cases, the call to the login method can be avoided after the first successful authentication by storing the authentication token from the provider. Microsoft Store- en UWP-apps kunt PasswordVault cache van het huidige verificatietoken na een geslaagde aanmelding, als volgt:Microsoft Store and UWP apps can use PasswordVault to cache the current authentication token after a successful sign-in, as follows:

await client.LoginAsync(MobileServiceAuthenticationProvider.Facebook);

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

De gebruikers-id-waarde wordt opgeslagen als de gebruikersnaam van de referentie en het token wordt de opgeslagen als het wachtwoord.The UserId value is stored as the UserName of the credential and the token is the stored as the Password. Op de volgende startende bedrijven, kunt u controleren de PasswordVault voor referenties in de cache.On subsequent start-ups, you can check the PasswordVault for cached credentials. Het volgende voorbeeld wordt in de cache opgeslagen referenties wanneer ze worden gevonden, en anders probeert opnieuw te verifiëren met de back-end:The following example uses cached credentials when they are found, and otherwise attempts to authenticate again with the backend:

// 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 zich afmeldt een gebruiker, moet u de opgeslagen referenties, ook als volgt verwijderen:When you sign out a user, you must also remove the stored credential, as follows:

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

Xamarin-apps gebruiken de Xamarin.Auth API's voor het veilig opslaan van referenties in een Account object.Xamarin apps use the Xamarin.Auth APIs to securely store credentials in an Account object. Zie voor een voorbeeld van het gebruik van deze API's, de AuthStore.cs codebestand in de ContosoMoments foto's delen voorbeeld.For an example of using these APIs, see the AuthStore.cs code file in the ContosoMoments photo sharing sample.

Wanneer u gebruikmaakt van verificatie softwareclient worden beheerd, kunt u ook de cache van het toegangstoken verkregen van de provider, zoals Facebook of Twitter.When you use client-managed authentication, you can also cache the access token obtained from your provider such as Facebook or Twitter. Dit token kan worden opgegeven voor het aanvragen van een nieuw verificatietoken van de back-end, als volgt:This token can be supplied to request a new authentication token from the backend, as follows:

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 verzendenPush Notifications

De volgende onderwerpen vindt u Pushmeldingen:The following topics cover Push Notifications:

Procedures: Registreren voor PushmeldingenHow to: Register for Push Notifications

De client met Mobile Apps kunt u zich registreren voor pushmeldingen kunt verzenden met Azure Notification Hubs.The Mobile Apps client enables you to register for push notifications with Azure Notification Hubs. Wanneer u registreert, kunt u een ingang die u hebt verkregen van de platform-specifieke Push Notification Service (PNS) verkrijgen.When registering, you obtain a handle that you obtain from the platform-specific Push Notification Service (PNS). Deze waarde samen met eventuele labels wordt vervolgens opgeven bij het maken van de registratie.You then provide this value along with any tags when you create the registration. De volgende code registreert uw Windows-app voor pushmeldingen met Windows Notification Service (WNS):The following code registers your Windows app for push notifications with the 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 voor WNS pusht, dan u moet verkrijgen van een pakket-SID van de Microsoft Store.If you are pushing to WNS, then you MUST obtain a Microsoft Store package SID. Zie voor meer informatie over Windows-apps, inclusief het registreren voor de sjabloon-registraties Pushmeldingen toevoegen aan uw app.For more information on Windows apps, including how to register for template registrations, see Add push notifications to your app.

Aanvragen van tags van de client wordt niet ondersteund.Requesting tags from the client is not supported. Tag-aanvragen zijn op de achtergrond verwijderd uit de inschrijving.Tag Requests are silently dropped from registration. Als u wilt dat uw apparaat te registreren bij tags, maakt u een aangepaste API die gebruikmaakt van de Notification Hubs-API om uit te voeren van de registratie namens.If you wish to register your device with tags, create a Custom API that uses the Notification Hubs API to perform the registration on your behalf. Aanroepen van de aangepaste API in plaats van de RegisterNativeAsync() methode.Call the Custom API instead of the RegisterNativeAsync() method.

Procedures: Verkrijgen van een pakket-SID van de Microsoft StoreHow to: Obtain a Microsoft Store package SID

Een pakket-SID is vereist voor het inschakelen van pushmeldingen in Microsoft Store-apps.A package SID is needed for enabling push notifications in Microsoft Store apps. Voor het ontvangen van een pakket-SID, moet u uw toepassing registreren met de Microsoft Store.To receive a package SID, register your application with the Microsoft Store.

Als u deze waarde:To obtain this value:

  1. In Visual Studio Solution Explorer met de rechtermuisknop op de Microsoft Store-app-project, klikt u op Store > App aan de Store koppelen... .In Visual Studio Solution Explorer, right-click the Microsoft Store app project, click Store > Associate App with the Store....
  2. In de wizard, klikt u op volgende, meld u aan met uw Microsoft-account, typ een naam voor uw app in een nieuwe appnaam reserveren, klikt u vervolgens op Reserve.In the wizard, click Next, sign in with your Microsoft account, type a name for your app in Reserve a new app name, then click Reserve.
  3. Nadat de app-registratie is gemaakt, selecteert u de appnaam, klikt u op volgende, en klik vervolgens op koppelen.After the app registration is successfully created, select the app name, click Next, and then click Associate.
  4. Meld u aan bij de Windows Dev Center met uw Microsoft-Account.Log in to the Windows Dev Center using your Microsoft Account. Onder mijn apps, klikt u op de appregistratie van de die u hebt gemaakt.Under My apps, click the app registration you created.
  5. Klik op appbeheer > identiteit App, en schuif vervolgens omlaag naar zoeken naar uw pakket-SID.Click App management > App identity, and then scroll down to find your Package SID.

Vele toepassingen van de pakket-SID behandelen als een URI, in welk geval u wilt gebruiken ms-app: / / als het schema.Many uses of the package SID treat it as a URI, in which case you need to use ms-app:// as the scheme. Noteer de versie van uw pakket-SID gevormd door het samenvoegen van deze waarde als een voorvoegsel.Make note of the version of your package SID formed by concatenating this value as a prefix.

Xamarin-apps vereisen aanvullende code om te kunnen registreren van een app die wordt uitgevoerd op het iOS- of Android-platformen.Xamarin apps require some additional code to be able to register an app running on the iOS or Android platforms. Zie voor meer informatie het onderwerp voor uw platform:For more information, see the topic for your platform:

Procedures: Push-sjablonen voor het verzenden van platformonafhankelijke meldingen registrerenHow to: Register push templates to send cross-platform notifications

Gebruik voor het registreren van sjablonen, de RegisterAsync() methode met de sjablonen kunt als volgt te werk:To register templates, use the RegisterAsync() method with the templates, as follows:

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

Uw sjablonen moet JObject van het type en kan meerdere sjablonen in de volgende JSON-indeling bevatten:Your templates should be JObject types and can contain multiple templates in the following JSON format:

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:The method RegisterAsync() also accepts Secondary Tiles:

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

Alle tags worden onmiddellijk verwijderd tijdens de registratie voor beveiliging.All tags are stripped away during registration for security. Tags toevoegen aan installaties of -sjablonen in installaties, Zie [werken met de .NET back-endserver SDK voor Azure Mobile Apps].To add tags to installations or templates within installations, see [Work with the .NET backend server SDK for Azure Mobile Apps].

Om meldingen te verzenden met behulp van deze geregistreerde sjablonen, raadpleegt u de Notification Hubs-API 's.To send notifications utilizing these registered templates, refer to the Notification Hubs APIs.

Diverse onderwerpenMiscellaneous Topics

Procedures: Fouten verwerkenHow to: Handle errors

Wanneer er een fout optreedt in de back-end, de client SDK retourneert een MobileServiceInvalidOperationException.When an error occurs in the backend, the client SDK raises a MobileServiceInvalidOperationException. Het volgende voorbeeld laat zien hoe voor het afhandelen van een uitzondering die is geretourneerd door de back-end:The following example shows how to handle an exception that is returned by the backend:

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 afhandelen van fouten kunt u vinden in de Voorbeeld van mobiele Apps-bestanden.Another example of dealing with error conditions can be found in the Mobile Apps Files Sample. De LoggingHandler voorbeeld biedt een handler voor het delegeren van logboekregistratie om de aanvragen worden ingediend bij de back-end te registreren.The LoggingHandler example provides a logging delegate handler to log the requests being made to the backend.

Procedures: Aanvraagheaders aanpassenHow to: Customize request headers

Ter ondersteuning van uw specifieke app-scenario, moet u mogelijk communicatie met de back-end van Mobile App aanpassen.To support your specific app scenario, you might need to customize communication with the Mobile App backend. U wilt bijvoorbeeld een aangepaste header toevoegen aan elke uitgaande aanvraag of antwoord-statuscodes zelfs wijzigen.For example, you may want to add a custom header to every outgoing request or even change responses status codes. U kunt een aangepaste DelegatingHandler, zoals in het volgende voorbeeld:You can use a custom DelegatingHandler, as in the following example:

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