Dostęp do systemu plików na platformie Xamarin.iOS

Pobieranie przykładu

Aby uzyskać dostęp do systemu plików iOS, możesz użyć platformy Xamarin.iOS i System.IO klas w bibliotece klas bazowych platformy .NET (BCL ). Klasa File umożliwia tworzenie, usuwanie i odczytywanie plików, a Directory klasa umożliwia tworzenie, usuwanie lub wyliczanie zawartości katalogów. Można również użyć Stream podklas, które mogą zapewnić większy stopień kontroli nad operacjami plików (takimi jak kompresja lub wyszukiwanie pozycji w pliku).

System iOS nakłada pewne ograniczenia dotyczące działania aplikacji w systemie plików w celu zachowania bezpieczeństwa danych aplikacji oraz ochrony użytkowników przed złośliwymi aplikacjami. Te ograniczenia są częścią piaskownicy aplikacji — zestaw reguł, które ograniczają dostęp aplikacji do plików, preferencji, zasobów sieciowych, sprzętu itp. Aplikacja jest ograniczona do odczytywania i zapisywania plików w katalogu głównym (lokalizacja zainstalowana); nie może uzyskać dostępu do plików innej aplikacji.

System iOS ma również pewne funkcje specyficzne dla systemu plików: niektóre katalogi wymagają specjalnego traktowania w odniesieniu do kopii zapasowych i uaktualnień, a aplikacje mogą również współużytkować pliki ze sobą i aplikację Pliki (od systemu iOS 11) i za pośrednictwem programu iTunes.

W tym artykule omówiono funkcje i ograniczenia systemu plików systemu iOS oraz przykładową aplikację, która pokazuje, jak używać platformy Xamarin.iOS do wykonywania niektórych prostych operacji systemu plików:

Ogólny dostęp do plików

Platforma Xamarin.iOS umożliwia używanie klas platformy .NET System.IO na potrzeby operacji systemu plików w systemie iOS.

Poniższe fragmenty kodu ilustrują niektóre typowe operacje na plikach. Wszystkie te elementy znajdziesz poniżej w pliku SampleCode.cs w przykładowej aplikacji dla tego artykułu.

Praca z katalogami

Ten kod wylicza podkatalogi w bieżącym katalogu (określonym przez parametr "./"), który jest lokalizacją pliku wykonywalnego aplikacji. Dane wyjściowe będą listą wszystkich plików i folderów wdrożonych w aplikacji (wyświetlanych w oknie konsoli podczas debugowania).

var directories = Directory.EnumerateDirectories("./");
foreach (var directory in directories) {
      Console.WriteLine(directory);
}

Odczytywanie plików

Aby odczytać plik tekstowy, wystarczy tylko jeden wiersz kodu. W tym przykładzie zostanie wyświetlona zawartość pliku tekstowego w oknie Dane wyjściowe aplikacji.

var text = File.ReadAllText("TestData/ReadMe.txt");
Console.WriteLine(text);

Serializacja XML

Mimo że praca z pełną System.Xml przestrzenią nazw wykracza poza zakres tego artykułu, można łatwo deserializacji dokumentu XML z systemu plików przy użyciu elementu StreamReader, takiego jak ten fragment kodu:

using (TextReader reader = new StreamReader("./TestData/test.xml")) {
      XmlSerializer serializer = new XmlSerializer(typeof(MyObject));
      var xml = (MyObject)serializer.Deserialize(reader);
}

Aby uzyskać więcej informacji, zobacz dokumentację dotyczącą pliku System.Xml i serializacji. Zapoznaj się z dokumentacją platformy Xamarin.iOS w konsolidatorze — często należy dodać [Preserve] atrybut do klas, które mają być serializować.

Tworzenie plików i katalogów

W tym przykładzie pokazano, jak używać Environment klasy w celu uzyskania dostępu do folderu Dokumenty, w którym można tworzyć pliki i katalogi.

var documents =
 Environment.GetFolderPath (Environment.SpecialFolder.MyDocuments); 
var filename = Path.Combine (documents, "Write.txt");
File.WriteAllText(filename, "Write this text into a file");

Tworzenie katalogu jest podobnym procesem:

var documents =
 Environment.GetFolderPath (Environment.SpecialFolder.MyDocuments);
var directoryname = Path.Combine (documents, "NewDirectory");
Directory.CreateDirectory(directoryname);

Aby uzyskać więcej informacji, zobacz dokumentację interfejsu API System.IO.

Serializowanie kodu JSON

Json.NET jest platformą JSON o wysokiej wydajności, która współpracuje z platformą Xamarin.iOS i jest dostępna w narzędziu NuGet. Dodaj pakiet NuGet do projektu aplikacji przy użyciu polecenia Dodaj nuGet w Visual Studio dla komputerów Mac:

Następnie dodaj klasę do działania jako model danych na potrzeby serializacji/deserializacji (w tym przypadku Account.cs):

using System;
using System.Collections.Generic;
using Foundation; // for Preserve attribute, which helps serialization with Linking enabled

namespace FileSystem
{
    [Preserve]
    public class Account
    {
        public string Email { get; set; }
        public bool Active { get; set; }
        public DateTime CreatedDate { get; set; }
        public List<string> Roles { get; set; }

        public Account() {
        }
    }
}

Na koniec utwórz wystąpienie Account klasy, serializuj je w danych json i zapisz je w pliku:

// Create a new record
var account = new Account(){
    Email = "monkey@xamarin.com",
    Active = true,
    CreatedDate = new DateTime(2015, 5, 27, 0, 0, 0, DateTimeKind.Utc),
    Roles = new List<string> {"User", "Admin"}
};

// Serialize object
var json = JsonConvert.SerializeObject(account, Newtonsoft.Json.Formatting.Indented);

// Save to file
var documents = Environment.GetFolderPath (Environment.SpecialFolder.MyDocuments);
var filename = Path.Combine (documents, "account.json");
File.WriteAllText(filename, json);

Aby uzyskać więcej informacji na temat pracy z danymi json w aplikacji .NET, zobacz dokumentację platformy Json.NET.

Specjalne uwagi

Pomimo podobieństw między operacjami plików Xamarin.iOS i .NET, systemy iOS i Xamarin.iOS różnią się od platformy .NET na kilka ważnych sposobów.

Udostępnianie plików projektu w czasie wykonywania

Domyślnie jeśli dodasz plik do projektu, nie zostanie on uwzględniony w ostatnim zestawie i dlatego nie będzie dostępny dla aplikacji. Aby dołączyć plik do zestawu, należy oznaczyć go specjalną akcją kompilacji o nazwie Zawartość.

Aby oznaczyć plik do włączenia, kliknij prawym przyciskiem myszy pliki i wybierz pozycję Kompiluj zawartość akcji > w Visual Studio dla komputerów Mac. Możesz również zmienić akcję kompilacji w arkuszu Właściwości pliku.

Uwzględnij wielkość liter

Ważne jest, aby zrozumieć, że w systemie plików systemu iOS jest uwzględniana wielkość liter. Ważność wielkości liter oznacza, że nazwy plików i katalogów muszą być dokładnie zgodne — README.txt i readme.txt będą traktowane jako różne nazwy plików.

Może to być mylące dla deweloperów platformy .NET, którzy są bardziej zaznajomieni z systemem plików Windows, co jest bez uwzględniania wielkości liter — pliki, pliki i pliki będą odwoływać się do tego samego katalogu.

Ostrzeżenie

Symulator systemu iOS nie uwzględnia wielkości liter. Jeśli wielkość nazwy pliku różni się między samym plikiem a odwołaniami do niego w kodzie, kod może nadal działać w symulatorze, ale zakończy się niepowodzeniem na rzeczywistym urządzeniu. Jest to jeden z powodów, dla których ważne jest wdrożenie i przetestowanie rzeczywistego urządzenia na wczesnym i często podczas opracowywania systemu iOS.

Separator ścieżki

System iOS używa ukośnika "/" jako separatora ścieżki (który różni się od systemu Windows, który używa ukośnika odwrotnego "\").

Z powodu tej mylącej różnicy dobrym rozwiązaniem jest użycie System.IO.Path.Combine metody, która dostosowuje się dla bieżącej platformy, zamiast kodować określony separator ścieżki. Jest to prosty krok, który sprawia, że kod jest bardziej przenośny na innych platformach.

Piaskownica aplikacji

Dostęp aplikacji do systemu plików (i innych zasobów, takich jak funkcje sieciowe i sprzętowe), jest ograniczony ze względów bezpieczeństwa. To ograniczenie jest nazywane piaskownicą aplikacji. Jeśli chodzi o system plików, aplikacja jest ograniczona do tworzenia i usuwania plików i katalogów w katalogu głównym.

Katalog główny to unikatowa lokalizacja w systemie plików, w którym aplikacja i wszystkie jej dane są przechowywane. Nie można wybrać (ani zmienić) lokalizacji katalogu macierzystego dla aplikacji; jednak systemy iOS i Xamarin.iOS udostępniają właściwości i metody zarządzania plikami i katalogami wewnątrz.

Pakiet aplikacji

Pakiet aplikacji to folder zawierający aplikację. Jest on rozróżniany od innych folderów przez dodanie sufiksu .app do nazwy katalogu. Pakiet aplikacji zawiera plik wykonywalny i całą zawartość (pliki, obrazy itp.) niezbędną dla projektu.

Podczas przechodzenia do pakietu aplikacji w systemie Mac OS jest wyświetlana inna ikona niż w innych katalogach (a sufiks .app jest ukryty). Jest to jednak zwykły katalog, który system operacyjny wyświetla inaczej.

Aby wyświetlić pakiet aplikacji dla przykładowego kodu, kliknij prawym przyciskiem myszy projekt w Visual Studio dla komputerów Mac i wybierz polecenie Ujawnij w programie Finder. Następnie przejdź do katalogu bin/ , w którym powinna znajdować się ikona aplikacji (podobnie jak na poniższym zrzucie ekranu).

Kliknij prawym przyciskiem myszy tę ikonę i wybierz polecenie Pokaż zawartość pakietu, aby przejrzeć zawartość katalogu Pakietu aplikacji. Zawartość jest wyświetlana tak samo jak zawartość zwykłego katalogu, jak pokazano poniżej:

Pakiet aplikacji jest instalowany na symulatorze lub na urządzeniu podczas testowania, a ostatecznie jest to to, co zostało przesłane do firmy Apple w celu włączenia do sklepu App Store.

Katalogi aplikacji

Po zainstalowaniu aplikacji na urządzeniu system operacyjny tworzy katalog główny dla aplikacji i tworzy wiele katalogów w katalogu głównym aplikacji, które są dostępne do użycia. Ponieważ system iOS 8 katalogi dostępne dla użytkownika nie znajdują się w katalogu głównym aplikacji, więc nie można uzyskać ścieżek dla pakietu aplikacji z katalogów użytkowników ani na odwrót.

Te katalogi, sposób określania ich ścieżki i ich celów są wymienione poniżej:

 

Katalog	opis
[ApplicationName].app/	W systemie iOS 7 lub starszym jest ApplicationBundle to katalog, w którym jest przechowywany plik wykonywalny aplikacji. Struktura katalogów utworzona w aplikacji istnieje w tym katalogu (na przykład obrazy i inne typy plików oznaczone jako Zasoby w projekcie Visual Studio dla komputerów Mac). Jeśli musisz uzyskać dostęp do plików zawartości w pakiecie aplikacji, ścieżka do tego katalogu jest dostępna za pośrednictwem NSBundle.MainBundle.BundlePath właściwości .
Dokumentów/	Ten katalog służy do przechowywania dokumentów użytkownika i plików danych aplikacji. Zawartość tego katalogu można udostępnić użytkownikowi za pośrednictwem udostępniania plików w programie iTunes (chociaż jest to domyślnie wyłączone). UIFileSharingEnabled Dodaj klucz logiczny do pliku Info.plist, aby umożliwić użytkownikom dostęp do tych plików. Nawet jeśli aplikacja nie włącza natychmiastowego udostępniania plików, należy unikać umieszczania plików, które powinny być ukryte przed użytkownikami w tym katalogu (na przykład plików bazy danych, chyba że zamierzasz je udostępnić). Jeśli poufne pliki pozostaną ukryte, te pliki nie zostaną ujawnione (i potencjalnie przeniesione, zmodyfikowane lub usunięte przez program iTunes), jeśli udostępnianie plików zostanie włączone w przyszłej wersji. Możesz użyć Environment.GetFolderPath (Environment.SpecialFolder.MyDocuments) metody , aby uzyskać ścieżkę do katalogu Documents dla aplikacji. Zawartość tego katalogu jest tworzona przez program iTunes.
Biblioteki/	Katalog Biblioteka to dobre miejsce do przechowywania plików, które nie są tworzone bezpośrednio przez użytkownika, takie jak bazy danych lub inne pliki generowane przez aplikację. Zawartość tego katalogu nigdy nie jest widoczna dla użytkownika za pośrednictwem programu iTunes. Możesz utworzyć własne podkatalogi w bibliotece; Jednak w tym miejscu istnieją już pewne katalogi utworzone przez system, o których należy pamiętać, w tym preferencje i pamięci podręczne. Zawartość tego katalogu (z wyjątkiem podkatalogu Pamięci podręczne) jest tworzona przez program iTunes. Kopie zapasowe katalogów niestandardowych utworzonych w bibliotece zostaną utworzone.
Biblioteka/preferencje/	Pliki preferencji specyficzne dla aplikacji są przechowywane w tym katalogu. Nie twórz tych plików bezpośrednio. Zamiast tego użyj NSUserDefaults klasy . Zawartość tego katalogu jest tworzona przez program iTunes.
Biblioteka/pamięci podręczne/	Katalog Caches to dobre miejsce do przechowywania plików danych, które mogą pomóc w uruchomieniu aplikacji, ale można je łatwo utworzyć ponownie. Aplikacja powinna utworzyć i usunąć te pliki zgodnie z potrzebami i w razie potrzeby ponownie utworzyć te pliki. System iOS 5 może również usunąć te pliki (w małych sytuacjach magazynowania), ale nie zrobi tego podczas działania aplikacji. Zawartość tego katalogu nie jest tworzona przez program iTunes, co oznacza, że nie będą obecne, jeśli użytkownik przywróci urządzenie i może nie być obecny po zainstalowaniu zaktualizowanej wersji aplikacji. Na przykład w przypadku, gdy aplikacja nie może nawiązać połączenia z siecią, możesz użyć katalogu Caches do przechowywania danych lub plików w celu zapewnienia dobrego środowiska w trybie offline. Aplikacja może zapisywać i pobierać te dane szybko podczas oczekiwania na odpowiedzi sieciowe, ale nie musi być wykonywana kopia zapasowa i można ją łatwo odzyskać lub ponownie utworzyć po przywróceniu lub aktualizacji wersji.
Tmp/	Aplikacje mogą przechowywać pliki tymczasowe, które są potrzebne tylko przez krótki okres w tym katalogu. Aby zaoszczędzić miejsce, pliki powinny być usuwane, gdy nie są już wymagane. System operacyjny może również usuwać pliki z tego katalogu, gdy aplikacja nie jest uruchomiona. Zawartość tego katalogu nie jest tworzona przez program iTunes. Na przykład katalog tmp może służyć do przechowywania plików tymczasowych pobranych do wyświetlania użytkownikowi (takich jak awatary usługi Twitter lub załączniki wiadomości e-mail), ale można je usunąć po wyświetleniu (i pobraniu ponownie, jeśli są one wymagane w przyszłości).

Ten zrzut ekranu przedstawia strukturę katalogu w oknie wyszukiwania:

Programowe uzyskiwanie dostępu do innych katalogów

Wcześniejszy katalog i przykłady plików uzyskiwały Documents dostęp do katalogu. Aby zapisać w innym katalogu, należy skonstruować ścieżkę przy użyciu składni ".". Jak pokazano poniżej:

var documents = Environment.GetFolderPath (Environment.SpecialFolder.MyDocuments);
var library = Path.Combine (documents, "..", "Library");
var filename = Path.Combine (library, "WriteToLibrary.txt");
File.WriteAllText(filename, "Write this text into a file in Library");

Tworzenie katalogu jest podobne:

var documents = Environment.GetFolderPath (Environment.SpecialFolder.MyDocuments);
var library = Path.Combine (documents, "..", "Library");
var directoryname = Path.Combine (library, "NewLibraryDirectory");
Directory.CreateDirectory(directoryname);

Ścieżki do Caches katalogów i tmp można utworzyć w następujący sposób:

var documents = Environment.GetFolderPath (Environment.SpecialFolder.MyDocuments);
var cache = Path.Combine (documents, "..", "Library", "Caches");
var tmp = Path.Combine (documents, "..", "tmp");

Udostępnianie aplikacji Pliki

System iOS 11 wprowadził aplikację Pliki — przeglądarkę plików dla systemu iOS, która umożliwia użytkownikowi wyświetlanie i interakcję z plikami w usłudze iCloud, a także przechowywanie ich przez dowolną aplikację, która ją obsługuje. Aby zezwolić użytkownikowi na bezpośredni dostęp do plików w aplikacji, utwórz nowy klucz logiczny w pliku LSSupportsOpeningDocumentsInPlace Info.plist i ustaw go na truewartość , jak pokazano tutaj:

Katalog Dokumenty aplikacji będzie teraz dostępny do przeglądania w aplikacji Pliki. W aplikacji Pliki przejdź do pozycji W obszarze Mój i Telefon a każda aplikacja z udostępnionymi plikami będzie widoczna. Zrzuty ekranu poniżej pokazują, jak wygląda przykładowa aplikacja systemu plików:

Udostępnianie plików użytkownikowi za pośrednictwem programu iTunes

Użytkownicy mogą uzyskiwać dostęp do plików w katalogu Dokumenty aplikacji, edytując Info.plist i tworząc aplikację, która obsługuje udostępnianie aplikacji iTunes (UIFileSharingEnabled) w widoku źródłowym, jak pokazano poniżej:

Dostęp do tych plików można uzyskać w programie iTunes, gdy urządzenie jest połączone, a użytkownik wybiera kartę Apps . Na przykład poniższy zrzut ekranu przedstawia pliki w wybranej aplikacji udostępnionej za pośrednictwem programu iTunes:

Użytkownicy mogą uzyskiwać dostęp tylko do elementów najwyższego poziomu w tym katalogu za pośrednictwem programu iTunes. Nie widzą zawartości żadnych podkatalogów (chociaż mogą je skopiować na komputer lub usunąć). Na przykład przy użyciu plików GoodReader, PDF i EPUB można udostępniać aplikacji, aby użytkownicy mogli je odczytywać na swoich urządzeniach z systemem iOS.

Użytkownicy, którzy modyfikują zawartość folderu Dokumenty, mogą powodować problemy, jeśli nie są ostrożni. Aplikacja powinna wziąć to pod uwagę i być odporna na destrukcyjne aktualizacje folderu Dokumenty.

Przykładowy kod tego artykułu tworzy zarówno plik, jak i folder w folderze Documents (w SampleCode.cs) i umożliwia udostępnianie plików w pliku Info.plist . Ten zrzut ekranu przedstawia sposób wyświetlania tych w programie iTunes:

Zapoznaj się z artykułem Praca z obrazami , aby uzyskać informacje o sposobie ustawiania ikon dla aplikacji i dowolnych niestandardowych typów dokumentów, które tworzysz.

UIFileSharingEnabled Jeśli klucz ma wartość false lub nie istnieje, udostępnianie plików jest domyślnie wyłączone, a użytkownicy nie będą mogli wchodzić w interakcje z katalogiem Documents.

Tworzenie kopii zapasowej i przywracanie

Po utworzeniu kopii zapasowej urządzenia przez program iTunes wszystkie katalogi utworzone w katalogu głównym aplikacji zostaną zapisane z wyjątkiem następujących katalogów:

• [ApplicationName].app — nie zapisuj w tym katalogu, ponieważ jest podpisany i musi pozostać niezmieniony po instalacji. Może zawierać zasoby, do których uzyskujesz dostęp z kodu, ale nie wymagają kopii zapasowej, ponieważ zostaną przywrócone przez ponowne pobranie aplikacji.
• Biblioteka/pamięci podręczne — katalog pamięci podręcznej jest przeznaczony do tworzenia kopii zapasowych plików roboczych, których kopia zapasowa nie jest potrzebna.
• tmp — ten katalog jest używany w przypadku plików tymczasowych, które są tworzone i usuwane, gdy nie są już potrzebne, lub w przypadku plików usuwanych przez system iOS, gdy potrzebuje miejsca.

Tworzenie kopii zapasowej dużej ilości danych może zająć dużo czasu. Jeśli zdecydujesz, że chcesz utworzyć kopię zapasową określonego dokumentu lub danych, aplikacja powinna użyć folderów Dokumenty i Biblioteka. W przypadku przejściowych danych lub plików, które można łatwo pobrać z sieci, użyj katalogu Caches lub tmp.

Uwaga

System iOS będzie "czyścić" system plików, gdy urządzenie będzie działać krytycznie nisko na dysku. Ten proces spowoduje usunięcie wszystkich plików z biblioteki/pamięci podręcznej i folderu tmp aplikacji, które nie są obecnie uruchomione.

Zgodność z ograniczeniami tworzenia kopii zapasowych w usłudze iCloud dla systemu iOS 5

Uwaga

Chociaż te zasady zostały wprowadzone po raz pierwszy w systemie iOS 5 (co wydaje się dawno temu), wskazówki są nadal istotne dla aplikacji dzisiaj.

Firma Apple wprowadziła funkcję tworzenia kopii zapasowych w usłudze iCloud w systemie iOS 5. Po włączeniu tworzenia kopii zapasowej w usłudze iCloud wszystkie pliki w katalogu głównym aplikacji (z wyłączeniem katalogów, których kopia zapasowa nie jest zwykle tworzona, np. pakiet aplikacji, Cachesi ) są kopiami zapasowymi serwerów iCloud tmp. Ta funkcja zapewnia użytkownikowi pełną kopię zapasową na wypadek utraty, kradzieży lub uszkodzenia urządzenia.

Ponieważ usługa iCloud zapewnia tylko 5 Gb wolnego miejsca dla każdego użytkownika i pozwala uniknąć niepotrzebnego korzystania z przepustowości, firma Apple oczekuje, że aplikacje będą tworzyć tylko kopie zapasowe podstawowych danych generowanych przez użytkownika. Aby zachować zgodność z wytycznymi dotyczącymi magazynu danych systemu iOS, należy ograniczyć ilość danych, których kopia zapasowa jest tworzona, przestrzegając następujących elementów:

• Przechowuj tylko dane generowane przez użytkownika lub dane, których w przeciwnym razie nie można utworzyć ponownie, w katalogu Documents (którego kopia zapasowa jest tworzona).
• Przechowuj wszystkie inne dane, które można łatwo utworzyć lub ponownie pobrać Library/Caches w programie lub tmp (które nie są kopiami zapasowymi i mogą być czyszczone).
• Jeśli masz pliki, które mogą być odpowiednie dla Library/Caches folderu lub tmp , ale nie chcesz być "czyszczone", zapisz je w innym miejscu (np Library/YourData. ) i zastosuj atrybut "Nie twórz kopii zapasowej", aby zapobiec używaniu przepustowości i miejsca do tworzenia kopii zapasowych w usłudze iCloud. Te dane nadal zużywają miejsce na urządzeniu, więc należy je starannie zarządzać i usuwać, gdy jest to możliwe.

Atrybut "Nie kopii zapasowej NSFileManager " jest ustawiany przy użyciu klasy . Upewnij się, że klasa jest using Foundation i wywołaj następującą metodę SetSkipBackupAttribute :

var documents = Environment.GetFolderPath (Environment.SpecialFolder.MyDocuments);
var filename = Path.Combine (documents, "LocalOnly.txt");
File.WriteAllText(filename, "This file will never get backed-up. It would need to be re-created after a restore or re-install");
NSFileManager.SetSkipBackupAttribute (filename, true); // backup will be skipped for this file

Gdy SetSkipBackupAttribute plik true nie będzie kopii zapasowej, niezależnie od katalogu, w nim jest przechowywany (nawet Documents katalog). Możesz wykonać zapytanie dotyczące atrybutu GetSkipBackupAttribute przy użyciu metody i zresetować go, wywołując metodę SetSkipBackupAttribute za falsepomocą metody , w następujący sposób:

NSFileManager.SetSkipBackupAttribute (filename, false); // file will be backed-up

Udostępnianie danych między aplikacjami systemu iOS i rozszerzeniami aplikacji

Ponieważ rozszerzenia aplikacji działają w ramach aplikacji hosta (w przeciwieństwie do ich aplikacji zawierającej), udostępnianie danych nie jest automatycznie uwzględniane, więc wymagana jest dodatkowa praca. Grupy aplikacji to mechanizm używany przez system iOS w celu umożliwienia różnym aplikacjom udostępniania danych. Jeśli aplikacje zostały prawidłowo skonfigurowane z odpowiednimi uprawnieniami i aprowizowaniem, mogą uzyskać dostęp do udostępnionego katalogu poza normalną piaskownicą systemu iOS.

Konfigurowanie grupy aplikacji

Lokalizacja udostępniona jest skonfigurowana przy użyciu grupy aplikacji, która jest skonfigurowana w sekcji Certyfikaty, identyfikatory i profile w systemie iOS Centrum deweloperów. Ta wartość musi być również przywoływała w pliku Entitlements.plist każdego projektu.

Aby uzyskać informacje na temat tworzenia i konfigurowania grupy aplikacji, zapoznaj się z przewodnikiem Możliwości grupy aplikacji.

Pliki

Aplikacja systemu iOS i rozszerzenie mogą również udostępniać pliki przy użyciu wspólnej ścieżki pliku (biorąc pod uwagę, że zostały one prawidłowo skonfigurowane przy użyciu odpowiednich uprawnień i aprowizacji):

var FileManager = new NSFileManager ();
var appGroupContainer =FileManager.GetContainerUrl ("group.com.xamarin.WatchSettings");
var appGroupContainerPath = appGroupContainer.Path

Console.WriteLine ("Group Path: " + appGroupContainerPath);

// use the path to create and update files
...

Ważne

Jeśli zwrócona ścieżka grupy to null, sprawdź konfigurację uprawnień i profilu aprowizacji i upewnij się, że są poprawne.

Aktualizacje wersji aplikacji

Po pobraniu nowej wersji aplikacji system iOS tworzy nowy katalog główny i przechowuje w nim nowy pakiet aplikacji. Następnie system iOS przenosi następujące foldery z poprzedniej wersji pakietu aplikacji do nowego katalogu macierzystego:

• Dokumenty
• Biblioteki

Inne katalogi mogą być również kopiowane do nowego katalogu macierzystego i umieszczane w nowym katalogu głównym, ale nie mają gwarancji, że zostaną skopiowane, więc aplikacja nie powinna polegać na tym zachowaniu systemu.

Podsumowanie

W tym artykule pokazano, że operacje systemu plików z platformą Xamarin.iOS są podobne do każdej innej aplikacji .NET. Wprowadziła również piaskownicę aplikacji i zbadała konsekwencje związane z zabezpieczeniami, które powoduje. Następnie zapoznano się z koncepcją pakietu aplikacji. Na koniec wyliczyła wyspecjalizowane katalogi dostępne dla aplikacji i wyjaśniła ich role podczas uaktualniania i tworzenia kopii zapasowych aplikacji.

Pokrewne łącza

• Przykładowy kod systemu plików
• Przewodnik programowania systemu plików
• Rejestrowanie typów plików, które obsługuje aplikacja