CloudKit in Xamarin.iOS

Artikel
05/11/2016

Das CloudKit-Framework optimiert die Entwicklung von Anwendungen, die auf iCloud zugreifen. Dazu gehören das Abrufen von Anwendungsdaten und Ressourcenrechten sowie die Möglichkeit, Anwendungsinformationen sicher zu speichern. Dieses Kit bietet Benutzern eine Ebene der Anonymität, indem sie den Zugriff auf Anwendungen mit ihren iCloud-IDs ermöglicht, ohne persönliche Informationen freizugeben.

Entwickler können sich auf ihre clientseitigen Anwendungen konzentrieren und iCloud die Notwendigkeit des Schreibens serverseitiger Anwendungslogik vermeiden lassen. CloudKit bietet Authentifizierungs-, private und öffentliche Datenbanken sowie strukturierte Daten- und Objektspeicherdienste.

Wichtig

Apple stellt Tools zur Verfügung, die Entwickler dabei unterstützen, die Datenschutz-Grundverordnung (DSGVO) der Europäischen Union umzusetzen.

Anforderungen

Die folgenden Schritte sind erforderlich, um die in diesem Artikel beschriebenen Schritte auszuführen:

Xcode und das iOS SDK – Die Xcode- und iOS 8-APIs von Apple müssen auf dem Computer des Entwicklers installiert und konfiguriert werden.
Visual Studio für Mac – Die neueste Version von Visual Studio für Mac sollte auf dem Benutzergerät installiert und konfiguriert werden.
iOS 8-Gerät – Ein iOS-Gerät, auf dem die neueste Version von iOS 8 zum Testen ausgeführt wird.

Was ist CloudKit?

CloudKit ist eine Möglichkeit, dem Entwickler Zugriff auf die iCloud-Server zu gewähren. Es bietet die Grundlage für iCloud Drive und iCloud Photo Library. CloudKit wird sowohl auf macOS- als auch auf iOS-Geräten unterstützt.

CloudKit verwendet die iCloud-Kontoinfrastruktur. Wenn ein Benutzer bei einem iCloud-Konto auf dem Gerät angemeldet ist, verwendet CloudKit seine ID, um den Benutzer zu identifizieren. Wenn kein Konto verfügbar ist, wird eingeschränkter schreibgeschützter Zugriff bereitgestellt.

CloudKit unterstützt sowohl das Konzept öffentlicher als auch privater Datenbanken. Öffentliche Datenbanken bieten eine "Suppe" aller Daten, auf die der Benutzer zugreifen kann. Private Datenbanken sollen die privaten Daten speichern, die an einen bestimmten Benutzer gebunden sind.

CloudKit unterstützt sowohl strukturierte als auch Massendaten. Es ist in der Lage, große Dateiübertragungen nahtlos zu verarbeiten. CloudKit kümmert sich um die effiziente Übertragung großer Dateien an und von den iCloud-Servern im Hintergrund und befreit den Entwickler, sich auf andere Aufgaben zu konzentrieren.

Hinweis

Es ist wichtig zu beachten, dass CloudKit eine Transporttechnologie ist. Es bietet keine Persistenz; sie ermöglicht es einer Anwendung nur, Informationen von den Servern effizient zu senden und zu empfangen.

Ab diesem Schreiben bietet Apple zunächst CloudKit kostenlos mit einem hohen Grenzwert für Bandbreite und Speicherkapazität. Bei größeren Projekten oder Anwendungen mit einer großen Benutzerbasis hat Apple darauf hinweist, dass eine erschwingliche Preisskala bereitgestellt wird.

Aktivieren von CloudKit in einer Xamarin-Anwendung

Bevor eine Xamarin-Anwendung das CloudKit-Framework verwenden kann, muss die Anwendung ordnungsgemäß bereitgestellt werden, wie in den Handbüchern zum Arbeiten mit Funktionen und Arbeiten mit Berechtigungen beschrieben.

Um auf CloudKit zuzugreifen, muss die Datei "Permissionss.plist" die Berechtigungen "iCloud", "Key-Value-Speicher" und "CloudKit" enthalten.

Beispiel-App

Die Beispiel-App veranschaulicht die Verwendung von CloudKit mit Xamarin. In den folgenden Schritten wird gezeigt, wie Sie das Beispiel konfigurieren– es erfordert zusätzliche Einstellungen, die nicht nur für CloudKit erforderlich sind:The steps below show how to configure the sample – it requires additional settings beyond what's require for CloudKit alone:

Öffnen Sie das Projekt in Visual Studio für Mac oder Visual Studio.
Öffnen Sie in der Projektmappen-Explorer die Datei "Info.plist", und stellen Sie sicher, dass der Bündelbezeichner dem in der App-ID definiert wurde, die im Rahmen der Bereitstellungseinrichtung erstellt wurde.
Scrollen Sie nach unten zur Info.plist-Datei, und wählen Sie "Aktivierte Hintergrundmodi", "Positionsaktualisierungen" und "Remotebenachrichtigungen" aus.
Klicken Sie mit der rechten Maustaste auf das iOS-Projekt in der Projektmappe, und wählen Sie "Optionen" aus.
Wählen Sie "iOS Bundle Signing" und dann das oben erstellte Entwickleridentitäts - und Bereitstellungsprofil aus.
Stellen Sie sicher, dass die Berechtigungsliste "Enable iCloud", "Key-Value Storage" und "CloudKit" enthält.
Stellen Sie sicher, dass der Ubiquity-Container für die Anwendung vorhanden ist. Beispiel: iCloud.com.your-company.CloudKitAtlas
Speichern Sie die Änderungen in der Datei.

Mit diesen Einstellungen ist die Beispiel-App jetzt bereit, auf die CloudKit Framework-APIs sowie auf Hintergrund-, Standort- und Benachrichtigungsdienste zuzugreifen.

Übersicht über die CloudKit-API

Vor der Implementierung von CloudKit in einer Xamarin iOS-Anwendung wird dieser Artikel die Grundlagen des CloudKit-Frameworks behandeln, die die folgenden Themen umfassen:

Container – Isolierte Silos der iCloud-Kommunikation.
Datenbanken – Öffentlich und privat sind für die Anwendung verfügbar.
Datensätze – Der Mechanismus, mit dem strukturierte Daten in CloudKit verschoben und aus cloudKit verschoben werden.
Datensatzzonen – Sind Datensatzgruppen.
Datensatzbezeichner – Sind vollständig normalisiert und stellen den spezifischen Speicherort des Datensatzes dar.
Referenz – Bereitstellen von Beziehungen zwischen verwandten Datensätzen innerhalb einer bestimmten Datenbank.
Ressourcen – Zulassen, dass die Datei großer, unstrukturierter Daten in iCloud hochgeladen und einem bestimmten Datensatz zugeordnet wird.

Container

Eine bestimmte Anwendung, die auf einem iOS-Gerät ausgeführt wird, wird immer parallel zu anderen Anwendungen und Diensten auf diesem Gerät ausgeführt. Auf dem Clientgerät wird die Anwendung auf irgendeine Weise isoliert oder sandkastenweise ausgeführt. In einigen Fällen ist dies ein Literal-Sandkasten, und in anderen wird die Anwendung einfach im eigenen Speicherplatz ausgeführt.

Das Konzept der Verwendung einer Clientanwendung und deren Ausführung, die von anderen Clients getrennt ist, ist sehr leistungsfähig und bietet die folgenden Vorteile:

Sicherheit – Eine Anwendung kann andere Client-Apps oder das Betriebssystem selbst nicht beeinträchtigen.
Stabilität – Wenn die Clientanwendung abstürzt, kann sie keine anderen Apps des Betriebssystems herausnehmen.
Datenschutz – Jede Clientanwendung hat eingeschränkten Zugriff auf die persönlichen Informationen, die auf dem Gerät gespeichert sind.

CloudKit wurde entwickelt, um die gleichen Vorteile wie die oben aufgeführten bereitzustellen und sie auf die Arbeit mit cloudbasierten Informationen anzuwenden:

Genau wie bei der Anwendung, die auf dem Gerät ausgeführt wird, handelt es sich also um die Kommunikation der Anwendung mit iCloud one-of-many. Jeder dieser unterschiedlichen Kommunikationssilos wird als Container bezeichnet.

Container werden über die CKContainer Klasse im CloudKit Framework verfügbar gemacht. Standardmäßig spricht eine Anwendung mit einem Container, und dieser Container trennt die Daten für diese Anwendung. Dies bedeutet, dass mehrere Anwendungen Informationen in demselben iCloud-Konto speichern können, aber diese Informationen werden nie bestimmt.

Die Containerisierung von iCloud-Daten ermöglicht cloudKit auch das Kapseln von Benutzerinformationen. Auf diese Weise verfügt die Anwendung über einen begrenzten Zugriff auf das iCloud-Konto und die darin gespeicherten Benutzerinformationen, während gleichzeitig der Datenschutz und die Sicherheit des Benutzers geschützt werden.

Container werden vollständig vom Entwickler der Anwendung über das WWDR-Portal verwaltet. Der Namespace des Containers ist global für alle Apple-Entwickler, sodass der Container nicht nur für die Anwendungen eines bestimmten Entwicklers, sondern für alle Apple-Entwickler und -Anwendungen einzigartig sein muss.

Apple schlägt vor, beim Erstellen des Namespaces für Anwendungscontainer reverse DNS-Notation zu verwenden. Beispiel: iCloud.com.company-name.application-name

Container sind zwar standardmäßig 1:1 an eine bestimmte Anwendung gebunden, sie können jedoch für alle Anwendungen freigegeben werden. So können mehrere Anwendungen auf einem einzelnen Container koordinieren. Eine einzelne Anwendung kann auch mit mehreren Containern kommunizieren.

Datenbanken

Eine der Hauptfunktionen von CloudKit besteht darin, das Datenmodell und die Replikation einer Anwendung bis zu den iCloud-Servern zu übernehmen. Einige Informationen sind für den Benutzer vorgesehen, der sie erstellt hat, andere Informationen sind öffentliche Daten, die von einem Benutzer für die öffentliche Verwendung erstellt werden können (z. B. eine Restaurantüberprüfung), oder es kann sich um Informationen handeln, die der Entwickler für die Anwendung veröffentlicht hat. In beiden Fällen ist die Zielgruppe nicht nur ein einzelner Benutzer, sondern eine Community von Personen.

Innerhalb eines Containers ist in erster Linie die öffentliche Datenbank. Hier leben alle öffentlichen Informationen und Co-Mingles. Darüber hinaus gibt es mehrere einzelne private Datenbanken für jeden Benutzer der Anwendung.

Wenn sie auf einem iOS-Gerät ausgeführt wird, hat die Anwendung nur Zugriff auf die Informationen für den aktuell angemeldeten iCloud-Benutzer. Die Ansicht der Anwendung für den Container lautet also wie folgt:

Sie kann nur die öffentliche Datenbank und die private Datenbank sehen, die dem aktuell angemeldeten iCloud-Benutzer zugeordnet ist.

Datenbanken werden im CloudKit Framework über die CKDatabase Klasse verfügbar gemacht. Jede Anwendung hat Zugriff auf zwei Datenbanken: die öffentliche Datenbank und die private Datenbank.

Der Container ist der erste Einstiegspunkt in CloudKit. Der folgende Code kann verwendet werden, um über den Standardcontainer der Anwendung auf die öffentliche und private Datenbank zuzugreifen:

using CloudKit;
//...

public CKDatabase PublicDatabase { get; set; }
public CKDatabase PrivateDatabase { get; set; }
//...

// Get the default public and private databases for
// the application
PublicDatabase = CKContainer.DefaultContainer.PublicCloudDatabase;
PrivateDatabase = CKContainer.DefaultContainer.PrivateCloudDatabase;

Hier sind die Unterschiede zwischen den Datenbanktypen:

	Öffentliche Datenbank	Private Datenbank
Datentyp	Freigegebene Daten	Aktuelle Benutzerdaten
Kontingent	Im Kontingent des Entwicklers berücksichtigt	Im Kontingent des Benutzers berücksichtigt
Standardberechtigungen	Weltlesbar	Benutzerlesbar
Bearbeitungsberechtigungen	iCloud-Dashboardrollen über eine Datensatzklassenebene	N/V

Datensätze

Container enthalten Datenbanken, und innerhalb von Datenbanken handelt es sich um Datensätze. Datensätze sind der Mechanismus, in dem strukturierte Daten in CloudKit verschoben und aus CloudKit verschoben werden:

Datensätze werden im CloudKit Framework über die CKRecord Klasse verfügbar gemacht, die Schlüsselwertpaare umschließt. Eine Instanz eines Objekts in einer Anwendung entspricht einem CKRecord in CloudKit. Darüber hinaus besitzt jeder CKRecord einen Datensatztyp, der der Klasse eines Objekts entspricht.

Datensätze weisen ein Just-in-Time-Schema auf, sodass die Daten in CloudKit beschrieben werden, bevor sie zur Verarbeitung übergeben werden. Ab diesem Zeitpunkt interpretiert CloudKit die Informationen und verarbeitet die Logistik des Speicherns und Abrufens des Datensatzes.

Die CKRecord Klasse unterstützt auch eine breite Palette von Metadaten. Beispielsweise enthält ein Datensatz Informationen darüber, wann er erstellt wurde, und den Benutzer, der ihn erstellt hat. Ein Datensatz enthält auch Informationen darüber, wann er zuletzt geändert wurde, und den Benutzer, der ihn geändert hat.

Datensätze enthalten den Begriff eines Änderungstags. Dies ist eine frühere Version einer Überarbeitung eines bestimmten Datensatzes. Das Änderungstag wird als leichte Methode verwendet, um festzustellen, ob der Client und der Server dieselbe Version eines bestimmten Datensatzes haben.

Wie oben erwähnt, CKRecords können Schlüsselwertpaare umschließen und als solche die folgenden Datentypen in einem Datensatz gespeichert werden:

NSString
NSNumber
NSData
NSDate
CLLocation
CKReferences
CKAssets

Zusätzlich zu den Einzelwerttypen kann ein Datensatz ein homogenes Array eines der oben aufgeführten Typen enthalten.

Der folgende Code kann verwendet werden, um einen neuen Datensatz zu erstellen und in einer Datenbank zu speichern:

using CloudKit;
//...

private const string ReferenceItemRecordName = "ReferenceItems";
//...

var newRecord = new CKRecord (ReferenceItemRecordName);
newRecord ["name"] = (NSString)nameTextField.Text;
await CloudManager.SaveAsync (newRecord);

Datensatzzonen

Datensätze sind nicht selbst innerhalb einer bestimmten Datenbank vorhanden – Gruppen von Datensätzen sind in einer Datensatzzone zusammen vorhanden. Datensatzzonen können als Tabellen in herkömmlichen relationalen Datenbanken betrachtet werden:

Es können mehrere Datensätze innerhalb einer bestimmten Datensatzzone und mehrere Datensatzzonen innerhalb einer bestimmten Datenbank vorhanden sein. Jede Datenbank enthält eine Standarddatensatzzone:

An dieser Stelle werden Datensätze standardmäßig gespeichert. Darüber hinaus können benutzerdefinierte Datensatzzonen erstellt werden. Datensatzzonen stellen die Basis-Granularität dar, bei der Atomic Commits und Änderungsnachverfolgung durchgeführt werden.

Datensatzbezeichner

Datensatzbezeichner werden als Tupel dargestellt, das sowohl einen vom Client bereitgestellten Datensatznamen als auch die Zone enthält, in der der Datensatz vorhanden ist. Datensatzbezeichner weisen die folgenden Merkmale auf:

Sie werden von der Clientanwendung erstellt.
Sie sind vollständig normalisiert und stellen den spezifischen Speicherort des Datensatzes dar.
Durch Zuweisen der eindeutigen ID eines Datensatzes in einer fremden Datenbank zum Datensatznamen können sie verwendet werden, um lokale Datenbanken zu überbrücken, die nicht in CloudKit gespeichert sind.

Wenn Entwickler neue Datensätze erstellen, können sie einen Datensatzbezeichner übergeben. Wenn kein Datensatzbezeichner angegeben ist, wird automatisch eine UUID erstellt und dem Datensatz zugewiesen.

Wenn Entwickler neue Datensatzbezeichner erstellen, können sie die Datensatzzone angeben, zu der jeder Datensatz gehört. Wenn keine angegeben ist, wird die Standarddatensatzzone verwendet.

Datensatzbezeichner werden über die CKRecordID Klasse im CloudKit Framework verfügbar gemacht. Der folgende Code kann zum Erstellen eines neuen Datensatzbezeichners verwendet werden:

var recordID =  new CKRecordID("My Record");

References

Verweise stellen Beziehungen zwischen verwandten Datensätzen innerhalb einer bestimmten Datenbank bereit:

Im obigen Beispiel besitzen Eltern Kinder, sodass das Kind ein untergeordneter Datensatz des Übergeordneten Datensatzes ist. Die Beziehung wechselt vom untergeordneten Datensatz zum übergeordneten Datensatz und wird als Back Reference bezeichnet.

Verweise werden im CloudKit Framework über die CKReference Klasse verfügbar gemacht. Sie sind eine Möglichkeit, den iCloud-Server die Beziehung zwischen Datensätzen zu verstehen.

Verweise stellen den Mechanismus hinter Cascading Deletes bereit. Wenn ein übergeordneter Datensatz aus der Datenbank gelöscht wird, werden alle untergeordneten Datensätze (wie in einer Beziehung angegeben) auch automatisch aus der Datenbank gelöscht.

Hinweis

Dangling Pointers sind eine Möglichkeit bei der Verwendung von CloudKit. Wenn die Anwendung beispielsweise eine Liste von Datensatzzeigern abgerufen hat, einen Datensatz ausgewählt und dann nach dem Datensatz gefragt wurde, ist der Datensatz möglicherweise nicht mehr in der Datenbank vorhanden. Eine Anwendung muss codiert werden, um diese Situation ordnungsgemäß zu behandeln.

Obwohl nicht erforderlich, werden Backverweise bevorzugt, wenn Sie mit dem CloudKit Framework arbeiten. Apple hat das System fein abgestimmt, um dies zum effizientesten Referenztyp zu machen.

Beim Erstellen eines Verweises kann der Entwickler entweder einen Datensatz bereitstellen, der sich bereits im Arbeitsspeicher befindet, oder einen Verweis auf einen Datensatzbezeichner erstellen. Wenn sie einen Datensatzbezeichner verwenden und der angegebene Verweis in der Datenbank nicht vorhanden war, wird ein Dangling Pointer erstellt.

Im Folgenden sehen Sie ein Beispiel zum Erstellen eines Verweises für einen bekannten Datensatz:

var reference = new CKReference(newRecord, new CKReferenceAction());

Objekte

Ressourcen ermöglichen, dass eine Datei mit großen, unstrukturierten Daten in iCloud hochgeladen und einem bestimmten Datensatz zugeordnet wird:

Auf dem Client wird eine CKRecord Erstellt, die die Datei beschreibt, die auf den iCloud-Server hochgeladen werden soll. A CKAsset wird erstellt, um die Datei zu enthalten und mit dem Datensatz verknüpft, der sie beschreibt.

Wenn die Datei auf den Server hochgeladen wird, wird der Datensatz in der Datenbank platziert, und die Datei wird in eine spezielle Massenspeicherdatenbank kopiert. Es wird eine Verknüpfung zwischen dem Datensatzzeiger und der hochgeladenen Datei erstellt.

Ressourcen werden im CloudKit Framework über die CKAsset Klasse verfügbar gemacht und zum Speichern großer, unstrukturierter Daten verwendet. Da der Entwickler niemals große, unstrukturierte Daten im Arbeitsspeicher haben möchte, werden Ressourcen mithilfe von Dateien auf dem Datenträger implementiert.

Assets are owned by records, which allows the assets to be retrieved from iCloud using the record as a pointer. Auf diese Weise kann der Server Ressourcen sammeln, wenn der Datensatz, der die Ressource besitzt, gelöscht wird.

Da CKAssets sie große Datendateien verarbeiten sollen, hat Apple CloudKit entwickelt, um die Objekte effizient hochzuladen und herunterzuladen.

Der folgende Code kann verwendet werden, um eine Ressource zu erstellen und sie dem Datensatz zuzuordnen:

var fileUrl = new NSUrl("LargeFile.mov");
var asset = new CKAsset(fileUrl);
newRecord ["name"] = asset;

Wir haben nun alle grundlegenden Objekte in CloudKit behandelt. Container sind Anwendungen zugeordnet und enthalten Datenbanken. Datenbanken enthalten Datensätze, die in Datensatzzonen gruppiert sind und auf die durch Datensatzbezeichner verwiesen wird. Beziehungen zwischen übergeordneten und untergeordneten Elementen werden zwischen Datensätzen mithilfe von Verweisen definiert. Schließlich können große Dateien mithilfe von Assets hochgeladen und datensätzen zugeordnet werden.

CloudKit Convenience API

Apple bietet zwei verschiedene API-Sätze für die Arbeit mit CloudKit:

Operative API – Bietet jedes einzelne Feature von CloudKit. Für komplexere Anwendungen bietet diese API eine differenzierte Kontrolle über CloudKit.
Komfort-API – Bietet eine allgemeine, vorkonfigurierte Teilmenge von CloudKit-Features. Es bietet eine bequeme, einfache Zugriffslösung für die Einbeziehung von CloudKit-Funktionen in eine iOS-Anwendung.

Die Convenience-API ist in der Regel die beste Wahl für die meisten iOS-Anwendungen und Apple schlägt vor, damit zu beginnen. Der Rest dieses Abschnitts behandelt die folgenden Themen der Convenience-API:

Speichern eines Datensatzes.
Abrufen eines Datensatzes.
Aktualisieren eines Datensatzes.

Allgemeiner Setupcode

Bevor Sie mit der CloudKit Convenience-API beginnen, ist ein Standardsetupcode erforderlich. Beginnen Sie, indem Sie die Datei der Anwendung AppDelegate.cs ändern und wie folgt aussehen lassen:

using System;
using System.Collections.Generic;
using System.Linq;
using Foundation;
using UIKit;
using CloudKit;

namespace CloudKitAtlas
{
    [Register ("AppDelegate")]
    public partial class AppDelegate : UIApplicationDelegate
    {
        public override UIWindow Window { get; set;}
        public CKDatabase PublicDatabase { get; set; }
        public CKDatabase PrivateDatabase { get; set; }

        public override bool FinishedLaunching (UIApplication application, NSDictionary launchOptions)
        {
            application.RegisterForRemoteNotifications ();

            // Get the default public and private databases for
            // the application
            PublicDatabase = CKContainer.DefaultContainer.PublicCloudDatabase;
            PrivateDatabase = CKContainer.DefaultContainer.PrivateCloudDatabase;

            return true;
        }

        public override void RegisteredForRemoteNotifications (UIApplication application, NSData deviceToken)
        {
            Console.WriteLine ("Registered for Push notifications with token: {0}", deviceToken);
        }

        public override void FailedToRegisterForRemoteNotifications (UIApplication application, NSError error)
        {
            Console.WriteLine ("Push subscription failed");
        }

        public override void ReceivedRemoteNotification (UIApplication application, NSDictionary userInfo)
        {
            Console.WriteLine ("Push received");
        }
    }
}

Der obige Code macht die öffentlichen und privaten CloudKit-Datenbanken als Verknüpfungen verfügbar, damit sie in der restlichen Anwendung einfacher arbeiten können.

Fügen Sie als Nächstes den folgenden Code zu einem beliebigen Ansichts- oder Ansichtscontainer hinzu, der CloudKit verwendet:

using CloudKit;
//...

public AppDelegate ThisApp {
    get { return (AppDelegate)UIApplication.SharedApplication.Delegate; }
}

Dadurch wird eine Verknüpfung hinzugefügt, um die oben erstellten Verknüpfungen für öffentliche und private Datenbanken abzurufen AppDelegate und darauf zuzugreifen.

Mit diesem Code werfen wir einen Blick auf die Implementierung der CloudKit Convenience-API in einer Xamarin iOS 8-Anwendung.

Speichern eines Datensatzes

Mithilfe des oben dargestellten Musters beim Diskutieren von Datensätzen erstellt der folgende Code einen neuen Datensatz und verwendet die Convenience-API, um ihn in der öffentlichen Datenbank zu speichern:

private const string ReferenceItemRecordName = "ReferenceItems";
...

// Create a new record
var newRecord = new CKRecord (ReferenceItemRecordName);
newRecord ["name"] = (NSString)nameTextField.Text;

// Save it to the database
ThisApp.PublicDatabase.SaveRecord(newRecord, (record, err) => {
    // Was there an error?
    if (err != null) {
        ...
    }
});

Drei Punkte, die Sie im obigen Code beachten müssen:

Durch Aufrufen der SaveRecord Methode des PublicDatabaseEntwicklers muss nicht angegeben werden, wie die Daten gesendet werden, in welche Zone sie geschrieben wird usw. Die Convenience-API kümmert sich um alle diese Details selbst.
Der Aufruf ist asynchron und stellt eine Rückrufroutine bereit, wenn der Aufruf abgeschlossen ist, entweder mit Erfolg oder Fehler. Wenn der Anruf fehlschlägt, wird eine Fehlermeldung angezeigt.
CloudKit bietet keinen lokalen Speicher/Persistenz; es ist nur ein Transfermedium. Wenn also eine Anforderung zum Speichern eines Datensatzes gestellt wird, wird sie sofort an die iCloud-Server gesendet.

Hinweis

Aufgrund der "verlustbehafteten" Art der Mobilfunkkommunikation, bei der Verbindungen ständig verworfen oder unterbrochen werden, muss der Entwickler bei der Arbeit mit CloudKit eine Fehlerbehandlung vornehmen.

Abrufen eines Datensatzes

Wenn ein Datensatz erstellt und erfolgreich auf dem iCloud-Server gespeichert wurde, verwenden Sie den folgenden Code, um den Datensatz abzurufen:

// Create a record ID and fetch the record from the database
var recordID = new CKRecordID("MyRecordName");
ThisApp.PublicDatabase.FetchRecord(recordID, (record, err) => {
    // Was there an error?
    if (err != null) {
        ...
    }
});

Genau wie beim Speichern des Datensatzes ist der obige Code asynchron, einfach und erfordert eine hervorragende Fehlerbehandlung.

Aktualisieren eines Datensatzes

Nachdem ein Datensatz von den iCloud-Servern abgerufen wurde, kann der folgende Code verwendet werden, um den Datensatz zu ändern und die Änderungen wieder in der Datenbank zu speichern:

// Create a record ID and fetch the record from the database
var recordID = new CKRecordID("MyRecordName");
ThisApp.PublicDatabase.FetchRecord(recordID, (record, err) => {
    // Was there an error?
    if (err != null) {

    } else {
        // Modify the record
        record["name"] = (NSString)"New Name";

        // Save changes to database
        ThisApp.PublicDatabase.SaveRecord(record, (r, e) => {
            // Was there an error?
            if (e != null) {
                 ...
            }
        });
    }
});

Die FetchRecord Methode der PublicDatabase Rückgabe eines CKRecord Erfolgreichen Aufrufs. Die Anwendung ändert dann den Datensatz und ruft erneut auf SaveRecord , um die Änderungen wieder in die Datenbank zu schreiben.

In diesem Abschnitt wird der typische Zyklus gezeigt, den eine Anwendung beim Arbeiten mit der CloudKit Convenience-API verwendet. Die Anwendung speichert Datensätze in iCloud, ruft diese Datensätze aus iCloud ab, ändert die Datensätze und speichert diese Änderungen wieder in iCloud.

Entwerfen für Skalierbarkeit

Bisher hat sich dieser Artikel mit dem Speichern und Abrufen des gesamten Objektmodells einer Anwendung von den iCloud-Servern befasst, jedes Mal, wenn er bearbeitet wird. Dieser Ansatz eignet sich zwar gut mit einer kleinen Datenmenge und einer sehr kleinen Benutzerbasis, wird aber nicht gut skaliert, wenn die Menge an Informationen und/oder Benutzerbasis steigt.

Big Data, winziges Gerät

Je beliebter eine Anwendung wird, desto mehr Daten in der Datenbank und desto weniger machbar ist es, einen Cache dieser gesamten Daten auf dem Gerät zu haben. Die folgenden Techniken können verwendet werden, um dieses Problem zu beheben:

Halten Sie die großen Daten in der Cloud – CloudKit wurde entwickelt, um große Daten effizient zu verarbeiten.
Der Client sollte nur ein Segment dieser Daten anzeigen – Bringen Sie das einzige Minimum an Daten herunter, die für die Verarbeitung einer Aufgabe zu einem bestimmten Zeitpunkt erforderlich sind.
Clientansichten können sich ändern – Da jeder Benutzer unterschiedliche Einstellungen hat, kann das angezeigte Datensegment von Benutzer zu Benutzer geändert werden, und die individuelle Ansicht des Benutzers eines bestimmten Datensegments kann unterschiedlich sein.
Der Client verwendet Abfragen, um den Standpunkt zu konzentrieren – Abfragen ermöglichen es dem Benutzer, eine kleine Teilmenge eines größeren Datasets anzuzeigen, das in der Cloud vorhanden ist.

Abfragen

Wie oben erwähnt, ermöglichen Abfragen dem Entwickler, eine kleine Teilmenge des größeren Datasets auszuwählen, das in der Cloud vorhanden ist. Abfragen werden im CloudKit Framework über die CKQuery Klasse verfügbar gemacht.

Eine Abfrage kombiniert drei verschiedene Dinge: einen Datensatztyp ( RecordType), ein Prädikat ( NSPredicate) und optional einen Sortdeskriptor ( NSSortDescriptors). CloudKit unterstützt die meisten von NSPredicate.

Unterstützte Prädikate

CloudKit unterstützt die folgenden Typen von NSPredicates Abfragen beim Arbeiten mit Abfragen:

Übereinstimmende Datensätze, bei denen der Name einem in einer Variablen gespeicherten Wert entspricht:
```
NSPredicate.FromFormat(string.Format("name = '{0}'", recordName))
```
Ermöglicht das Abgleichen auf einem dynamischen Schlüsselwert, sodass der Schlüssel zur Kompilierungszeit nicht wissen muss:
```
NSPredicate.FromFormat(string.Format("{0} = '{1}'", key, value))
```
Übereinstimmende Datensätze, bei denen der Wert des Datensatzes größer als der angegebene Wert ist:
```
NSPredicate.FromFormat(string.Format("start > {0}", (NSDate)date))
```

Übereinstimmende Datensätze, bei denen die Position des Datensatzes innerhalb von 100 Metern vom angegebenen Standort liegt:

var location = new CLLocation(37.783,-122.404);
var predicate = NSPredicate.FromFormat(string.Format("distanceToLocation:fromLocation(Location,{0}) < 100", location));

CloudKit unterstützt eine tokenisierte Suche. Dieser Aufruf erstellt zwei Token, eine für after und eine für session. Es wird ein Datensatz zurückgegeben, der diese beiden Token enthält:
```
NSPredicate.FromFormat(string.Format("ALL tokenize({0}, 'Cdl') IN allTokens", "after session"))
```

CloudKit unterstützt zusammengesetzte Prädikate, die mit dem AND Operator verbunden sind.

NSPredicate.FromFormat(string.Format("start > {0} AND name = '{1}'", (NSDate)date, recordName))

Erstellen von Abfragen

Der folgende Code kann zum Erstellen einer CKQuery Xamarin iOS 8-Anwendung verwendet werden:

var recordName = "MyRec";
var predicate = NSPredicate.FromFormat(string.Format("name = '{0}'", recordName));
var query = new CKQuery("CloudRecords", predicate);

Zunächst wird ein Prädikat erstellt, um nur Datensätze auszuwählen, die einem bestimmten Namen entsprechen. Anschließend wird eine Abfrage erstellt, die Datensätze des angegebenen Datensatztyps auswählt, die dem Prädikat entsprechen.

Ausführen einer Abfrage

Nachdem eine Abfrage erstellt wurde, verwenden Sie den folgenden Code, um die Abfrage auszuführen und die zurückgegebenen Datensätze zu verarbeiten:

var recordName = "MyRec";
var predicate = NSPredicate.FromFormat(string.Format("name = {0}", recordName));
var query = new CKQuery("CloudRecords", predicate);

ThisApp.PublicDatabase.PerformQuery(query, CKRecordZone.DefaultRecordZone().ZoneId, (NSArray results, NSError err) => {
    // Was there an error?
    if (err != null) {
       ...
    } else {
        // Process the returned records
        for(nint i = 0; i < results.Count; ++i) {
            var record = (CKRecord)results[i];
        }
    }
});

Der obige Code verwendet die oben erstellte Abfrage und führt sie für die öffentliche Datenbank aus. Da keine Datensatzzone angegeben ist, werden alle Zonen durchsucht. Wenn keine Fehler aufgetreten sind, wird ein Array zurückgegeben CKRecords , das mit den Parametern der Abfrage übereinstimmen soll.

Die Möglichkeit zum Nachdenken über Abfragen besteht darin, dass sie Umfragen sind und sich hervorragend für das Slicing durch große Datasets eignen. Abfragen eignen sich jedoch aufgrund der folgenden Gründe nicht gut für große, meist statische Datasets:

Sie sind schlecht für die Akkulaufzeit des Geräts.
Sie sind für den Netzwerkdatenverkehr schlecht.
Sie sind schlecht für die Benutzererfahrung, da die angezeigten Informationen durch die Häufigkeit der Abfrage der Datenbank durch die Anwendung eingeschränkt sind. Benutzer erwarten heute Pushbenachrichtigungen, wenn sich etwas ändert.

Abonnements

Bei großen, meist statischen Datasets sollte die Abfrage nicht auf dem Clientgerät ausgeführt werden, sie sollte auf dem Server im Auftrag des Clients ausgeführt werden. Die Abfrage sollte im Hintergrund ausgeführt werden und nach jedem Speichern eines einzelnen Datensatzes ausgeführt werden, unabhängig davon, ob das aktuelle Gerät oder ein anderes Gerät dieselbe Datenbank berührt.

Schließlich sollte eine Pushbenachrichtigung an jedes Gerät gesendet werden, das an die Datenbank angefügt ist, wenn die serverseitige Abfrage ausgeführt wird.

Abonnements werden über die CKSubscription Klasse im CloudKit Framework verfügbar gemacht. Sie kombinieren einen Datensatztyp ( RecordType), ein Prädikat ( NSPredicate) und eine Apple Push Notification ( Push).

Hinweis

CloudKit-Pushs werden leicht erweitert, da sie eine Nutzlast enthalten, die CloudKit-spezifische Informationen enthält, z. B. was dazu führte, dass der Push erfolgt.

Funktionsweise von Abonnements

Bevor Sie Das Abonnement im C#-Code implementieren, werfen wir einen schnellen Überblick über die Funktionsweise von Abonnements:

Das obige Diagramm zeigt den typischen Abonnementprozess wie folgt:

Das Clientgerät erstellt ein neues Abonnement, das die Reihe von Bedingungen enthält, die das Abonnement auslösen, und eine Pushbenachrichtigung, die gesendet wird, wenn der Trigger auftritt.
Das Abonnement wird an die Datenbank gesendet, in der es der Sammlung vorhandener Abonnements hinzugefügt wird.
Ein zweites Gerät erstellt einen neuen Datensatz und speichert diesen Datensatz in der Datenbank.
Die Datenbank durchsucht die Liste der Abonnements, um festzustellen, ob der neue Datensatz einer ihrer Bedingungen entspricht.
Wenn eine Übereinstimmung gefunden wird, wird die Pushbenachrichtigung an das Gerät gesendet, das das Abonnement mit Informationen zum Datensatz registriert hat, die dazu führte, dass sie ausgelöst wurde.

Mit diesem Wissen befassen wir uns mit dem Erstellen von Abonnements in einer Xamarin iOS 8-Anwendung.

Erstellen von Abonnements

Der folgende Code kann zum Erstellen eines Abonnements verwendet werden:

// Create a new subscription
DateTime date;
var predicate = NSPredicate.FromFormat(string.Format("start > {0}", (NSDate)date));
var subscription = new CKSubscription("RecordType", predicate, CKSubscriptionOptions.FiresOnRecordCreation);

// Describe the type of notification
var notificationInfo = new CKNotificationInfo();
notificationInfo.AlertLocalizationKey = "LOCAL_NOTIFICATION_KEY";
notificationInfo.SoundName = "ping.aiff";
notificationInfo.ShouldBadge = true;

// Attach the notification info to the subscription
subscription.NotificationInfo = notificationInfo;

Zunächst wird ein Prädikat erstellt, das die Bedingung zum Auslösen des Abonnements bereitstellt. Als Nächstes erstellt es das Abonnement mit einem bestimmten Datensatztyp und legt die Option fest, wann der Trigger getestet wird. Schließlich wird der Typ der Benachrichtigung definiert, die beim Auslösen des Abonnements auftritt und dem Abonnement angefügt wird.

Speichern von Abonnements

Nachdem das Abonnement erstellt wurde, wird er im folgenden Code in der Datenbank gespeichert:

// Save the subscription to the database
ThisApp.PublicDatabase.SaveSubscription(subscription, (s, err) => {
    // Was there an error?
    if (err != null) {

    }
});

Mithilfe der Convenience-API ist der Aufruf asynchron, einfach und bietet eine einfache Fehlerbehandlung.

Behandeln von Pushbenachrichtigungen

Wenn der Entwickler zuvor Apple Push Notifications (APS) verwendet hat, sollte der Prozess des Umgangs mit von CloudKit generierten Benachrichtigungen vertraut sein.

Überschreiben Sie in der AppDelegate.csKlasse wie folgt die ReceivedRemoteNotification Klasse:

public override void ReceivedRemoteNotification (UIApplication application, NSDictionary userInfo)
{
    // Parse the notification into a CloudKit Notification
    var notification = CKNotification.FromRemoteNotificationDictionary (userInfo);

    // Get the body of the message
    var alertBody = notification.AlertBody;

    // Was this a query?
    if (notification.NotificationType == CKNotificationType.Query) {
        // Yes, convert to a query notification and get the record ID
        var query = notification as CKQueryNotification;
        var recordID = query.RecordId;
    }
}

Der obige Code fordert CloudKit auf, die UserInfo in eine CloudKit-Benachrichtigung zu analysieren. Als Nächstes werden Informationen über die Warnung extrahiert. Schließlich wird der Typ der Benachrichtigung getestet und die Benachrichtigung entsprechend behandelt.

In diesem Abschnitt wird gezeigt, wie Sie das oben dargestellte Problem mit Big Data, Tiny Device, mithilfe von Abfragen und Abonnements beantworten. Die Anwendung belässt ihre großen Daten in der Cloud und verwendet diese Technologien, um Ansichten in diesem Dataset bereitzustellen.

CloudKit-Benutzerkonten

Wie zu Beginn dieses Artikels erwähnt, basiert CloudKit auf der vorhandenen iCloud-Infrastruktur. Im folgenden Abschnitt wird ausführlich erläutert, wie Konten einem Entwickler mithilfe der CloudKit-API verfügbar gemacht werden.

Authentifizierung

Beim Umgang mit Benutzerkonten ist die erste Berücksichtigung die Authentifizierung. CloudKit unterstützt die Authentifizierung über den aktuell angemeldeten iCloud-Benutzer auf dem Gerät. Die Authentifizierung findet hinter den Kulissen statt und wird von iOS verarbeitet. Auf diese Weise müssen entwickler sich nie um die Details der Implementierung der Authentifizierung kümmern. Sie testen nur, ob ein Benutzer angemeldet ist.

Benutzerkontoinformationen

CloudKit stellt dem Entwickler die folgenden Benutzerinformationen bereit:

Identität – eine Möglichkeit, den Benutzer eindeutig zu identifizieren.
Metadaten – Die Möglichkeit zum Speichern und Abrufen von Informationen zu Benutzern.
Datenschutz – Alle Informationen werden in einem datenschutzbewussten Gutshaus behandelt. Nichts wird verfügbar gemacht, es sei denn, der Benutzer hat sich damit einverstanden erklärt.
Ermittlung – Bietet Benutzern die Möglichkeit, ihre Freunde zu entdecken, die dieselbe Anwendung verwenden.

Als Nächstes befassen wir uns mit diesen Themen ausführlich.

Identität

Wie oben erwähnt, bietet CloudKit eine Möglichkeit für die Anwendung, einen bestimmten Benutzer eindeutig zu identifizieren:

Es gibt eine Clientanwendung, die auf den Geräten eines Benutzers und allen spezifischen privaten Benutzerdatenbanken im CloudKit-Container ausgeführt wird. Die Clientanwendung wird mit einem dieser spezifischen Benutzer verknüpft. Dies basiert auf dem Benutzer, der lokal auf dem Gerät bei iCloud angemeldet ist.

Da dies von iCloud stammt, gibt es einen umfassenden Sicherungsspeicher von Benutzerinformationen. Und da iCloud tatsächlich den Container hosten, kann es Benutzer korrelieren. In der obigen Grafik wird der Benutzer, dessen iCloud-Konto user@icloud.com mit dem aktuellen Client verknüpft ist.

Auf Containerbasis wird eine eindeutige, zufällig generierte Benutzer-ID erstellt und dem iCloud-Konto des Benutzers (E-Mail-Adresse) zugeordnet. Diese Benutzer-ID wird an die Anwendung zurückgegeben und kann auf jede Weise verwendet werden, die vom Entwickler angezeigt wird.

Hinweis

Verschiedene Anwendungen, die auf demselben Gerät für denselben iCloud-Benutzer ausgeführt werden, weisen unterschiedliche Benutzer-IDs auf, da sie mit verschiedenen CloudKit-Containern verbunden sind.

Der folgende Code ruft die CloudKit-Benutzer-ID für den aktuell angemeldeten iCloud-Benutzer auf dem Gerät ab:

public CKRecordID UserID { get; set; }
...

// Get the CloudKit User ID
CKContainer.DefaultContainer.FetchUserRecordId ((recordID, err) => {
    // Was there an error?
    if (err!=null) {
        Console.WriteLine("Error: {0}", err.LocalizedDescription);
    } else {
        // Save user ID
        UserID = recordID;
    }
});

Der obige Code fordert den CloudKit-Container auf, die ID des aktuell angemeldeten Benutzers bereitzustellen. Da diese Informationen vom iCloud-Server stammen, ist der Aufruf asynchron und fehlerbehandlung erforderlich.

Metadaten

Jeder Benutzer in CloudKit verfügt über spezifische Metadaten, die sie beschreiben. Diese Metadaten werden als CloudKit-Datensatz dargestellt:

Wenn Sie in der privaten Datenbank nach einem bestimmten Benutzer eines Containers suchen, gibt es einen Datensatz, der diesen Benutzer definiert. Es gibt viele Benutzerdatensätze innerhalb der öffentlichen Datenbank, eine für jeden Benutzer des Containers. Eine dieser Datensätze enthält eine Datensatz-ID, die der aktuell angemeldeten Datensatz-ID des Benutzers entspricht.

Benutzerdatensätze in der öffentlichen Datenbank sind weltweit lesbar. Sie werden größtenteils als gewöhnlicher Datensatz behandelt und haben eine Art von CKRecordTypeUserRecord. Diese Datensätze sind vom System reserviert und stehen für Abfragen nicht zur Verfügung.

Verwenden Sie den folgenden Code, um auf einen Benutzerdatensatz zuzugreifen:

public CKRecord UserRecord { get; set; }
...

// Get the user's record
PublicDatabase.FetchRecord(UserID, (record ,er) => {
    //was there an error?
    if (er != null) {
        Console.WriteLine("Error: {0}", er.LocalizedDescription);
    } else {
        // Save the user record
        UserRecord = record;
    }
});

Der obige Code fordert die öffentliche Datenbank auf, den Benutzerdatensatz für den Benutzer zurückzugeben, auf den wir oben zugegriffen haben. Da diese Informationen vom iCloud-Server stammen, ist der Aufruf asynchron und fehlerbehandlung erforderlich.

Datenschutz

CloudKit war standardmäßig so gestaltet, dass der Datenschutz des aktuell angemeldeten Benutzers geschützt wurde. Standardmäßig werden keine persönlichen Informationen über den Benutzer verfügbar gemacht. Es gibt einige Fälle, in denen die Anwendung eingeschränkte Informationen über den Benutzer benötigt.

In diesen Fällen kann die Anwendung verlangen, dass der Benutzer diese Informationen offenlegt. Dem Benutzer wird ein Dialogfeld angezeigt, in dem er aufgefordert wird, sich anzumelden, um seine Kontoinformationen verfügbar zu machen.

Ermittlung

Wenn sich der Benutzer für den eingeschränkten Zugriff der Anwendung auf seine Benutzerkontoinformationen entschieden hat, kann er für andere Benutzer der Anwendung auffindbar sein:

Die Clientanwendung spricht mit einem Container, und der Container spricht von iCloud, um auf Benutzerinformationen zuzugreifen. Der Benutzer kann eine E-Mail-Adresse bereitstellen, und die Ermittlung kann verwendet werden, um Informationen über den Benutzer abzurufen. Optional kann die Benutzer-ID auch verwendet werden, um Informationen über den Benutzer zu ermitteln.

CloudKit bietet außerdem eine Möglichkeit, Informationen zu jedem Benutzer zu ermitteln, der möglicherweise Freunde des aktuell angemeldeten iCloud-Benutzers ist, indem er das gesamte Adressbuch abfragt. Der CloudKit-Prozess ruft das Kontaktbuch des Benutzers ab und verwendet die E-Mail-Adressen, um festzustellen, ob es die Anwendung anderer Benutzer finden kann, die mit diesen Adressen übereinstimmen.

Dadurch kann die Anwendung das Kontaktbuch des Benutzers nutzen, ohne zugriff darauf zu gewähren oder den Benutzer aufzufordern, den Zugriff auf die Kontakte zu genehmigen. Die Kontaktinformationen, die der Anwendung zur Verfügung gestellt werden, sind nicht verfügbar, nur der CloudKit-Prozess hat Zugriff.

Um eine Zusammenfassung zu erhalten, stehen drei verschiedene Arten von Eingaben für die Benutzerermittlung zur Verfügung:

Benutzerdatensatz-ID – Die Ermittlung kann anhand der Benutzer-ID des aktuell angemeldeten CloudKit-Benutzers erfolgen.
E-Mail-Adresse des Benutzers – Der Benutzer kann eine E-Mail-Adresse angeben und zur Ermittlung verwendet werden.
Kontaktbuch – Das Adressbuch des Benutzers kann verwendet werden, um Benutzer der Anwendung zu ermitteln, die dieselbe E-Mail-Adresse wie in ihren Kontakten aufgeführt haben.

Die Benutzerermittlung gibt die folgenden Informationen zurück:

Benutzerdatensatz-ID – Die eindeutige ID eines Benutzers in der öffentlichen Datenbank.
Vorname und Nachname – Wie in der öffentlichen Datenbank gespeichert.

Diese Informationen werden nur für Benutzer zurückgegeben, die sich für Discovery entschieden haben.

Der folgende Code ermittelt Informationen über den Aktuell bei iCloud angemeldeten Benutzer auf dem Gerät:

public CKDiscoveredUserInfo UserInfo { get; set; }
//...

// Get the user's metadata
CKContainer.DefaultContainer.DiscoverUserInfo(UserID, (info, e) => {
    // Was there an error?
    if (e != null) {
        Console.WriteLine("Error: {0}", e.LocalizedDescription);
    } else {
        // Save the user info
        UserInfo = info;
    }
});

Verwenden Sie den folgenden Code, um alle Benutzer im Kontaktbuch abzufragen:

// Ask CloudKit for all of the user's friends information
CKContainer.DefaultContainer.DiscoverAllContactUserInfos((info, er) => {
    // Was there an error
    if (er != null) {
        Console.WriteLine("Error: {0}", er.LocalizedDescription);
    } else {
        // Process all returned records
        for(int i = 0; i < info.Count(); ++i) {
            // Grab a user
            var userInfo = info[i];
        }
    }
});

In diesem Abschnitt haben wir die vier Hauptbereiche des Zugriffs auf das Konto eines Benutzers behandelt, die CloudKit für eine Anwendung bereitstellen kann. Vom Abrufen der Identität und Metadaten des Benutzers zu den Datenschutzrichtlinien, die in CloudKit integriert sind, und schließlich die Möglichkeit, andere Benutzer der Anwendung zu entdecken.

Die Entwicklungs- und Produktionsumgebungen

CloudKit stellt separate Entwicklungs- und Produktionsumgebungen für die Datensatztypen und Daten einer Anwendung bereit. Die Entwicklungsumgebung ist eine flexiblere Umgebung, die nur Mitgliedern eines Entwicklungsteams zur Verfügung steht. Wenn eine Anwendung einem Datensatz ein neues Feld hinzufügt und diesen Datensatz in der Entwicklungsumgebung speichert, aktualisiert der Server die Schemainformationen automatisch.

Der Entwickler kann dieses Feature verwenden, um während der Entwicklung Änderungen an einem Schema vorzunehmen, was Zeit spart. Eine Einschränkung besteht darin, dass der diesem Feld zugeordnete Datentyp nach dem Hinzufügen eines Felds zu einem Datensatz nicht programmgesteuert geändert werden kann. Um den Typ eines Felds zu ändern, muss der Entwickler das Feld im CloudKit-Dashboard löschen und es erneut mit dem neuen Typ hinzufügen.

Vor der Bereitstellung der Anwendung kann der Entwickler sein Schema und seine Daten mithilfe des CloudKit-Dashboards in die Produktionsumgebung migrieren. Wenn sie für die Produktionsumgebung ausgeführt wird, verhindert der Server, dass eine Anwendung das Schema programmgesteuert ändert. Der Entwickler kann weiterhin Änderungen am CloudKit-Dashboard vornehmen, aber Versuche, einem Datensatz in der Produktionsumgebung Felder hinzuzufügen, führen zu Fehlern.

Hinweis

Der iOS Simulator funktioniert nur mit der Entwicklungsumgebung. Wenn der Entwickler bereit ist, eine Anwendung in einer Produktionsumgebung zu testen, ist ein physisches iOS-Gerät erforderlich.

Versenden einer aktivierten CloudKit-App

Vor dem Versand einer Anwendung, die CloudKit verwendet, muss sie für die Produktions-CloudKit-Umgebung konfiguriert werden, oder die Anwendung wird von Apple abgelehnt.

Gehen Sie folgendermaßen vor:

Kompilieren Sie in Visual Studio für Ma die Anwendung für das Release-iOS-Gerät>:
Wählen Sie im Menü "Erstellen" die Option "Archiv" aus:
Das Archiv wird in Visual Studio für Mac erstellt und angezeigt:
Starten Sie Xcode.
Wählen Sie im Menü "Fenster" die Option "Organisieren" aus:
Wählen Sie das Archiv der Anwendung aus, und klicken Sie auf die Schaltfläche "Exportieren..." :
Wählen Sie eine Methode für den Export aus, und klicken Sie auf die Schaltfläche "Weiter ":
Wählen Sie das Entwicklungsteam aus der Dropdownliste aus, und klicken Sie auf die Schaltfläche "Auswählen ":
Wählen Sie "Produktion " aus der Dropdownliste aus, und klicken Sie auf die Schaltfläche "Weiter ":
Überprüfen Sie die Einstellung, und klicken Sie auf die Schaltfläche "Exportieren ":
Wählen Sie einen Speicherort aus, um die resultierende Anwendungsdatei .ipa zu generieren.

Der Vorgang ähnelt dem Senden der Bewerbung direkt an iTunes Verbinden, klicken Sie einfach auf die Schaltfläche "Absenden" und nicht auf die Schaltfläche "Exportieren"... nach auswahl eines Archivs im Fenster "Organisator".

Gründe für die Verwendung von CloudKit

Wie wir in diesem Artikel gesehen haben, bietet CloudKit eine einfache Möglichkeit für eine Anwendung zum Speichern und Abrufen von Informationen von den iCloud-Servern. Das heißt, CloudKit veraltet oder veraltet keine der vorhandenen Tools oder Frameworks.

Anwendungsfälle

Die folgenden Anwendungsfälle sollten dem Entwickler helfen, zu entscheiden, wann ein bestimmtes iCloud-Framework oder eine bestimmte Technologie verwendet werden soll:

iCloud Key-Value Store – Hält asynchron kleine Datenmengen auf dem neuesten Stand und eignet sich hervorragend für die Arbeit mit Anwendungseinstellungen. Sie ist jedoch auf eine sehr kleine Menge an Informationen beschränkt.
iCloud Drive – Basiert auf den vorhandenen iCloud Documents-APIs und bietet eine einfache API zum Synchronisieren unstrukturierter Daten aus dem Dateisystem. Es bietet einen vollständigen Offlinecache auf Mac OS X und eignet sich hervorragend für dokumentorientierte Anwendungen.
iCloud Core Data – Ermöglicht die Replikation von Daten zwischen allen Geräten des Benutzers. Die Daten sind einzelbenutzer und hervorragend geeignet, private, strukturierte Daten synchron zu halten.
CloudKit – Stellt öffentliche Daten sowohl Struktur als auch Massen bereit und kann sowohl große Datasets als auch große unstrukturierte Dateien verarbeiten. Seine Verbindung mit dem iCloud-Konto des Benutzers und stellt die Datenübertragung durch den Kunden bereit.

Beachten Sie diese Anwendungsfälle, sollte der Entwickler die richtige iCloud-Technologie auswählen, um sowohl die aktuelle erforderliche Anwendungsfunktionalität bereitzustellen als auch eine gute Skalierbarkeit für zukünftiges Wachstum zu bieten.

Zusammenfassung

Dieser Artikel enthält eine kurze Einführung in die CloudKit-API. Es hat gezeigt, wie Eine Xamarin iOS-Anwendung für die Verwendung von CloudKit bereitgestellt und konfiguriert wird. Es hat die Features der CloudKit Convenience-API behandelt. Es zeigt, wie Sie eine CloudKit-aktivierte Anwendung zur Skalierbarkeit mithilfe von Abfragen und Abonnements entwerfen. Und schließlich wurden die Benutzerkontoinformationen angezeigt, die von CloudKit für eine Anwendung verfügbar gemacht werden.

Freigeben über

CloudKit in Xamarin.iOS

Anforderungen

Was ist CloudKit?

Aktivieren von CloudKit in einer Xamarin-Anwendung

Beispiel-App

Übersicht über die CloudKit-API

Container

Datenbanken

Datensätze

Datensatzzonen

Datensatzbezeichner

References

Objekte

CloudKit Convenience API

Allgemeiner Setupcode

Speichern eines Datensatzes

Abrufen eines Datensatzes

Aktualisieren eines Datensatzes

Entwerfen für Skalierbarkeit

Big Data, winziges Gerät

Abfragen

Unterstützte Prädikate

Erstellen von Abfragen

Ausführen einer Abfrage

Abonnements

Funktionsweise von Abonnements

Erstellen von Abonnements

Speichern von Abonnements

Behandeln von Pushbenachrichtigungen

CloudKit-Benutzerkonten

Authentifizierung

Benutzerkontoinformationen

Identität

Metadaten

Datenschutz

Ermittlung

Die Entwicklungs- und Produktionsumgebungen

Versenden einer aktivierten CloudKit-App

Gründe für die Verwendung von CloudKit

Anwendungsfälle

Zusammenfassung

Verwandte Links

Zusätzliche Ressourcen