CloudKit in Xamarin.iOS

Artikel
07/13/2023

Das CloudKit-Framework optimiert die Entwicklung von Anwendungen, die auf iCloud zugreifen. Dies umfasst den Abruf von Anwendungsdaten und Ressourcenrechten sowie die Möglichkeit, Anwendungsinformationen sicher zu speichern. Dieses Kit bietet Benutzern eine Ebene der Anonymität, indem es den Zugriff auf Anwendungen mit ihren iCloud-IDs ermöglicht, ohne persönliche Informationen zu teilen.

Entwickler können sich auf ihre clientseitigen Anwendungen konzentrieren und iCloud das Schreiben von serverseitiger Anwendungslogik erübrigen. CloudKit bietet Authentifizierung, private und öffentliche Datenbanken sowie strukturierte Daten- und Ressourcenspeicherdienste.

Wichtig

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

Anforderungen

Zum Ausführen der in diesem Artikel beschriebenen Schritte ist Folgendes erforderlich:

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, entwicklern Zugriff auf die iCloud-Server zu gewähren. Es bildet 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 der öffentlichen als auch der privaten Datenbanken. Öffentliche Datenbanken bieten eine "Suppe" aller Daten, auf die der Benutzer Zugriff hat. 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 zu und von den iCloud-Servern im Hintergrund, wodurch sich der Entwickler auf andere Aufgaben konzentrieren kann.

Hinweis

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

Derzeit stellt Apple CloudKit zunächst kostenlos mit einer hohen Grenze für Bandbreite und Speicherkapazität bereit. Für größere Projekte oder Anwendungen mit einer großen Benutzerbasis hat Apple angedeutet, 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 Leitfäden Arbeiten mit Funktionen und Arbeiten mit Berechtigungen beschrieben.

Für den Zugriff auf CloudKit muss die Datei Entitlements.plistdie Berechtigungen "iCloud aktivieren", "Schlüssel-Wert-Speicher" und "CloudKit " enthalten.

Beispiel-App

Das CloudKitAtlas-Beispiel veranschaulicht die Verwendung von CloudKit mit Xamarin. Die folgenden Schritte zeigen, wie Sie das Beispiel konfigurieren– es sind zusätzliche Einstellungen erforderlich, die über die Anforderungen für CloudKit allein hinausgehen:

Öffnen Sie das Projekt in Visual Studio für Mac oder Visual Studio.
Öffnen Sie im Projektmappen-Explorer die Datei Info.plist, und stellen Sie sicher, dass der Bundle-Bezeichner mit dem in der App-ID definiert wurde, die im Rahmen der Bereitstellungseinrichtung erstellt wurde.
Scrollen Sie nach unten in der Datei Info.plist, und wählen Sie Aktivierte Hintergrundmodi, Speicherort Updates und Remotebenachrichtigungen aus.
Klicken Sie in der Projektmappe mit der rechten Maustaste auf das iOS-Projekt, und wählen Sie Optionen aus.
Wählen Sie iOS-Bundlesignatur und dann die oben erstellte Entwickleridentität und das Bereitstellungsprofil aus.
Stellen Sie sicher , dass Entitlements.plistiCloud aktivieren, Schlüssel-Wert-Speicher und CloudKit enthält.
Stellen Sie sicher, dass der Ubiquity-Container für die Anwendung vorhanden ist. Ein Beispiel: iCloud.com.your-company.CloudKitAtlas
Speichern Sie die Änderungen in der Datei.

Nachdem diese Einstellungen vorhanden sind, kann die Beispiel-App jetzt auf die CloudKit Framework-APIs sowie auf Hintergrund-, Standort- und Benachrichtigungsdienste zugreifen.

Übersicht über die CloudKit-API

Vor der Implementierung von CloudKit in einer Xamarin iOS-Anwendung behandelt dieser Artikel die Grundlagen des CloudKit-Frameworks, das die folgenden Themen enthält:

Container : Isolierte Silos der iCloud-Kommunikation.
Datenbanken : Öffentliche und private Datenbanken sind für die Anwendung verfügbar.
Datensätze : Der Mechanismus, bei dem strukturierte Daten in und aus CloudKit verschoben werden.
Datensatzzonen : Sind Gruppen von Datensätzen.
Datensatzbezeichner : Sind vollständig normalisiert und stellen den spezifischen Speicherort des Datensatzes dar.
Verweis : Stellen Sie Beziehungen zwischen über- und untergeordneten Elementen zwischen verknüpften Datensätzen innerhalb einer bestimmten Datenbank bereit.
Assets : Ermöglicht das Hochladen einer Datei mit großen, unstrukturierten Daten in iCloud und das Zuordnen zu einem bestimmten Datensatz.

Container

Eine bestimmte Anwendung, die auf einem iOS-Gerät ausgeführt wird, wird immer zusammen mit anderen Anwendungen und Diensten auf diesem Gerät ausgeführt. Auf dem Clientgerät wird die Anwendung in irgendeiner Weise isoliert oder sandkastenweise verwendet. In einigen Fällen ist dies eine literale Sandbox, und in anderen wird die Anwendung einfach im eigenen Speicherplatz ausgeführt.

Das Konzept, eine Clientanwendung zu verwenden und getrennt von anderen Clients auszuführen, 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, können 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 zu bieten und sie auf die Arbeit mit cloudbasierten Informationen anzuwenden:

Genau wie die Anwendung eine von vielen ist, die auf dem Gerät ausgeführt wird, ist auch die Kommunikation der Anwendung mit iCloud one-of-many. Jedes dieser verschiedenen Kommunikationssilos wird als Container bezeichnet.

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

Die Containerisierung von iCloud-Daten ermöglicht es CloudKit auch, Benutzerinformationen zu kapseln. Auf diese Weise hat die Anwendung eingeschränkten Zugriff auf das iCloud-Konto und die darin gespeicherten Benutzerinformationen, während gleichzeitig die Privatsphäre und Sicherheit des Benutzers geschützt wird.

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

Apple schlägt vor, beim Erstellen des Namespace für Anwendungscontainer die Verwendung von Reverse-DNS-Notation zu verwenden. Ein Beispiel: iCloud.com.company-name.application-name

Obwohl Container standardmäßig 1:1 an eine bestimmte Anwendung gebunden sind, können sie anwendungsübergreifend gemeinsam genutzt werden. Daher können mehrere Anwendungen auf einem einzelnen Container koordinieren. Eine einzelne Anwendung kann auch mit mehreren Containern kommunizieren.

Datenbanken

Eine der wichtigsten Funktionen von CloudKit besteht darin, das Datenmodell und die Replikation einer Anwendung auf die iCloud-Server zu übertragen. Einige Informationen sind für den Benutzer bestimmt, der sie erstellt hat. Andere Informationen sind öffentliche Daten, die von einem Benutzer zur öffentlichen Verwendung erstellt werden können (z. B. eine Restaurantüberprüfung), oder es können Informationen sein, 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 befindet sich in erster Linie die öffentliche Datenbank. Hier leben und vermeinen sich alle Informationen der Öffentlichkeit. Darüber hinaus gibt es mehrere private Datenbanken für jeden Benutzer der Anwendung.

Bei der Ausführung auf einem iOS-Gerät hat die Anwendung nur Zugriff auf die Informationen für den aktuell angemeldeten iCloud-Benutzer. Daher sieht die Anwendung den Container wie folgt aus:

Es können nur die öffentliche Datenbank und die private Datenbank angezeigt werden, die dem derzeit 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 aufgeführt:

	Ö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
Bearbeiten von Berechtigungen	iCloud-Dashboardrollen über eine Datensatzklassenebene	–

Datensätze

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

Datensätze werden im CloudKit-Framework über die CKRecord -Klasse verfügbar gemacht, die Schlüssel-Wert-Paare umschließt. Eine instance eines Objekts in einer Anwendung entspricht einem CKRecord in CloudKit. Darüber hinaus besitzt jede CKRecord einen Datensatztyp, der der Klasse eines Objekts entspricht.

Datensätze weisen ein Just-in-Time-Schema auf, sodass die Daten an CloudKit beschrieben werden, bevor sie zur Verarbeitung übergeben werden. Von diesem Punkt an interpretiert CloudKit die Informationen und übernimmt die Logistik der Speicherung und des Abrufs des Datensatzes.

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

Datensätze enthalten das Konzept eines Änderungstags. Dies ist eine frühere Version einer Revision eines bestimmten Datensatzes. Das Änderungstag wird als einfache Methode verwendet, um zu bestimmen, ob der Client und der Server über die gleiche Version eines bestimmten Datensatzes verfügen.

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

NSString
NSNumber
NSData
NSDate
CLLocation
CKReferences
CKAssets

Zusätzlich zu den einzelnen Werttypen 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);

Aufzeichnen von Zonen

Datensätze sind in einer bestimmten Datenbank nicht selbst vorhanden – Gruppen von Datensätzen sind innerhalb 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 Standardeintragszone:

Hier werden Datensätze standardmäßig gespeichert. Darüber hinaus können benutzerdefinierte Datensatzzonen erstellt werden. Datensatzzonen stellen die Basisgranularität dar, mit der Atomic Commits und Änderungsnachverfolgung ausgeführt werden.

Datensatzbezeichner

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

Sie werden von der Clientanwendung erstellt.
Sie sind vollständig normalisiert und stellen die spezifische Position des Datensatzes dar.
Durch Zuweisen der eindeutigen ID eines Datensatzes in einer fremden Datenbank zum Namen des Datensatzes 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 wird, 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 Standardeintragszone verwendet.

Datensatzbezeichner werden im CloudKit-Framework über die CKRecordID -Klasse verfügbar gemacht. Der folgende Code kann verwendet werden, um einen neuen Datensatzbezeichner zu erstellen:

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

Referenzen

Verweise stellen Beziehungen zwischen verknüpften Datensätzen innerhalb einer bestimmten Datenbank bereit:

Im obigen Beispiel besitzen Eltern Kinder, sodass child ein untergeordneter Datensatz des übergeordneten Datensatzes ist. Die Beziehung wechselt vom untergeordneten Datensatz zum übergeordneten Datensatz und wird als Zurückverweis 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) automatisch auch aus der Datenbank gelöscht.

Hinweis

Dangling-Zeiger sind eine Möglichkeit, wenn Sie CloudKit verwenden. Wenn die Anwendung beispielsweise eine Liste von Datensatzzeigern abgerufen, einen Datensatz ausgewählt und dann nach dem Datensatz gefragt hat, 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 Rückverweise bevorzugt, wenn Sie mit dem CloudKit-Framework arbeiten. Apple hat das System optimiert, um dies zur effizientesten Referenzart 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 ein Datensatzbezeichner verwendet wird und der angegebene Verweis in der Datenbank nicht vorhanden war, wird ein Dangling-Zeiger erstellt.

Im Folgenden finden Sie ein Beispiel für das Erstellen eines Verweises auf einen bekannten Datensatz:

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

Objekte

Ressourcen ermöglichen es, eine Datei mit großen, unstrukturierten Daten in iCloud hochzuladen und einem bestimmten Datensatz zuzuordnen:

Auf dem Client wird eine CKRecord erstellt, die die Datei beschreibt, die auf den iCloud-Server hochgeladen werden soll. Ein CKAsset wird erstellt, um die Datei zu enthalten, und ist 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. Zwischen dem Datensatzzeiger und der hochgeladenen Datei wird ein Link 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 Assets mithilfe von Dateien auf dem Datenträger implementiert.

Ressourcen sind im Besitz von Datensätzen, wodurch die Ressourcen aus iCloud abgerufen werden können, indem der Datensatz als Zeiger verwendet wird. Auf diese Weise kann der Server Garbage Collect Assets durchführen, wenn der Datensatz, der das Medienobjekt besitzt, gelöscht wird.

Da CKAssets große Datendateien verarbeitet werden sollen, hat Apple CloudKit entwickelt, um die Assets effizient hoch- und herunterzuladen.

Der folgende Code kann verwendet werden, um ein Medienobjekt zu erstellen und es 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 von Datensatzbezeichnern verwiesen wird. Beziehungen zwischen über- und untergeordneten Elementen werden zwischen Datensätzen mithilfe von Verweisen definiert. Schließlich können mithilfe von Assets große Dateien 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.
Convenience-API : Bietet eine gemeinsame, vorkonfigurierte Teilmenge der CloudKit-Features. Es bietet eine bequeme, einfache Zugriffslösung für die Einbindung 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. Im weiteren Verlauf dieses Abschnitts werden die folgenden Themen der Convenience-API behandelt:

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

Allgemeiner Setupcode

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

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, um die Arbeit mit ihnen im Rest der Anwendung zu erleichtern.

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

using CloudKit;
//...

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

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

Mit diesem Code sehen wir uns die Implementierung der CloudKit-Convenience-API in einer Xamarin iOS 8-Anwendung an.

Speichern eines Datensatzes

Bei Verwendung des obigen Musters bei der Besprechung 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 beim obigen Code beachten müssen:

Durch Aufrufen der SaveRecord -Methode PublicDatabasemuss der Entwickler nicht angeben, wie die Daten gesendet werden, in welche Zone sie geschrieben werden usw. Die Convenience-API kümmert sich um all diese Details selbst.
Der Aufruf ist asynchron und stellt eine Rückrufroutine bereit, wenn der Aufruf entweder erfolgreich oder fehlgeschlagen ist. Wenn der Aufruf fehlschlägt, wird eine Fehlermeldung angezeigt.
CloudKit bietet keinen lokalen Speicher/Persistenz. es ist nur ein Übertragungsmedium. Wenn also eine Anforderung zum Speichern eines Datensatzes gestellt wird, wird dieser sofort an die iCloud-Server gesendet.

Hinweis

Aufgrund des "Verlusts" der Mobilfunkkommunikation, bei der Verbindungen ständig unterbrochen oder unterbrochen werden, ist eine der ersten Überlegungen, die der Entwickler bei der Arbeit mit CloudKit machen muss, die Fehlerbehandlung.

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 große 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 gibt einen zurück CKRecord , wenn der Aufruf erfolgreich war. Die Anwendung ändert dann den Datensatz und ruft erneut auf SaveRecord , um die Änderungen zurück in die Datenbank zu schreiben.

In diesem Abschnitt wurde 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 damit gearbeitet wird. Dieser Ansatz funktioniert zwar gut mit einer kleinen Datenmenge und einer sehr kleinen Benutzerbasis, kann jedoch nicht gut skaliert werden, wenn die Menge an Informationen und/oder die Benutzerbasis zunimmt.

Big Data, winziges Gerät

Je beliebter eine Anwendung wird, desto mehr Daten sind in der Datenbank vorhanden und desto weniger ist es möglich, einen Cache mit den gesamten Daten auf dem Gerät zu haben. Die folgenden Techniken können verwendet werden, um dieses Problem zu lösen:

Behalten Sie die großen Daten in der Cloud bei – CloudKit wurde entwickelt, um große Daten effizient zu verarbeiten.
Der Client sollte nur einen Slice dieser Daten anzeigen : Reduzieren Sie das minimum an Daten, die zum Verarbeiten einer Aufgabe zu einem bestimmten Zeitpunkt erforderlich sind.
Clientansichten können sich ändern : Da jeder Benutzer unterschiedliche Einstellungen hat, kann sich der angezeigte Datenschnitt von Benutzer zu Benutzer ändern, und die individuelle Ansicht des Benutzers für einen bestimmten Slice kann unterschiedlich sein.
Client verwendet Abfragen, um den Standpunkt zu fokussieren : 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 es 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 Sort-Deskriptor ( NSSortDescriptors). CloudKit unterstützt die meisten von NSPredicate.

Unterstützte Prädikate

CloudKit unterstützt die folgenden Arten von bei der NSPredicates Arbeit mit Abfragen:

Übereinstimmende Datensätze, bei denen der Name einem wert entspricht, der in einer Variablen gespeichert ist:
```
NSPredicate.FromFormat(string.Format("name = '{0}'", recordName))
```
Ermöglicht den Abgleich auf grundlage eines dynamischen Schlüsselwerts, sodass der Schlüssel zur Kompilierzeit nicht bekannt sein 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 sich der Standort von Record innerhalb von 100 Metern vom angegebenen Standort befindet:

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. Durch diesen Aufruf werden zwei Token erstellt, eines für after und ein anderes 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 verbundbasierte Prädikate, die mit dem AND Operator verknüpft sind.

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

Erstellen von Abfragen

Der folgende Code kann verwendet werden, um eine CKQuery in einer Xamarin iOS 8-Anwendung zu erstellen:

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 angegebenen 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 übernimmt 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 von CKRecords zurückgegeben, das den Parametern der Abfrage entspricht.

Die Möglichkeit, sich über Abfragen gedanken zu machen, besteht darin, dass es sich um Umfragen handelt und sich hervorragend durch große Datasets schneiden lässt. Abfragen eignen sich jedoch aus folgenden Gründen nicht gut für große, meist statische Datasets:

Sie sind schlecht für die Akkulaufzeit des Geräts.
Sie sind schlecht für den Netzwerkdatenverkehr.
Sie sind schlecht für die Benutzerfreundlichkeit, da die angezeigten Informationen dadurch eingeschränkt sind, wie oft die Anwendung die Datenbank abruft. 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 im Auftrag des Clients auf dem Server ausgeführt werden. Die Abfrage sollte im Hintergrund ausgeführt und nach jedem einzelnen Datensatzspeicher 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 im CloudKit-Framework über die CKSubscription -Klasse verfügbar gemacht. Sie kombinieren einen Datensatztyp ( RecordType), ein Prädikat ( NSPredicate) und eine Apple-Pushbenachrichtigung ( Push).

Hinweis

CloudKit-Pushvorgänge werden leicht erweitert, da sie eine Nutzlast enthalten, die CloudKit-spezifische Informationen enthält, z. B. was den Push verursacht hat.

Funktionsweise von Abonnements

Bevor Sie das Abonnement in C#-Code implementieren, können Sie sich einen kurzen Überblick über die Funktionsweise von Abonnements verschaffen:

Das obige Diagramm zeigt den typischen Abonnementprozess wie folgt:

Das Clientgerät erstellt ein neues Abonnement mit den Bedingungen, die das Abonnement auslösen, und eine Pushbenachrichtigung, die gesendet wird, wenn der Trigger auftritt.
Das Abonnement wird an die Datenbank gesendet, wo 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 mit einer ihrer Bedingungen übereinstimmt.
Wenn eine Übereinstimmung gefunden wird, wird die Pushbenachrichtigung an das Gerät gesendet, das das Abonnement registriert hat, mit Informationen zum Datensatz, durch den es ausgelöst wurde.

Mit diesem Wissen sehen wir uns das Erstellen von Abonnements in einer Xamarin iOS 8-Anwendung an.

Erstellen von Abonnements

Der folgende Code kann verwendet werden, um ein Abonnement zu erstellen:

// 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 wird das Abonnement für einen bestimmten Datensatztyp erstellt und die Option festgelegt, wann der Trigger getestet wird. Schließlich definiert es den Typ der Benachrichtigung, die beim Auslösen des Abonnements auftritt, und fügt es dem Abonnement an.

Speichern von Abonnements

Nachdem das Abonnement erstellt wurde, wird es mit dem 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 die AppDelegate.csReceivedRemoteNotification -Klasse in der wie folgt:

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

Im obigen Code wird CloudKit aufgefordert, die userInfo in eine CloudKit-Benachrichtigung zu analysieren. Als Nächstes werden Informationen zur Warnung extrahiert. Schließlich wird der Benachrichtigungstyp getestet und die Benachrichtigung entsprechend behandelt.

In diesem Abschnitt wurde gezeigt, wie Sie das oben beschriebene Big Data-Problem mit winzigen Geräten mithilfe von Abfragen und Abonnements beantworten. Die Anwendung belässt ihre großen Daten in der Cloud und verwendet diese Technologien, um Ansichten in dieses Dataset bereitzustellen.

CloudKit-Benutzerkonten

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

Authentifizierung

Beim Umgang mit Benutzerkonten ist die erste Überlegung 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 sich Entwickler 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, Informationen zu Benutzern zu speichern und abzurufen.
Datenschutz – Alle Informationen werden in einem datenschutzbewussten Herrenhaus behandelt. Es wird nichts verfügbar gemacht, es sei denn, der Benutzer hat zugestimmt.
Ermittlung : Bietet Benutzern die Möglichkeit, ihre Freunde zu entdecken, die dieselbe Anwendung verwenden.

Als Nächstes befassen wir uns mit diesen Themen im Detail.

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 umfangreichen Speicher für Benutzerinformationen. Und da iCloud den Container tatsächlich hostt, können Benutzer korrelieren. In der obigen Grafik der Benutzer, dessen iCloud-Konto user@icloud.com mit dem aktuellen Client verknüpft ist.

Auf Container by Container-Basis 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 in beliebiger Weise verwendet werden, die der Entwickler für richtig hält.

Hinweis

Verschiedene Anwendungen, die auf demselben Gerät für denselben iCloud-Benutzer ausgeführt werden, verfügen über unterschiedliche Benutzer-IDs, 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;
    }
});

Im obigen Code wird der CloudKit-Container aufgefordert, die ID des aktuell angemeldeten Benutzers anzugeben. Da diese Informationen vom iCloud-Server stammen, ist der Aufruf asynchron, und die Fehlerbehandlung ist 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 in der öffentlichen Datenbank, einen für jeden Benutzer des Containers. Einer davon verfügt über eine Datensatz-ID, die mit der Datensatz-ID des aktuell angemeldeten Benutzers übereinstimmt.

Benutzerdatensätze in der öffentlichen Datenbank sind weltweit lesbar. Sie werden größtenteils als gewöhnlicher Datensatz behandelt und weisen einen Typ von auf CKRecordTypeUserRecord. Diese Datensätze werden vom System reserviert und stehen nicht für Abfragen 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 dessen ID wir oben zugegriffen haben. Da diese Informationen vom iCloud-Server stammen, ist der Aufruf asynchron, und die Fehlerbehandlung ist erforderlich.

Datenschutz

CloudKit wurde standardmäßig so gestaltet, dass die Privatsphäre des aktuell angemeldeten Benutzers geschützt wird. Standardmäßig werden keine personenbezogenen Informationen über den Benutzer verfügbar gemacht. Es gibt einige Fälle, in denen die Anwendung begrenzte Informationen über den Benutzer erfordert.

In diesen Fällen kann die Anwendung anfordern, dass der Benutzer diese Informationen offenlegt. Dem Benutzer wird ein Dialogfeld angezeigt, in dem er aufgefordert wird, sich für die Offenlegung seiner Kontoinformationen zu entscheiden.

Ermittlung

Unter der Annahme, dass der Benutzer als angemeldet ist, der Anwendung eingeschränkten Zugriff auf seine Benutzerkontoinformationen zu gewähren, können sie für andere Benutzer der Anwendung auffindbar sein:

Die Clientanwendung spricht mit einem Container, und der Container spricht iCloud, um auf Benutzerinformationen zuzugreifen. Der Benutzer kann eine E-Mail-Adresse angeben, 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 auch eine Möglichkeit, Informationen zu jedem Benutzer zu ermitteln, der mit dem aktuell angemeldeten iCloud-Benutzer befreundet sein könnte, indem das gesamte Adressbuch abgefragt wird. Der CloudKit-Prozess ruft das Kontaktbuch des Benutzers ein und verwendet die E-Mail-Adressen, um zu ermitteln, ob andere Benutzer der Anwendung gefunden werden können, 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. Zu keinem Zeitpunkt werden die Kontaktinformationen für die Anwendung zur Verfügung gestellt, nur der CloudKit-Prozess hat Zugriff.

Zur Zusammenfassung stehen drei verschiedene Arten von Eingaben für die Benutzerermittlung zur Verfügung:

Benutzerdatensatz-ID : Die Ermittlung kann für die Benutzer-ID des aktuell angemeldeten CloudKit-Benutzers durchgeführt werden.
Benutzer Email Adresse: Der Benutzer kann eine E-Mail-Adresse angeben, die für die Ermittlung verwendet werden kann.
Kontaktbuch : Das Adressbuch des Benutzers kann verwendet werden, um Benutzer der Anwendung zu ermitteln, die die gleiche E-Mail-Adresse wie in ihren Kontakten angegeben haben.

Die Benutzerermittlung gibt die folgenden Informationen zurück:

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

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

Der folgende Code ermittelt Informationen zu dem Benutzer, der sich derzeit auf dem Gerät bei iCloud angemeldet hat:

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 über die in CloudKit integrierten Datenschutzrichtlinien und schließlich die Möglichkeit, andere Benutzer der Anwendung zu ermitteln.

Entwicklungs- und Produktionsumgebungen

CloudKit bietet separate Entwicklungs- und Produktionsumgebungen für die Datensatztypen und Daten einer Anwendung. 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 mit dem neuen Typ erneut hinzufügen.

Vor der Bereitstellung der Anwendung kann der Entwickler sein Schema und seine Daten mithilfe des CloudKit-Dashboards in die Produktionsumgebung migrieren. Beim Ausführen für die Produktionsumgebung verhindert der Server, dass eine Anwendung das Schema programmgesteuert ändert. Der Entwickler kann weiterhin Änderungen mit dem 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.

Versand einer CloudKit-fähigen App

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

Gehen Sie folgendermaßen vor:

Kompilieren Sie in Visual Studio für Ma die Anwendung für Release>iOS Device:
Wählen Sie im Menü Erstellendie Option Archiv aus:
Das Archiv wird erstellt und in Visual Studio für Mac angezeigt:
Starten Sie Xcode.
Wählen Sie im Menü Fensterdie Option Organizer 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 in der Dropdownliste Produktion 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 ist ähnlich, wenn Sie die Anwendung direkt an iTunes Connect übermitteln. Klicken Sie einfach auf die Schaltfläche Senden... anstatt auf exportieren... nachdem Sie im Fenster Organizer ein Archiv ausgewählt haben.

Wann CloudKit verwendet werden sollte

Wie wir in diesem Artikel gesehen haben, bietet CloudKit eine einfache Möglichkeit für eine Anwendung, Informationen zu speichern und von den iCloud-Servern abzurufen. Allerdings veraltet CloudKit keine vorhandenen Tools oder Frameworks.

Anwendungsfälle

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

iCloud Key-Value Store : Hält kleine Datenmengen asynchron auf dem neuesten Stand und eignet sich hervorragend für die Arbeit mit Anwendungseinstellungen. Sie ist jedoch für eine sehr kleine Menge an Informationen eingeschränkt.
iCloud Drive – Basiert auf den vorhandenen iCloud-Dokument-APIs und bietet eine einfache API zum Synchronisieren unstrukturierter Daten aus dem Dateisystem. Es bietet einen vollständigen Offlinecache unter Mac OS X und eignet sich hervorragend für dokumentorientierte Anwendungen.
iCloud Core-Daten : Ermöglicht die Replikation von Daten zwischen allen Geräten des Benutzers. Die Daten sind Einzelbenutzer und ideal für die Synchronisierung privater, strukturierter Daten.
CloudKit : Stellt öffentliche Daten sowohl Struktur als auch Massendaten bereit und kann sowohl große Datasets als auch große unstrukturierte Dateien verarbeiten. Es ist an das iCloud-Konto des Benutzers gebunden und ermöglicht die clientgesteuerte Datenübertragung.

Unter Berücksichtigung dieser Anwendungsfälle sollte der Entwickler die richtige iCloud-Technologie auswählen, um sowohl die aktuell 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 wurde gezeigt, wie Sie eine Xamarin iOS-Anwendung für die Verwendung von CloudKit bereitstellen und konfigurieren. Sie hat die Features der CloudKit-Convenience-API behandelt. Es wurde gezeigt, wie Sie eine CloudKit-fähige Anwendung für die Skalierbarkeit mithilfe von Abfragen und Abonnements entwerfen. Schließlich wurden die Benutzerkontoinformationen angezeigt, die von CloudKit für eine Anwendung verfügbar gemacht werden.

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

Aufzeichnen von Zonen

Datensatzbezeichner

Referenzen

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

Entwicklungs- und Produktionsumgebungen

Versand einer CloudKit-fähigen App

Wann CloudKit verwendet werden sollte

Anwendungsfälle

Zusammenfassung

Verwandte Links

Zusätzliche Ressourcen