C# IsolatedStorageFile.OpenFile方法代码示例

 private static void GetFile(IsolatedStorageFile istorage, string filename, Action<File> returns)
 {
     using (var openedFile = istorage.OpenFile(filename, System.IO.FileMode.Open))
     {
         ReadFileFromOpenFile(filename, openedFile, returns);
     }
 }

 public IsolatedStorageTracer()
 {
     _storageFile = IsolatedStorageFile.GetUserStoreForApplication();
     _storageFileStream = _storageFile.OpenFile("MagellanTrace.log", FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.ReadWrite);
     _streamWriter = new StreamWriter(_storageFileStream);
     _streamWriter.AutoFlush = true;
 }

        private void Save()
        {
            store = IsolatedStorageFile.GetUserStoreForApplication();

            IsolatedStorageFileStream stream = store.OpenFile(filterFilename, FileMode.Truncate);
            if (null != stream)
            {
                DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(FilterViewModel));
                ser.WriteObject(stream, App.ViewModelFilter);
                stream.Close();
            }
        }

 protected static string ReadTextFile(IsolatedStorageFile isf, string path)
 {
     string text;
     using (var fileStream = isf.OpenFile(path, FileMode.Open))
     {
         using (StreamReader sr = new StreamReader(fileStream))
         {
             text = sr.ReadToEnd();
         }
     }
     return text;
 }

    /**
     * implements of CCUserDefault
     */
    private CCUserDefault()
    {
        myIsolatedStorage = IsolatedStorageFile.GetUserStoreForApplication();

        // only create xml file once if it doesnt exist
        if ((!isXMLFileExist())) {
            createXMLFile();
        }

        using (IsolatedStorageFileStream fileStream = myIsolatedStorage.OpenFile(XML_FILE_NAME, FileMode.Open, FileAccess.Read)) {
            parseXMLFile(fileStream);
        }
    }

        private static Stream OpenLogFile(IsolatedStorageFile store)
        {
            if (Profile == null)
            {
                return Stream.Null;
            }

            try
            {
                var fileName = string.Format(LOGFILE_TEMPLATE, DateTime.UtcNow.ToString("yyyy-MM-dd"));
                var folderPath = Path.Combine(Profile.CurrentProfilePath(), LOGFOLDER);

                if (!store.DirectoryExists(folderPath))
                {
                    store.CreateDirectory(folderPath);
                }

                var filePath = Path.Combine(folderPath, fileName);

                if (store.FileExists(filePath))
                {
                    return store.OpenFile(filePath, FileMode.Append);
                }
                else
                {
                    CleanupLogs(store, folderPath);

                    return store.OpenFile(filePath, FileMode.Create);
                }
            }
            catch (Exception ex)
            {
                // Logging Failed, don't kill the process because of it
                Debugger.Break();

                return Stream.Null;
            }
        }

        private static void CopyToIsolatedStorage(string file, IsolatedStorageFile store, bool overwrite = true)
        {
            if (store.FileExists(file) && !overwrite)
                return;

            using (Stream resourceStream = Application.GetResourceStream(new Uri(file, UriKind.Relative)).Stream)
            using (IsolatedStorageFileStream fileStream = store.OpenFile(file, FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite))
            {
                int bytesRead;
                var buffer = new byte[resourceStream.Length];
                while ((bytesRead = resourceStream.Read(buffer, 0, buffer.Length)) > 0)
                    fileStream.Write(buffer, 0, bytesRead);
            }
        }

        private BitmapImage getThumbnail(string file, IsolatedStorageFile iso)
        {
            BitmapImage bmp = new BitmapImage();

            if (iso.FileExists(file))
            {
                using (IsolatedStorageFileStream stream = iso.OpenFile(file, FileMode.Open, FileAccess.Read))
                {
                    bmp.SetSource(stream);
                }
            }
            else
                bmp = null;

            return bmp;
        }

        private void Load()
        {
            store = IsolatedStorageFile.GetUserStoreForApplication();

            IsolatedStorageFileStream stream = store.OpenFile(filterFilename, FileMode.OpenOrCreate);
            if (null != stream)
            {
                DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(FilterViewModel));
                App.ViewModelFilter = (FilterViewModel)ser.ReadObject(stream);
                stream.Close();

                if (null == App.ViewModelFilter)
                {   // First time app was run since installation
                    App.ViewModelFilter = new FilterViewModel();
                }
            }
        }

        /// <summary>
        /// 读取指定的story.
        /// </summary>
        /// <param name="storyName">story名称.</param>
        /// <param name="userStore">如果参数为null, 创建一个新的.</param>
        internal static void ReadStoryFile(string storyName, IsolatedStorageFile userStore = null)
        {
            if (userStore == null)
            {
                userStore = IsolatedStorageFile.GetUserStoreForApplication();
            }
            using (IsolatedStorageFileStream fileStream = userStore.OpenFile(storyName + ".xml", System.IO.FileMode.Open))
            {
                XDocument xdoc = XDocument.Load(fileStream);
                var picturesLibrary = new MediaLibrary().Pictures;

                // Load all photos.
                foreach (XElement photoElement in xdoc.Root.Elements())
                {
                    try
                    {
                        Photo photo = new Photo()
                        {
                            Name = photoElement.Attribute("Name").Value,
                        };
                        string photoDurationString = photoElement.Attribute("PhotoDuration").Value;
                        int photoDuration = int.Parse(photoDurationString);
                        photo.PhotoDuration = TimeSpan.FromSeconds(photoDuration);
                        XElement transitionElement = photoElement.Element("Transition");
                        if (transitionElement != null)
                        {
                            photo.Transition = TransitionBase.Load(photoElement.Element("Transition"));
                        }
                        Picture picture = picturesLibrary.Where(p => p.Name == photo.Name).FirstOrDefault();
                        if (picture == null)
                        {
                            // 如果找不到原文件，可能已经被删除了
                            // TODO: 我们需要记录错误吗? 我们是继续下一个图片还是抛出异常?
                            continue;
                        }
                        photo.ThumbnailStream = picture.GetThumbnail();
                        App.MediaCollection.Add(photo);
                    }
                    catch
                    {
                        // TODO: 我们需要记录错误吗? 我们是继续下一个图片还是抛出异常?
                        continue;
                    }
                }
            }
        }

        private void signInButton_SessionChanged_1(object sender, Microsoft.Live.Controls.LiveConnectSessionChangedEventArgs e)
        {
            if (e.Status != LiveConnectSessionStatus.Connected)
                return;


            manager.AllRoadMapsReceived += (o, eventAllRoadMaps) =>
            {
                if (eventAllRoadMaps.RoadMaps.Count  == 0)
                {
                    Debug.WriteLine("Aucun rendez-vous n'existe pour les jours sélectionnés");
                    return;
                }

                try
                {
                    //SaveTableur();
                    SpreadSheetRoadmapGenerator.GenerateXLS("feuilles-de-route.xlsx", eventAllRoadMaps.RoadMaps, 5.5f, 1.6f);
                    if (e.Session != null && e.Status == LiveConnectSessionStatus.Connected)
                    {
                        myIsolatedStorage = IsolatedStorageFile.GetUserStoreForApplication();
                        fileStream = myIsolatedStorage.OpenFile("feuilles-de-route.xlsx", FileMode.Open, FileAccess.Read);
                        reader = new StreamReader(fileStream);
                        App.Session = e.Session;
                        LiveConnectClient client = new LiveConnectClient(e.Session);
                        client.UploadCompleted += client_UploadCompleted;
                        client.UploadAsync("me/skydrive", "feuilles-de-route.xlsx", reader.BaseStream, OverwriteOption.Overwrite);
                    }
                }
                catch (Exception exception)
                {
                    Debug.WriteLine(exception.Message);
                }
            };
            ReferenceMeeting start = new ReferenceMeeting(new DateTime(2013, 1, 2, 8, 30, 0), new Location()
            {
                Latitude = 48.85693,
                Longitude = 2.3412
            }) { City = "Paris", Subject = "Start" };
            ReferenceMeeting end = start;
            end.Subject = "End";

            manager.GetAllRoadMapsAsync(new DateTime(2013, 1, 2), new DateTime(2013, 2, 10), start, end);

        }

    /**
     * implements of CCUserDefault
     */
    private CCUserDefault()
    {
        #if WINDOWS || MACOS || LINUX
        // only create xml file once if it doesnt exist
        if ((!isXMLFileExist())) {
            createXMLFile();
        }
        using (FileStream fileStream = new FileInfo(XML_FILE_NAME).OpenRead()){
            parseXMLFile(fileStream);
        }
        #else
        myIsolatedStorage = IsolatedStorageFile.GetUserStoreForApplication();

        // only create xml file once if it doesnt exist
        if ((!isXMLFileExist())) {
            createXMLFile();
        }

        using (IsolatedStorageFileStream fileStream = myIsolatedStorage.OpenFile(XML_FILE_NAME, FileMode.Open, FileAccess.Read)) {
            parseXMLFile(fileStream);
        }
        #endif
    }

        private void LoadRepos(IsolatedStorageFile iso)
        {
            if (!iso.FileExists(RepoFilename))
                return;

            try
            {
                using (var stream = iso.OpenFile(RepoFilename, FileMode.Open, FileAccess.Read))
                using (var br = new BinaryReader(stream))
                {
                    var fileVer = br.ReadInt32();
                    var numContexts = br.ReadInt32();
                    for (int i = 0; i < numContexts; i++)
                    {
                        var login = br.ReadString();
                        foreach (var context in Contexts)
                        {
                            if (context.User.Login.Equals(login))
                            {
                                var numMyRepos = br.ReadInt32();
                                context.Repositories.Clear();
                                for (int j = 0; j < numMyRepos; j++)
                                {
                                    var repo = new Repo();
                                    repo.Load(br, fileVer);
                                    context.Repositories.Add(repo);
                                }
                                break;
                            }
                        }
                    }

                    br.Close();
                }
            }
            catch (EndOfStreamException)
            {
                iso.DeleteFile(RepoFilename);
            }
        }

        private static void saveImageToCache(ExtendedImage image, string filename, IsolatedStorageFile storage)
        {
            try
            {
                using (IsolatedStorageFileStream cachedFile = storage.OpenFile(filename, FileMode.Create))
                {
                    WriteableBitmap bitmap = ImageExtensions.ToBitmap(image);
                    bitmap.SaveJpeg(cachedFile, bitmap.PixelWidth, bitmap.PixelHeight, 0, 80);

#if DEBUG
                    App.logger.log("Created cached file {0}", filename);
#endif
                }
            }
            catch (Exception)
            {
#if DEBUG
                throw;
#endif
            }
        }

        private void LoadAuth(IsolatedStorageFile isoStore)
        {
            if (isoStore.FileExists(AuthFilename))
            {
                try
                {
                    using (var stream = isoStore.OpenFile(AuthFilename, FileMode.Open, FileAccess.Read))
                    using (var br = new BinaryReader(stream))
                    {
                        var fileVer = br.ReadInt32();
                        var unameLen = br.ReadInt32();
                        var unameEncrypted = br.ReadBytes(unameLen);
                        var pwordLen = br.ReadInt32();
                        var pwordEncrypted = br.ReadBytes(pwordLen);
                        var unamePlain = ProtectedData.Unprotect(unameEncrypted, null);
                        var pwordPlain = ProtectedData.Unprotect(pwordEncrypted, null);
                        _username = System.Text.Encoding.UTF8.GetString(unamePlain, 0, unamePlain.Length);
                        _password = System.Text.Encoding.UTF8.GetString(pwordPlain, 0, pwordPlain.Length);
                        IsAuthenticated = true;
                        InitAuth(_username, _password);

                        var numContexts = br.ReadInt32();
                        Contexts.Clear();
                        for (int i = 0; i < numContexts; i++)
                        {
                            var usr = new User();
                            usr.Load(br, fileVer);
                            Contexts.Add(new Context() { User = usr });
                        }
                        AuthenticatedUser = Contexts[0].User;

                        br.Close();
                    }
                }
                catch (EndOfStreamException)
                {
                    isoStore.DeleteFile(AuthFilename);
                }
            }
            else
            {
                IsAuthenticated = false;
            }
        }