Uprawnienia dostępu do plików

Aplikacje platformy uniwersalnej systemu Windows (UWP) mogą domyślnie uzyskiwać dostęp do określonych lokalizacji systemu plików. Aplikacje mogą również uzyskiwać dostęp do dodatkowych lokalizacji za pośrednictwem selektora plików lub deklarując możliwości.

Lokalizacje, do których mogą uzyskiwać dostęp aplikacje platformy UWP

Podczas tworzenia nowej aplikacji można domyślnie uzyskać dostęp do następujących lokalizacji systemu plików:

Katalog instalacji aplikacji

Folder, w którym aplikacja jest zainstalowana w systemie użytkownika.

Istnieją dwa podstawowe sposoby uzyskiwania dostępu do plików i folderów w katalogu instalacyjnym aplikacji:

1. Możesz pobrać StorageFolder, który reprezentuje katalog instalacyjny aplikacji, w następujący sposób:

   Windows.Storage.StorageFolder installedLocation = Windows.ApplicationModel.Package.Current.InstalledLocation;
   

   var installDirectory = Windows.ApplicationModel.Package.current.installedLocation;
   

   #include <winrt/Windows.Storage.h>
   ...
   Windows::Storage::StorageFolder installedLocation{ Windows::ApplicationModel::Package::Current().InstalledLocation() };
   

   Windows::Storage::StorageFolder^ installedLocation = Windows::ApplicationModel::Package::Current->InstalledLocation;
   

   Następnie można uzyskać dostęp do plików i folderów w katalogu przy użyciu metod StorageFolder. W tym przykładzie ten StorageFolder jest przechowywany w zmiennej installDirectory. Aby dowiedzieć się więcej na temat pracy z pakietem aplikacji i katalogu instalacji, zobacz przykładowe informacje o pakiecie aplikacji w witrynie GitHub.

2. Plik można pobrać bezpośrednio z katalogu instalacji aplikacji przy użyciu identyfikatora URI aplikacji, w następujący sposób:

   using Windows.Storage;            
   StorageFile file = await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appx:///file.txt"));
   

   Windows.Storage.StorageFile.getFileFromApplicationUriAsync("ms-appx:///file.txt").done(
       function(file) {
           // Process file
       }
   );
   

   Windows::Foundation::IAsyncAction ExampleCoroutineAsync()
   {
       Windows::Storage::StorageFile file{
           co_await Windows::Storage::StorageFile::GetFileFromApplicationUriAsync(Windows::Foundation::Uri{L"ms-appx:///file.txt"})
       };
       // Process file
   }
   

   auto getFileTask = create_task(StorageFile::GetFileFromApplicationUriAsync(ref new Uri("ms-appx:///file.txt")));
   getFileTask.then([](StorageFile^ file) 
   {
       // Process file
   });
   

   Po zakończeniu funkcji GetFileFromApplicationUriAsync zwraca ona StorageFile, który reprezentuje plik file.txt w katalogu instalacyjnym aplikacji (file w przykładzie).

   Prefiks "ms-appx:///" w identyfikatorze URI odnosi się do katalogu instalacji aplikacji. Więcej informacji na temat używania identyfikatorów URI aplikacji można dowiedzieć się w How to use URIs to reference content.

Ponadto i w przeciwieństwie do innych lokalizacji można również uzyskiwać dostęp do plików w katalogu instalacji aplikacji przy użyciu niektórych Win32 i COM dla aplikacji platformy uniwersalnej systemu Windows (UWP) i niektórych funkcji biblioteki standardowej C/C++ z programu Microsoft Visual Studio.

Katalog instalacyjny aplikacji to lokalizacja tylko do odczytu. Nie można uzyskać dostępu do katalogu instalacji za pomocą selektora plików.

Uzyskiwanie dostępu do lokalizacji danych aplikacji

Foldery, w których aplikacja może przechowywać dane. Te foldery (lokalne, mobilne i tymczasowe) są tworzone podczas instalowania aplikacji.

Istnieją dwa podstawowe sposoby uzyskiwania dostępu do plików i folderów z lokalizacji danych aplikacji:

1. Użyj właściwości ApplicationData, aby pobrać folder danych aplikacji.

   Na przykład można użyć ApplicationData.LocalFolder, aby pobrać StorageFolder, który reprezentuje lokalny folder aplikacji w taki sposób:

   using Windows.Storage;
   StorageFolder localFolder = ApplicationData.Current.LocalFolder;
   

   var localFolder = Windows.Storage.ApplicationData.current.localFolder;
   

   Windows::Storage::StorageFolder storageFolder{
       Windows::Storage::ApplicationData::Current().LocalFolder()
   };
   

   using namespace Windows::Storage;
   StorageFolder^ storageFolder = ApplicationData::Current->LocalFolder;
   

   Jeśli chcesz uzyskać dostęp do folderu roamingowego lub folderu tymczasowego aplikacji, zamiast tego użyj właściwości RoamingFolder lub TemporaryFolder.

   Po pobraniu StorageFolder reprezentującej lokalizację danych aplikacji można uzyskać dostęp do plików i folderów w tej lokalizacji przy użyciu metod StorageFolder. W tym przykładzie te obiekty StorageFolder są przechowywane w zmiennej localFolder. Możesz dowiedzieć się więcej na temat używania lokalizacji danych aplikacji, zapoznając się z wytycznymi na stronie klasy ApplicationData, a także pobierając przykładowe dane aplikacji z GitHub.

2. Plik można pobrać bezpośrednio z folderu lokalnego aplikacji przy użyciu identyfikatora URI aplikacji, w następujący sposób:

   using Windows.Storage;
   StorageFile file = await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appdata:///local/file.txt"));
   

   Windows.Storage.StorageFile.getFileFromApplicationUriAsync("ms-appdata:///local/file.txt").done(
       function(file) {
           // Process file
       }
   );
   

   Windows::Storage::StorageFile file{
       co_await Windows::Storage::StorageFile::GetFileFromApplicationUriAsync(Windows::Foundation::Uri{ L"ms-appdata:///local/file.txt" })
   };
   // Process file
   

   using Windows::Storage;
   auto getFileTask = create_task(StorageFile::GetFileFromApplicationUriAsync(ref new Uri("ms-appdata:///local/file.txt")));
   getFileTask.then([](StorageFile^ file) 
   {
       // Process file
   });
   

   Po zakończeniu GetFileFromApplicationUriAsync zwraca StorageFile, który reprezentuje plik file.txt w lokalnym folderze aplikacji (file w przykładzie).

   Prefiks "ms-appdata:///local/" w identyfikatorze URI odnosi się do folderu lokalnego aplikacji. Aby uzyskać dostęp do plików w folderach mobilnych lub tymczasowych aplikacji, zamiast tego użyj polecenia "ms-appdata:///roaming/" lub "ms-appdata:///temporary/". Więcej informacji na temat używania identyfikatorów URI aplikacji można uzyskać w Jak załadować zasoby plików.

Ponadto i w przeciwieństwie do innych lokalizacji można również uzyskiwać dostęp do plików w lokalizacjach danych aplikacji przy użyciu niektórych Win32 i COM dla aplikacji platformy UWP i niektórych funkcji biblioteki standardowej C/C++ z programu Visual Studio.

Nie można uzyskać dostępu do folderów lokalnych, mobilnych ani tymczasowych za pośrednictwem selektora plików.

Uzyskiwanie dostępu do urządzeń wymiennych

Ponadto aplikacja może domyślnie uzyskiwać dostęp do niektórych plików na połączonych urządzeniach. Jest to opcja, jeśli aplikacja używa rozszerzenia Autoodtwarzania do automatycznego uruchamiania, gdy użytkownicy podłączają urządzenie, takie jak aparat lub pendrive, do swojego systemu. Pliki, do których aplikacja może uzyskać dostęp, są ograniczone do określonych typów plików określonych za pomocą deklaracji skojarzenia typu pliku w manifeście aplikacji.

Oczywiście można również uzyskać dostęp do plików i folderów na urządzeniu wymiennym, wywołując selektor plików (przy użyciu FileOpenPicker i FolderPicker) i pozwalając użytkownikowi wybrać pliki i foldery, aby aplikacja mogła uzyskać dostęp. Dowiedz się, jak używać selektora plików w Otwórz pliki i foldery przy użyciu selektora.

Folder pobierania użytkownika

Folder, w którym pobierane pliki są domyślnie zapisywane.

Domyślnie aplikacja może uzyskiwać dostęp tylko do plików i folderów w folderze Pobrane utworzonej przez aplikację użytkownika. Można jednak uzyskać dostęp do plików i folderów w folderze Pliki do pobrania użytkownika, wywołując selektor plików (FileOpenPicker lub FolderPicker), aby użytkownicy mogli nawigować i wybierać pliki lub foldery, aby aplikacja mogła uzyskać dostęp.

• Plik można utworzyć w folderze Pobrane użytkownika w ten sposób:

  using Windows.Storage;
  StorageFile newFile = await DownloadsFolder.CreateFileAsync("file.txt");
  

  Windows.Storage.DownloadsFolder.createFileAsync("file.txt").done(
      function(newFile) {
          // Process file
      }
  );
  

  Windows::Storage::StorageFile newFile{
      co_await Windows::Storage::DownloadsFolder::CreateFileAsync(L"file.txt")
  };
  // Process file
  

  using Windows::Storage;
  auto createFileTask = create_task(DownloadsFolder::CreateFileAsync(L"file.txt"));
  createFileTask.then([](StorageFile^ newFile)
  {
      // Process file
  });
  

  DownloadsFolder. CreateFileAsync jest przeciążony, dzięki czemu można określić, co system powinien zrobić, jeśli w folderze Pobrane znajduje się już istniejący plik o tej samej nazwie. Po zakończeniu tych metod zwracają StorageFile, który reprezentuje utworzony plik. Ten plik jest nazywany newFile w przykładzie.

• Podfolder można utworzyć w folderze Pobrane użytkownika w następujący sposób:

  using Windows.Storage;
  StorageFolder newFolder = await DownloadsFolder.CreateFolderAsync("New Folder");
  

  Windows.Storage.DownloadsFolder.createFolderAsync("New Folder").done(
      function(newFolder) {
          // Process folder
      }
  );
  

  Windows::Storage::StorageFolder newFolder{
      co_await Windows::Storage::DownloadsFolder::CreateFolderAsync(L"New Folder")
  };
  // Process folder
  

  using Windows::Storage;
  auto createFolderTask = create_task(DownloadsFolder::CreateFolderAsync(L"New Folder"));
  createFolderTask.then([](StorageFolder^ newFolder)
  {
      // Process folder
  });
  

  DownloadsFolder. CreateFolderAsync jest przeciążona, dzięki czemu można określić, co system powinien zrobić, jeśli w folderze Pobrane znajduje się już istniejący podfolder o tej samej nazwie. Po zakończeniu tych metod zwracają StorageFolder, który reprezentuje utworzony podfolder. Ten plik jest nazywany newFolder w przykładzie.

Uzyskiwanie dostępu do dodatkowych lokalizacji

Oprócz domyślnych lokalizacji aplikacja może uzyskiwać dostęp do dodatkowych plików i folderów przez deklarowanie możliwości w manifeście aplikacji lub przez wywoływanie selektora plików, aby umożliwić użytkownikowi pobieranie plików i folderów w celu uzyskania dostępu do aplikacji.

Aplikacje, które deklarują rozszerzenie AppExecutionAlias, mają uprawnienia systemu plików z katalogu, z którego są uruchamiane w oknie konsoli i w dół.

Zachowywanie dostępu do plików i folderów

Gdy aplikacja pobiera plik lub folder za pomocą selektora, aktywacji pliku, operacji przeciągania i upuszczania itp., ma dostęp tylko do tego pliku lub folderu do momentu zakończenia działania aplikacji. Jeśli chcesz automatycznie uzyskać dostęp do pliku lub folderu w przyszłości, możesz dodać go do FutureAccessList, aby aplikacja mogła łatwo uzyskać dostęp do tego elementu w przyszłości. Możesz również użyć MostRecentlyUsedList, aby łatwo zarządzać listą ostatnio używanych plików.

Możliwości uzyskiwania dostępu do innych lokalizacji

W poniższej tabeli wymieniono dodatkowe lokalizacje, do których można uzyskać dostęp, deklarując co najmniej jedną funkcję i korzystając ze skojarzonego interfejsu API Windows.Storage.

Przykład

W tym przykładzie dodano ograniczoną broadFileSystemAccess możliwości. Oprócz określenia możliwości, należy dodać przestrzeń nazw rescap, która jest również dodawana do IgnorableNamespaces.

<Package
  ...
  xmlns:rescap="http://schemas.microsoft.com/appx/manifest/foundation/windows10/restrictedcapabilities"
  IgnorableNamespaces="uap mp rescap">
...
<Capabilities>
    <rescap:Capability Name="broadFileSystemAccess" />
</Capabilities>