Code:
/ Dotnetfx_Win7_3.5.1 / Dotnetfx_Win7_3.5.1 / 3.5.1 / DEVDIV / depot / DevDiv / releases / Orcas / NetFXw7 / wpf / src / Base / MS / Internal / IO / Zip / ZipIOModeEnforcingStream.cs / 1 / ZipIOModeEnforcingStream.cs
//------------------------------------------------------------------------------
//------------- *** WARNING ***
//------------- This file is part of a legally monitored development project.
//------------- Do not check in changes to this project. Do not raid bugs on this
//------------- code in the main PS database. Do not contact the owner of this
//------------- code directly. Contact the legal team at ‘ZSLegal’ for assistance.
//------------- *** WARNING ***
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//
//
// Copyright (C) Microsoft Corporation. All rights reserved.
//
//
// Description:
// This is an internal class that enables interactions with Zip archives
// for OPC scenarios
//
// History:
// 11/19/2004: IgorBel: Initial creation.
//
//-----------------------------------------------------------------------------
using System;
using System.IO;
using System.Diagnostics;
using System.Text;
using System.Collections;
using System.Windows;
namespace MS.Internal.IO.Zip
{
internal class ZipIOModeEnforcingStream: Stream, IDisposable
{
// !!!!!!!!! Attention !!!!!!!!!!!!
// This stream is NOT doing any data buffering by design
// All data buffering is done underneath, by either
// FileItemStream or Compression Stream
// This assumption is used through the code of the
// FileItemBlock to calculate up to data CompressedSize UncompressedSize DirtyFlag and others
// !!!!!!!!! Attention !!!!!!!!!!!!
////////////////////////////////////
// Stream section
/////////////////////////////////
override public bool CanRead
{
get
{
return (!_disposedFlag &&
_baseStream.CanRead &&
((_access == FileAccess.Read) || (_access == FileAccess.ReadWrite)));
}
}
override public bool CanSeek
{
get
{
return (!_disposedFlag) && (_baseStream.CanSeek);
}
}
override public bool CanWrite
{
get
{
return (!_disposedFlag &&
_baseStream.CanWrite &&
((_access == FileAccess.Write) || (_access == FileAccess.ReadWrite)));
}
}
override public long Length
{
get
{
CheckDisposed();
long result = _baseStream.Length;
// This can definetly lead to consuming more memory Compression stream
// might sitch to Emulation mode
// disabling auto flushing functionality As a part of implementing Isolated storage fallback in the Sparse MemoryStream
//_trackingMemoryStreamFactory.ReportTransactionComplete();
return result;
}
}
override public long Position
{
get
{
CheckDisposed();
return _currentStreamPosition;
}
set
{
CheckDisposed();
Seek(value, SeekOrigin.Begin);
}
}
public override void SetLength(long newLength)
{
CheckDisposed();
if (!CanWrite)
{
throw new NotSupportedException(SR.Get(SRID.SetLengthNotSupported));
}
_baseStream.SetLength(newLength);
if (newLength < _currentStreamPosition)
_currentStreamPosition = newLength;
// This can definetly lead to consuming more memory
// disabling auto flushing functionality As a part of implementing Isolated storage fallback in the Sparse MemoryStream
//_trackingMemoryStreamFactory.ReportTransactionComplete();
}
override public long Seek(long offset, SeekOrigin origin)
{
CheckDisposed();
long newStreamPosition = _currentStreamPosition;
if (origin ==SeekOrigin.Begin)
{
newStreamPosition = offset;
}
else if (origin == SeekOrigin.Current)
{
checked{newStreamPosition += offset;}
}
else if (origin == SeekOrigin.End)
{
checked{newStreamPosition = Length + offset;}
}
else
{
throw new ArgumentOutOfRangeException("origin");
}
if (newStreamPosition < 0)
{
throw new ArgumentException(SR.Get(SRID.SeekNegative));
}
_currentStreamPosition = newStreamPosition;
return _currentStreamPosition;
}
override public int Read(byte[] buffer, int offset, int count)
{
CheckDisposed();
if (!CanRead)
{
throw new NotSupportedException(SR.Get(SRID.ReadNotSupported));
}
long originalStreamPosition = _currentStreamPosition;
int readResult;
try
{
_baseStream.Seek(_currentStreamPosition, SeekOrigin.Begin);
readResult = _baseStream.Read(buffer, offset, count);
checked{_currentStreamPosition += readResult;}
}
catch
{
// when an exception is thrown, the stream position should remain unchanged
_currentStreamPosition = originalStreamPosition;
throw;
}
// This can definetly lead to consuming more memory (compression emulation mode)
// disabling auto flushing functionality As a part of implementing Isolated storage fallback in the Sparse MemoryStream
//_trackingMemoryStreamFactory.ReportTransactionComplete();
return readResult;
}
override public void Write(byte[] buffer, int offset, int count)
{
CheckDisposed();
if (!CanWrite)
{
throw new NotSupportedException(SR.Get(SRID.WriteNotSupported));
}
if (_baseStream.CanSeek)
_baseStream.Seek(_currentStreamPosition, SeekOrigin.Begin);
// if CanSeek() is false, we are already in the correct position by default
_baseStream.Write(buffer, offset, count);
checked{_currentStreamPosition += count;}
// This can definetly lead to consuming more memory (compression emulation mode)
// disabling auto flushing functionality As a part of implementing Isolated storage fallback in the Sparse MemoryStream
//_trackingMemoryStreamFactory.ReportTransactionComplete();
}
override public void Flush()
{
CheckDisposed();
_baseStream.Flush(); // we must be calling flush on underlying stream
// we can not do something like _blockManager.SaveStream here
// as it will make impossible to push data through the stream stack
}
//------------------------------------------------------
//
// Internal Properties
//
//-----------------------------------------------------
internal bool Disposed
{
get
{
return _disposedFlag;
}
}
//------------------------------------------------------
//
// Protected Methods
//
//------------------------------------------------------
///
/// Dispose(bool)
///
///
protected override void Dispose(bool disposing)
{
try
{
if (disposing)
{
// multiple calls are fine - just ignore them
if (!_disposedFlag)
{
// we do that so that the block Manager and Local File Block can make a decision whether
// there are any more open streams or not
_disposedFlag = true;
// This will enable us to make accurate decisions in regard to the number of currently opened streams
_block.DeregisterExposedStream(this);
// we must NOT Dispose underlying stream, as it canbe used by other opened
// ZipIOModeEnforcingStream(s) and even if there no other open
// ZipIOModeEnforcingStream(s) at the moment, Cleint app can ask for more later;
// we can only Dispose underlying stream as a part of the Container Close/Dispose calls
#if !DEBUG
// Don't call Flush() in retail builds but do in debug builds to catch any
// logic errors.
if (_access == FileAccess.ReadWrite || _access == FileAccess.Write)
#endif
{
// Tell the block manager that we want to be closed
// the second parameter is ignored in the non-streaming cases , and it will result
// in a non-streaming container level flush
_blockManager.SaveStream(_block, true);
}
}
}
}
finally
{
_baseStream = null;
base.Dispose(disposing);
}
}
//-----------------------------------------------------
//
// Private Methods
//
//------------------------------------------------------
///
/// Constructor - streaming and non-streaming mode
///
///
///
/// block manager
/// associated block
internal ZipIOModeEnforcingStream(Stream baseStream, FileAccess access,
ZipIOBlockManager blockManager,
ZipIOLocalFileBlock block)
{
Debug.Assert(baseStream != null);
_baseStream = baseStream;
_access = access;
_blockManager = blockManager;
_block = block;
}
private void CheckDisposed()
{
if (_disposedFlag)
{
throw new ObjectDisposedException(null, SR.Get(SRID.StreamObjectDisposed));
}
}
//-----------------------------------------------------
//
// Private Members
//
//-----------------------------------------------------
private Stream _baseStream;
private FileAccess _access;
private bool _disposedFlag;
private long _currentStreamPosition;
// Streaming Mode only
private ZipIOLocalFileBlock _block; // null if not in streaming mode
private ZipIOBlockManager _blockManager; // null if not in streaming mode
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------------------------
//------------- *** WARNING ***
//------------- This file is part of a legally monitored development project.
//------------- Do not check in changes to this project. Do not raid bugs on this
//------------- code in the main PS database. Do not contact the owner of this
//------------- code directly. Contact the legal team at ‘ZSLegal’ for assistance.
//------------- *** WARNING ***
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//
//
// Copyright (C) Microsoft Corporation. All rights reserved.
//
//
// Description:
// This is an internal class that enables interactions with Zip archives
// for OPC scenarios
//
// History:
// 11/19/2004: IgorBel: Initial creation.
//
//-----------------------------------------------------------------------------
using System;
using System.IO;
using System.Diagnostics;
using System.Text;
using System.Collections;
using System.Windows;
namespace MS.Internal.IO.Zip
{
internal class ZipIOModeEnforcingStream: Stream, IDisposable
{
// !!!!!!!!! Attention !!!!!!!!!!!!
// This stream is NOT doing any data buffering by design
// All data buffering is done underneath, by either
// FileItemStream or Compression Stream
// This assumption is used through the code of the
// FileItemBlock to calculate up to data CompressedSize UncompressedSize DirtyFlag and others
// !!!!!!!!! Attention !!!!!!!!!!!!
////////////////////////////////////
// Stream section
/////////////////////////////////
override public bool CanRead
{
get
{
return (!_disposedFlag &&
_baseStream.CanRead &&
((_access == FileAccess.Read) || (_access == FileAccess.ReadWrite)));
}
}
override public bool CanSeek
{
get
{
return (!_disposedFlag) && (_baseStream.CanSeek);
}
}
override public bool CanWrite
{
get
{
return (!_disposedFlag &&
_baseStream.CanWrite &&
((_access == FileAccess.Write) || (_access == FileAccess.ReadWrite)));
}
}
override public long Length
{
get
{
CheckDisposed();
long result = _baseStream.Length;
// This can definetly lead to consuming more memory Compression stream
// might sitch to Emulation mode
// disabling auto flushing functionality As a part of implementing Isolated storage fallback in the Sparse MemoryStream
//_trackingMemoryStreamFactory.ReportTransactionComplete();
return result;
}
}
override public long Position
{
get
{
CheckDisposed();
return _currentStreamPosition;
}
set
{
CheckDisposed();
Seek(value, SeekOrigin.Begin);
}
}
public override void SetLength(long newLength)
{
CheckDisposed();
if (!CanWrite)
{
throw new NotSupportedException(SR.Get(SRID.SetLengthNotSupported));
}
_baseStream.SetLength(newLength);
if (newLength < _currentStreamPosition)
_currentStreamPosition = newLength;
// This can definetly lead to consuming more memory
// disabling auto flushing functionality As a part of implementing Isolated storage fallback in the Sparse MemoryStream
//_trackingMemoryStreamFactory.ReportTransactionComplete();
}
override public long Seek(long offset, SeekOrigin origin)
{
CheckDisposed();
long newStreamPosition = _currentStreamPosition;
if (origin ==SeekOrigin.Begin)
{
newStreamPosition = offset;
}
else if (origin == SeekOrigin.Current)
{
checked{newStreamPosition += offset;}
}
else if (origin == SeekOrigin.End)
{
checked{newStreamPosition = Length + offset;}
}
else
{
throw new ArgumentOutOfRangeException("origin");
}
if (newStreamPosition < 0)
{
throw new ArgumentException(SR.Get(SRID.SeekNegative));
}
_currentStreamPosition = newStreamPosition;
return _currentStreamPosition;
}
override public int Read(byte[] buffer, int offset, int count)
{
CheckDisposed();
if (!CanRead)
{
throw new NotSupportedException(SR.Get(SRID.ReadNotSupported));
}
long originalStreamPosition = _currentStreamPosition;
int readResult;
try
{
_baseStream.Seek(_currentStreamPosition, SeekOrigin.Begin);
readResult = _baseStream.Read(buffer, offset, count);
checked{_currentStreamPosition += readResult;}
}
catch
{
// when an exception is thrown, the stream position should remain unchanged
_currentStreamPosition = originalStreamPosition;
throw;
}
// This can definetly lead to consuming more memory (compression emulation mode)
// disabling auto flushing functionality As a part of implementing Isolated storage fallback in the Sparse MemoryStream
//_trackingMemoryStreamFactory.ReportTransactionComplete();
return readResult;
}
override public void Write(byte[] buffer, int offset, int count)
{
CheckDisposed();
if (!CanWrite)
{
throw new NotSupportedException(SR.Get(SRID.WriteNotSupported));
}
if (_baseStream.CanSeek)
_baseStream.Seek(_currentStreamPosition, SeekOrigin.Begin);
// if CanSeek() is false, we are already in the correct position by default
_baseStream.Write(buffer, offset, count);
checked{_currentStreamPosition += count;}
// This can definetly lead to consuming more memory (compression emulation mode)
// disabling auto flushing functionality As a part of implementing Isolated storage fallback in the Sparse MemoryStream
//_trackingMemoryStreamFactory.ReportTransactionComplete();
}
override public void Flush()
{
CheckDisposed();
_baseStream.Flush(); // we must be calling flush on underlying stream
// we can not do something like _blockManager.SaveStream here
// as it will make impossible to push data through the stream stack
}
//------------------------------------------------------
//
// Internal Properties
//
//-----------------------------------------------------
internal bool Disposed
{
get
{
return _disposedFlag;
}
}
//------------------------------------------------------
//
// Protected Methods
//
//------------------------------------------------------
///
/// Dispose(bool)
///
///
protected override void Dispose(bool disposing)
{
try
{
if (disposing)
{
// multiple calls are fine - just ignore them
if (!_disposedFlag)
{
// we do that so that the block Manager and Local File Block can make a decision whether
// there are any more open streams or not
_disposedFlag = true;
// This will enable us to make accurate decisions in regard to the number of currently opened streams
_block.DeregisterExposedStream(this);
// we must NOT Dispose underlying stream, as it canbe used by other opened
// ZipIOModeEnforcingStream(s) and even if there no other open
// ZipIOModeEnforcingStream(s) at the moment, Cleint app can ask for more later;
// we can only Dispose underlying stream as a part of the Container Close/Dispose calls
#if !DEBUG
// Don't call Flush() in retail builds but do in debug builds to catch any
// logic errors.
if (_access == FileAccess.ReadWrite || _access == FileAccess.Write)
#endif
{
// Tell the block manager that we want to be closed
// the second parameter is ignored in the non-streaming cases , and it will result
// in a non-streaming container level flush
_blockManager.SaveStream(_block, true);
}
}
}
}
finally
{
_baseStream = null;
base.Dispose(disposing);
}
}
//-----------------------------------------------------
//
// Private Methods
//
//------------------------------------------------------
///
/// Constructor - streaming and non-streaming mode
///
///
///
/// block manager
/// associated block
internal ZipIOModeEnforcingStream(Stream baseStream, FileAccess access,
ZipIOBlockManager blockManager,
ZipIOLocalFileBlock block)
{
Debug.Assert(baseStream != null);
_baseStream = baseStream;
_access = access;
_blockManager = blockManager;
_block = block;
}
private void CheckDisposed()
{
if (_disposedFlag)
{
throw new ObjectDisposedException(null, SR.Get(SRID.StreamObjectDisposed));
}
}
//-----------------------------------------------------
//
// Private Members
//
//-----------------------------------------------------
private Stream _baseStream;
private FileAccess _access;
private bool _disposedFlag;
private long _currentStreamPosition;
// Streaming Mode only
private ZipIOLocalFileBlock _block; // null if not in streaming mode
private ZipIOBlockManager _blockManager; // null if not in streaming mode
}
}
// 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
- DataTableNewRowEvent.cs
- HitTestWithPointDrawingContextWalker.cs
- IgnoreDataMemberAttribute.cs
- OutOfMemoryException.cs
- NeutralResourcesLanguageAttribute.cs
- ThemeDictionaryExtension.cs
- SafeCryptoHandles.cs
- ReachFixedPageSerializerAsync.cs
- TabletDevice.cs
- UriTemplateCompoundPathSegment.cs
- CheckBoxStandardAdapter.cs
- SoapSchemaExporter.cs
- ContentElement.cs
- PaintEvent.cs
- VariableBinder.cs
- RuntimeResourceSet.cs
- SettingsPropertyNotFoundException.cs
- ViewStateException.cs
- TextSchema.cs
- AncillaryOps.cs
- SqlStatistics.cs
- DetailsViewDeletedEventArgs.cs
- GeneralTransform3DTo2D.cs
- WindowsImpersonationContext.cs
- ClientData.cs
- PointAnimationUsingKeyFrames.cs
- ToolStripDesignerAvailabilityAttribute.cs
- TextTreeRootNode.cs
- ViewPort3D.cs
- AuthenticatingEventArgs.cs
- InstanceKeyNotReadyException.cs
- WithParamAction.cs
- Point3DAnimationBase.cs
- FixedSOMPage.cs
- CapabilitiesPattern.cs
- DataTableExtensions.cs
- Send.cs
- CheckBoxFlatAdapter.cs
- ThicknessAnimationBase.cs
- MsdtcClusterUtils.cs
- ColumnResult.cs
- Select.cs
- EventDrivenDesigner.cs
- BmpBitmapDecoder.cs
- CombinedHttpChannel.cs
- ContentOperations.cs
- DescriptionAttribute.cs
- DataChangedEventManager.cs
- SqlResolver.cs
- DataGridViewRowPrePaintEventArgs.cs
- BookmarkTable.cs
- AsyncCallback.cs
- MemoryFailPoint.cs
- CornerRadiusConverter.cs
- CodeMethodInvokeExpression.cs
- WebContext.cs
- httpstaticobjectscollection.cs
- SafeSecurityHandles.cs
- ExpanderAutomationPeer.cs
- HyperLinkColumn.cs
- oledbmetadatacollectionnames.cs
- BitmapCodecInfoInternal.cs
- InvalidateEvent.cs
- ProfileWorkflowElement.cs
- DesignerAutoFormatCollection.cs
- NumericExpr.cs
- SourceSwitch.cs
- SecurityState.cs
- XmlSecureResolver.cs
- LogicalTreeHelper.cs
- TlsnegoTokenAuthenticator.cs
- LazyInitializer.cs
- DataGridAutomationPeer.cs
- Reference.cs
- Util.cs
- WindowsHyperlink.cs
- DbProviderConfigurationHandler.cs
- TextRangeBase.cs
- EditorPart.cs
- _IPv4Address.cs
- LinqDataView.cs
- ActivityDesignerLayoutSerializers.cs
- XmlSchemaComplexContentRestriction.cs
- BigInt.cs
- WindowsListViewGroupSubsetLink.cs
- GridViewAutomationPeer.cs
- UseLicense.cs
- ChooseAction.cs
- PresentationTraceSources.cs
- MsmqInputChannel.cs
- IncrementalReadDecoders.cs
- ModulesEntry.cs
- MatrixIndependentAnimationStorage.cs
- InfoCardSymmetricCrypto.cs
- ValidatingPropertiesEventArgs.cs
- FolderBrowserDialog.cs
- ScrollItemPatternIdentifiers.cs
- ToolboxDataAttribute.cs
- ParseElement.cs
- IOException.cs