| public EndWrite ( IAsyncResult asyncResult ) : void | ||
| asyncResult | IAsyncResult | |
| 리턴 | void | |
static IEnumerable<Task> CopyStream(Stream input, Stream output)
{
var buffer = new byte[0x2000];
while (true)
{
// Create task to read from the input stream
var read = Task<int>.Factory.FromAsync((buf, offset, count, callback, state) =>
{
Console.WriteLine("Issuing BeginRead");
return input.BeginRead(buf, offset, count, callback, state);
},
ar =>
{
Console.WriteLine("Read completed");
return input.EndRead(ar);
},
buffer, 0, buffer.Length, null);
yield return read;
// If we read no data, return
if (read.Result == 0) break;
// Create task to write to the output stream
yield return Task.Factory.FromAsync((buf, offset, count, callback, state) =>
{
Console.WriteLine("Issuing BeginWrite");
return output.BeginWrite(buf, offset, count, callback, state);
},
ar =>
{
Console.WriteLine("Write completed");
output.EndWrite(ar);
}, buffer, 0, read.Result, null);
}
}
private static void WriteToStreamAsync(Stream s)
{
var t = Task.Factory.FromAsync(
(callback, state) => s.BeginWrite(new byte[] { 1, 2, 3 }, 0, 3, callback, state),
(ar) => s.EndWrite(ar),
null);
t.Wait();
}
public override void EndWrite(IAsyncResult ares)
{
if (disposed)
{
throw new ObjectDisposedException(GetType().ToString());
}
if (ignore_errors)
{
try {
stream.EndWrite(ares);
if (response.SendChunked)
{
stream.Write(crlf, 0, 2);
}
} catch { }
}
else
{
stream.EndWrite(ares);
if (response.SendChunked)
{
stream.Write(crlf, 0, 2);
}
}
}
// http://stackoverflow.com/questions/1540658/net-asynchronous-stream-read-write
public static void CopyTo(this Stream input, Stream output, int bufferSize)
{
if (!input.CanRead) throw new InvalidOperationException("input must be open for reading");
if (!output.CanWrite) throw new InvalidOperationException("output must be open for writing");
byte[][] buf = { new byte[bufferSize], new byte[bufferSize] };
int[] bufl = { 0, 0 };
int bufno = 0;
IAsyncResult read = input.BeginRead(buf[bufno], 0, buf[bufno].Length, null, null);
IAsyncResult write = null;
while (true) {
// wait for the read operation to complete
read.AsyncWaitHandle.WaitOne();
bufl[bufno] = input.EndRead(read);
// if zero bytes read, the copy is complete
if (bufl[bufno] == 0) {
break;
}
// wait for the in-flight write operation, if one exists, to complete
// the only time one won't exist is after the very first read operation completes
if (write != null) {
write.AsyncWaitHandle.WaitOne();
output.EndWrite(write);
}
// start the new write operation
write = output.BeginWrite(buf[bufno], 0, bufl[bufno], null, null);
// toggle the current, in-use buffer
// and start the read operation on the new buffer
bufno = (bufno == 0 ? 1 : 0);
read = input.BeginRead(buf[bufno], 0, buf[bufno].Length, null, null);
}
// wait for the final in-flight write operation, if one exists, to complete
// the only time one won't exist is if the input stream is empty.
if (write != null) {
write.AsyncWaitHandle.WaitOne();
output.EndWrite(write);
}
output.Flush();
// return to the caller ;
return;
}
protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
{
var tcs = new TaskCompletionSource<object>();
_body.Invoke(
(data, callback) =>
{
if (data.Count == 0)
{
stream.Flush();
}
else if (callback == null)
{
stream.Write(data.Array, data.Offset, data.Count);
}
else
{
var sr = stream.BeginWrite(data.Array, data.Offset, data.Count, ar =>
{
if (!ar.CompletedSynchronously)
{
try { stream.EndWrite(ar); }
catch { }
try { callback.Invoke(); }
catch { }
}
}, null);
if (!sr.CompletedSynchronously)
{
return true;
}
stream.EndWrite(sr);
callback.Invoke();
}
return false;
},
ex =>
{
if (ex == null)
{
tcs.TrySetResult(null);
}
else
{
tcs.TrySetException(ex);
}
},
_cancellationToken);
return tcs.Task;
}
protected void WriteCallback(IAsyncResult ar)
{
ResultHandler rh = (ResultHandler)ar.AsyncState;
mStream.EndWrite(ar);
rh(mHandle, MoSync.Constants.CONNOP_WRITE, 1);
}
public bool VerifyEndWriteException(System.IO.Stream serialStream, IAsyncResult asyncResult, Type expectedException)
{
bool retValue = true;
try
{
serialStream.EndWrite(asyncResult);
if (null != expectedException)
{
Console.WriteLine("ERROR!!!: No Excpetion was thrown");
retValue = false;
}
}
catch (System.Exception e)
{
if (null == expectedException)
{
Console.WriteLine("ERROR!!!: Expected no exception to be thrown and {0} was thrown", e);
retValue = false;
}
else if (e.GetType() != expectedException)
{
Console.WriteLine("ERROR!!!: Expected {0} to be thrown and the following exception was thrown:\n{1}", expectedException, e);
retValue = false;
}
}
return(retValue);
}
public override void EndWrite(
IAsyncResult asyncResult
)
{
Trace.WriteLine("TraceStream", "EndWrite()");
m_in.EndWrite(asyncResult);
}
/// <summary>
/// Pipes data from one stream to another
/// </summary>
/// <param name="input">Stream to read from</param>
/// <param name="output">Stream to write to</param>
/// <param name="MaxBufferSize">Size of buffer to use</param>
/// <returns>Number of bytes piped</returns>
public static int Pipe(Stream input, Stream output, int MaxBufferSize)
{
//Internal buffer are two buffers, each half of allowed buffer size, aligned to 1kb blocks
int bufferSize = (MaxBufferSize / 2) & ~1023;
if (bufferSize <= 0) throw new Exception("Specified buffer size to small");
byte[][] buffer = new byte[2][];
buffer[0] = new byte[bufferSize];
buffer[1] = new byte[bufferSize];
int currentBuffer = 0;
int r, total=0;
IAsyncResult asyncRead,asyncWrite;
//Read first block
r = input.Read(buffer[currentBuffer], 0, bufferSize);
//Continue while we're getting data
while (r > 0)
{
//read and write simultaneously
asyncWrite = output.BeginWrite(buffer[currentBuffer], 0, r, null, null);
asyncRead = input.BeginRead(buffer[1-currentBuffer], 0, bufferSize, null, null);
//Wait for both
output.EndWrite(asyncWrite);
r = input.EndRead(asyncRead);
//Switch buffers
currentBuffer = 1 - currentBuffer;
//Count bytes
total += r;
}
//Return number of bytes piped
return total;
}
public static WaitHandle AsyncCopy(this Stream src, Stream dst)
{
var evt = new ManualResetEvent(false);
var buffer = new byte[BUFFER_SIZE];
AsyncCallback cbk = null;
cbk = (asyncReadResult) =>
{
int bytesRead = src.EndRead(asyncReadResult);
if (bytesRead > 0)
{
//Console.Write("r");
dst.BeginWrite(buffer, 0, bytesRead,
(asyncWriteResult) =>
{
//Console.Write("w");
dst.EndWrite(asyncWriteResult);
src.BeginRead(buffer, 0, buffer.Length, cbk, null);
}, null);
}
else
{
Console.WriteLine();
dst.Flush();
dst.Position = 0;
evt.Set();
}
};
src.BeginRead(buffer, 0, buffer.Length, cbk, buffer);
return evt;
}
private static void EndWrite(Stream stream, IAsyncResult ar, byte[] buffer)
{
try
{
stream.EndWrite(ar);
}
catch (Exception)
{
stream.WriteAsync(buffer).Wait();
}
}
private static void FinishWriteAsync(Stream stream, IAsyncResult asyncResult, TaskCompletionSource<int> taskCompletionSource) {
try {
stream.EndWrite(asyncResult);
taskCompletionSource.SetResult(0);
}
catch (OperationCanceledException) {
taskCompletionSource.TrySetCanceled();
}
catch (Exception exception) {
taskCompletionSource.SetException(exception);
}
}
private static IEnumerable<CompletionPort> CreateFixedVhdFileAtAsync(AsyncMachine machine, Stream destination, long virtualSize)
{
var footer = VhdFooterFactory.CreateFixedDiskFooter(virtualSize);
var serializer = new VhdFooterSerializer(footer);
var buffer = serializer.ToByteArray();
destination.SetLength(virtualSize + VhdConstants.VHD_FOOTER_SIZE);
destination.Seek(-VhdConstants.VHD_FOOTER_SIZE, SeekOrigin.End);
destination.BeginWrite(buffer, 0, buffer.Length, machine.CompletionCallback, null);
yield return CompletionPort.SingleOperation;
destination.EndWrite(machine.CompletionResult);
destination.Flush();
}
/// <summary>
/// Copies the contents between two <see cref="Stream"/> instances in an async fashion.
/// </summary>
/// <param name="source">The source stream to copy from.</param>
/// <param name="destination">The destination stream to copy to.</param>
/// <param name="onComplete">Delegate that should be invoked when the operation has completed. Will pass the source, destination and exception (if one was thrown) to the function. Can pass in <see langword="null" />.</param>
public static void CopyTo(this Stream source, Stream destination, Action<Stream, Stream, Exception> onComplete)
{
var buffer =
new byte[BufferSize];
Action<Exception> done = e =>
{
if (onComplete != null)
{
onComplete.Invoke(source, destination, e);
}
};
AsyncCallback rc = null;
rc = readResult =>
{
try
{
var read =
source.EndRead(readResult);
if (read <= 0)
{
done.Invoke(null);
return;
}
destination.BeginWrite(buffer, 0, read, writeResult =>
{
try
{
destination.EndWrite(writeResult);
source.BeginRead(buffer, 0, buffer.Length, rc, null);
}
catch (Exception ex)
{
done.Invoke(ex);
}
}, null);
}
catch (Exception ex)
{
done.Invoke(ex);
}
};
source.BeginRead(buffer, 0, buffer.Length, rc, null);
}
private void OnWriteFinished(System.IAsyncResult ar)
{
object[] objs = (object[])ar.AsyncState;
IO.Stream ostream = (IO.Stream)objs[0];
PeerFinishedPieceTransfer callback = (PeerFinishedPieceTransfer)objs[1];
object state = objs[2];
try
{
ostream.EndWrite(ar);
this.upthrottle.AddData((int)objs[3]);
Config.LogDebugMessage("Piece sent: " + (int)objs[3]);
callback(state, true);
}
catch (System.Exception)
{
callback(state, false);
}
}
private static IEnumerator<Int32> CopyStream(AsyncEnumerator<Int64> ae, Stream source, Stream destination, Int32 bufferSize, Action<Int64> reportProgress) {
Byte[] buffer = new Byte[bufferSize];
Int64 totalBytesRead = 0;
while (true) {
ae.SetOperationTag("Reading from source stream");
// Read whichever is smaller (number of bytes left to read OR the buffer size)
source.BeginRead(buffer, 0, buffer.Length, ae.End(), null);
yield return 1;
Int32 bytesReadThisTime = source.EndRead(ae.DequeueAsyncResult());
totalBytesRead += bytesReadThisTime;
ae.SetOperationTag("Writing to destination stream");
destination.BeginWrite(buffer, 0, bytesReadThisTime, ae.End(), null);
yield return 1;
destination.EndWrite(ae.DequeueAsyncResult());
if (reportProgress != null) reportProgress(totalBytesRead);
if (bytesReadThisTime < buffer.Length) break;
}
ae.Result = totalBytesRead;
}
public Task Start(Stream stream)
{
TaskCompletionSource<object> completed = new TaskCompletionSource<object>();
var bytes = encoding.GetBytes(text);
stream.BeginWrite(bytes, 0, bytes.Length,
async =>
{
try
{
stream.EndWrite(async);
completed.TrySetResult(null);
}
catch (Exception ex)
{
completed.TrySetException(ex);
}
},
null);
return completed.Task;
}
public static void CopyTo(this Stream source, Stream destination, int bufferSize)
{
long ts = DateTime.Now.Ticks;
long cbTotal = 0L;
byte[] read_buffer = new byte[bufferSize];
int cb = source.Read(read_buffer, 0, read_buffer.Length);
AutoResetEvent writeLock = new AutoResetEvent(false);
while (cb > 0)
{
cbTotal += cb;
try
{
byte[] write_buffer = read_buffer;
destination.BeginWrite(write_buffer, 0, cb, (AsyncCallback)delegate(IAsyncResult ar)
{
try
{
destination.EndWrite(ar);
}
finally
{
writeLock.Set();
}
}, null);
}
catch
{
writeLock.Set();
throw;
}
read_buffer = new byte[bufferSize];
cb = source.Read(read_buffer, 0, read_buffer.Length);
writeLock.WaitOne();
}
ts = DateTime.Now.Ticks - ts;
}
static IAsyncResult DoBeginWrite(Stream stream, ManualResetEvent mre, byte[] RandomBuffer)
{
return stream.BeginWrite (RandomBuffer, 0, RandomBuffer.Length, ar => {
IAsyncResult begin_write_recursive_ares;
try {
stream.EndWrite (ar);
// we don't supply an ManualResetEvent so this will throw an NRE on the second run
// which nunit-console will ignore (but other test runners don't like that)
if (mre == null)
return;
begin_write_recursive_ares = DoBeginWrite (stream, null, RandomBuffer);
begin_write_recursive_ares.AsyncWaitHandle.WaitOne ();
mre.Set ();
} catch (ObjectDisposedException e) {
Console.WriteLine ("stream was disposed: {0}", e);
}
}, null);
}
static void Write(Cargo<ArraySegment<byte>> cargo, Stream stream)
{
if (!cargo.Delayable) {
stream.Write(cargo.Result.Array, cargo.Result.Offset, cargo.Result.Count);
return;
}
var result = stream.BeginWrite(cargo.Result.Array, cargo.Result.Offset, cargo.Result.Count, asyncResult => {
if (asyncResult.CompletedSynchronously)
return;
stream.EndWrite(asyncResult);
cargo.Resume();
}, null);
if (result.CompletedSynchronously)
stream.EndWrite(result);
else
cargo.Delay();
}
private CopyItemAction CopyStreamAsync(Stream sourceStream, Stream destStream, IVirtualItem sourceItem, IVirtualItem destItem)
{
object obj2;
lock ((obj2 = this.FSnapshotLock))
{
this.FCopyMode = CopyMode.Async;
}
if (this.Buffer2 == null)
{
this.Buffer2 = new byte[this.Buffer1.Length];
}
byte[] buffer = this.Buffer1;
byte[] buffer2 = this.Buffer2;
int count = 0;
ProcessedSize processed = CreateFileProcessed(sourceStream, sourceItem);
if (!((processed.Total <= buffer.Length) || this.RaiseFileProgress(ref processed)))
{
return CopyItemAction.SkipUndoDest;
}
IAsyncResult asyncResult = sourceStream.BeginRead(buffer, 0, buffer.Length, null, null);
do
{
count = sourceStream.EndRead(asyncResult);
if (base.CheckCancellationPending())
{
return CopyItemAction.SkipUndoDest;
}
IAsyncResult result2 = destStream.BeginWrite(buffer, 0, count, null, null);
byte[] buffer3 = buffer;
if (count > 0)
{
asyncResult = sourceStream.BeginRead(buffer2, 0, buffer2.Length, null, null);
buffer2 = Interlocked.Exchange<byte[]>(ref buffer, buffer2);
}
try
{
destStream.EndWrite(result2);
}
catch (IOException exception)
{
CopyItemAction action = this.HandleCopyIOException(destItem, sourceItem, destItem, destStream, buffer3, count, exception);
if (action != CopyItemAction.Next)
{
return action;
}
}
lock ((obj2 = this.FSnapshotLock))
{
this.FTotalProcessed.AddProcessedSize((long) count);
}
this.RaiseProgress();
processed.AddProcessedSize((long) count);
if (!this.RaiseFileProgress(ref processed))
{
return CopyItemAction.SkipUndoDest;
}
}
while (count > 0);
return CopyItemAction.Next;
}
/// <include file='../_Doc/mscorlib.xml' path='doc/members/member[@name="M:System.IO.Stream.EndWrite(System.IAsyncResult)"]/*' />
/// <param name="stream">Stream on which to end writing.</param>
public static void EndWrite(this Stream stream, IAsyncResult asyncResult)
{
#if DOTNET || WINDOWS_PHONE
stream.EndWrite(asyncResult);
#endif
}
/// <summary>
/// Starts writing response to the specified stream.
/// </summary>
/// <param name="session">Owner IMAP session.</param>
/// <param name="stream">Stream where to store response.</param>
/// <param name="mailboxEncoding">Specifies how mailbox name is encoded.</param>
/// <param name="completedAsyncCallback">Callback to be called when this method completes asynchronously.</param>
/// <returns>Returns true is method completed asynchronously(the completedAsyncCallback is raised upon completion of the operation).
/// Returns false if operation completed synchronously.</returns>
/// <exception cref="ArgumentNullException">Is raised when <b>stream</b> is null reference.</exception>
protected virtual bool ToStreamAsync(IMAP_Session session,Stream stream,IMAP_Mailbox_Encoding mailboxEncoding,EventHandler<EventArgs<Exception>> completedAsyncCallback)
{
if(stream == null){
throw new ArgumentNullException("stream");
}
string responseS = ToString(mailboxEncoding);
byte[] response = Encoding.UTF8.GetBytes(responseS);
// Log.
if(session != null){
session.LogAddWrite(response.Length,responseS.TrimEnd());
}
// Starts writing response to stream.
IAsyncResult ar = stream.BeginWrite(
response,
0,
response.Length,
delegate(IAsyncResult r){
if(r.CompletedSynchronously){
return;
}
try{
stream.EndWrite(r);
if(completedAsyncCallback != null){
completedAsyncCallback(this,new EventArgs<Exception>(null));
}
}
catch(Exception x){
if(completedAsyncCallback != null){
completedAsyncCallback(this,new EventArgs<Exception>(x));
}
}
},
null
);
// Completed synchronously, process result.
if(ar.CompletedSynchronously){
stream.EndWrite(ar);
return false;
}
// Completed asynchronously, stream.BeginWrite AsyncCallback will continue processing.
else{
return true;
}
}
public static Action WriteToStream(this BodyAction body, Stream stream, Action<Exception> error, Action complete)
{
Action[] cancel = {() => { }};
int[] completion = {0};
Action<Exception> errorHandler = ex => { if (Interlocked.Increment(ref completion[0]) == 1) error(ex); };
cancel[0] = body(
(data, continuation) =>
{
if (completion[0] != 0)
return false;
try
{
if (continuation == null)
{
stream.Write(data.Array, data.Offset, data.Count);
return false;
}
var sr = stream.BeginWrite(data.Array, data.Offset, data.Count, ar =>
{
if (ar.CompletedSynchronously) return;
try
{
stream.EndWrite(ar);
}
catch (Exception ex)
{
error(ex);
}
continuation();
}, null);
if (sr.CompletedSynchronously)
{
stream.EndWrite(sr);
return false;
}
return true;
}
catch (Exception ex)
{
errorHandler(ex);
cancel[0]();
return false;
}
},
errorHandler,
() => { if (Interlocked.Increment(ref completion[0]) == 1) complete(); });
return () =>
{
Interlocked.Increment(ref completion[0]);
cancel[0]();
};
}
public override void EndWrite(IAsyncResult asyncResult)
{
_innerStream.EndWrite(asyncResult);
}
private Result Write(Action<string> activity, Stream stream, byte[] buffer, int offset, int count, Result result)
{
// asynchronously execute read operation
Result<IAsyncResult> inner = new Result<IAsyncResult>(TimeSpan.MaxValue);
inner.WhenDone(delegate(Result<IAsyncResult> _unused) {
try {
activity(string.Format("pre {0}!EndWrite", stream.GetType().FullName));
stream.EndWrite(inner.Value);
activity("post EndWrite");
result.Return();
} catch(Exception e) {
activity("throw Write 1");
result.Throw(e);
}
});
try {
activity(string.Format("pre {0}!BeginWrite", stream.GetType().FullName));
stream.BeginWrite(buffer, offset, count, inner.Return, stream);
activity("post BeginWrite");
} catch(Exception e) {
activity("throw Write 2");
result.Throw(e);
}
// return yield handle
return result;
}
public static void StreamWriteAsync(
Stream stream,
byte[] buffer,
int offset,
int count,
SynchronizationContextWrapper syncContext,
Action<int, Exception> callback)
{
Debug.Assert(syncContext != null);
stream.BeginWrite(
buffer,
offset,
count,
delegate(IAsyncResult ar)
{
if (ar.IsCompleted)
{
Exception error = null;
try
{
stream.EndWrite(ar);
stream.Flush();
}
catch (IOException ioe)
{
error = ioe;
}
finally
{
syncContext.Post(() => callback(count, error));
}
}
},
null);
}
/// <summary>
/// Starts writing response to the specified stream.
/// </summary>
/// <param name="session">Owner IMAP session.</param>
/// <param name="stream">Stream where to store response.</param>
/// <param name="mailboxEncoding">Specifies how mailbox name is encoded.</param>
/// <param name="completedAsyncCallback">Callback to be called when this method completes asynchronously.</param>
/// <returns>Returns true is method completed asynchronously(the completedAsyncCallback is raised upon completion of the operation).
/// Returns false if operation completed synchronously.</returns>
/// <exception cref="ArgumentNullException">Is raised when <b>stream</b> is null reference.</exception>
protected override bool ToStreamAsync(IMAP_Session session,Stream stream,IMAP_Mailbox_Encoding mailboxEncoding,EventHandler<EventArgs<Exception>> completedAsyncCallback)
{
if(stream == null){
throw new ArgumentNullException("stream");
}
StringBuilder buffer = new StringBuilder();
buffer.Append("* " + m_MsgSeqNo + " FETCH (");
for(int i=0;i<m_pDataItems.Count;i++){
IMAP_t_Fetch_r_i dataItem = m_pDataItems[i];
if(i > 0){
buffer.Append(" ");
}
if(dataItem is IMAP_t_Fetch_r_i_Flags){
buffer.Append("FLAGS (" + ((IMAP_t_Fetch_r_i_Flags)dataItem).Flags.ToString() + ")");
}
else if(dataItem is IMAP_t_Fetch_r_i_Uid){
buffer.Append("UID " + ((IMAP_t_Fetch_r_i_Uid)dataItem).UID.ToString());
}
else{
throw new NotImplementedException("Fetch response data-item '" + dataItem.ToString() + "' not implemented.");
}
}
buffer.Append(")\r\n");
string responseS = buffer.ToString();
byte[] response = Encoding.UTF8.GetBytes(responseS);
// Log.
if(session != null){
session.LogAddWrite(response.Length,responseS.TrimEnd());
}
// Starts writing response to stream.
IAsyncResult ar = stream.BeginWrite(
response,
0,
response.Length,
delegate(IAsyncResult r){
if(r.CompletedSynchronously){
return;
}
try{
stream.EndWrite(r);
if(completedAsyncCallback != null){
completedAsyncCallback(this,new EventArgs<Exception>(null));
}
}
catch(Exception x){
if(completedAsyncCallback != null){
completedAsyncCallback(this,new EventArgs<Exception>(x));
}
}
},
null
);
// Completed synchronously, process result.
if(ar.CompletedSynchronously){
stream.EndWrite(ar);
return false;
}
// Completed asynchronously, stream.BeginWrite AsyncCallback will continue processing.
else{
return true;
}
}
public static void CopyTo(this Stream input, Stream output, int buffer_size)
{
if (!input.CanRead)
throw new InvalidOperationException("input must be open for reading");
if (!output.CanWrite)
throw new InvalidOperationException("output must be open for writing");
byte[][] buffer = { new byte[buffer_size], new byte[buffer_size] };
int[] length = { 0, 0 };
int index = 0;
IAsyncResult read = input.BeginRead(buffer[index], 0, buffer[index].Length, null, null);
IAsyncResult write = null;
while (true)
{
// wait for the read operation to complete
read.AsyncWaitHandle.WaitOne();
length[index] = input.EndRead(read);
// if zero bytes read, the copy is complete
if (length[index] == 0)
break;
// wait for the in-flight write operation, if one exists, to complete
// the only time one won't exist is after the very first read operation completes
if (write != null)
{
write.AsyncWaitHandle.WaitOne();
output.EndWrite(write);
}
// start the new write operation
write = output.BeginWrite(buffer[index], 0, length[index], null, null);
// toggle the current, in-use buffer
// and start the read operation on the new buffer.
//
// Changed to use XOR to toggle between 0 and 1.
// A little speedier than using a ternary expression.
index ^= 1; // bufno = ( bufno == 0 ? 1 : 0 ) ;
read = input.BeginRead(buffer[index], 0, buffer[index].Length, null, null);
}
// wait for the final in-flight write operation, if one exists, to complete
// the only time one won't exist is if the input stream is empty.
if (write != null)
{
write.AsyncWaitHandle.WaitOne();
output.EndWrite(write);
}
output.Flush();
// return to the caller ;
return;
}
private void ProcessSelectedPart(int BufferSize, long Begin, long End, Stream fsRead, Stream fsWrite, CryptMethod3Key Algorythm, ulong[] KeyList1, ulong[] KeyList2, ulong[] KeyList3, ulong IV, bool FlipKey)
{
byte[] Buffer = new byte[BufferSize];
byte[] CurBuffer = new byte[BufferSize];
byte[] temp;
IAsyncResult ReadResult;
IAsyncResult WriteResult;
fsRead.Seek(Begin, SeekOrigin.Begin);
ReadResult = fsRead.BeginRead(Buffer, 0, BufferSize, null, null);
fsRead.EndRead(ReadResult);
long i;
for (i = Begin + BufferSize; i < End; i += BufferSize)
{
fsRead.Seek(i, SeekOrigin.Begin);
ReadResult = fsRead.BeginRead(CurBuffer, 0, BufferSize, null, null);
Buffer = CryptBuffer(Buffer, Algorythm, KeyList1, KeyList2, KeyList3, ref IV, FlipKey);
fsWrite.Seek(i - BufferSize, SeekOrigin.Begin);
WriteResult = fsWrite.BeginWrite(Buffer, 0, BufferSize, null, null);
fsRead.EndRead(ReadResult);
fsWrite.EndWrite(WriteResult);
temp = Buffer;
Buffer = CurBuffer;
CurBuffer = temp;
}
fsWrite.Seek(i - BufferSize, SeekOrigin.Begin);
WriteResult = fsWrite.BeginWrite(Buffer, 0, BufferSize, null, null);
fsWrite.EndWrite(WriteResult);
}
static IAsyncResult DoBeginWrite(Stream stream, ManualResetEvent mre, byte[] RandomBuffer)
{
return stream.BeginWrite (RandomBuffer, 0, RandomBuffer.Length, ar => {
stream.EndWrite (ar);
// we don't supply an ManualResetEvent so this will throw an NRE on the second run
// which nunit-console will ignore (but other test runners don't like that)
if (mre == null)
return;
DoBeginWrite (stream, null, RandomBuffer).AsyncWaitHandle.WaitOne ();
mre.Set ();
}, null);
}
static IAsyncResult DoBeginWrite(Stream stream, ManualResetEvent mre, byte[] RandomBuffer)
{
return stream.BeginWrite (RandomBuffer, 0, RandomBuffer.Length, ar => {
stream.EndWrite (ar);
DoBeginWrite (stream, null, RandomBuffer).AsyncWaitHandle.WaitOne ();
mre.Set ();
}, null);
}
public static void StreamWriteAsync(
Stream stream,
byte[] buffer,
int offset,
int count,
SynchronizationContextWrapper syncContext,
Action<int, Exception> callback)
{
Exception error = null;
int length = 0;
try
{
stream.BeginWrite(buffer, offset, count,
delegate(IAsyncResult ar)
{
try
{
stream.EndWrite(ar);
stream.Flush();
length = count;
}
catch (Exception e)
{
error = e;
}
callback(length, error);
},
null);
}
catch (Exception e)
{
error = e;
callback(length, error);
}
}
private long AsyncWriteToStream(Stream stream)
{
byte[] data = ConcatenateBufferAndAddIndividualOperations(stream);
var resetEvent = new ManualResetEvent(false);
pendingWritesHandles.Add(resetEvent);
long positionAfterWrite = stream.Position + data.Length;
stream.BeginWrite(data, 0, data.Length, delegate(IAsyncResult ar)
{
try
{
stream.EndWrite(ar);
}
catch (Exception e)
{
lock (pendingWritesFailures)
{
pendingWritesFailures.Add(e);
}
}
finally
{
resetEvent.Set();
}
}, null);
return positionAfterWrite;
}
private static void WriteComplete(IAsyncResult result, HttpMessageContent thisPtr, Stream stream, TaskCompletionSource<object> writeTask)
{
Contract.Assert(result != null, "result cannot be null");
Contract.Assert(thisPtr != null, "thisPtr cannot be null");
Contract.Assert(stream != null, "stream cannot be null");
Contract.Assert(writeTask != null, "writeTask cannot be null");
try
{
stream.EndWrite(result);
}
catch (Exception e)
{
writeTask.TrySetException(e);
}
thisPtr.PrepareContentAsync().Then(content =>
{
if (content != null)
{
content.CopyToAsync(stream)
.CopyResultToCompletionSource(writeTask, completionResult: null);
}
else
{
writeTask.TrySetResult(null);
}
});
}
public static void CopyStreamToStream(Stream source, Stream destination, int buffersize,
Action<Stream, Stream, Exception> completed)
{
//byte[] buffer = new byte[0x2500];
byte[] buffer = new byte[buffersize];
AsyncOperation asyncOp = AsyncOperationManager.CreateOperation(null);
Action<Exception> done = e =>
{
if (completed != null)
asyncOp.Post(delegate { completed(source, destination, e); }, null);
};
AsyncCallback[] rc = { null };
rc[0] = readResult =>
{
try
{
int read = source.EndRead(readResult);
if (read > 0)
{
destination.BeginWrite(buffer, 0, read, writeResult =>
{
try
{
destination.EndWrite(writeResult);
source.BeginRead(
buffer, 0, buffer.Length,
rc[0], null);
}
catch (Exception exc)
{
done(exc);
}
}, null);
}
else done(null);
}
catch (Exception exc) { done(exc); }
};
source.BeginRead(buffer, 0, buffer.Length, rc[0], null);
}
private void CopyStreamAsync(Stream input, Stream output, bool flushInput, bool flushOutput, StreamCopyCompletedDelegate completed)
{
byte[] buffer = new byte[1024 * 4];
var asyncOp = System.ComponentModel.AsyncOperationManager.CreateOperation(null);
Action<Exception> done = e =>
{
if (completed != null) asyncOp.Post(delegate
{
completed(input, output, e);
}, null);
};
AsyncCallback rc = null;
rc = readResult =>
{
try
{
int read = input.EndRead(readResult);
if (read > 0)
{
if (flushInput) input.Flush();
output.BeginWrite(buffer, 0, read, writeResult =>
{
try
{
output.EndWrite(writeResult);
if (flushOutput) output.Flush();
input.BeginRead(buffer, 0, buffer.Length, rc, null);
}
catch (Exception exc) { done(exc); }
}, null);
}
else done(null);
}
catch (Exception exc) { done(exc); }
};
input.BeginRead(buffer, 0, buffer.Length, rc, null);
}
public override void EndWrite(IAsyncResult asyncResult)
{
lock (_stream)
_stream.EndWrite(asyncResult);
}