Zestaw CloudKit w środowisku Xamarin.iOS

Artykuł
05/11/2016

Struktura CloudKit usprawnia tworzenie aplikacji, które uzyskują dostęp do usługi iCloud. Obejmuje to pobieranie danych aplikacji i praw do zasobów, a także możliwość bezpiecznego przechowywania informacji o aplikacji. Ten zestaw zapewnia użytkownikom warstwę anonimowości, umożliwiając dostęp do aplikacji przy użyciu identyfikatorów iCloud bez udostępniania informacji osobistych.

Deweloperzy mogą skupić się na aplikacjach po stronie klienta i pozwolić usłudze iCloud wyeliminować konieczność pisania logiki aplikacji po stronie serwera. Zestaw CloudKit zapewnia uwierzytelnianie, prywatne i publiczne bazy danych oraz ustrukturyzowane usługi magazynu danych i zasobów.

Ważne

Firma Apple udostępnia narzędzia pomagające deweloperom w prawidłowym obsłudze ogólnego rozporządzenia o ochronie danych (RODO) Unii Europejskiej.

Wymagania

Do wykonania kroków przedstawionych w tym artykule są wymagane następujące czynności:

Xcode i zestaw SDK systemu iOS — interfejsy API Xcode i iOS 8 firmy Apple muszą być zainstalowane i skonfigurowane na komputerze dewelopera.
Visual Studio dla komputerów Mac — najnowsza wersja Visual Studio dla komputerów Mac powinna być zainstalowana i skonfigurowana na urządzeniu użytkownika.
Urządzenie z systemem iOS 8 — urządzenie z systemem iOS z najnowszą wersją systemu iOS 8 na potrzeby testowania.

Co to jest CloudKit?

CloudKit to sposób na zapewnienie deweloperom dostępu do serwerów iCloud. Stanowi podstawę zarówno dla dysków iCloud, jak i biblioteki zdjęć iCloud. Zestaw CloudKit jest obsługiwany zarówno na urządzeniach z systemem macOS, jak i iOS.

Zestaw CloudKit używa infrastruktury konta usługi iCloud. Jeśli na urządzeniu zalogowano użytkownika do konta usługi iCloud, zestaw CloudKit użyje swojego identyfikatora, aby zidentyfikować użytkownika. Jeśli żadne konto nie jest dostępne, zostanie udostępniony ograniczony dostęp tylko do odczytu.

Zestaw CloudKit obsługuje zarówno koncepcję baz danych publicznych, jak i prywatnych. Publiczne bazy danych zapewniają "zupę" wszystkich danych, do których użytkownik ma dostęp. Prywatne bazy danych są przeznaczone do przechowywania prywatnych danych powiązanych z określonym użytkownikiem.

Zestaw CloudKit obsługuje zarówno dane ustrukturyzowane, jak i zbiorcze. Jest w stanie bezproblemowo obsługiwać duże transfery plików. Zestaw CloudKit efektywnie przenosi duże pliki do i z serwerów iCloud w tle, co zwalnia dewelopera w celu skoncentrowania się na innych zadaniach.

Uwaga

Należy pamiętać, że zestaw CloudKit jest technologią transportową. Nie zapewnia żadnej trwałości; umożliwia aplikacji wydajne wysyłanie i odbieranie informacji z serwerów.

W związku z tym pisaniem firma Apple początkowo udostępnia zestaw CloudKit bezpłatnie z wysokim limitem przepustowości i pojemności magazynu. W przypadku większych projektów lub aplikacji z dużą bazą użytkowników firma Apple zasugerowała, że zostanie udostępniona przystępna cenowo skala.

Włączanie zestawu CloudKit w aplikacji platformy Xamarin

Aby aplikacja Xamarin mogła korzystać z platformy CloudKit, aplikacja musi być poprawnie aprowizowana zgodnie z opisem w przewodnikach Praca z możliwościami i Praca z upoważnieniami .

Aby uzyskać dostęp do zestawu CloudKit, plik Entitlements.plist musi zawierać uprawnienia Enable iCloud, Key-value Storage i CloudKit .

Przykładowa aplikacja

Przykładowa aplikacja pokazuje, jak używać zestawu CloudKit z platformą Xamarin. W poniższych krokach pokazano, jak skonfigurować przykład — wymaga to dodatkowych ustawień poza wymaganiami biblioteki CloudKit:

Otwórz projekt w programie Visual Studio dla komputerów Mac lub Visual Studio.
W Eksplorator rozwiązań otwórz plik Info.plist i upewnij się, że identyfikator pakietu jest zgodny z identyfikatorem zdefiniowanym w identyfikatorze aplikacji utworzonym w ramach konfiguracji aprowizacji.
Przewiń w dół do dołu pliku Info.plist i wybierz pozycję Włączone tryby tła, Lokalizacja Aktualizacje i Powiadomienia zdalne.
Kliknij prawym przyciskiem myszy projekt systemu iOS w rozwiązaniu i wybierz pozycję Opcje.
Wybierz pozycję Podpisywanie pakietu dla systemu iOS, wybierz utworzony powyżej profil tożsamości dewelopera i aprowizacji.
Upewnij się, że plik Entitlements.plist zawiera pozycje Enable iCloud, Key-value Storage i CloudKit.
Upewnij się, że kontener Ubiquity istnieje dla aplikacji. Przykład: iCloud.com.your-company.CloudKitAtlas
Zapisz zmiany w pliku.

Dzięki tym ustawieniom przykładowa aplikacja jest teraz gotowa do uzyskiwania dostępu do interfejsów API platformy CloudKit Framework, a także w tle, lokalizacji i usług powiadomień.

Omówienie interfejsu API zestawu CloudKit

Przed zaimplementowaniem biblioteki CloudKit w aplikacji platformy Xamarin dla systemu iOS ten artykuł obejmuje podstawy struktury CloudKit Framework, które będą zawierać następujące tematy:

Kontenery — izolowane silosy komunikacji z usługą iCloud.
Bazy danych — publiczne i prywatne są dostępne dla aplikacji.
Records — mechanizm, w którym dane ustrukturyzowane są przenoszone do i z zestawu CloudKit.
Strefy rekordów — to grupy rekordów.
Identyfikatory rekordów — są w pełni znormalizowane i reprezentują określoną lokalizację rekordu.
Odwołanie — podaj relacje nadrzędny-podrzędny między powiązanymi rekordami w ramach danej bazy danych.
Zasoby — umożliwia przekazywanie dużych, nieustrukturyzowanych danych do usługi iCloud i skojarzonych z danym rekordem.

Kontenery

Dana aplikacja uruchomiona na urządzeniu z systemem iOS zawsze działa razem z innymi aplikacjami i usługami na tym urządzeniu. Na urządzeniu klienckim aplikacja będzie w jakiś sposób silosowana lub w trybie piaskownicy. W niektórych przypadkach jest to piaskownica literału, a w innych aplikacja jest po prostu uruchomiona we własnej przestrzeni pamięci.

Koncepcja przyjmowania aplikacji klienckiej i jej uruchamiania oddzielona od innych klientów jest bardzo zaawansowana i zapewnia następujące korzyści:

Zabezpieczenia — jedna aplikacja nie może zakłócać działania innych aplikacji klienckich ani samego systemu operacyjnego.
Stabilność — jeśli aplikacja kliencka ulegnie awarii, nie może wyjąć innych aplikacji systemu operacyjnego.
Prywatność — każda aplikacja kliencka ma ograniczony dostęp do danych osobowych przechowywanych w urządzeniu.

Zestaw CloudKit został zaprojektowany tak, aby zapewnić takie same korzyści jak wymienione powyżej i zastosować je do pracy z informacjami opartymi na chmurze:

Podobnie jak aplikacja będąca jednym z wielu uruchomiona na urządzeniu, dlatego komunikacja aplikacji z usługą iCloud jest jednym z wielu. Każdy z tych różnych silosów komunikacyjnych jest nazywany kontenerami.

Kontenery są uwidacznione w strukturze CloudKit Framework za pośrednictwem CKContainer klasy . Domyślnie jedna aplikacja komunikuje się z jednym kontenerem, a ten kontener segreguje dane dla tej aplikacji. Oznacza to, że kilka aplikacji może przechowywać informacje na tym samym koncie usługi iCloud, ale te informacje nigdy nie będą przeplatane.

Konteneryzacja danych usługi iCloud umożliwia również zestawowi CloudKit hermetyzowanie informacji o użytkowniku. W ten sposób aplikacja będzie miała ograniczony dostęp do konta usługi iCloud i przechowywanych w nich informacji o użytkowniku, jednocześnie chroniąc prywatność i bezpieczeństwo użytkownika.

Kontenery są w pełni zarządzane przez dewelopera aplikacji za pośrednictwem portalu WWDR. Przestrzeń nazw kontenera jest globalna dla wszystkich deweloperów firmy Apple, więc kontener musi być nie tylko unikatowy dla aplikacji danego dewelopera, ale dla wszystkich deweloperów i aplikacji firmy Apple.

Firma Apple sugeruje używanie odwrotnej notacji DNS podczas tworzenia przestrzeni nazw dla kontenerów aplikacji. Przykład: iCloud.com.company-name.application-name

Kontenery są domyślnie powiązane z jedną do jednej aplikacji, ale mogą być współużytkowane przez aplikacje. W związku z tym wiele aplikacji może koordynować jedną kontener. Jedna aplikacja może również komunikować się z wieloma kontenerami.

Bazy danych

Jedną z podstawowych funkcji zestawu CloudKit jest zastosowanie modelu danych i replikacji aplikacji, który modeluje do serwerów iCloud. Niektóre informacje są przeznaczone dla użytkownika, który go utworzył, inne informacje to dane publiczne, które mogą zostać utworzone przez użytkownika do użytku publicznego (na przykład recenzja restauracji) lub mogą to być informacje opublikowane przez dewelopera dla aplikacji. W obu przypadkach publiczność nie jest tylko pojedynczym użytkownikiem, ale jest społecznością osób.

W kontenerze przede wszystkim jest publiczna baza danych. Jest to miejsce, w którym wszystkie informacje publiczne żyją i współwłaścicielami. Ponadto istnieje kilka pojedynczych prywatnych baz danych dla każdego użytkownika aplikacji.

W przypadku uruchamiania na urządzeniu z systemem iOS aplikacja będzie miała dostęp tylko do informacji dla aktualnie zalogowanego użytkownika w usłudze iCloud. W związku z tym widok aplikacji kontenera będzie następujący:

Może ona wyświetlać tylko publiczną bazę danych i prywatną bazę danych skojarzona z aktualnie zalogowanym użytkownikiem usługi iCloud.

Bazy danych są udostępniane w strukturze CloudKit Framework za pośrednictwem CKDatabase klasy . Każda aplikacja ma dostęp do dwóch baz danych: publicznej bazy danych i prywatnej.

Kontener jest początkowym punktem wejścia do zestawu CloudKit. Poniższy kod może służyć do uzyskiwania dostępu do publicznej i prywatnej bazy danych z domyślnego kontenera aplikacji:

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;

Poniżej przedstawiono różnice między typami baz danych:

	Publiczna baza danych	Prywatna baza danych
Typ danych	Dane udostępnione	Dane bieżącego użytkownika
Norma	Uwzględniane w limitach przydziału dewelopera	Konto w ramach limitu przydziału użytkownika
Uprawnienia domyślne	World Readable	Czytelny dla użytkownika
Uprawnienia do edycji	Role pulpitu nawigacyjnego usługi iCloud za pośrednictwem poziomu klasy rekordu	Nie dotyczy

Rekordy

Kontenery przechowują bazy danych, a wewnątrz baz danych są rekordy. Rekordy to mechanizm, w którym dane ustrukturyzowane są przenoszone do i z zestawu CloudKit:

Rekordy są widoczne w strukturze CloudKit Framework za pośrednictwem CKRecord klasy, która opakowuje pary klucz-wartość. Wystąpienie obiektu w aplikacji jest równoważne elementowi CKRecord w zestawie CloudKit. Ponadto każdy z nich CKRecord posiada typ rekordu, który jest odpowiednikiem klasy obiektu.

Rekordy mają schemat just in time, więc dane są opisane w zestawie CloudKit przed przekazaniem do przetwarzania. Od tego momentu zestaw CloudKit zinterpretuje informacje i będzie obsługiwać logistykę przechowywania i pobierania rekordu.

Klasa CKRecord obsługuje również szeroką gamę metadanych. Na przykład rekord zawiera informacje o tym, kiedy został utworzony, oraz o użytkowniku, który go utworzył. Rekord zawiera również informacje o ostatniej modyfikacji i użytkowniku, który go zmodyfikował.

Rekordy zawierają pojęcie tagu zmiany. Jest to poprzednia wersja poprawki danego rekordu. Tag zmiany jest używany jako lekki sposób określania, czy klient i serwer mają tę samą wersję danego rekordu.

Jak wspomniano powyżej, CKRecords zawijanie par klucz-wartość i w związku z tym w rekordzie mogą być przechowywane następujące typy danych:

NSString
NSNumber
NSData
NSDate
CLLocation
CKReferences
CKAssets

Oprócz typów pojedynczej wartości rekord może zawierać homogeniczną tablicę dowolnego z powyższych typów.

Poniższy kod może służyć do tworzenia nowego rekordu i przechowywania go w bazie danych:

using CloudKit;
//...

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

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

Strefy rekordów

Rekordy nie istnieją samodzielnie w ramach danej bazy danych — grupy rekordów istnieją razem w strefie rekordów. Strefy rekordów można traktować jako tabele w tradycyjnych relacyjnych bazach danych:

W danej strefie rekordów może istnieć wiele rekordów i wiele stref rekordów w ramach danej bazy danych. Każda baza danych zawiera domyślną strefę rekordu:

Jest to miejsce, w którym rekordy są domyślnie przechowywane. Ponadto można tworzyć strefy rekordów niestandardowych. Strefy rekordów reprezentują stopień szczegółowości podstawowej, w której wykonywane są zatwierdzenia niepodzielne i śledzenie zmian.

Identyfikatory rekordów

Identyfikatory rekordów są reprezentowane jako krotka zawierająca zarówno podaną przez klienta nazwę rekordu, jak i strefę, w której istnieje rekord. Identyfikatory rekordów mają następujące cechy:

Są one tworzone przez aplikację klienczą.
Są one w pełni znormalizowane i reprezentują określoną lokalizację rekordu.
Przypisując unikatowy identyfikator rekordu w obcej bazie danych do nazwy rekordu, można ich użyć do łączenia lokalnych baz danych, które nie są przechowywane w zestawie CloudKit.

Podczas tworzenia nowych rekordów deweloperzy mogą zdecydować się na przekazanie identyfikatora rekordu. Jeśli nie określono identyfikatora rekordu, identyfikator UUID zostanie automatycznie utworzony i przypisany do rekordu.

Podczas tworzenia nowych identyfikatorów rekordów deweloperzy mogą określić strefę rekordu, do której będzie należeć każdy rekord. Jeśli żadna z nich nie zostanie określona, zostanie użyta domyślna strefa rekordu.

Identyfikatory rekordów są udostępniane w strukturze CloudKit Framework za pośrednictwem CKRecordID klasy . Do utworzenia nowego identyfikatora rekordu można użyć następującego kodu:

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

Informacje

Odwołania zapewniają relacje między powiązanymi rekordami w ramach danej bazy danych:

W powyższym przykładzie rodzice są właścicielami elementów podrzędnych, tak aby element Podrzędny był rekordem podrzędnym rekordu nadrzędnego. Relacja przechodzi z rekordu podrzędnego do rekordu nadrzędnego i jest nazywana odwołaniem wstecznym.

Odwołania są uwidocznione w strukturze CloudKit Framework za pośrednictwem CKReference klasy . Umożliwiają one serwerowi iCloud zrozumienie relacji między rekordami.

Odwołania zapewniają mechanizm usuwania kaskadowego. Jeśli rekord nadrzędny zostanie usunięty z bazy danych, wszystkie rekordy podrzędne (określone w relacji) również zostaną automatycznie usunięte z bazy danych.

Uwaga

Wskaźniki zwisające mogą być używane w zestawie CloudKit. Na przykład po pobraniu przez aplikację listy wskaźników rekordów wybrano rekord, a następnie poproszono o rekord, rekord może już nie istnieć w bazie danych. Aby można było bezpiecznie obsłużyć tę sytuację, należy zastosować kod aplikacji.

Chociaż nie są wymagane, odwołania wsteczne są preferowane podczas pracy z platformą CloudKit Framework. Firma Apple dostroiła system, aby był to najbardziej wydajny typ odwołania.

Podczas tworzenia odwołania deweloper może podać rekord, który jest już w pamięci, lub utworzyć odwołanie do identyfikatora rekordu. Jeśli używasz identyfikatora rekordu, a określone odwołanie nie istnieje w bazie danych, zostanie utworzony wskaźnik zwisania.

Poniżej przedstawiono przykład tworzenia odwołania do znanego rekordu:

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

Zasoby

Zasoby umożliwiają przekazywanie dużych, nieustrukturyzowanych danych do usługi iCloud i skojarzonych z danym rekordem:

Na kliencie tworzony jest element CKRecord opisujący plik, który ma zostać przekazany na serwer iCloud. Zostanie CKAsset utworzony element zawierający plik i jest połączony z rekordem opisującym go.

Po przekazaniu pliku na serwer rekord jest umieszczany w bazie danych, a plik jest kopiowany do specjalnej bazy danych magazynu zbiorczego. Zostanie utworzone łącze między wskaźnikiem rekordu a przekazanym plikiem.

Zasoby są udostępniane w strukturze CloudKit Framework za pośrednictwem CKAsset klasy i są używane do przechowywania dużych, nieustrukturyzowanych danych. Ponieważ deweloper nigdy nie chce mieć dużych, nieustrukturyzowanych danych w pamięci, zasoby są implementowane przy użyciu plików na dysku.

Zasoby są własnością rekordów, co umożliwia pobieranie zasobów z usługi iCloud przy użyciu rekordu jako wskaźnika. W ten sposób serwer może odśmiecać elementy zawartości podczas usuwania rekordu będącego właścicielem zasobu.

Ponieważ CKAssets są przeznaczone do obsługi dużych plików danych, firma Apple zaprojektowała zestaw CloudKit do wydajnego przekazywania i pobierania zasobów.

Poniższy kod może służyć do tworzenia elementu zawartości i kojarzenia go z rekordem:

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

Omówiliśmy teraz wszystkie podstawowe obiekty w zestawie CloudKit. Kontenery są skojarzone z aplikacjami i zawierają bazy danych. Bazy danych zawierają rekordy pogrupowane w strefy rekordów i wskazywane przez identyfikatory rekordów. Relacje nadrzędny-podrzędne są definiowane między rekordami przy użyciu odwołań. Na koniec duże pliki można przekazywać i kojarzyć z rekordami przy użyciu zasobów.

Interfejs API wygody zestawu CloudKit

Firma Apple oferuje dwa różne zestawy interfejsów API do pracy z zestawem CloudKit:

Interfejs API operacyjny — oferuje każdą pojedynczą funkcję zestawu CloudKit. W przypadku bardziej złożonych aplikacji ten interfejs API zapewnia szczegółową kontrolę nad zestawem CloudKit.
Interfejs API wygody — oferuje wspólny, wstępnie skonfigurowany podzestaw funkcji CloudKit. Zapewnia wygodne, łatwe rozwiązanie dostępu do funkcji CloudKit w aplikacji systemu iOS.

Interfejs API convenience jest zwykle najlepszym wyborem dla większości aplikacji systemu iOS, a firma Apple sugeruje rozpoczęcie od niego. W pozostałej części tej sekcji zostaną omówione następujące tematy dotyczące interfejsu API wygody:

Zapisywanie rekordu.
Pobieranie rekordu.
Aktualizowanie rekordu.

Wspólny kod konfiguracji

Przed rozpoczęciem pracy z interfejsem API wygody zestawu CloudKit wymagany jest standardowy kod konfiguracji. Zacznij od zmodyfikowania pliku aplikacji AppDelegate.cs i utwórz go w następujący sposób:

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

Powyższy kod uwidacznia publiczne i prywatne bazy danych CloudKit jako skróty, aby ułatwić im pracę w pozostałej części aplikacji.

Następnie dodaj następujący kod do dowolnego kontenera widoku lub widoku, który będzie używał biblioteki CloudKit:

using CloudKit;
//...

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

Spowoduje to dodanie skrótu umożliwiającego dostęp do AppDelegate skrótów do publicznej i prywatnej bazy danych utworzonej powyżej.

W tym kodzie przyjrzyjmy się implementacji interfejsu API CloudKit Convenience w aplikacji platformy Xamarin iOS 8.

Zapisywanie rekordu

Korzystając ze wzorca przedstawionego powyżej podczas omawiania rekordów, poniższy kod utworzy nowy rekord i użyje interfejsu API wygody, aby zapisać go w publicznej bazie danych:

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

Trzy kwestie do zanotowania powyższego kodu:

Wywołując metodę SaveRecordPublicDatabase, deweloper nie musi określać, w jaki sposób dane są wysyłane, do czego jest zapisywana strefa itp. Interfejs API Convenience zajmuje się wszystkimi tymi szczegółami.
Wywołanie jest asynchroniczne i zapewnia procedurę wywołania zwrotnego po zakończeniu wywołania z powodzeniem lub niepowodzeniem. Jeśli wywołanie zakończy się niepowodzeniem, zostanie podany komunikat o błędzie.
Zestaw CloudKit nie zapewnia magazynu lokalnego/trwałości; jest to tylko nośnik transferowy. Dlatego po wysłaniu żądania zapisania rekordu jest natychmiast wysyłany do serwerów iCloud.

Uwaga

Ze względu na "stratną" naturę komunikacji sieci komórkowej, w której połączenia są stale przerywane lub przerywane, jednym z pierwszych zagadnień, które deweloper musi wziąć pod uwagę podczas pracy z zestawem CloudKit, jest obsługa błędów.

Pobieranie rekordu

Po utworzeniu rekordu i pomyślnym zapisie na serwerze iCloud użyj następującego kodu, aby pobrać rekord:

// 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) {
        ...
    }
});

Podobnie jak w przypadku zapisywania rekordu powyższy kod jest asynchroniczny, prosty i wymaga doskonałej obsługi błędów.

Aktualizowanie rekordu

Po pobraniu rekordu z serwerów iCloud można użyć następującego kodu, aby zmodyfikować rekord i zapisać zmiany z powrotem w bazie danych:

// 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) {
                 ...
            }
        });
    }
});

FetchRecord Metoda metody zwraca wartość PublicDatabase , CKRecord jeśli wywołanie zakończyło się pomyślnie. Następnie aplikacja modyfikuje rekord i wywołuje SaveRecord ponownie, aby zapisać zmiany z powrotem w bazie danych.

W tej sekcji przedstawiono typowy cykl używany przez aplikację podczas pracy z interfejsem API Wygoda zestawu CloudKit. Aplikacja zapisze rekordy w usłudze iCloud, pobierze te rekordy z usługi iCloud, zmodyfikuje rekordy i zapisze te zmiany z powrotem w usłudze iCloud.

Projektowanie pod kątem skalowalności

Do tej pory w tym artykule opatrzono przechowywanie i pobieranie całego modelu obiektów aplikacji z serwerów iCloud, za każdym razem, gdy będzie ono działać. Chociaż takie podejście działa dobrze z niewielką ilością danych i bardzo małą bazą użytkowników, nie skaluje się dobrze, gdy ilość informacji i/lub bazy użytkowników wzrasta.

Dane big data, małe urządzenie

Tym bardziej popularna staje się aplikacja, tym więcej danych w bazie danych i tym mniej wykonalne jest posiadanie pamięci podręcznej tych całych danych na urządzeniu. Następujące techniki mogą służyć do rozwiązania tego problemu:

Zachowaj duże dane w chmurze — CloudKit zaprojektowano tak, aby wydajnie obsługiwać duże dane.
Klient powinien wyświetlić tylko wycinkę tych danych — obniżyć minimalną ilość danych potrzebnych do obsługi dowolnego zadania w danym momencie.
Widoki klientów mogą ulec zmianie — ponieważ każdy użytkownik ma różne preferencje, fragment wyświetlanych danych może zmienić się z użytkownika na użytkownika, a indywidualny widok danego wycinka może być inny.
Klient używa zapytań, aby skoncentrować punkt widzenia — zapytania umożliwiają użytkownikowi wyświetlanie małego podzbioru większego zestawu danych, który istnieje w chmurze.

Zapytania

Jak wspomniano powyżej, zapytania umożliwiają deweloperowi wybranie małego podzestawu większego zestawu danych, który istnieje w chmurze. Zapytania są uwidacznione w strukturze CloudKit Framework za pośrednictwem CKQuery klasy .

Zapytanie łączy trzy różne elementy: typ rekordu ( RecordType), predykat ( NSPredicate) i, opcjonalnie, deskryptor sortowania ( NSSortDescriptors). Zestaw CloudKit obsługuje większość elementów NSPredicate.

Obsługiwane predykaty

Zestaw CloudKit obsługuje następujące typy NSPredicates funkcji podczas pracy z zapytaniami:

Pasujące rekordy, w których nazwa jest równa wartości przechowywanej w zmiennej:
```
NSPredicate.FromFormat(string.Format("name = '{0}'", recordName))
```
Umożliwia dopasowywanie na podstawie wartości klucza dynamicznego, dzięki czemu klucz nie musi być wie w czasie kompilacji:
```
NSPredicate.FromFormat(string.Format("{0} = '{1}'", key, value))
```
Pasujące rekordy, w których wartość rekordu jest większa niż dana wartość:
```
NSPredicate.FromFormat(string.Format("start > {0}", (NSDate)date))
```

Pasujące rekordy, w których lokalizacja rekordu mieści się w odległości 100 metrów od danej lokalizacji:

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

Zestaw CloudKit obsługuje wyszukiwanie tokenizowane. To wywołanie spowoduje utworzenie dwóch tokenów, jeden dla after i drugi dla elementu session. Zostanie zwrócony rekord zawierający te dwa tokeny:
```
NSPredicate.FromFormat(string.Format("ALL tokenize({0}, 'Cdl') IN allTokens", "after session"))
```

Zestaw CloudKit obsługuje predykaty złożone przyłączone przy użyciu AND operatora .

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

Tworzenie zapytań

Poniższy kod może służyć do utworzenia elementu CKQuery w aplikacji platformy Xamarin dla systemu iOS 8:

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

Najpierw tworzy predykat, aby wybrać tylko rekordy zgodne z daną nazwą. Następnie tworzy zapytanie, które wybierze pozycję Rekordy danego typu rekordu zgodnego z predykatem.

Wykonywanie zapytania

Po utworzeniu zapytania użyj następującego kodu, aby wykonać zapytanie i przetworzyć zwrócone rekordy:

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

Powyższy kod pobiera utworzone powyżej zapytanie i wykonuje je względem publicznej bazy danych. Ponieważ żadna strefa rekordu nie jest określona, wszystkie strefy są przeszukiwane. Jeśli nie wystąpią żadne błędy, zostanie zwrócona tablica CKRecords odpowiadająca parametrom zapytania.

Sposób myślenia o zapytaniach polega na tym, że są one sondami i doskonale nadają się do fragmentowania dużych zestawów danych. Jednak zapytania nie są odpowiednie dla dużych, głównie statycznych zestawów danych z następujących powodów:

Są one złe dla żywotność baterii urządzenia.
Są one złe dla ruchu sieciowego.
Są one złe w przypadku środowiska użytkownika, ponieważ informacje, które widzą, są ograniczone przez częstotliwość sondowania bazy danych przez aplikację. Użytkownicy oczekują dziś powiadomień wypychanych, gdy coś się zmieni.

Subskrypcje

W przypadku obsługi dużych, głównie statycznych zestawów danych zapytanie nie powinno być wykonywane na urządzeniu klienckim, powinno być uruchamiane na serwerze w imieniu klienta. Zapytanie powinno być uruchamiane w tle i powinno być wykonywane po każdym zapisie pojedynczego rekordu, zarówno przez bieżące urządzenie, jak i inne urządzenie dotykające tej samej bazy danych.

Na koniec powiadomienie wypychane powinno być wysyłane do każdego urządzenia dołączonego do bazy danych po uruchomieniu zapytania po stronie serwera.

Subskrypcje są udostępniane w strukturze CloudKit Framework za pośrednictwem CKSubscription klasy . Łączą one typ rekordu ( RecordType), predykat ( NSPredicate) i apple push notification ( Push).

Uwaga

Wypychania zestawu CloudKit są nieco rozszerzone, ponieważ zawierają ładunek zawierający informacje specyficzne dla zestawu CloudKit, takie jak przyczyna wypychania.

Jak działają subskrypcje

Przed zaimplementowaniem subskrypcji w kodzie języka C# zapoznajmy się z krótkim omówieniem sposobu działania subskrypcji:

Powyższy wykres przedstawia typowy proces subskrypcji w następujący sposób:

Urządzenie klienckie tworzy nową subskrypcję zawierającą zestaw warunków, które spowodują wyzwolenie subskrypcji i powiadomienie wypychane, które zostanie wysłane po wystąpieniu wyzwalacza.
Subskrypcja jest wysyłana do bazy danych, w której jest dodawana do kolekcji istniejących subskrypcji.
Drugie urządzenie tworzy nowy rekord i zapisuje ten rekord w bazie danych.
Baza danych przeszukuje listę subskrypcji, aby sprawdzić, czy nowy rekord jest zgodny z dowolnym z ich warunków.
Jeśli zostanie znalezione dopasowanie, powiadomienie wypychane zostanie wysłane na urządzenie, na które zarejestrowano subskrypcję z informacjami o rekordzie, który spowodował jego wyzwolenie.

Dzięki tej wiedzy przyjrzyjmy się tworzeniu subskrypcji w aplikacji platformy Xamarin dla systemu iOS 8.

Tworzenie subskrypcji

Do utworzenia subskrypcji można użyć następującego kodu:

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

Najpierw tworzy predykat, który udostępnia warunek wyzwalający subskrypcję. Następnie tworzy subskrypcję dla określonego typu rekordu i ustawia opcję po przetestowaniu wyzwalacza. Na koniec definiuje typ powiadomienia, które będzie wykonywane po wyzwoleniu subskrypcji i dołącza ją do subskrypcji.

Zapisywanie subskrypcji

Po utworzeniu subskrypcji następujący kod zapisze go w bazie danych:

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

    }
});

Za pomocą interfejsu API wygody wywołanie jest asynchroniczne, proste i zapewnia łatwą obsługę błędów.

Obsługa powiadomień wypychanych

Jeśli deweloper wcześniej korzystał z funkcji Apple Push Notifications (APS), proces obsługi powiadomień generowanych przez zestaw CloudKit powinien być znany.

W pliku AppDelegate.csprzesłoń klasę ReceivedRemoteNotification w następujący sposób:

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

Powyższy kod prosi zestaw CloudKit o przeanalizowanie informacji o użytkowniku w powiadomieniu cloudkit. Następnie informacje są wyodrębniane z alertu. Na koniec typ powiadomienia jest testowany, a powiadomienie jest obsługiwane odpowiednio.

W tej sekcji pokazano, jak odpowiedzieć na problem z danymi big data, tiny device przedstawiony powyżej przy użyciu zapytań i subskrypcji. Aplikacja pozostawi duże dane w chmurze i użyje tych technologii do udostępniania widoków w tym zestawie danych.

Konta użytkowników zestawu CloudKit

Jak wspomniano na początku tego artykułu, zestaw CloudKit jest oparty na istniejącej infrastrukturze iCloud. W poniższej sekcji szczegółowo omówiono sposób uwidaczniania kont deweloperowi przy użyciu interfejsu API CloudKit.

Uwierzytelnianie

Podczas pracy z kontami użytkowników pierwszą kwestią jest uwierzytelnianie. Zestaw CloudKit obsługuje uwierzytelnianie za pośrednictwem aktualnie zalogowanego użytkownika usługi iCloud na urządzeniu. Uwierzytelnianie odbywa się za kulisami i jest obsługiwane przez system iOS. W ten sposób deweloperzy nigdy nie muszą martwić się o szczegóły implementowania uwierzytelniania. Testują tylko to, czy użytkownik jest zalogowany.

Informacje o koncie użytkownika

Zestaw CloudKit udostępnia deweloperowi następujące informacje o użytkowniku:

Tożsamość — sposób unikatowego identyfikowania użytkownika.
Metadane — możliwość zapisywania i pobierania informacji o użytkownikach.
Prywatność — wszystkie informacje są obsługiwane w dworze świadomym prywatności. Nic nie jest ujawniane, chyba że użytkownik zgodził się na to.
Odnajdywanie — umożliwia użytkownikom odnajdywanie znajomych korzystających z tej samej aplikacji.

Następnie przyjrzymy się szczegółowo tym tematom.

Tożsamość

Jak wspomniano powyżej, zestaw CloudKit umożliwia aplikacji unikatowe zidentyfikowanie danego użytkownika:

Na urządzeniach użytkownika jest uruchomiona aplikacja kliencka i wszystkie określone prywatne bazy danych użytkownika w kontenerze CloudKit. Aplikacja kliencka zostanie połączona z jednym z tych konkretnych użytkowników. Jest to oparte na użytkowniku, który jest zalogowany lokalnie w usłudze iCloud na urządzeniu.

Ponieważ pochodzi to z usługi iCloud, istnieje bogaty magazyn zapasowy informacji o użytkowniku. Ponieważ usługa iCloud rzeczywiście hostuje kontener, może skorelować użytkowników. Na powyższej ilustracji użytkownik, którego konto user@icloud.com w usłudze iCloud jest połączone z bieżącym klientem.

Dla kontenera według kontenera tworzony jest unikatowy, losowo wygenerowany identyfikator użytkownika i skojarzony z kontem użytkownika w usłudze iCloud (adres e-mail). Ten identyfikator użytkownika jest zwracany do aplikacji i może być używany w dowolny sposób, w jaki deweloper widzi dopasowanie.

Uwaga

Różne aplikacje uruchomione na tym samym urządzeniu dla tego samego użytkownika usługi iCloud będą miały różne identyfikatory użytkowników, ponieważ są połączone z różnymi kontenerami CloudKit.

Poniższy kod pobiera identyfikator użytkownika CloudKit dla aktualnie zalogowanego użytkownika usługi iCloud na urządzeniu:

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

Powyższy kod prosi kontener CloudKit o podanie identyfikatora aktualnie zalogowanego użytkownika. Ponieważ te informacje pochodzą z serwera iCloud, wywołanie jest asynchroniczne, a obsługa błędów jest wymagana.

Metadane

Każdy użytkownik w zestawie CloudKit ma określone metadane, które je opisują. Te metadane są reprezentowane jako rekord CloudKit:

Patrząc wewnątrz prywatnej bazy danych dla określonego użytkownika kontenera istnieje jeden rekord, który definiuje tego użytkownika. Istnieje wiele rekordów użytkowników w publicznej bazie danych, po jednym dla każdego użytkownika kontenera. Jeden z nich będzie miał identyfikator rekordu zgodny z aktualnie zalogowanym identyfikatorem rekordu użytkownika.

Rekordy użytkowników w publicznej bazie danych są na świecie czytelne. Są one traktowane w większości jako zwykły rekord i mają typ CKRecordTypeUserRecord. Te rekordy są zarezerwowane przez system i nie są dostępne dla zapytań.

Użyj następującego kodu, aby uzyskać dostęp do rekordu użytkownika:

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

Powyższy kod prosi publiczną bazę danych o zwrócenie rekordu użytkownika dla użytkownika, do którym uzyskujemy dostęp. Ponieważ te informacje pochodzą z serwera iCloud, wywołanie jest asynchroniczne, a obsługa błędów jest wymagana.

Prywatność

Zestaw CloudKit był domyślnie projektowany w celu ochrony prywatności aktualnie zalogowanego użytkownika. Domyślnie nie są widoczne żadne informacje identyfikujące użytkownika. W niektórych przypadkach aplikacja będzie wymagać ograniczonych informacji o użytkowniku.

W takich przypadkach aplikacja może zażądać, aby użytkownik ujawnił te informacje. Zostanie wyświetlone okno dialogowe z prośbą o zgodę na ujawnienie informacji o koncie.

Odnajdowanie

Zakładając, że użytkownik jako użytkownik zdecydował się na zezwolenie aplikacji na ograniczony dostęp do informacji o koncie użytkownika, może być wykrywalny dla innych użytkowników aplikacji:

Aplikacja kliencka rozmawia z kontenerem, a kontener rozmawia z usługą iCloud, aby uzyskać dostęp do informacji o użytkowniku. Użytkownik może podać adres e-mail i odnajdywanie może służyć do uzyskiwania informacji o użytkowniku. Opcjonalnie identyfikator użytkownika może być również używany do odnajdywania informacji o użytkowniku.

Zestaw CloudKit umożliwia również odnajdywanie informacji o każdym użytkowniku, który może być znajomym aktualnie zalogowanym użytkownikiem usługi iCloud, wysyłając zapytanie do całej książki adresowej. Proces CloudKit wciągnie książkę kontaktową użytkownika i użyje adresów e-mail, aby sprawdzić, czy może znaleźć innych użytkowników aplikacji pasujących do tych adresów.

Dzięki temu aplikacja może korzystać z książki kontaktowej użytkownika bez udzielania dostępu do niej lub monitowania użytkownika o zatwierdzenie dostępu do kontaktów. W żadnym momencie nie są dostępne informacje kontaktowe aplikacji, tylko proces CloudKit Ma dostęp.

Aby podsumować, istnieją trzy różne rodzaje danych wejściowych dostępnych dla odnajdywania użytkowników:

Identyfikator rekordu użytkownika — odnajdywanie można wykonać względem identyfikatora użytkownika aktualnie zalogowanego użytkownika zestawu CloudKit.
Adres e-mail użytkownika — użytkownik może podać adres e-mail i może służyć do odnajdywania.
Książka kontaktowa — książka adresowa użytkownika może służyć do odnajdywania użytkowników aplikacji, którzy mają ten sam adres e-mail, co wymienione w kontaktach.

Odnajdywanie użytkowników zwróci następujące informacje:

Identyfikator rekordu użytkownika — unikatowy identyfikator użytkownika w publicznej bazie danych.
Imię i nazwisko — jako przechowywane w publicznej bazie danych.

Te informacje zostaną zwrócone tylko dla użytkowników, którzy wyrazili zgodę na odnajdywanie.

Poniższy kod umożliwia odnalezienie informacji o użytkowniku aktualnie zalogowanym w usłudze iCloud na urządzeniu:

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

Użyj następującego kodu, aby wysłać zapytanie do wszystkich użytkowników w książce kontaktowej:

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

W tej sekcji omówiliśmy cztery główne obszary dostępu do konta użytkownika, które zestaw CloudKit może udostępnić aplikacji. Od pobrania tożsamości i metadanych użytkownika do zasad ochrony prywatności wbudowanych w zestaw CloudKit, a na koniec możliwość odnajdywania innych użytkowników aplikacji.

Środowiska programistyczne i produkcyjne

Zestaw CloudKit udostępnia oddzielne środowiska programistyczne i produkcyjne dla typów rekordów i danych aplikacji. Środowisko programistyczne to bardziej elastyczne środowisko, które jest dostępne tylko dla członków zespołu deweloperskiego. Gdy aplikacja dodaje nowe pole do rekordu i zapisuje ten rekord w środowisku programistycznym, serwer automatycznie aktualizuje informacje o schemacie.

Deweloper może użyć tej funkcji, aby wprowadzić zmiany w schemacie podczas opracowywania, co pozwala zaoszczędzić czas. Jednym z zastrzeżeń jest to, że po dodaniu pola do rekordu nie można programowo zmienić typu danych skojarzonego z tym polem. Aby zmienić typ pola, deweloper musi usunąć pole na pulpicie nawigacyjnym zestawu CloudKit i dodać je ponownie przy użyciu nowego typu.

Przed wdrożeniem aplikacji deweloper może przeprowadzić migrację schematu i danych do środowiska produkcyjnego przy użyciu pulpitu nawigacyjnego zestawu CloudKit. Podczas uruchamiania w środowisku produkcyjnym serwer uniemożliwia programowe zmienianie schematu przez aplikację. Deweloper może nadal wprowadzać zmiany za pomocą pulpitu nawigacyjnego zestawu CloudKit, ale próbuje dodać pola do rekordu w środowisku produkcyjnym, powodują błędy.

Uwaga

Symulator systemu iOS działa tylko ze środowiskiem projektowym. Gdy deweloper jest gotowy do testowania aplikacji w środowisku produkcyjnym, wymagane jest fizyczne urządzenie z systemem iOS.

Wysyłanie aplikacji z obsługą zestawu CloudKit

Przed wysyłką aplikacji korzystającej z zestawu CloudKit należy skonfigurować ją tak, aby była docelowa aplikacja Production CloudKit Environment lub aplikacja zostanie odrzucona przez firmę Apple.

Należy wykonać następujące czynności:

W programie Visual Studio for Ma skompiluj aplikację dla wydania>urządzenia z systemem iOS:
W menu Kompilacja wybierz pozycję Archiwum:
Archiwum zostanie utworzone i wyświetlone w Visual Studio dla komputerów Mac:
Uruchom program Xcode.
W menu Okno wybierz pozycję Organizator:
Wybierz archiwum aplikacji i kliknij przycisk Eksportuj ... :
Wybierz metodę eksportu i kliknij przycisk Dalej :
Wybierz zespół programistyczny z listy rozwijanej i kliknij przycisk Wybierz:
Wybierz pozycję Produkcja z listy rozwijanej i kliknij przycisk Dalej :
Przejrzyj ustawienie i kliknij przycisk Eksportuj:
Wybierz lokalizację do wygenerowania wynikowego pliku aplikacji .ipa .

Proces jest podobny do przesyłania aplikacji bezpośrednio do Połączenie iTunes, wystarczy kliknąć przycisk Prześlij... zamiast Eksportuj... po wybraniu archiwum w oknie Organizator.

Kiedy należy używać zestawu CloudKit

Jak pokazano w tym artykule, zestaw CloudKit zapewnia łatwy sposób przechowywania i pobierania informacji z serwerów iCloud. Oznacza to, że zestaw CloudKit nie jest przestarzały lub przestarzał żadnego z istniejących narzędzi lub struktur.

Przypadki użycia

Następujące przypadki użycia powinny pomóc deweloperowi zdecydować, kiedy używać określonej struktury lub technologii iCloud:

Magazyn klucz-wartość w usłudze iCloud — asynchronicznie przechowuje niewielką ilość danych i doskonale nadaje się do pracy z preferencjami aplikacji. Jednak jest on ograniczony dla bardzo małej ilości informacji.
iCloud Drive — oparta na istniejących interfejsach API dokumentów usługi iCloud i udostępnia prosty interfejs API do synchronizowania danych bez struktury z systemu plików. Zapewnia pełną pamięć podręczną w trybie offline w systemie Mac OS X i doskonale nadaje się do obsługi aplikacji skoncentrowanych na dokumentach.
Dane podstawowe usługi iCloud — umożliwia replikowanie danych między wszystkimi urządzeniami użytkownika. Dane są jednym użytkownikiem i doskonale nadają się do synchronizowania prywatnych, ustrukturyzowanych danych.
CloudKit — udostępnia dane publiczne zarówno ze strukturą, jak i zbiorczą i umożliwia obsługę zarówno dużych zestawów danych, jak i dużych plików bez struktury. Jest on powiązany z kontem użytkownika w usłudze iCloud i zapewnia przekierowywany transfer danych przez klienta.

Mając na uwadze te przypadki użycia, deweloper powinien wybrać poprawną technologię iCloud, aby zapewnić zarówno bieżącą wymaganą funkcjonalność aplikacji, jak i zapewnić dobrą skalowalność dla przyszłego wzrostu.

Podsumowanie

W tym artykule opisano krótkie wprowadzenie do interfejsu API zestawu CloudKit. Pokazano, jak aprowizować i skonfigurować aplikację platformy Xamarin dla systemu iOS do korzystania z zestawu CloudKit. Omówiono w nim funkcje interfejsu API CloudKit Convenience. Pokazano w nim, jak zaprojektować aplikację z obsługą zestawu CloudKit pod kątem skalowalności przy użyciu zapytań i subskrypcji. Na koniec zostały wyświetlone informacje o koncie użytkownika, które są widoczne dla aplikacji firmy CloudKit.

Zestaw CloudKit w środowisku Xamarin.iOS

Wymagania

Co to jest CloudKit?

Włączanie zestawu CloudKit w aplikacji platformy Xamarin

Przykładowa aplikacja

Omówienie interfejsu API zestawu CloudKit

Kontenery

Bazy danych

Rekordy

Strefy rekordów

Identyfikatory rekordów

Informacje

Zasoby

Interfejs API wygody zestawu CloudKit

Wspólny kod konfiguracji

Zapisywanie rekordu

Pobieranie rekordu

Aktualizowanie rekordu

Projektowanie pod kątem skalowalności

Dane big data, małe urządzenie

Zapytania

Obsługiwane predykaty

Tworzenie zapytań

Wykonywanie zapytania

Subskrypcje

Jak działają subskrypcje

Tworzenie subskrypcji

Zapisywanie subskrypcji

Obsługa powiadomień wypychanych

Konta użytkowników zestawu CloudKit

Uwierzytelnianie

Informacje o koncie użytkownika

Tożsamość

Metadane

Prywatność

Odnajdowanie

Środowiska programistyczne i produkcyjne

Wysyłanie aplikacji z obsługą zestawu CloudKit

Kiedy należy używać zestawu CloudKit

Przypadki użycia

Podsumowanie

Pokrewne łącza

Dodatkowe zasoby