| private GetFullPath ( string partialPath ) : string | ||
| partialPath | string | |
| return | string | |
// If the isolated storage file is null, then we default to using a file
// that is scoped by user, appdomain, and assembly.
public IsolatedStorageFileStream(String path, FileMode mode,
FileAccess access, FileShare share, int bufferSize,
IsolatedStorageFile isf)
{
if (path == null)
{
throw new ArgumentNullException(nameof(path));
}
Contract.EndContractBlock();
if ((path.Length == 0) || path.Equals(s_BackSlash))
{
throw new ArgumentException(
SR.IsolatedStorage_Path);
}
if (isf == null)
{
throw new ArgumentNullException(nameof(isf));
}
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);
}
_isf = isf;
_givenPath = path;
_fullPath = _isf.GetFullPath(_givenPath);
try
{
_fs = new
FileStream(_fullPath, mode, access, share, bufferSize,
FileOptions.None);
}
catch (Exception e)
{
// Exception message might leak the IsolatedStorage path. The desktop 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("IsolatedStorage_Operation_ISFS", e);
}
}
private long GetFileSize(IsolatedStorageFile store, string path) {
string fullPath = store.GetFullPath(path);
try {
if (File.Exists(fullPath))
return new System.IO.FileInfo(fullPath).Length;
} catch (IOException ex) {
System.Diagnostics.Trace.WriteLine("Exceptionless: Error getting size of file: {0}", ex.Message);
}
return -1;
}
// If the isolated storage file is null, then we default to using a file
// that is scoped by user, appdomain, and assembly.
public IsolatedStorageFileStream(String path, FileMode mode,
FileAccess access, FileShare share, int bufferSize,
IsolatedStorageFile isf)
{
if (path == null)
throw new ArgumentNullException("path");
Contract.EndContractBlock();
if ((path.Length == 0) || path.Equals(s_BackSlash))
throw new ArgumentException(
SR.IsolatedStorage_Path);
if (isf == null)
{
throw new ArgumentNullException("isf");
}
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);
}
_isf = isf;
_givenPath = path;
_fullPath = _isf.GetFullPath(_givenPath);
try
{
_fs = new
FileStream(_fullPath, mode, access, share, bufferSize,
FileOptions.None);
}
catch (Exception e)
{
// Exception message might leak the IsolatedStorage path. The desktop 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("IsolatedStorage_Operation_ISFS", e);
}
}
// 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 desktop 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");
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);
#else
m_fs = new
FileStream(m_FullPath, mode, access, share, bufferSize,
FileOptions.None, m_GivenPath, true, true);
#endif
} catch {
if (fNewFile)
m_isf.UnreserveOneBlock();
#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.
throw new IsolatedStorageException(Environment.GetResourceString("IsolatedStorage_Operation_ISFS"));
#else
throw;
#endif // FEATURE_ISOSTORE_LIGHT
}
// 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();
}
// 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 desktop 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);
}
[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
}
/// <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");
}
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();
}
