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
- EntityCommandCompilationException.cs
- SymDocumentType.cs
- TypeConverterHelper.cs
- SqlCommandBuilder.cs
- WebPartUtil.cs
- Font.cs
- EntitySetRetriever.cs
- PropertyGridCommands.cs
- SupportsEventValidationAttribute.cs
- CollectionChangedEventManager.cs
- WebServiceData.cs
- WebPartTransformerCollection.cs
- RtType.cs
- StrongNameUtility.cs
- SqlReorderer.cs
- XmlCharacterData.cs
- PictureBox.cs
- BamlTreeUpdater.cs
- EncoderParameter.cs
- RecordConverter.cs
- DynamicPropertyReader.cs
- LookupBindingPropertiesAttribute.cs
- SoapSchemaExporter.cs
- RotateTransform.cs
- ToggleButton.cs
- HtmlElement.cs
- SelectionProviderWrapper.cs
- CodeIterationStatement.cs
- ValidationVisibilityAttribute.cs
- Zone.cs
- RbTree.cs
- DataRowExtensions.cs
- RequestQueryParser.cs
- SiteMapNode.cs
- ReadOnlyDataSource.cs
- LayoutEvent.cs
- XmlNamespaceDeclarationsAttribute.cs
- XmlDataFileEditor.cs
- Security.cs
- BinaryCommonClasses.cs
- ParsedAttributeCollection.cs
- DocumentOrderComparer.cs
- RegexReplacement.cs
- XmlSerializerNamespaces.cs
- listitem.cs
- UserUseLicenseDictionaryLoader.cs
- lengthconverter.cs
- PropertyMetadata.cs
- NonParentingControl.cs
- DependencyPropertyHelper.cs
- RequestCachePolicy.cs
- BindingExpression.cs
- StdRegProviderWrapper.cs
- ToolStripItemEventArgs.cs
- EastAsianLunisolarCalendar.cs
- BaseAddressElement.cs
- GreenMethods.cs
- BoundsDrawingContextWalker.cs
- TypefaceCollection.cs
- SmtpCommands.cs
- CodeDomSerializationProvider.cs
- InvalidWMPVersionException.cs
- TextContainer.cs
- UnsafeCollabNativeMethods.cs
- XXXOnTypeBuilderInstantiation.cs
- XdrBuilder.cs
- PingOptions.cs
- TextRangeEditLists.cs
- RequestQueue.cs
- XmlSchemaNotation.cs
- CookieProtection.cs
- Converter.cs
- MetadataWorkspace.cs
- Parameter.cs
- MessageEncodingBindingElement.cs
- OperationCanceledException.cs
- ImplicitInputBrush.cs
- ColumnWidthChangingEvent.cs
- WS2007FederationHttpBindingElement.cs
- TransportSecurityProtocol.cs
- HwndProxyElementProvider.cs
- CommandField.cs
- FormsAuthenticationConfiguration.cs
- TableColumn.cs
- GenerateScriptTypeAttribute.cs
- AssemblyContextControlItem.cs
- PointAnimation.cs
- messageonlyhwndwrapper.cs
- DataContractFormatAttribute.cs
- FilteredDataSetHelper.cs
- SmiRecordBuffer.cs
- ArraySegment.cs
- InternalRelationshipCollection.cs
- DocumentOrderComparer.cs
- NativeRightsManagementAPIsStructures.cs
- AttributeQuery.cs
- WindowsListView.cs
- ObjectDataSourceWizardForm.cs
- PrintDialog.cs
- _BasicClient.cs