Georg fährt extra nach Berlin um Steve Ballmer zu treffen

31 Tage Mango | Tag #16: Isolated Storage Explorer

Die­ser Arti­kel ist Tag #16 der Serie 31 Tage Man­go von Jeff Blankenburg.

Der Ori­gi­nal­ar­ti­kel befin­det sich hier: Day #16: Iso­la­ted Sto­rage Explo­rer.

Die­ser Arti­kel wur­de in der Ori­gi­nal­se­rie von Gast­au­tor Sami­dip Basu geschrie­ben. Bei Twit­ter kann Sami­dip unter @samidip erreicht werden. 

Im Win­dows Pho­ne SDK 7.1 ist ein neu­es Werk­zeug für Ent­wick­ler ent­hal­ten: der Iso­la­ted Sto­rage Explo­rer. In die­sem Arti­kel wol­len wir uns anse­hen, wie man den Iso­la­ted Sto­rage Explo­rer ver­wen­det und wie er beim Test von Anwen­dun­gen, die Daten im Iso­la­ted Sto­rage able­gen, hel­fen kann. Der Iso­la­ted Sto­rage Explo­rer funk­tio­niert sowohl mit Anwen­dun­gen, die die Win­dows Pho­ne 7.1 Run­time ver­wen­den, als auch mit Anwen­dun­gen für Win­dows Pho­ne 7.0.

Die Grundlagen

Iso­la­ted Sto­rage ist für Win­dows Pho­ne Anwen­dun­gen die Lösung, Daten per­sis­tent und nur für die Anwen­dung sicht­bar („Sand­bo­xed“) zu spei­chern (Jeff hat das an Tag #15 der Ori­gi­nal 31 Days of Win­dows Pho­ne behan­delt). Die Abs­trak­ti­on vom dar­un­ter lie­gen­den Datei­sys­tem des Betriebs­sys­tems hat für 3rd-Par­ty Anwen­dun­gen den Vor­teil der Sich­her­heit und Zuver­läs­sig­keit. Bei der Abla­ge von Daten im Iso­la­ted Sto­rage ist es wich­tig, dass wir ers­tens die rich­ti­gen Daten able­gen und zwei­tens, dass wir den Fuß­ab­druck der Anwen­dung mög­lichst klein hal­ten, also nicht benö­tig­te Daten wie­der löschen, etc.. Hier­bei kann der Iso­la­ted Sto­rage Explo­rer helfen.

Die Ver­wen­dung von Iso­la­ted Sto­rage kann auf drei unter­schied­li­che Wei­sen erfolgen:

  • Spei­che­rung von Name-Wert-Paa­ren durch die Klas­se Iso­la­tedS­to­rage­Set­tings.
  • Spei­che­rung von Ord­nern und Datei­en im Iso­la­ted Storage.
  • Ver­wen­dung von SQL CE um rela­tio­na­le Daten im Iso­la­ted Sto­rage abzulegen.

Vie­le Anwen­dun­gen ver­wen­den die zwei­te Mög­lich­keit der Abla­ge belie­bi­ger Datei­en und Ord­ner im Iso­la­ted Sto­rage. Da der Win­dows Pho­ne Emu­la­tor eine VM ist, war es vor dem Win­dows Pho­ne Man­go SDK 7.1 etwas umständ­lich, die Kor­rekt­heit der Ord­ner- und Datei­struk­tur im Iso­la­ted Sto­rage zu überprüfen.

Mit dem neu­en SDK haben wir das Iso­la­ted Sto­rage Explo­rer Werk­zeug bekom­men, mit dem es mög­lich ist, die Datei­en und Ver­zeich­nis­se im Iso­la­ted Sto­rage anzu­se­hen und zu mani­pu­lie­ren. Das funk­tio­niert sowohl für Iso­la­ted Sto­rage im Emu­la­tor als auch für ent­sperr­te Ent­wick­ler­ge­rä­te. Die­ses Kom­man­do­zei­len­werk­zeug erlaubt die Auf­lis­tung von Datei­en im der Wur­zel des Iso­la­ted Sto­rage der Anwen­dung aber auch in Unter­ver­zeich­nis­sen, die von der Anwen­dung zur Lauf­zeit erstellt wur­den. Zudem kön­nen wir den Inhalt des Iso­la­ted Sto­rage aus dem Emu­la­tor oder dem Gerät in einen Ord­ner auf dem Com­pu­ter trans­fe­rie­ren. Dort kön­nen wir Datei­en oder Ver­zeich­nis­se ver­än­dern und die geän­der­ten Daten wie­der zurück­spie­len. Ers­tens kön­nen wir damit die von der Anwen­dung ange­leg­ten Struk­tu­ren über­prü­fen. Zwei­tens kön­nen wir das Ver­hal­ten der Anwen­dung — z.B. in Rand­fäl­len — tes­ten, indem wir die Daten im Iso­la­ted Sto­rage mani­pu­lie­ren und wie­der in den Emu­la­tor oder auf das Gerät über­tra­gen. Doch genug der Vor­re­de — las­sen Sie uns beginnen!

Unsere Beispielanwendung

In unse­rer Demo Win­dows Pho­ne Anwen­dung wer­den wir eini­ge Bei­spiel­da­tei­en in der Wur­zel des Iso­la­ted Sto­rage anle­gen. Außer­dem wer­den wir eini­ge Ord­ner erstel­len und auch dort ein paar Bei­spiel­da­tei­en able­gen. Wir begin­nen dies­mal mit der Pro­jekt­vor­la­ge für eine Pivot Anwen­dung. Im ers­ten Bereich wer­den wir die Datei­en in der Wur­zel anzei­gen, im zwei­ten die Unter­ord­ner mit Datei­en und der drit­te Bereich wird eine klei­ne Überraschung.

Wenn die Anwen­dung zum ers­ten Mal star­tet, rufen wir eine klei­ne Metho­de, die die Datei­en und Ver­zeich­nis­se im Iso­la­ted Sto­rage für uns anlegt. Im Kon­struk­tor unse­rer App.xaml.cs set­zen wir also ein glo­ba­les Flag, wel­ches uns anzei­gen wird, ob wir die Initia­li­sie­rung durch­füh­ren müssen:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Navigation;
using System.Windows.Shapes;
using Microsoft.Phone.Controls;
using Microsoft.Phone.Shell;

namespace Day16_IsolatedStorageExplorer
{
   public partial class App : Application
   {
      public PhoneApplicationFrame RootFrame { get; private set; }
      public bool FirstLaunch;

        // Constructor
      public App()
      {
         // All the automatically-added code...

         // Set the flag for fresh App launches.
         this.FirstLaunch = true;
      }

      // Everything else ...
   }
} 

Unse­re Anwen­dung braucht immer noch eine Metho­de, die den Iso­la­ted Sto­rage beim ers­ten Start mit Datei­en und Ver­zeich­nis­sen füllt. Im fol­gen­den Code­bei­spiel spei­chern wir also eini­ge Bei­spiel­da­tei­en und ‑Ver­zeich­nis­se. Wenn Sie schon eine Anwen­dung haben, die Inhal­te im Iso­la­ted Sto­rage ablegt, kön­nen Sie die­sen Schritt auch weg­las­sen. Beach­ten Sie die Ver­wen­dung des Name­spaces System.IO.IsolatedStorage. Die­sen brau­chen wir, um auf die Klas­sen Iso­la­tedS­to­rage­Fi­le und Iso­la­tedS­to­rage­FileStream zuzu­grei­fen. Die­se wie­der­um brau­chen wir, um unse­re Bei­spiel­da­tei­en zu schreiben.

using System;
using System.IO;
using System.IO.IsolatedStorage;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;
using Microsoft.Phone.Controls;

namespace Day16_IsolatedStorageExplorer
{
   public partial class MainPage : PhoneApplicationPage
   {
      IsolatedStorageFile fileStorage;

      // Constructor
      public MainPage()
      {
         InitializeComponent();

         // Create a reference to the App's Isolated Storage
         fileStorage = IsolatedStorageFile.GetUserStoreForApplication();

         // Create initial sample Files & Directories, for fresh App Launch only.
         if ((App.Current as Day16_IsolatedStorageExplorer.App).FirstLaunch)
            this.CreateInitialFilesAndDirectories();

         // Reset the flag.
         (App.Current as Day16_IsolatedStorageExplorer.App).FirstLaunch = false;
      }

      private void CreateInitialFilesAndDirectories()
      {
         // Create a new StreamWriter, to write files to the root directory.
         StreamWriter fileWriter = new StreamWriter(new IsolatedStorageFileStream("RootFile1.txt", FileMode.OpenOrCreate, fileStorage));

         // Write sample data.
         fileWriter.WriteLine("This is test data.");

         // Close the StreamWriter.
         fileWriter.Close();

         // Repeat.
         fileWriter = new StreamWriter(new IsolatedStorageFileStream("RootFile2.txt", FileMode.OpenOrCreate, fileStorage));
         fileWriter.WriteLine("This is test data.");
         fileWriter.Close();

         // Create 2 new SubDirectories.
         fileStorage.CreateDirectory("SubDirectory1");
         fileStorage.CreateDirectory("SubDirectory2");

         // Put sample files in them.
         fileWriter = new StreamWriter(new IsolatedStorageFileStream("SubDirectory1\\SubDir1File1.txt", FileMode.OpenOrCreate, fileStorage));
         fileWriter.WriteLine("This is test data.");
         fileWriter.Close();
         fileWriter = new StreamWriter(new IsolatedStorageFileStream("SubDirectory1\\SubDir1File2.txt", FileMode.OpenOrCreate, fileStorage));
         fileWriter.WriteLine("This is test data.");
         fileWriter.Close();
         fileWriter = new StreamWriter(new IsolatedStorageFileStream("SubDirectory2\\SubDir2File2.txt", FileMode.OpenOrCreate, fileStorage));
         fileWriter.WriteLine("This is test data.");
         fileWriter.Close();
      }
   }
} 

Um mehr über die Mög­lich­kei­ten der Datei­sys­tem­ope­ra­tio­nen mit den Klas­sen Iso­la­tedS­to­rage­Fi­le und Iso­la­tedS­to­rage­FileStream zu erfah­ren, kön­nen Sie in der MSDN Doku­men­ta­ti­on hier und hier nachlesen.

So, jetzt haben wir eini­ge Bei­spiel­da­tei­en in der Wur­zel des Iso­la­ted Sto­rage und zudem eini­ge Ver­zeich­nis­se, die eben­falls Bei­spiel­da­tei­en ent­hal­ten. Las­sen Sie uns jetzt den Inhalt des Iso­la­ted Sto­rage an der Benut­zer­ober­flä­che aus­ge­ben. Indem wir den Inhalt des Iso­la­ted Sto­rage dyna­misch aus­ge­ben, kön­nen wir spä­ter die Ände­run­gen über­prü­fen, die wir mit Hil­fe des Iso­la­ted Sto­rage Explo­rer Werk­zeugs an den Daten vor­neh­men wer­den. Damit der heu­ti­ge Arti­kel nicht zu lang wird, über­sprin­gen wir den XAML Code für die Benut­zer­ober­flä­che. Er ist aber in der Bei­spiel­an­wen­dung ent­hal­ten, die Sie unten her­un­ter­la­den kön­nen. Fol­gen­de Din­ge fügen wir hier hin­zu: eine klei­ne Klas­se Direc­to­ry­Sys­tem, die eine Lis­te unse­rer Ver­zeich­nis­se ver­wal­ten und uns beim Bin­ding hel­fen wird, den Code zum Scan­nen der Datei­en und Ver­zeich­nis­se und die Bin­dings an die bei­den List­Bo­xes Root­List­Box und Direc­to­ry­Sys­tem­List­Box im Pivot Con­trol. Hier ist also die modi­fi­zier­te code-behind Datei für die Main Page:

using System;
using System.IO;
using System.IO.IsolatedStorage;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;
using Microsoft.Phone.Controls;

namespace Day16_IsolatedStorageExplorer
{
   public partial class MainPage : PhoneApplicationPage
   {
      IsolatedStorageFile fileStorage;
      string[] rootFiles;
      string[] directories;
      string[] directoryFiles;

      List<DirectorySystem> listDirectorySystem = new List<DirectorySystem>();
        
      // Constructor
      public MainPage()
      {
         InitializeComponent();

         // Create a reference to the App's Isolated Storage
         fileStorage = IsolatedStorageFile.GetUserStoreForApplication();

         // Create initial sample Files & Directories, for fresh App Launch only.
         if ((App.Current as Day16_IsolatedStorageExplorer.App).FirstLaunch)
            this.CreateInitialFilesAndDirectories();

         // Reset the flag.
         (App.Current as Day16_IsolatedStorageExplorer.App).FirstLaunch = false;

         // Read root files.
         rootFiles = fileStorage.GetFileNames();
         this.RootListBox.ItemsSource = rootFiles;

         // Read Directories & build File system.
         directories = fileStorage.GetDirectoryNames();

         foreach (string dir in directories)
         {
            directoryFiles = fileStorage.GetFileNames(dir + "\\*");

            DirectorySystem newDir = new DirectorySystem();
            newDir.DirectoryName = dir;
            newDir.DirectoryFiles = directoryFiles;

            listDirectorySystem.Add(newDir);
         }

         // Bind to UI.
         this.DirectorySystemListBox.ItemsSource = listDirectorySystem;
      }       

      private void CreateInitialFilesAndDirectories()
      {
         // Create a new StreamWriter, to write files to the root directory.
         StreamWriter fileWriter = new StreamWriter(new IsolatedStorageFileStream("RootFile1.txt", FileMode.OpenOrCreate, fileStorage));

         // Write sample data.
         fileWriter.WriteLine("This is test data.");

         // Close the StreamWriter.
         fileWriter.Close();

         // Repeat.
         fileWriter = new StreamWriter(new IsolatedStorageFileStream("RootFile2.txt", FileMode.OpenOrCreate, fileStorage));
         fileWriter.WriteLine("This is test data.");
         fileWriter.Close();

         // Create 2 new SubDirectories.
         fileStorage.CreateDirectory("SubDirectory1");
         fileStorage.CreateDirectory("SubDirectory2");

         // Put sample files in them.
         fileWriter = new StreamWriter(new IsolatedStorageFileStream("SubDirectory1\\SubDir1File1.txt", FileMode.OpenOrCreate, fileStorage));
         fileWriter.WriteLine("This is test data.");
         fileWriter.Close();
         fileWriter = new StreamWriter(new IsolatedStorageFileStream("SubDirectory1\\SubDir1File2.txt", FileMode.OpenOrCreate, fileStorage));
         fileWriter.WriteLine("This is test data.");
         fileWriter.Close();
         fileWriter = new StreamWriter(new IsolatedStorageFileStream("SubDirectory2\\SubDir2File2.txt", FileMode.OpenOrCreate, fileStorage));
         fileWriter.WriteLine("This is test data.");
         fileWriter.Close();
      }      
   }

   public class DirectorySystem
   {
      public string DirectoryName { get; set; }
      public string[] DirectoryFiles { get; set; }
   }
} 

Falls Ihnen das ein biss­chen zuviel Code ist, laden Sie doch ein­fach den kom­plet­ten Source Code ganz unten im Arti­kel her­un­ter und pro­bie­ren Sie die Anwen­dung selbst aus. Wenn wir die Anwen­dung auf dem Emu­la­tor instal­lie­ren, wird unse­re obi­ge Initia­li­sie­rungs­me­tho­de auf­ge­ru­fen, um die Bei­spiel­da­ten im Iso­la­ted Sto­rage zu spei­chern. Als nächs­tes wird der Code aus­ge­führt, der den Iso­la­ted Sto­rage nach Datei­en und Ord­nern durch­sucht und die Ergeb­nis­se an die Benut­zer­ober­flä­che bin­det. Wenn alles funk­tio­niert, kön­nen Sie ein­fach F5 drü­cken um die Anwen­dung zu star­ten. Das soll­te dann unge­fähr so aussehen:

Demo AppDirectories with FilesRoot Files

Wir kön­nen jetzt in der Anwen­dung die Datei­en im Iso­la­ted Sto­rage anse­hen. Als nächs­tes wol­len wir die Datei­en auch öff­nen, den Inhalt betrach­ten und bear­bei­ten. Auf die­se Wei­se kön­nen wir den Inhalt von Datei­en nach der Bear­bei­tung prü­fen und zudem tes­ten, wie sich die Anwen­dung ver­hält, wenn wir Datei­en außer­halb des Emu­la­tors modi­fi­zie­ren. Um die Bear­bei­tung zu rea­li­sie­ren, fügen wir unse­rem Pro­jekt eine zwei­te ein­fa­che XAML Sei­te hin­zu, die uns zur Betrach­tung und Bear­bei­tung ein­zel­ner Datei­en die­nen wird. Hier ist die ange­streb­te Benutzeroberfläche:

Um die Sei­te zu einer ein­zel­nen Datei zu öff­nen, regis­trie­ren wir einen Mou­seLeft­But­tonUp Event Hand­ler für die Root­List­Box unse­rer Haupt­sei­te um fest­zu­stel­len, wel­che Datei der Anwen­der betrach­ten möch­te. Als nächs­tes fügen wir den fol­gen­den klei­nen Code­aus­schnitt im code-behind hinzu:

private void RootListBox_MouseLeftButtonUp(object sender, MouseButtonEventArgs e) 
{ 
   if (this.RootListBox.SelectedItem != null) 
   { 
      string selectedFileName = this.RootListBox.SelectedItem.ToString(); 
      this.NavigationService.Navigate(new Uri("/FileContent.xaml?FileName=" + selectedFileName, UriKind.Relative)); 

      this.RootListBox.SelectedItem = null; 
   } 
} 

Im Wesent­li­chen über­ge­ben wir ein­fach den Datei­na­men der gewähl­ten Datei an die zwei­te XAML Sei­te. Schau­en wir uns jetzt an, wie wir die Datei in der neu­en Sei­te lesen, zur Bear­bei­tung öff­nen und schließ­lich die Ände­run­gen des Anwen­ders speichern:

using System; 
using System.IO; 
using System.IO.IsolatedStorage; 
using System.Collections.Generic; 
using System.Linq; 
using System.Net; 
using System.Windows; 
using System.Windows.Controls; 
using System.Windows.Documents; 
using System.Windows.Input; 
using System.Windows.Media; 
using System.Windows.Media.Animation; 
using System.Windows.Shapes; 
using Microsoft.Phone.Controls; 

namespace Day16_IsolatedStorageExplorer 
{ 
   public partial class FileContent : PhoneApplicationPage 
   {       
      string currentFileName; 

      private void PhoneApplicationPage_Loaded(object sender, RoutedEventArgs e) 
      { 
         if (this.NavigationContext.QueryString.ContainsKey("FileName")) 
         { 
            currentFileName = this.NavigationContext.QueryString["FileName"]; 
            this.actualFileName.Text = currentFileName; 

            this.ReadFileData(currentFileName); 
         } 
      } 

      private void btnSave_Click(object sender, EventArgs e) 
      { 
         this.EditFileData(currentFileName); 
      } 

      private void ReadFileData(string filePath) 
      { 
         using (IsolatedStorageFile appIsolatedStorage = IsolatedStorageFile.GetUserStoreForApplication()) 
         { 
            if (appIsolatedStorage.FileExists(filePath)) 
            { 
               using (IsolatedStorageFileStream fileStream = appIsolatedStorage.OpenFile(filePath, FileMode.Open, FileAccess.Read)) 
               { 
                  using (StreamReader reader = new StreamReader(fileStream)) 
                  { 
                     this.fileContent.Text = reader.ReadLine(); 
                  } 
               } 
            } 
         } 
      } 

      private void EditFileData(string filePath) 
      { 
         using (IsolatedStorageFile appIsolatedStorage = IsolatedStorageFile.GetUserStoreForApplication()) 
         { 
            if (appIsolatedStorage.FileExists(filePath)) 
            { 
               using (IsolatedStorageFileStream fileStream = appIsolatedStorage.OpenFile(filePath, FileMode.Open, FileAccess.Write)) 
               { 
                  using (StreamWriter writer = new StreamWriter(fileStream)) 
                  { 
                     string editedText = this.fileContent.Text.Trim(); 
                     writer.Write(editedText); 
                     writer.Close(); 
                  } 
               } 
            } 
         } 

         this.NavigationService.Navigate(new Uri("/DirectoryListings.xaml", UriKind.Relative)); 
      } 
   } 
} 

Wenn die Sei­te lädt, lesen wir den Datei­na­men aus dem Query Para­me­ter, den wir von der Pivot Page über­ge­ben bekom­men haben. Mit dem Datei­na­men und einer Refe­renz auf den Iso­la­ted Sto­rage der Anwen­dung liest die Metho­de Read­Fi­le­Da­ta den Inhalt der Datei im les­ba­ren Modus zur Anzei­ge an der Ober­flä­che ein. Was pas­siert, wenn der Anwen­der Ände­run­gen am Datei­in­halt vor­nimmt und den Save But­ton drückt? Dann rufen wir die Metho­de Edit­Fi­le­Da­ta auf, wel­che die Datei öff­net — dies­mal aller­dings im schreib­ba­ren Modus. Sie ver­wen­det dann ein Objekt vom Typ Iso­la­tedS­to­rage­FileStream um den aktua­li­sier­ten Inhalt zurück in die Datei zu schreiben.

Wir sind jetzt so weit, dass wir Bei­spiel­da­tei­en im Iso­la­ted Sto­rage erstel­len, betrach­ten und bear­bei­ten kön­nen. Wei­ter­hin haben wir sogar eine ein­fa­che Ver­zeich­nis­struk­tur ange­legt. Das ist alles schon mal nicht schlecht — wir hät­ten aber etwas mehr Sicher­heit, wenn wir uns die im Emu­la­tor oder dem Gerät erstell­ten Struk­tu­ren und Inhal­te direkt anschau­en könn­ten. Hier kommt der Iso­la­ted Sto­rage Explo­rer ins Spiel!

Verwendung des Isolated Storage Explorers

Der Iso­la­ted Sto­rage Explo­rer ist ein Kom­man­do­zei­len­werk­zeug, wel­ches im Win­dows Pho­ne SDK 7.1 ent­hal­ten ist. Das Werk­zeug heißt ISETool.exe und befin­det sich nor­ma­ler­wei­se im Ver­zeich­nis Pro­gram Files\Microsoft SDKs\Windows Phone\v7.1\Tools\IsolatedStorageExplorerTool. Las­sen Sie uns also die Kom­man­do­zei­le star­ten und in das obi­ge Ver­zeich­nis wech­seln um das Werk­zeug zu starten.

Das ISE Werk­zeug kann in den Iso­la­ted Sto­rage des Emu­la­tors oder eines ent­sperr­ten Ent­wick­ler­ge­räts schau­en. Die Anwen­dung, deren Iso­la­ted Sto­rage Sie betrach­ten möch­ten, muss auf dem lau­fen­den Emu­la­tor instal­liert sein. Sie muss aber selbst nicht lau­fen, da der Sinn des Iso­la­ted Sto­rage genau die Per­sis­tenz ist. Wie jedes ande­re Kom­man­do­zei­len­werk­zeug gibt es für das ISE Werk­zeug eini­ge Kom­man­do­zei­len­schal­ter, die das Ver­hal­ten steu­ern. Die gene­rel­le Syn­tax ist wie folgt. Auf die ein­zel­nen Optio­nen gehen wir noch im Detail ein.

ISETool.exe <ts|rs|dir[:device-folder]> <xd|de> <Pro­duct GUID> [<com­pu­ter-path>]

Sobald unse­re Bei­spiel­an­wen­dung ein­mal gestar­tet wur­de, befin­den sich Datei­en und Ver­zeich­nis­se im Iso­la­ted Sto­rage. Ange­nom­men, die Anwen­dung läuft gera­de nicht und wir wol­len die Daten im Iso­la­ted Sto­rage nur mal anse­hen. Das Kom­man­do hier­für ist:

ISETool.exe dir xd 04ce6350-faf0-4977–8e5b-fb288fc127c0

Die Bestand­tei­le im Ein­zel­nen sind:

  • ISETool.exe = das Kom­man­do­zei­len­pro­gramm selbst.
  • dir = lis­tet alle Datei­en und Ver­zeich­nis­se unter­halb des ange­ge­be­nen Ver­zeich­nis­ses auf (oder unter­halb der Wur­zel, wenn kein Ver­zeich­nis ange­ge­ben wird).
  • xd = damit geben wir an, dass wir den Iso­la­ted Sto­rage des Emu­la­tors betrach­ten wollen.
  • de = mit de anstatt xd wür­den wir ange­ben, dass wir das sel­be Kom­man­do — nur für den Iso­la­ted Sto­rage auf dem ech­ten Gerät — aus­füh­ren möchten.
  • <Pro­duct GUID> = das ist die Appli­ca­ti­on ID unse­rer Anwen­dung, so dass das Werk­zeug weiß, in wel­chen Bereich des Iso­la­ted Sto­rage es schau­en soll. Die Pro­duct GUID zu jeder Anwen­dung steht in der Datei WMAppManifest.xml.

Mit die­sem Befehl gibt unser Kom­man­do­zei­len-Hel­fer­lein alle Bei­spiel­da­tei­en in der Wur­zel des Iso­la­ted Sto­rage und alle von uns ange­leg­ten Unter­ver­zeich­nis­se aus. Wol­len Sie den Inhalt eines der Unter­ver­zeich­nis­se anse­hen? Hier ist das Kommand:

ISETool.exe dir:„SubDirectory1“ xd 04ce6350-faf0-4977–8e5b-fb288fc127c0

Alles an dem Kom­man­do bleibt gleich. Wir geben ledig­lich ein Ver­zeich­nis an, des­sen Inhalt aus­ge­ge­ben wer­den soll.

Kom­men wir zum wirk­lich inter­es­san­ten Teil! Hier ist das Kom­man­do, um den Inhalt des Iso­la­ted Sto­rage vom Emu­la­tor oder vom Gerät in ein Ver­zeich­nis auf dem PC zu kopieren:

ISETool.exe ts xd 04ce6350-faf0-4977–8e5b-fb288fc127c0 „C:\Users\Sami\Desktop“

Zwei Din­ge sind hier neu:

  • ts = Take Snapshot („Abzug machen“). Wie der Name schon sagt, machen wir hier einen kom­plet­ten Abzug des Wur­zel­ver­zeich­nis­ses oder des ange­ge­be­nen Verzeichnisses.
  • <Com­pu­ter Path> = Hier­mit geben wir das Ziel­ver­zeich­nis auf dem Com­pu­ter an. Der Inhalt des Iso­la­ted Sto­rage wird in die­ses Ver­zeich­nis kopiert.

Unter­halb des ange­ge­be­nen Ver­zeich­nis­ses wird immer noch ein Ord­ner „Iso­la­tedS­to­re“ ange­legt. Wenn die­ser Ord­ner bereits exis­tiert, wird der Inhalt über­schrie­ben. Das sel­be Kom­man­do kann ver­wen­det wer­den, um nur den Inhalt eines Unter­ver­zeich­nis­ses im Iso­la­ted Sto­rage zu kopie­ren. Wie oben gibt man hier im Kom­man­do­zei­len­be­fehl das ent­spre­chen­de Unter­ver­zeich­nis an. Wenn Ihre Anwen­dung eine Win­dows Pho­ne 7.1 Anwen­dung ist, wird der Ord­ner „Iso­la­tedS­to­re“ ein Unter­ver­zeich­nis „Shared“ ent­hal­ten. Hier sind die anwen­dungs­spe­zi­fi­schen Daten der Hin­ter­grund­auf­ga­ben (Back­ground Trans­fer) und Shell­Con­tent der Secon­da­ry Tiles abge­legt. Wenn Sie den Inhalt mit dem obi­gen Kom­man­do auf den Desk­top kopiert haben, wür­de das Ergeb­nis in etwa so aussehen:

Was, wenn wir Datei­en oder Ver­zeich­nis­se vom Com­pu­ter zurück in den Iso­la­ted Sto­rage bekom­men wol­len? Das ist eine gute Mög­lich­keit zum Tes­ten, da wir hier­mit aus­pro­bie­ren kön­nen, wie sich die Anwen­dung bei Ände­run­gen der Datei­en oder Ver­zeich­nis­se ver­hält. Hier ist das Kommando:

ISETool.exe rs xd 04ce6350-faf0-4977–8e5b-fb288fc127c0 „C:\Users\Sami\Desktop\IsolatedStore“

Neu ist nur ein klei­ner Teil:

  • rs = Res­to­re Snapshot (Abzug wie­der­her­stel­len). Wie der Name schon sagt, wer­den hier­mit die Dateien/Verzeichnisse im Iso­la­ted Sto­rage mit dem Ver­zeich­nis­in­halt auf dem Com­pu­ter ersetzt. Beach­ten Sie, dass wir für das Quell­ver­zeich­nis hier „Iso­la­tedS­to­re“ mit im Pfad ange­ben müssen.

Erstel­len wir eine belie­bi­ge Text­da­tei im Ver­zeich­nis „Iso­la­tedS­to­re“. Dies ent­spricht der Wur­zel des Iso­la­ted Sto­rage im Emu­la­tor bzw. Gerät:

Wenn wir jetzt das Res­to­re Snapshot Kom­man­do auf­ru­fen, wird die Datei im ent­spre­chen­den Iso­la­ted Sto­rage auf­tau­chen. Wenn wir jetzt unse­re Anwen­dung wie­der aus­füh­ren, wer­den wir sehen, dass sie die neue Datei anzeigt und auch der Inhalt vor­han­den ist:

File Transfer into EmulatorFile Contents from Desktop

Damit Sie noch mal genau wis­sen, was Sie zu erwar­ten haben, sind hier die Aus­ga­ben aller unse­rer Kommandos:

Zusammenfassung

Das war’s! Egal, was für Datei­en oder Ver­zeich­nis­se Sie im Iso­la­ted Sto­rage able­gen — mit dem Iso­la­ted Sto­rage Explo­rer kön­nen Sie sicher­stel­len, dass der Inhalt tat­säch­lich der ist, den Sie wollten.

Adi­os!

Um eine kom­plet­te Win­dows Pho­ne Anwen­dung mit dem Bei­spiel­code die­ses Arti­kels zur Ver­wen­dung des Iso­la­ted Sto­rage Explo­rer run­ter­zu­la­den, kli­cken Sie auf den Down­load Code Button:

Mor­gen wer­den wir uns ein wei­te­res coo­les The­ma anschau­en: Wir wer­den sehen, wie man Win­dows Azu­re ver­wen­den kann, um eine Win­dows Pho­ne Anwen­dung zu unterstützen.

Bis dahin!

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert