GetUserStoreForDomain() публичный статический Метод

public static GetUserStoreForDomain ( ) : IsolatedStorageFile
Результат IsolatedStorageFile
Пример #1
0
        // If IsolatedStorageFile is null, then we default to using a file that is scoped by user, appdomain, and assembly.
        private static InitialiationData InitializeFileStream(string path, FileMode mode, FileAccess access, FileShare share, int bufferSize, IsolatedStorageFile?isf)
        {
            if (path == null)
            {
                throw new ArgumentNullException(nameof(path));
            }

            if ((path.Length == 0) || path.Equals(BackSlash))
            {
                throw new ArgumentException(
                          SR.IsolatedStorage_Path);
            }

            bool createdStore = false;

            if (isf == null)
            {
                isf          = IsolatedStorageFile.GetUserStoreForDomain();
                createdStore = true;
            }

            if (isf.Disposed)
            {
                throw new ObjectDisposedException(null, SR.IsolatedStorage_StoreNotOpen);
            }

            switch (mode)
            {
            case FileMode.CreateNew:            // Assume new file
            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
            case FileMode.Open:                 // Open existing, else exception
                break;

            default:
                throw new ArgumentException(SR.IsolatedStorage_FileOpenMode);
            }

            InitialiationData data = new InitialiationData
            {
                FullPath    = isf.GetFullPath(path),
                StorageFile = isf
            };

            try
            {
                data.NestedStream = new FileStream(data.FullPath, mode, access, share, bufferSize, FileOptions.None);
            }
            catch (Exception e)
            {
                // Make an attempt to clean up the StorageFile if we created it
                try
                {
                    if (createdStore)
                    {
                        data.StorageFile?.Dispose();
                    }
                }
                catch
                {
                }

                // Exception message might leak the IsolatedStorage path. The .NET Framework prevented this by calling an
                // internal API which made sure that the exception message was scrubbed. However since the innerException
                // is never returned to the user(GetIsolatedStorageException() does not populate the innerexception
                // in retail bits we leak the path only under the debugger via IsolatedStorageException._underlyingException which
                // they can any way look at via IsolatedStorageFile instance as well.
                throw IsolatedStorageFile.GetIsolatedStorageException(SR.IsolatedStorage_Operation_ISFS, e);
            }

            return(data);
        }
Пример #2
0
        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, fLock = 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();
            fiop.PermitOnly();

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

            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
                    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();               // oldFileSize needs to be
                                                // protected
                    fLock = true;               // Lock succeded

                    try {
                        fOld        = new FileInfo(m_FullPath);
                        oldFileSize = IsolatedStorageFile.RoundToBlockSize((ulong)fOld.Length);
                    } 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 {
                    m_fs = new
                           FileStream(m_FullPath, mode, access, share, bufferSize,
                                      FileOptions.None, m_GivenPath, true);
                } catch {
                    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);
                    }
                }
            } finally {
                if (fLock)
                {
                    m_isf.Unlock();
                }
            }
            CodeAccessPermission.RevertAll();
        }
Пример #3
0
        [System.Security.SecuritySafeCritical]  // auto-generated
        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"));
            }

            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"));
            }

            switch (mode)
            {
            case FileMode.CreateNew:            // Assume new file
            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
            case FileMode.Open:                 // Open existing, else exception
                break;

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

            m_isf = isf;

#if !FEATURE_CORECLR
            FileIOPermission fiop =
                new FileIOPermission(FileIOPermissionAccess.AllAccess,
                                     m_isf.RootDirectory);

            fiop.Assert();
            fiop.PermitOnly();
#endif

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

#if FEATURE_ISOLATED_STORAGE_QUOTA_ENFORCEMENT
            ulong oldFileSize = 0, newFileSize;
            bool  fNewFile = false, fLock = false;

            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)(FileInfo.UnsafeCreateFileInfo(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;
                }

                if (fNewFile)
                {
                    m_isf.ReserveOneBlock();
                }
#endif // FEATURE_ISOLATED_STORAGE_QUOTA_ENFORCEMENT

            try {
#if FEATURE_CORECLR
                // Since FileStream's .ctor won't do a demand, we need to do our access check here.
                m_isf.Demand(m_FullPath);
#endif

#if FEATURE_ISOSTORE_LIGHT
                m_fs = new
                       FileStream(m_FullPath, mode, access, share, bufferSize,
                                  FileOptions.None, m_GivenPath, true);
            } catch (Exception e) {
#else
                m_fs = new
                       FileStream(m_FullPath, mode, access, share, bufferSize,
                                  FileOptions.None, m_GivenPath, true, true);
            } catch {
#endif
#if FEATURE_ISOLATED_STORAGE_QUOTA_ENFORCEMENT
                if (fNewFile)
                {
                    m_isf.UnreserveOneBlock();
                }
#endif // FEATURE_ISOLATED_STORAGE_QUOTA_ENFORCEMENT
#if FEATURE_ISOSTORE_LIGHT
                // IsoStore generally does not let arbitrary exceptions flow out: a
                // IsolatedStorageException is thrown instead (see examples in IsolatedStorageFile.cs
                // Keeping this scoped to coreclr just because changing the exception type thrown is a
                // breaking change and that should not be introduced into the desktop without deliberation.
                //
                // Note that GetIsolatedStorageException may set InnerException. To the real exception
                // Today it always does this, for debug and chk builds, and for other builds asks the host
                // if it is okay to do so.
                throw IsolatedStorageFile.GetIsolatedStorageException("IsolatedStorage_Operation_ISFS", e);
#else
                throw;
#endif // FEATURE_ISOSTORE_LIGHT
            }

#if FEATURE_ISOLATED_STORAGE_QUOTA_ENFORCEMENT
            // 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);
                }
            }
        }

        finally {
            if (fLock)
            {
                m_isf.Unlock();
            }
        }
#endif // FEATURE_ISOLATED_STORAGE_QUOTA_ENFORCEMENT

#if !FEATURE_CORECLR
            CodeAccessPermission.RevertAll();
#endif
        }
Пример #4
0
        public IsolatedStorageFileStream(string path, FileMode mode, FileAccess access, FileShare share, int bufferSize, IsolatedStorageFile isf)
        {
            if (path == null)
            {
                throw new ArgumentNullException("path");
            }
            if (path.Length == 0 || path.Equals("\\"))
            {
                throw new ArgumentException(Environment.GetResourceString("IsolatedStorage_Path"));
            }
            if (isf == null)
            {
                this.m_OwnedStore = true;
                isf = IsolatedStorageFile.GetUserStoreForDomain();
            }
            if (isf.Disposed)
            {
                throw new ObjectDisposedException((string)null, Environment.GetResourceString("IsolatedStorage_StoreNotOpen"));
            }
            switch (mode)
            {
            case FileMode.CreateNew:
            case FileMode.Create:
            case FileMode.Open:
            case FileMode.OpenOrCreate:
            case FileMode.Truncate:
            case FileMode.Append:
                this.m_isf = isf;
                FileIOPermission fileIoPermission = new FileIOPermission(FileIOPermissionAccess.AllAccess, this.m_isf.RootDirectory);
                fileIoPermission.Assert();
                fileIoPermission.PermitOnly();
                this.m_GivenPath = path;
                this.m_FullPath  = this.m_isf.GetFullPath(this.m_GivenPath);
                ulong num    = 0;
                bool  flag   = false;
                bool  locked = false;
                RuntimeHelpers.PrepareConstrainedRegions();
                try
                {
                    switch (mode)
                    {
                    case FileMode.CreateNew:
                        flag = true;
                        break;

                    case FileMode.Create:
                    case FileMode.OpenOrCreate:
                    case FileMode.Truncate:
                    case FileMode.Append:
                        this.m_isf.Lock(ref locked);
                        try
                        {
                            num = IsolatedStorageFile.RoundToBlockSize((ulong)LongPathFile.GetLength(this.m_FullPath));
                            break;
                        }
                        catch (FileNotFoundException ex)
                        {
                            flag = true;
                            break;
                        }
                        catch
                        {
                            break;
                        }
                    }
                    if (flag)
                    {
                        this.m_isf.ReserveOneBlock();
                    }
                    try
                    {
                        this.m_fs = new FileStream(this.m_FullPath, mode, access, share, bufferSize, FileOptions.None, this.m_GivenPath, true, true);
                    }
                    catch
                    {
                        if (flag)
                        {
                            this.m_isf.UnreserveOneBlock();
                        }
                        throw;
                    }
                    if (!flag)
                    {
                        if (mode != FileMode.Truncate)
                        {
                            if (mode != FileMode.Create)
                            {
                                goto label_34;
                            }
                        }
                        ulong blockSize = IsolatedStorageFile.RoundToBlockSize((ulong)this.m_fs.Length);
                        if (num > blockSize)
                        {
                            this.m_isf.Unreserve(num - blockSize);
                        }
                        else if (blockSize > num)
                        {
                            this.m_isf.Reserve(blockSize - num);
                        }
                    }
                }
                finally
                {
                    if (locked)
                    {
                        this.m_isf.Unlock();
                    }
                }
label_34:
                CodeAccessPermission.RevertAll();
                break;

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