C# IsolatedStorageFile.Reserve方法代码示例

        /// <include file='doc\IsolatedStorageFileStream.uex' path='docs/doc[@for="IsolatedStorageFileStream.IsolatedStorageFileStream7"]/*' />
        public IsolatedStorageFileStream(String path, FileMode mode, 
            FileAccess access, FileShare share, int bufferSize,  
            IsolatedStorageFile isf) 
        {
            if (path == null)
                throw new ArgumentNullException("path");

            if (s_BackSlash == null)
                s_BackSlash = new String(System.IO.Path.DirectorySeparatorChar,1);

            if ((path.Length == 0) || path.Equals(s_BackSlash))
                throw new ArgumentException(
                    Environment.GetResourceString(
                        "IsolatedStorage_path"));

            ulong oldFileSize=0, newFileSize;
            bool fNewFile = false;
            FileInfo fOld;
 
            if (isf == null)
            {
                m_OwnedStore = true;
                isf = IsolatedStorageFile.GetUserStoreForDomain();
            }

            m_isf = isf;

            FileIOPermission fiop = 
                new FileIOPermission(FileIOPermissionAccess.AllAccess,
                    m_isf.RootDirectory);

            fiop.Assert();

            m_GivenPath = path;
            m_FullPath  = m_isf.GetFullPath(m_GivenPath);

            // Cache the old file size if the file size could change
            // Also find if we are going to create a new file.

            switch (mode) {
            case FileMode.CreateNew:        // Assume new file
                fNewFile = true;
                break;

            case FileMode.Create:           // Check for New file & Unreserve
            case FileMode.OpenOrCreate:     // Check for new file
            case FileMode.Truncate:         // Unreserve old file size
            case FileMode.Append:           // Check for new file

                try {
                    fOld = new FileInfo(m_FullPath);
                    oldFileSize = IsolatedStorageFile.RoundToBlockSize((ulong)fOld.Length);
                } catch (Exception e) {
                    if (e is FileNotFoundException)
                        fNewFile = true;
                }

                break;

            case FileMode.Open:             // Open existing, else exception
                break;

            default:
                throw new ArgumentException(
                    Environment.GetResourceString(
                        "IsolatedStorage_FileOpenMode"));
            }

            if (fNewFile)
                m_isf.ReserveOneBlock();

            try {
                m_fs = new 
                    FileStream(m_FullPath, mode, access, share, bufferSize, 
                        false, m_GivenPath, true);
            } catch (Exception) {

                if (fNewFile)
                    m_isf.UnreserveOneBlock();

                throw;
            }

            // make adjustment to the Reserve / Unreserve state

            if ((fNewFile == false) &&
                ((mode == FileMode.Truncate) || (mode == FileMode.Create)))
            {
                newFileSize = IsolatedStorageFile.RoundToBlockSize((ulong)m_fs.Length);
    
                if (oldFileSize > newFileSize)
                    m_isf.Unreserve(oldFileSize - newFileSize);
                else if (newFileSize > oldFileSize)     // Can this happen ?
                    m_isf.Reserve(newFileSize - oldFileSize);
            }
        }

        public IsolatedStorageFileStream(String path, FileMode mode, 
            FileAccess access, FileShare share, int bufferSize, 
            IsolatedStorageFile isf)
        { 
            if (path == null)
                throw new ArgumentNullException("path");
            Contract.EndContractBlock();
 
#if FEATURE_PAL
            if (s_BackSlash == null) 
                s_BackSlash = new String(System.IO.Path.DirectorySeparatorChar,1); 
#endif // FEATURE_PAL
 
            if ((path.Length == 0) || path.Equals(s_BackSlash))
                throw new ArgumentException(
                    Environment.GetResourceString(
                        "IsolatedStorage_Path")); 

            ulong oldFileSize=0, newFileSize; 
            bool fNewFile = false, fLock=false; 

            if (isf == null) 
            {
#if FEATURE_ISOSTORE_LIGHT
                throw new ArgumentNullException("isf");
#else // !FEATURE_ISOSTORE_LIGHT 
                m_OwnedStore = true;
                isf = IsolatedStorageFile.GetUserStoreForDomain(); 
#endif // !FEATURE_ISOSTORE_LIGHT 
            }
 
            if (isf.Disposed)
                throw new ObjectDisposedException(null, Environment.GetResourceString("IsolatedStorage_StoreNotOpen"));

 
            m_isf = isf;
 
            FileIOPermission fiop = 
                new FileIOPermission(FileIOPermissionAccess.AllAccess,
                    m_isf.RootDirectory); 

            fiop.Assert();
            fiop.PermitOnly();
 
            m_GivenPath = path;
            m_FullPath  = m_isf.GetFullPath(m_GivenPath); 
 
            RuntimeHelpers.PrepareConstrainedRegions();
            try { // for finally Unlocking locked store 

                // Cache the old file size if the file size could change
                // Also find if we are going to create a new file.
 
                switch (mode) {
                case FileMode.CreateNew:        // Assume new file 
#if FEATURE_ISOSTORE_LIGHT 
                    // We are going to call Reserve so we need to lock the store.
                    m_isf.Lock(ref fLock); 
#endif
                    fNewFile = true;
                    break;
 
                case FileMode.Create:           // Check for New file & Unreserve
                case FileMode.OpenOrCreate:     // Check for new file 
                case FileMode.Truncate:         // Unreserve old file size 
                case FileMode.Append:           // Check for new file
 
                    m_isf.Lock(ref fLock);      // oldFileSize needs to be
                                                // protected

                    try { 
#if FEATURE_ISOSTORE_LIGHT
                        oldFileSize = IsolatedStorageFile.RoundToBlockSize((ulong)(new FileInfo(m_FullPath).Length)); 
#else 
                        oldFileSize = IsolatedStorageFile.RoundToBlockSize((ulong)LongPathFile.GetLength(m_FullPath));
#endif 
                    } catch (FileNotFoundException) {
                        fNewFile = true;
                    } catch {
                    } 

                    break; 
 
                case FileMode.Open:             // Open existing, else exception
                    break; 

                default:
                    throw new ArgumentException(
                        Environment.GetResourceString( 
                            "IsolatedStorage_FileOpenMode"));
                } 
 
                if (fNewFile)
                    m_isf.ReserveOneBlock(); 

                try {
#if FEATURE_ISOSTORE_LIGHT
                    m_fs = new 
                        FileStream(m_FullPath, mode, access, share, bufferSize,
                            FileOptions.None, m_GivenPath, true); 
//.........这里部分代码省略.........

        [System.Security.SecurityCritical] // auto-generated
        #endif
        private static string FetchOrCreateStore(string groupName, string storeName, IsolatedStorageFile isf) {
            string groupRootPath = GetGroupPathFromName(groupName);
            string obfuscatedStoreName = GetHash(storeName);
            string obfuscatedGroupName = GetHash(groupName);
            string storeRootPath = Path.Combine(IsolatedStorageRoot, Path.Combine(s_StorePathPrefix, obfuscatedStoreName));

            FileLock rootLock = FileLock.GetFileLock(IsolatedStorageRoot);

            try {
                rootLock.Lock();

                if(Directory.UnsafeExists(storeRootPath)) {

                    if (!File.UnsafeExists(Path.Combine(storeRootPath, s_IdFileName))) {
                        File.UnsafeWriteAllText(Path.Combine(storeRootPath, s_IdFileName), storeName);
                    } else {
                        if (!storeName.Equals(File.UnsafeReadAllText(Path.Combine(storeRootPath, s_IdFileName)))) {
                            throw new IsolatedStorageException(Environment.GetResourceString("IsolatedStorage_Init"));
                        }
                    }

                    File.UnsafeWriteAllText(Path.Combine(storeRootPath, s_GroupFileName), obfuscatedGroupName);
                    

                    if (!Directory.UnsafeExists(Path.Combine(storeRootPath, s_FilesPathPrefix))) {
                        Directory.UnsafeCreateDirectory(Path.Combine(storeRootPath, s_FilesPathPrefix));
                    }

                    if(File.UnsafeExists(Path.Combine(storeRootPath, s_CleanupFileName))) {
                        bool removedAll = isf.CleanDirectory(Path.Combine(storeRootPath, s_FilesPathPrefix));

                        if(removedAll) {
                            File.UnsafeDelete(Path.Combine(storeRootPath, s_CleanupFileName));
                            return storeRootPath;
                        } else {
                            throw new IsolatedStorageException(Environment.GetResourceString("IsolatedStorage_Init"));
                        }
                    } else {
                        return storeRootPath;
                    }
                } else {
                    isf.Reserve(s_DirSize);
                    Directory.UnsafeCreateDirectory(storeRootPath);
                    TouchFile(Path.Combine(storeRootPath, s_CleanupFileName));

                    Directory.UnsafeCreateDirectory(Path.Combine(storeRootPath, s_FilesPathPrefix));
                    File.UnsafeWriteAllText(Path.Combine(storeRootPath, s_GroupFileName), obfuscatedGroupName);
                    File.UnsafeWriteAllText(Path.Combine(storeRootPath, s_IdFileName), storeName);
                    File.UnsafeDelete(Path.Combine(storeRootPath, s_CleanupFileName));
                    return storeRootPath;
                }
            } catch(IOException e) {
                throw GetIsolatedStorageException("IsolatedStorage_Init", e);
            } catch (UnauthorizedAccessException e) {
                throw GetIsolatedStorageException("IsolatedStorage_Init", e);
            } finally {
                if(rootLock != null) {
                    rootLock.Unlock();
                }
            }
        }