Code:
/ Dotnetfx_Win7_3.5.1 / Dotnetfx_Win7_3.5.1 / 3.5.1 / DEVDIV / depot / DevDiv / releases / Orcas / NetFXw7 / wpf / src / Base / System / IO / Packaging / CompoundFile / StorageRoot.cs / 1 / StorageRoot.cs
//------------------------------------------------------------------------------
//
//
// Copyright (C) Microsoft Corporation. All rights reserved.
//
//
// Description:
// The root object for manipulating the WPP container.
//
// History:
// 05/10/2002: RogerCh: Initial creation.
// 06/12/2002: RogerCh: Catch & translate COMException from native calls.
// 06/25/2002: RogerCh: Add a constructor to build on top of IStorage.
// 06/28/2002: RogerCh: Add a boolean to avoid infinite loops in data space
// manager initialization.
// 07/31/2002: RogerCh: Make obvious that we are using security suppressed interfaces.
// 05/20/2003: RogerCh: Ported to WCP tree.
//
//-----------------------------------------------------------------------------
using System;
using System.IO;
using System.Runtime.InteropServices;
using System.Windows; // For exception string lookup table
using MS.Internal; // for Invariant
using MS.Internal.IO.Packaging.CompoundFile;
namespace System.IO.Packaging
{
///
/// The main container class, one instance per compound file
///
internal class StorageRoot : StorageInfo
{
/***********************************************************************/
// Default values to use for the StorageRoot.Open shortcuts
const FileMode defaultFileMode = FileMode.OpenOrCreate;
const FileAccess defaultFileAccess = FileAccess.ReadWrite;
const FileShare defaultFileShare = FileShare.None;
const int defaultSectorSize = 512;
const int stgFormatDocFile = 5; // STGFMT_DOCFILE
/***********************************************************************/
// Instance values
///
/// The reference to the IStorage root of this container. This value
/// is initialized at Open and zeroed out at Close. If this value is
/// zero, it means the object has been disposed.
///
IStorage rootIStorage;
///
/// Cached instance to our data space manager
///
DataSpaceManager dataSpaceManager;
///
/// If we know we are in a read-only mode, we know not to do certain things.
///
bool containerIsReadOnly;
///
/// When data space manager is being initialized, sometimes it trips
/// actions that would (in other circumstances) require checking the
/// data space manager. To avoid an infinite loop, we break it by knowing
/// when data space manager is being initialized.
///
bool dataSpaceManagerInitializationInProgress;
/***********************************************************************/
private StorageRoot(IStorage root, bool readOnly )
: base( root )
{
rootIStorage = root;
containerIsReadOnly = readOnly;
dataSpaceManagerInitializationInProgress = false;
}
///
/// The access mode available on this container
///
internal FileAccess OpenAccess
{
get
{
CheckRootDisposedStatus();
if(containerIsReadOnly)
{
return FileAccess.Read;
}
else
{
return FileAccess.ReadWrite;
}
}
}
///
/// Create a container StorageRoot based on the given System.IO.Stream object
///
/// The new Stream upon which to build the new StorageRoot
/// New StorageRoot object built on the given Stream
internal static StorageRoot CreateOnStream( Stream baseStream )
{
if (baseStream == null)
{
throw new ArgumentNullException("baseStream");
}
if( 0 == baseStream.Length )
{
return CreateOnStream( baseStream, FileMode.Create );
}
else
{
return CreateOnStream( baseStream, FileMode.Open );
}
}
///
/// Create a container StorageRoot based on the given System.IO.Stream object
///
/// The new Stream upon which to build the new StorageRoot
/// The mode (Open or Create) to use on the lock bytes
/// New StorageRoot object built on the given Stream
internal static StorageRoot CreateOnStream(Stream baseStream, FileMode mode)
{
if( null == baseStream )
throw new ArgumentNullException("baseStream");
IStorage storageOnStream;
int returnValue;
int openFlags = SafeNativeCompoundFileConstants.STGM_SHARE_EXCLUSIVE;
if( baseStream.CanRead )
{
if( baseStream.CanWrite )
{
openFlags |= SafeNativeCompoundFileConstants.STGM_READWRITE;
}
else
{
openFlags |= SafeNativeCompoundFileConstants.STGM_READ;
if( FileMode.Create == mode )
throw new ArgumentException(
SR.Get(SRID.CanNotCreateContainerOnReadOnlyStream));
}
}
else
{
throw new ArgumentException(
SR.Get(SRID.CanNotCreateStorageRootOnNonReadableStream));
}
if( FileMode.Create == mode )
{
returnValue = SafeNativeCompoundFileMethods.SafeStgCreateDocfileOnStream(
baseStream,
openFlags | SafeNativeCompoundFileConstants.STGM_CREATE,
out storageOnStream);
}
else if( FileMode.Open == mode )
{
returnValue = SafeNativeCompoundFileMethods.SafeStgOpenStorageOnStream(
baseStream,
openFlags,
out storageOnStream );
}
else
{
throw new ArgumentException(
SR.Get(SRID.CreateModeMustBeCreateOrOpen));
}
switch( (uint) returnValue )
{
case SafeNativeCompoundFileConstants.S_OK:
return StorageRoot.CreateOnIStorage(
storageOnStream );
default:
throw new IOException(
SR.Get(SRID.UnableToCreateOnStream),
new COMException(
SR.Get(SRID.CFAPIFailure),
returnValue));
}
}
/// Open a container, given only the path.
/// Path to container file on local file system
/// StorageRoot instance representing the file
internal static StorageRoot Open(
string path )
{
return Open( path, defaultFileMode, defaultFileAccess, defaultFileShare, defaultSectorSize );
}
/// Open a container, given path and open mode
/// Path to container file on local file system
/// Access mode, see System.IO.FileMode in .NET SDK
/// StorageRoot instance representing the file
internal static StorageRoot Open(
string path,
FileMode mode )
{
return Open( path, mode, defaultFileAccess, defaultFileShare, defaultSectorSize );
}
/// Open a container, given path, open mode, and access flag
/// Path to container file on local file system
/// See System.IO.FileMode in .NET SDK
/// See System.IO.FileAccess in .NET SDK
/// StorageRoot instance representing the file
internal static StorageRoot Open(
string path,
FileMode mode,
FileAccess access )
{
return Open( path, mode, access, defaultFileShare, defaultSectorSize );
}
/// Open a container, given path, open mode, access flag, and sharing settings
/// Path to container on local file system
/// See System.IO.FileMode in .NET SDK
/// See System.IO.FileAccess in .NET SDK
/// See System.IO.FileSharing in .NET SDK
/// StorageRoot instance representing the file
internal static StorageRoot Open(
string path,
FileMode mode,
FileAccess access,
FileShare share )
{
return Open( path, mode, access, share, defaultSectorSize );
}
/// Open a container given all the settings
/// Path to container on local file system
/// See System.IO.FileMode in .NET SDK
/// See System.IO.FileAccess in .NET SDK
/// See System.IO.FileShare in .NET SDK
/// Compound File sector size, must be 512 or 4096
/// StorageRoot instance representing the file
internal static StorageRoot Open(
string path,
FileMode mode,
FileAccess access,
FileShare share,
int sectorSize )
{
int grfMode = 0;
int returnValue = 0;
// Simple path validation
ContainerUtilities.CheckStringAgainstNullAndEmpty( path, "Path" );
Guid IID_IStorage = new Guid(0x0000000B,0x0000,0x0000,0xC0,0x00,
0x00,0x00,0x00,0x00,0x00,0x46);
IStorage newRootStorage;
////////////////////////////////////////////////////////////////////
// Generate STGM from FileMode
switch(mode)
{
case FileMode.Append:
throw new ArgumentException(
SR.Get(SRID.FileModeUnsupported));
case FileMode.Create:
grfMode |= SafeNativeCompoundFileConstants.STGM_CREATE;
break;
case FileMode.CreateNew:
{
FileInfo existTest = new FileInfo(path);
if( existTest.Exists )
{
throw new IOException(
SR.Get(SRID.FileAlreadyExists));
}
}
goto case FileMode.Create;
case FileMode.Open:
break;
case FileMode.OpenOrCreate:
{
FileInfo existTest = new FileInfo(path);
if( existTest.Exists )
{
// File exists, use open code path
goto case FileMode.Open;
}
else
{
// File does not exist, use create code path
goto case FileMode.Create;
}
}
case FileMode.Truncate:
throw new ArgumentException(
SR.Get(SRID.FileModeUnsupported));
default:
throw new ArgumentException(
SR.Get(SRID.FileModeInvalid));
}
// Generate the access flags from the access parameter
SafeNativeCompoundFileMethods.UpdateModeFlagFromFileAccess( access, ref grfMode );
// Generate STGM from FileShare
// Note: the .NET SDK does not specify the proper behavior in reaction to
// incompatible flags being sent in together. Should ArgumentException be
// thrown? Or do some values "trump" others?
if( 0 != (share & FileShare.Inheritable) )
{
throw new ArgumentException(
SR.Get(SRID.FileShareUnsupported));
}
else if( share == FileShare.None ) // FileShare.None is zero, using "&" to check causes unreachable code error
{
grfMode |= SafeNativeCompoundFileConstants.STGM_SHARE_EXCLUSIVE;
}
else if( share == FileShare.Read )
{
grfMode |= SafeNativeCompoundFileConstants.STGM_SHARE_DENY_WRITE;
}
else if( share == FileShare.Write )
{
grfMode |= SafeNativeCompoundFileConstants.STGM_SHARE_DENY_READ; // Note that this makes little sense when we don't support combination of flags
}
else if( share == FileShare.ReadWrite )
{
grfMode |= SafeNativeCompoundFileConstants.STGM_SHARE_DENY_NONE;
}
else
{
throw new ArgumentException(
SR.Get(SRID.FileShareInvalid));
}
if( 0 != (grfMode & SafeNativeCompoundFileConstants.STGM_CREATE))
{
// STGM_CREATE set, call StgCreateStorageEx.
returnValue = SafeNativeCompoundFileMethods.SafeStgCreateStorageEx(
path,
grfMode,
stgFormatDocFile,
0,
IntPtr.Zero,
IntPtr.Zero,
ref IID_IStorage,
out newRootStorage );
}
else
{
// STGM_CREATE not set, call StgOpenStorageEx.
returnValue = SafeNativeCompoundFileMethods.SafeStgOpenStorageEx(
path,
grfMode,
stgFormatDocFile,
0,
IntPtr.Zero,
IntPtr.Zero,
ref IID_IStorage,
out newRootStorage );
}
switch( returnValue )
{
case SafeNativeCompoundFileConstants.S_OK:
return StorageRoot.CreateOnIStorage(
newRootStorage );
case SafeNativeCompoundFileConstants.STG_E_FILENOTFOUND:
throw new FileNotFoundException(
SR.Get(SRID.ContainerNotFound));
case SafeNativeCompoundFileConstants.STG_E_INVALIDFLAG:
throw new ArgumentException(
SR.Get(SRID.StorageFlagsUnsupported),
new COMException(
SR.Get(SRID.CFAPIFailure),
returnValue));
default:
throw new IOException(
SR.Get(SRID.ContainerCanNotOpen),
new COMException(
SR.Get(SRID.CFAPIFailure),
returnValue));
}
}
///
/// Clean up this container storage instance
///
internal void Close()
{
if( null == rootIStorage )
return; // Extraneous calls to Close() are ignored
if( null != dataSpaceManager )
{
// Tell data space manager to flush all information as necessary
dataSpaceManager.Dispose();
dataSpaceManager = null;
}
try
{
// Shut down the underlying storage
if( !containerIsReadOnly )
rootIStorage.Commit(0);
}
finally
{
// We need these clean up steps to run even if there's a problem
// with the commit above.
RecursiveStorageInfoCoreRelease( core );
rootIStorage = null;
}
}
///
/// Flush the storage root.
///
internal void Flush()
{
CheckRootDisposedStatus();
// Shut down the underlying storage
if( !containerIsReadOnly )
rootIStorage.Commit(0);
}
///
/// Obtains the data space manager object for this instance of the
/// container. Subsequent calls will return reference to the same
/// object.
///
/// Reference to the manager object
internal DataSpaceManager GetDataSpaceManager()
{
CheckRootDisposedStatus();
if( null == dataSpaceManager )
{
if ( dataSpaceManagerInitializationInProgress )
return null; // initialization in progress - abort
// Create new instance of data space manager
dataSpaceManagerInitializationInProgress = true;
dataSpaceManager = new DataSpaceManager( this );
dataSpaceManagerInitializationInProgress = false;
}
return dataSpaceManager;
}
internal IStorage GetRootIStorage()
{
return rootIStorage;
}
// Check whether this StorageRoot class still has its underlying storage.
// If not, throw an object disposed exception. This should be checked from
// every non-static container external API.
internal void CheckRootDisposedStatus()
{
if( RootDisposed )
throw new ObjectDisposedException(null, SR.Get(SRID.StorageRootDisposed));
}
// Check whether this StorageRoot class still has its underlying storage.
internal bool RootDisposed
{
get
{
return ( null == rootIStorage );
}
}
///
/// This will create a container StorageRoot based on the given IStorage
/// interface
///
/// The new IStorage (RCW) upon which to build the new StorageRoot
/// New StorageRoot object built on the given IStorage
private static StorageRoot CreateOnIStorage( IStorage root )
{
// The root is created by calling unmanaged CompoundFile APIs. The return value from the call is always
// checked to see if is S_OK. If it is S_OK, the root should never be null. However, just to make sure
// call Invariant.Assert
Invariant.Assert(root != null);
System.Runtime.InteropServices.ComTypes.STATSTG rootSTAT;
bool readOnly;
root.Stat( out rootSTAT, SafeNativeCompoundFileConstants.STATFLAG_NONAME );
readOnly =( SafeNativeCompoundFileConstants.STGM_WRITE != ( rootSTAT.grfMode & SafeNativeCompoundFileConstants.STGM_WRITE ) &&
SafeNativeCompoundFileConstants.STGM_READWRITE != (rootSTAT.grfMode & SafeNativeCompoundFileConstants.STGM_READWRITE) );
return new StorageRoot( root, readOnly );
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------------------------
//
//
// Copyright (C) Microsoft Corporation. All rights reserved.
//
//
// Description:
// The root object for manipulating the WPP container.
//
// History:
// 05/10/2002: RogerCh: Initial creation.
// 06/12/2002: RogerCh: Catch & translate COMException from native calls.
// 06/25/2002: RogerCh: Add a constructor to build on top of IStorage.
// 06/28/2002: RogerCh: Add a boolean to avoid infinite loops in data space
// manager initialization.
// 07/31/2002: RogerCh: Make obvious that we are using security suppressed interfaces.
// 05/20/2003: RogerCh: Ported to WCP tree.
//
//-----------------------------------------------------------------------------
using System;
using System.IO;
using System.Runtime.InteropServices;
using System.Windows; // For exception string lookup table
using MS.Internal; // for Invariant
using MS.Internal.IO.Packaging.CompoundFile;
namespace System.IO.Packaging
{
///
/// The main container class, one instance per compound file
///
internal class StorageRoot : StorageInfo
{
/***********************************************************************/
// Default values to use for the StorageRoot.Open shortcuts
const FileMode defaultFileMode = FileMode.OpenOrCreate;
const FileAccess defaultFileAccess = FileAccess.ReadWrite;
const FileShare defaultFileShare = FileShare.None;
const int defaultSectorSize = 512;
const int stgFormatDocFile = 5; // STGFMT_DOCFILE
/***********************************************************************/
// Instance values
///
/// The reference to the IStorage root of this container. This value
/// is initialized at Open and zeroed out at Close. If this value is
/// zero, it means the object has been disposed.
///
IStorage rootIStorage;
///
/// Cached instance to our data space manager
///
DataSpaceManager dataSpaceManager;
///
/// If we know we are in a read-only mode, we know not to do certain things.
///
bool containerIsReadOnly;
///
/// When data space manager is being initialized, sometimes it trips
/// actions that would (in other circumstances) require checking the
/// data space manager. To avoid an infinite loop, we break it by knowing
/// when data space manager is being initialized.
///
bool dataSpaceManagerInitializationInProgress;
/***********************************************************************/
private StorageRoot(IStorage root, bool readOnly )
: base( root )
{
rootIStorage = root;
containerIsReadOnly = readOnly;
dataSpaceManagerInitializationInProgress = false;
}
///
/// The access mode available on this container
///
internal FileAccess OpenAccess
{
get
{
CheckRootDisposedStatus();
if(containerIsReadOnly)
{
return FileAccess.Read;
}
else
{
return FileAccess.ReadWrite;
}
}
}
///
/// Create a container StorageRoot based on the given System.IO.Stream object
///
/// The new Stream upon which to build the new StorageRoot
/// New StorageRoot object built on the given Stream
internal static StorageRoot CreateOnStream( Stream baseStream )
{
if (baseStream == null)
{
throw new ArgumentNullException("baseStream");
}
if( 0 == baseStream.Length )
{
return CreateOnStream( baseStream, FileMode.Create );
}
else
{
return CreateOnStream( baseStream, FileMode.Open );
}
}
///
/// Create a container StorageRoot based on the given System.IO.Stream object
///
/// The new Stream upon which to build the new StorageRoot
/// The mode (Open or Create) to use on the lock bytes
/// New StorageRoot object built on the given Stream
internal static StorageRoot CreateOnStream(Stream baseStream, FileMode mode)
{
if( null == baseStream )
throw new ArgumentNullException("baseStream");
IStorage storageOnStream;
int returnValue;
int openFlags = SafeNativeCompoundFileConstants.STGM_SHARE_EXCLUSIVE;
if( baseStream.CanRead )
{
if( baseStream.CanWrite )
{
openFlags |= SafeNativeCompoundFileConstants.STGM_READWRITE;
}
else
{
openFlags |= SafeNativeCompoundFileConstants.STGM_READ;
if( FileMode.Create == mode )
throw new ArgumentException(
SR.Get(SRID.CanNotCreateContainerOnReadOnlyStream));
}
}
else
{
throw new ArgumentException(
SR.Get(SRID.CanNotCreateStorageRootOnNonReadableStream));
}
if( FileMode.Create == mode )
{
returnValue = SafeNativeCompoundFileMethods.SafeStgCreateDocfileOnStream(
baseStream,
openFlags | SafeNativeCompoundFileConstants.STGM_CREATE,
out storageOnStream);
}
else if( FileMode.Open == mode )
{
returnValue = SafeNativeCompoundFileMethods.SafeStgOpenStorageOnStream(
baseStream,
openFlags,
out storageOnStream );
}
else
{
throw new ArgumentException(
SR.Get(SRID.CreateModeMustBeCreateOrOpen));
}
switch( (uint) returnValue )
{
case SafeNativeCompoundFileConstants.S_OK:
return StorageRoot.CreateOnIStorage(
storageOnStream );
default:
throw new IOException(
SR.Get(SRID.UnableToCreateOnStream),
new COMException(
SR.Get(SRID.CFAPIFailure),
returnValue));
}
}
/// Open a container, given only the path.
/// Path to container file on local file system
/// StorageRoot instance representing the file
internal static StorageRoot Open(
string path )
{
return Open( path, defaultFileMode, defaultFileAccess, defaultFileShare, defaultSectorSize );
}
/// Open a container, given path and open mode
/// Path to container file on local file system
/// Access mode, see System.IO.FileMode in .NET SDK
/// StorageRoot instance representing the file
internal static StorageRoot Open(
string path,
FileMode mode )
{
return Open( path, mode, defaultFileAccess, defaultFileShare, defaultSectorSize );
}
/// Open a container, given path, open mode, and access flag
/// Path to container file on local file system
/// See System.IO.FileMode in .NET SDK
/// See System.IO.FileAccess in .NET SDK
/// StorageRoot instance representing the file
internal static StorageRoot Open(
string path,
FileMode mode,
FileAccess access )
{
return Open( path, mode, access, defaultFileShare, defaultSectorSize );
}
/// Open a container, given path, open mode, access flag, and sharing settings
/// Path to container on local file system
/// See System.IO.FileMode in .NET SDK
/// See System.IO.FileAccess in .NET SDK
/// See System.IO.FileSharing in .NET SDK
/// StorageRoot instance representing the file
internal static StorageRoot Open(
string path,
FileMode mode,
FileAccess access,
FileShare share )
{
return Open( path, mode, access, share, defaultSectorSize );
}
/// Open a container given all the settings
/// Path to container on local file system
/// See System.IO.FileMode in .NET SDK
/// See System.IO.FileAccess in .NET SDK
/// See System.IO.FileShare in .NET SDK
/// Compound File sector size, must be 512 or 4096
/// StorageRoot instance representing the file
internal static StorageRoot Open(
string path,
FileMode mode,
FileAccess access,
FileShare share,
int sectorSize )
{
int grfMode = 0;
int returnValue = 0;
// Simple path validation
ContainerUtilities.CheckStringAgainstNullAndEmpty( path, "Path" );
Guid IID_IStorage = new Guid(0x0000000B,0x0000,0x0000,0xC0,0x00,
0x00,0x00,0x00,0x00,0x00,0x46);
IStorage newRootStorage;
////////////////////////////////////////////////////////////////////
// Generate STGM from FileMode
switch(mode)
{
case FileMode.Append:
throw new ArgumentException(
SR.Get(SRID.FileModeUnsupported));
case FileMode.Create:
grfMode |= SafeNativeCompoundFileConstants.STGM_CREATE;
break;
case FileMode.CreateNew:
{
FileInfo existTest = new FileInfo(path);
if( existTest.Exists )
{
throw new IOException(
SR.Get(SRID.FileAlreadyExists));
}
}
goto case FileMode.Create;
case FileMode.Open:
break;
case FileMode.OpenOrCreate:
{
FileInfo existTest = new FileInfo(path);
if( existTest.Exists )
{
// File exists, use open code path
goto case FileMode.Open;
}
else
{
// File does not exist, use create code path
goto case FileMode.Create;
}
}
case FileMode.Truncate:
throw new ArgumentException(
SR.Get(SRID.FileModeUnsupported));
default:
throw new ArgumentException(
SR.Get(SRID.FileModeInvalid));
}
// Generate the access flags from the access parameter
SafeNativeCompoundFileMethods.UpdateModeFlagFromFileAccess( access, ref grfMode );
// Generate STGM from FileShare
// Note: the .NET SDK does not specify the proper behavior in reaction to
// incompatible flags being sent in together. Should ArgumentException be
// thrown? Or do some values "trump" others?
if( 0 != (share & FileShare.Inheritable) )
{
throw new ArgumentException(
SR.Get(SRID.FileShareUnsupported));
}
else if( share == FileShare.None ) // FileShare.None is zero, using "&" to check causes unreachable code error
{
grfMode |= SafeNativeCompoundFileConstants.STGM_SHARE_EXCLUSIVE;
}
else if( share == FileShare.Read )
{
grfMode |= SafeNativeCompoundFileConstants.STGM_SHARE_DENY_WRITE;
}
else if( share == FileShare.Write )
{
grfMode |= SafeNativeCompoundFileConstants.STGM_SHARE_DENY_READ; // Note that this makes little sense when we don't support combination of flags
}
else if( share == FileShare.ReadWrite )
{
grfMode |= SafeNativeCompoundFileConstants.STGM_SHARE_DENY_NONE;
}
else
{
throw new ArgumentException(
SR.Get(SRID.FileShareInvalid));
}
if( 0 != (grfMode & SafeNativeCompoundFileConstants.STGM_CREATE))
{
// STGM_CREATE set, call StgCreateStorageEx.
returnValue = SafeNativeCompoundFileMethods.SafeStgCreateStorageEx(
path,
grfMode,
stgFormatDocFile,
0,
IntPtr.Zero,
IntPtr.Zero,
ref IID_IStorage,
out newRootStorage );
}
else
{
// STGM_CREATE not set, call StgOpenStorageEx.
returnValue = SafeNativeCompoundFileMethods.SafeStgOpenStorageEx(
path,
grfMode,
stgFormatDocFile,
0,
IntPtr.Zero,
IntPtr.Zero,
ref IID_IStorage,
out newRootStorage );
}
switch( returnValue )
{
case SafeNativeCompoundFileConstants.S_OK:
return StorageRoot.CreateOnIStorage(
newRootStorage );
case SafeNativeCompoundFileConstants.STG_E_FILENOTFOUND:
throw new FileNotFoundException(
SR.Get(SRID.ContainerNotFound));
case SafeNativeCompoundFileConstants.STG_E_INVALIDFLAG:
throw new ArgumentException(
SR.Get(SRID.StorageFlagsUnsupported),
new COMException(
SR.Get(SRID.CFAPIFailure),
returnValue));
default:
throw new IOException(
SR.Get(SRID.ContainerCanNotOpen),
new COMException(
SR.Get(SRID.CFAPIFailure),
returnValue));
}
}
///
/// Clean up this container storage instance
///
internal void Close()
{
if( null == rootIStorage )
return; // Extraneous calls to Close() are ignored
if( null != dataSpaceManager )
{
// Tell data space manager to flush all information as necessary
dataSpaceManager.Dispose();
dataSpaceManager = null;
}
try
{
// Shut down the underlying storage
if( !containerIsReadOnly )
rootIStorage.Commit(0);
}
finally
{
// We need these clean up steps to run even if there's a problem
// with the commit above.
RecursiveStorageInfoCoreRelease( core );
rootIStorage = null;
}
}
///
/// Flush the storage root.
///
internal void Flush()
{
CheckRootDisposedStatus();
// Shut down the underlying storage
if( !containerIsReadOnly )
rootIStorage.Commit(0);
}
///
/// Obtains the data space manager object for this instance of the
/// container. Subsequent calls will return reference to the same
/// object.
///
/// Reference to the manager object
internal DataSpaceManager GetDataSpaceManager()
{
CheckRootDisposedStatus();
if( null == dataSpaceManager )
{
if ( dataSpaceManagerInitializationInProgress )
return null; // initialization in progress - abort
// Create new instance of data space manager
dataSpaceManagerInitializationInProgress = true;
dataSpaceManager = new DataSpaceManager( this );
dataSpaceManagerInitializationInProgress = false;
}
return dataSpaceManager;
}
internal IStorage GetRootIStorage()
{
return rootIStorage;
}
// Check whether this StorageRoot class still has its underlying storage.
// If not, throw an object disposed exception. This should be checked from
// every non-static container external API.
internal void CheckRootDisposedStatus()
{
if( RootDisposed )
throw new ObjectDisposedException(null, SR.Get(SRID.StorageRootDisposed));
}
// Check whether this StorageRoot class still has its underlying storage.
internal bool RootDisposed
{
get
{
return ( null == rootIStorage );
}
}
///
/// This will create a container StorageRoot based on the given IStorage
/// interface
///
/// The new IStorage (RCW) upon which to build the new StorageRoot
/// New StorageRoot object built on the given IStorage
private static StorageRoot CreateOnIStorage( IStorage root )
{
// The root is created by calling unmanaged CompoundFile APIs. The return value from the call is always
// checked to see if is S_OK. If it is S_OK, the root should never be null. However, just to make sure
// call Invariant.Assert
Invariant.Assert(root != null);
System.Runtime.InteropServices.ComTypes.STATSTG rootSTAT;
bool readOnly;
root.Stat( out rootSTAT, SafeNativeCompoundFileConstants.STATFLAG_NONAME );
readOnly =( SafeNativeCompoundFileConstants.STGM_WRITE != ( rootSTAT.grfMode & SafeNativeCompoundFileConstants.STGM_WRITE ) &&
SafeNativeCompoundFileConstants.STGM_READWRITE != (rootSTAT.grfMode & SafeNativeCompoundFileConstants.STGM_READWRITE) );
return new StorageRoot( root, readOnly );
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- MethodBuilderInstantiation.cs
- ObservableCollectionDefaultValueFactory.cs
- UnitySerializationHolder.cs
- ExecutionEngineException.cs
- ObservableDictionary.cs
- Viewport3DAutomationPeer.cs
- UIElement3D.cs
- DictionaryGlobals.cs
- DrawingDrawingContext.cs
- ZoomComboBox.cs
- PackagePartCollection.cs
- ScriptingJsonSerializationSection.cs
- BaseCAMarshaler.cs
- CustomAttribute.cs
- UrlMappingsSection.cs
- DesignerImageAdapter.cs
- SHA384.cs
- EdmError.cs
- DBBindings.cs
- CommonXSendMessage.cs
- newinstructionaction.cs
- DataGridViewComboBoxCell.cs
- PerformanceCountersElement.cs
- XmlTextReader.cs
- TreeNodeSelectionProcessor.cs
- ObjectViewEntityCollectionData.cs
- Polyline.cs
- ConstNode.cs
- HttpCacheParams.cs
- Triplet.cs
- WizardStepBase.cs
- _NTAuthentication.cs
- ToolZone.cs
- PropertyGrid.cs
- ProvidePropertyAttribute.cs
- TreeViewImageIndexConverter.cs
- AspCompat.cs
- ChannelManager.cs
- Rule.cs
- RectValueSerializer.cs
- ImageKeyConverter.cs
- RichTextBox.cs
- GeometryCollection.cs
- SqlStream.cs
- CaseStatementSlot.cs
- MessageBuffer.cs
- TraceEventCache.cs
- PageParser.cs
- MatrixCamera.cs
- TextBox.cs
- MarkupExtensionParser.cs
- ObjectStateEntryDbDataRecord.cs
- DrawListViewSubItemEventArgs.cs
- TimersDescriptionAttribute.cs
- ScriptRegistrationManager.cs
- DefaultPropertiesToSend.cs
- Selector.cs
- KeyValuePair.cs
- DuplicateWaitObjectException.cs
- MultiSelectRootGridEntry.cs
- MobileResource.cs
- LayoutEvent.cs
- EncryptedPackage.cs
- CharacterBuffer.cs
- RelationshipEndCollection.cs
- CharacterBuffer.cs
- ListViewInsertedEventArgs.cs
- FileStream.cs
- ClientRuntimeConfig.cs
- CreateSequenceResponse.cs
- MediaEntryAttribute.cs
- OleDbPermission.cs
- BasicBrowserDialog.designer.cs
- PropertyGroupDescription.cs
- BinHexDecoder.cs
- TrustManager.cs
- smtppermission.cs
- GuidConverter.cs
- UpDownEvent.cs
- StylusTip.cs
- XmlAtomicValue.cs
- SafeSecurityHelper.cs
- RsaKeyIdentifierClause.cs
- ToolStripGripRenderEventArgs.cs
- EventSinkActivityDesigner.cs
- AuthStoreRoleProvider.cs
- DataBoundControl.cs
- ReflectionUtil.cs
- DrawingAttributesDefaultValueFactory.cs
- NativeRightsManagementAPIsStructures.cs
- FieldInfo.cs
- XmlSortKey.cs
- ServerProtocol.cs
- BindableTemplateBuilder.cs
- DesignerActionKeyboardBehavior.cs
- WebHttpEndpointElement.cs
- FreezableCollection.cs
- DataListItemCollection.cs
- counter.cs
- PackagingUtilities.cs