Code:
/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / clr / src / ManagedLibraries / Remoting / Channels / CORE / StreamHelper.cs / 1305376 / StreamHelper.cs
// ==++==
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// ==--==
//============================================================
//
// File: StreamHelper.cs
//
// Summary: Helper methods for streams.
//
//===========================================================
using System;
using System.IO;
using System.Runtime.Remoting;
using System.Threading;
namespace System.Runtime.Remoting.Channels
{
internal static class StreamHelper
{
private static AsyncCallback _asyncCopyStreamReadCallback = new AsyncCallback(AsyncCopyStreamReadCallback);
private static AsyncCallback _asyncCopyStreamWriteCallback = new AsyncCallback(AsyncCopyStreamWriteCallback);
internal static void CopyStream(Stream source, Stream target)
{
if (source == null)
return;
// see if this is a ChunkedMemoryStream (we can do a direct write)
ChunkedMemoryStream chunkedMemStream = source as ChunkedMemoryStream;
if (chunkedMemStream != null)
{
chunkedMemStream.WriteTo(target);
}
else
{
// see if this is a MemoryStream (we can do a direct write)
MemoryStream memContentStream = source as MemoryStream;
if (memContentStream != null)
{
memContentStream.WriteTo(target);
}
else
{
// otherwise, we need to copy the data through an intermediate buffer
byte[] buffer = CoreChannel.BufferPool.GetBuffer();
int bufferSize = buffer.Length;
int readCount = source.Read(buffer, 0, bufferSize);
while (readCount > 0)
{
target.Write(buffer, 0, readCount);
readCount = source.Read(buffer, 0, bufferSize);
}
CoreChannel.BufferPool.ReturnBuffer(buffer);
}
}
} // CopyStream
internal static void BufferCopy(byte[] source, int srcOffset,
byte[] dest, int destOffset,
int count)
{
if (count > 8)
{
Buffer.BlockCopy(source, srcOffset, dest, destOffset, count);
}
else
{
for (int co = 0; co < count; co++)
dest[destOffset + co] = source[srcOffset + co];
}
} // BufferCopy
internal static IAsyncResult BeginAsyncCopyStream(
Stream source, Stream target,
bool asyncRead, bool asyncWrite,
bool closeSource, bool closeTarget,
AsyncCallback callback, Object state)
{
AsyncCopyStreamResult streamState = new AsyncCopyStreamResult(callback, state);
byte[] buffer = CoreChannel.BufferPool.GetBuffer();
streamState.Source = source;
streamState.Target = target;
streamState.Buffer = buffer;
streamState.AsyncRead = asyncRead;
streamState.AsyncWrite = asyncWrite;
streamState.CloseSource = closeSource;
streamState.CloseTarget = closeTarget;
try
{
AsyncCopyReadHelper(streamState);
}
catch (Exception e)
{
streamState.SetComplete(null, e);
}
return streamState;
} // BeginAsyncCopyStream
internal static void EndAsyncCopyStream(IAsyncResult iar)
{
AsyncCopyStreamResult asyncResult = (AsyncCopyStreamResult)iar;
if (!iar.IsCompleted)
{
iar.AsyncWaitHandle.WaitOne();
}
if (asyncResult.Exception != null)
{
throw asyncResult.Exception;
}
} // EndAsyncCopyStream
private static void AsyncCopyReadHelper(AsyncCopyStreamResult streamState)
{
// There is no try-catch here because the calling method always has a try-catch.
if (streamState.AsyncRead)
{
byte[] buffer = streamState.Buffer;
streamState.Source.BeginRead(buffer, 0, buffer.Length, _asyncCopyStreamReadCallback, streamState);
}
else
{
byte[] buffer = streamState.Buffer;
int bytesRead = streamState.Source.Read(buffer, 0, buffer.Length);
if (bytesRead == 0)
{
streamState.SetComplete(null, null);
}
else
if (bytesRead < 0)
{
throw new RemotingException(
CoreChannel.GetResourceString("Remoting_Stream_UnknownReadError"));
}
else
{
AsyncCopyWriteHelper(streamState, bytesRead);
}
}
} // AsyncCopyReadHelper
private static void AsyncCopyWriteHelper(AsyncCopyStreamResult streamState, int bytesRead)
{
// There is no try-catch here because the calling method always has a try-catch.
if (streamState.AsyncWrite)
{
byte[] buffer = streamState.Buffer;
streamState.Target.BeginWrite(buffer, 0, bytesRead, _asyncCopyStreamWriteCallback, streamState);
}
else
{
byte[] buffer = streamState.Buffer;
streamState.Target.Write(buffer, 0, bytesRead);
AsyncCopyReadHelper(streamState);
}
} // AsyncCopyWriteHelper
private static void AsyncCopyStreamReadCallback(IAsyncResult iar)
{
AsyncCopyStreamResult state = (AsyncCopyStreamResult)iar.AsyncState;
try
{
Stream source = state.Source;
int bytesRead = source.EndRead(iar);
if (bytesRead == 0)
{
state.SetComplete(null, null);
}
else
if (bytesRead < 0)
{
throw new RemotingException(
CoreChannel.GetResourceString("Remoting_Stream_UnknownReadError"));
}
else
{
AsyncCopyWriteHelper(state, bytesRead);
}
}
catch (Exception e)
{
state.SetComplete(null, e);
}
} // AsyncCopyStreamReadCallback
private static void AsyncCopyStreamWriteCallback(IAsyncResult iar)
{
AsyncCopyStreamResult state = (AsyncCopyStreamResult)iar.AsyncState;
try
{
state.Target.EndWrite(iar);
AsyncCopyReadHelper(state);
}
catch (Exception e)
{
state.SetComplete(null, e);
}
} // AsyncCopyStreamWriteCallback
} // class StreamHelper
internal class AsyncCopyStreamResult : BasicAsyncResult
{
internal Stream Source;
internal Stream Target;
internal byte[] Buffer;
internal bool AsyncRead;
internal bool AsyncWrite;
internal bool CloseSource;
internal bool CloseTarget;
internal AsyncCopyStreamResult(AsyncCallback callback, Object state) :
base(callback, state)
{
}
internal override void CleanupOnComplete()
{
if (Buffer != null)
CoreChannel.BufferPool.ReturnBuffer(Buffer);
if (CloseSource)
Source.Close();
if (CloseTarget)
Target.Close();
} // CleanupOnComplete
} // class AsyncCopyStreamResult
} // namespace System.Runtime.Remoting.Channels
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// ==++==
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// ==--==
//============================================================
//
// File: StreamHelper.cs
//
// Summary: Helper methods for streams.
//
//===========================================================
using System;
using System.IO;
using System.Runtime.Remoting;
using System.Threading;
namespace System.Runtime.Remoting.Channels
{
internal static class StreamHelper
{
private static AsyncCallback _asyncCopyStreamReadCallback = new AsyncCallback(AsyncCopyStreamReadCallback);
private static AsyncCallback _asyncCopyStreamWriteCallback = new AsyncCallback(AsyncCopyStreamWriteCallback);
internal static void CopyStream(Stream source, Stream target)
{
if (source == null)
return;
// see if this is a ChunkedMemoryStream (we can do a direct write)
ChunkedMemoryStream chunkedMemStream = source as ChunkedMemoryStream;
if (chunkedMemStream != null)
{
chunkedMemStream.WriteTo(target);
}
else
{
// see if this is a MemoryStream (we can do a direct write)
MemoryStream memContentStream = source as MemoryStream;
if (memContentStream != null)
{
memContentStream.WriteTo(target);
}
else
{
// otherwise, we need to copy the data through an intermediate buffer
byte[] buffer = CoreChannel.BufferPool.GetBuffer();
int bufferSize = buffer.Length;
int readCount = source.Read(buffer, 0, bufferSize);
while (readCount > 0)
{
target.Write(buffer, 0, readCount);
readCount = source.Read(buffer, 0, bufferSize);
}
CoreChannel.BufferPool.ReturnBuffer(buffer);
}
}
} // CopyStream
internal static void BufferCopy(byte[] source, int srcOffset,
byte[] dest, int destOffset,
int count)
{
if (count > 8)
{
Buffer.BlockCopy(source, srcOffset, dest, destOffset, count);
}
else
{
for (int co = 0; co < count; co++)
dest[destOffset + co] = source[srcOffset + co];
}
} // BufferCopy
internal static IAsyncResult BeginAsyncCopyStream(
Stream source, Stream target,
bool asyncRead, bool asyncWrite,
bool closeSource, bool closeTarget,
AsyncCallback callback, Object state)
{
AsyncCopyStreamResult streamState = new AsyncCopyStreamResult(callback, state);
byte[] buffer = CoreChannel.BufferPool.GetBuffer();
streamState.Source = source;
streamState.Target = target;
streamState.Buffer = buffer;
streamState.AsyncRead = asyncRead;
streamState.AsyncWrite = asyncWrite;
streamState.CloseSource = closeSource;
streamState.CloseTarget = closeTarget;
try
{
AsyncCopyReadHelper(streamState);
}
catch (Exception e)
{
streamState.SetComplete(null, e);
}
return streamState;
} // BeginAsyncCopyStream
internal static void EndAsyncCopyStream(IAsyncResult iar)
{
AsyncCopyStreamResult asyncResult = (AsyncCopyStreamResult)iar;
if (!iar.IsCompleted)
{
iar.AsyncWaitHandle.WaitOne();
}
if (asyncResult.Exception != null)
{
throw asyncResult.Exception;
}
} // EndAsyncCopyStream
private static void AsyncCopyReadHelper(AsyncCopyStreamResult streamState)
{
// There is no try-catch here because the calling method always has a try-catch.
if (streamState.AsyncRead)
{
byte[] buffer = streamState.Buffer;
streamState.Source.BeginRead(buffer, 0, buffer.Length, _asyncCopyStreamReadCallback, streamState);
}
else
{
byte[] buffer = streamState.Buffer;
int bytesRead = streamState.Source.Read(buffer, 0, buffer.Length);
if (bytesRead == 0)
{
streamState.SetComplete(null, null);
}
else
if (bytesRead < 0)
{
throw new RemotingException(
CoreChannel.GetResourceString("Remoting_Stream_UnknownReadError"));
}
else
{
AsyncCopyWriteHelper(streamState, bytesRead);
}
}
} // AsyncCopyReadHelper
private static void AsyncCopyWriteHelper(AsyncCopyStreamResult streamState, int bytesRead)
{
// There is no try-catch here because the calling method always has a try-catch.
if (streamState.AsyncWrite)
{
byte[] buffer = streamState.Buffer;
streamState.Target.BeginWrite(buffer, 0, bytesRead, _asyncCopyStreamWriteCallback, streamState);
}
else
{
byte[] buffer = streamState.Buffer;
streamState.Target.Write(buffer, 0, bytesRead);
AsyncCopyReadHelper(streamState);
}
} // AsyncCopyWriteHelper
private static void AsyncCopyStreamReadCallback(IAsyncResult iar)
{
AsyncCopyStreamResult state = (AsyncCopyStreamResult)iar.AsyncState;
try
{
Stream source = state.Source;
int bytesRead = source.EndRead(iar);
if (bytesRead == 0)
{
state.SetComplete(null, null);
}
else
if (bytesRead < 0)
{
throw new RemotingException(
CoreChannel.GetResourceString("Remoting_Stream_UnknownReadError"));
}
else
{
AsyncCopyWriteHelper(state, bytesRead);
}
}
catch (Exception e)
{
state.SetComplete(null, e);
}
} // AsyncCopyStreamReadCallback
private static void AsyncCopyStreamWriteCallback(IAsyncResult iar)
{
AsyncCopyStreamResult state = (AsyncCopyStreamResult)iar.AsyncState;
try
{
state.Target.EndWrite(iar);
AsyncCopyReadHelper(state);
}
catch (Exception e)
{
state.SetComplete(null, e);
}
} // AsyncCopyStreamWriteCallback
} // class StreamHelper
internal class AsyncCopyStreamResult : BasicAsyncResult
{
internal Stream Source;
internal Stream Target;
internal byte[] Buffer;
internal bool AsyncRead;
internal bool AsyncWrite;
internal bool CloseSource;
internal bool CloseTarget;
internal AsyncCopyStreamResult(AsyncCallback callback, Object state) :
base(callback, state)
{
}
internal override void CleanupOnComplete()
{
if (Buffer != null)
CoreChannel.BufferPool.ReturnBuffer(Buffer);
if (CloseSource)
Source.Close();
if (CloseTarget)
Target.Close();
} // CleanupOnComplete
} // class AsyncCopyStreamResult
} // namespace System.Runtime.Remoting.Channels
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- Mouse.cs
- BindingsCollection.cs
- HtmlInputCheckBox.cs
- PageCache.cs
- EntityDesignerBuildProvider.cs
- ArgumentFixer.cs
- OleDbConnection.cs
- CodeTypeReference.cs
- XPathAxisIterator.cs
- Trace.cs
- AppSecurityManager.cs
- SystemEvents.cs
- BoundColumn.cs
- Preprocessor.cs
- SystemIPInterfaceStatistics.cs
- PrimaryKeyTypeConverter.cs
- ReachVisualSerializer.cs
- XmlSchemaAttributeGroupRef.cs
- UriTemplateEquivalenceComparer.cs
- XomlCompilerHelpers.cs
- Perspective.cs
- SqlException.cs
- WebPartCollection.cs
- ProviderUtil.cs
- SimpleWebHandlerParser.cs
- ArithmeticException.cs
- ConvertersCollection.cs
- CapabilitiesUse.cs
- UnsupportedPolicyOptionsException.cs
- EUCJPEncoding.cs
- activationcontext.cs
- ThemeableAttribute.cs
- PropertyGroupDescription.cs
- WhitespaceRuleReader.cs
- WsdlHelpGeneratorElement.cs
- CatalogPartCollection.cs
- NameTable.cs
- PolygonHotSpot.cs
- XmlMtomWriter.cs
- SharedConnectionInfo.cs
- SynchronizedInputProviderWrapper.cs
- Comparer.cs
- Utility.cs
- ClickablePoint.cs
- DataGridViewAutoSizeColumnModeEventArgs.cs
- PropertyChangedEventManager.cs
- RectangleGeometry.cs
- ACL.cs
- OleDbWrapper.cs
- DomainUpDown.cs
- ComponentFactoryHelpers.cs
- WebEncodingValidator.cs
- QueryResponse.cs
- BamlMapTable.cs
- SecUtil.cs
- ThreadAttributes.cs
- ModelItemCollectionImpl.cs
- ComEventsInfo.cs
- XamlSerializerUtil.cs
- RotateTransform3D.cs
- ClientConfigurationSystem.cs
- ConfigurationValue.cs
- IdentityReference.cs
- ValidatorCollection.cs
- HttpHandlerAction.cs
- SpellCheck.cs
- ConstructorNeedsTagAttribute.cs
- DynamicValueConverter.cs
- EdmValidator.cs
- PrimitiveSchema.cs
- CharacterBufferReference.cs
- CommandHelper.cs
- ResXFileRef.cs
- ExtendedPropertyDescriptor.cs
- IntSecurity.cs
- ToolboxItemFilterAttribute.cs
- CurrentChangingEventArgs.cs
- FrameworkRichTextComposition.cs
- DeferredBinaryDeserializerExtension.cs
- PKCS1MaskGenerationMethod.cs
- MultipleViewPattern.cs
- VirtualizedItemPattern.cs
- TabItemWrapperAutomationPeer.cs
- DefaultBindingPropertyAttribute.cs
- SQLResource.cs
- ListViewCommandEventArgs.cs
- RecordsAffectedEventArgs.cs
- RadioButtonList.cs
- IndexedWhereQueryOperator.cs
- XPathNodeHelper.cs
- RepeaterItemCollection.cs
- ParentUndoUnit.cs
- RelationshipEndCollection.cs
- DoubleAnimationClockResource.cs
- diagnosticsswitches.cs
- ValueExpressions.cs
- JobPageOrder.cs
- CqlParserHelpers.cs
- WebControlAdapter.cs
- LinqMaximalSubtreeNominator.cs