| public static GetUserStoreForDomain ( ) : IsolatedStorageFile | ||
| Результат | IsolatedStorageFile | |
// 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);
}
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();
}
[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
}
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"));
}
}