| private BeginWrite ( byte buffer, int offset, int count, AsyncCallback callback, Object state ) : IAsyncResult | ||
| buffer | byte | |
| offset | int | |
| count | int | |
| callback | AsyncCallback | |
| state | Object | |
| Résultat | IAsyncResult | |
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 IAsyncResult BeginWrite(byte [] buffer, int offset, int count,
AsyncCallback cback, object state)
{
if (disposed)
{
throw new ObjectDisposedException(GetType().ToString());
}
byte [] bytes = null;
MemoryStream ms = GetHeaders(false);
bool chunked = response.SendChunked;
if (ms != null)
{
long start = ms.Position;
ms.Position = ms.Length;
if (chunked)
{
bytes = GetChunkSizeBytes(count, false);
ms.Write(bytes, 0, bytes.Length);
}
ms.Write(buffer, offset, count);
buffer = ms.GetBuffer();
offset = (int)start;
count = (int)(ms.Position - start);
}
else if (chunked)
{
bytes = GetChunkSizeBytes(count, false);
InternalWrite(bytes, 0, bytes.Length);
}
return(stream.BeginWrite(buffer, offset, count, cback, state));
}
/// <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;
}
public override IAsyncResult BeginWrite(
byte[] buffer,
int offset,
int count,
AsyncCallback callback,
object state
)
{
Trace.WriteLine("TraceStream", String.Format("BeginWrite(): offset({0}), count({1})", offset, count));
return(m_in.BeginWrite(buffer, offset, count, callback, state));
}
// 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;
}
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);
}
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;
}
public void SendPiece(IO.Stream ostream, int pieceId, int begin, int length, IO.Stream istream, PeerFinishedPieceTransfer callback, object state)
{
SendMessageHeader(ostream, PeerMessage.Piece, 8 + length);
WriteInt(ostream, pieceId);
WriteInt(ostream, begin);
byte[] writeData = new byte[length];
istream.Read(writeData, 0, length);
object[] objs = new object[4];
objs[0] = ostream;
objs[1] = callback;
objs[2] = state;
objs[3] = length;
ostream.BeginWrite(writeData, 0, writeData.Length, new System.AsyncCallback(OnWriteFinished), (object)objs);
}
public override void write(byte[] buffer, int offset, int size,
ResultHandler rh)
{
if (mResponse != null)
{
throw new Exception("HTTP write");
}
if (mStream == null)
{
mRequest.BeginGetRequestStream(
new AsyncCallback(delegate(IAsyncResult ar)
{
mStream = mRequest.EndGetRequestStream(ar);
mStream.BeginWrite(buffer, offset, size,
new AsyncCallback(WriteCallback), rh);
}), rh);
return;
}
mStream.BeginWrite(buffer, offset, size,
new AsyncCallback(WriteCallback), rh);
}
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;
}
internal void UpLoadFile(string fullFileName, string uploadedName, string dirName)
{
string fileName = uploadedName + new FileInfo(fullFileName).Extension;
string uri = string.Format("ftp://{0}:{1}/{2}/{3}", _ip, _port, dirName, fileName);
_request = (System.Net.FtpWebRequest)System.Net.FtpWebRequest.Create(new Uri(uri));
//request.Credentials = new System.Net.NetworkCredential(sftpUsername, sftpPassword);
_request.KeepAlive = false;
_request.UseBinary = true;
_request.Method = System.Net.WebRequestMethods.Ftp.UploadFile;
_request.UseBinary = true;
System.IO.FileStream fs = new System.IO.FileStream(fullFileName, System.IO.FileMode.Open);
_request.ContentLength = fs.Length;
byte[] buffer = new byte[fs.Length];
fs.Read(buffer, 0, buffer.Length);
System.IO.Stream stream = _request.GetRequestStream();
UploadObject uo = new UploadObject {
stream = stream, fs = fs
};
stream.BeginWrite(buffer, 0, buffer.Length, UploadCallBack, uo);
}
public static bool VerifyWriteException(System.IO.Stream serialStream, Type expectedException)
{
bool retValue = true;
System.IAsyncResult writeAsyncResult;
try
{
writeAsyncResult = serialStream.BeginWrite(new byte[BYTE_SIZE_EXCEPTION], 0, BYTE_SIZE_EXCEPTION, null, null);
writeAsyncResult.AsyncWaitHandle.WaitOne();
Console.WriteLine("ERROR!!!: No Excpetion was thrown");
retValue = false;
}
catch (System.Exception e)
{
if (e.GetType() != expectedException)
{
Console.WriteLine("ERROR!!!: {0} exception was thrown expected {1}", e.GetType(), expectedException);
retValue = false;
}
}
return(retValue);
}
public ProgressWriteAsyncResult(Stream innerStream, ProgressStream progressStream, byte[] buffer, int offset, int count, AsyncCallback callback, object state)
: base(callback, state)
{
Contract.Assert(innerStream != null);
Contract.Assert(progressStream != null);
Contract.Assert(buffer != null);
_innerStream = innerStream;
_progressStream = progressStream;
_count = count;
try
{
IAsyncResult result = innerStream.BeginWrite(buffer, offset, count, _writeCompletedCallback, this);
if (result.CompletedSynchronously)
{
WriteCompleted(result);
}
}
catch (Exception e)
{
Complete(true, e);
}
}
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 => {
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);
}
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);
}
}
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);
}
public Task WriteToStreamAsync(Stream stream)
{
return Task.Factory.FromAsync((Func<AsyncCallback, object, IAsyncResult>) ((callback, state) => stream.BeginWrite(this.buffer, 0, this.storedCount, callback, state)), new Action<IAsyncResult>(stream.EndWrite), null);
}
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;
}
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();
}
/// <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;
}
}
/// <inheritdoc />
public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
return(_stream.BeginWrite(buffer, offset, count, callback, state));
}
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);
}
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;
}
/// <summary>
/// 数据流异步写
/// </summary>
/// <param name="stream">数据流</param>
/// <param name="buffer">目标字节数组</param>
/// <param name="offset">目标起始位置</param>
/// <param name="count">读取数据字节数</param>
/// <param name="state">绑定用户对象</param>
public streamWriter(Stream stream, byte[] buffer, int offset, int count, object state)
{
this.stream = stream;
try
{
stream.BeginWrite(buffer, offset, count, onWrite, state);
}
catch (Exception error)
{
this.error = error;
completed();
}
}
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);
}
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 write(byte[] buffer, int offset, int size,
ResultHandler rh)
{
if (mResponse != null)
throw new Exception("HTTP write");
if (mStream == null)
{
mRequest.BeginGetRequestStream(
new AsyncCallback(delegate(IAsyncResult ar)
{
mStream = mRequest.EndGetRequestStream(ar);
mStream.BeginWrite(buffer, offset, size,
new AsyncCallback(WriteCallback), rh);
}), rh);
return;
}
mStream.BeginWrite(buffer, offset, size,
new AsyncCallback(WriteCallback), rh);
}
/// <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 bool BeginIO(Stream stream, PhpStream phpStream, StreamAccessOptions access, int desc_no)
{
if (access == StreamAccessOptions.Read && !phpStream.CanWrite ||
access == StreamAccessOptions.Write && !phpStream.CanRead)
{
PhpException.Throw(PhpError.Warning, LibResources.GetString("descriptor_item_invalid_mode", desc_no));
return false;
}
ActivePipe pipe = new ActivePipe();
pipe.stream = stream;
pipe.phpStream = phpStream;
pipe.access = access;
pipe.callback = new AsyncCallback(pipe.Callback);
if (access == StreamAccessOptions.Read)
{
var buffer = new byte[BufferSize];
stream.BeginRead(buffer, 0, buffer.Length, pipe.callback, null);
pipe.buffer = new PhpBytes(buffer);
}
else
{
pipe.buffer = phpStream.ReadBytes(BufferSize);
if (pipe.buffer != null)
stream.BeginWrite(pipe.buffer.ReadonlyData, 0, pipe.buffer.Length, pipe.callback, null);
else
stream.Close();
}
return true;
}
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);
}
/// <summary>
/// Begins an asynchronous write operation.
/// </summary>
/// <param name="stream">The stream to write to.</param>
/// <param name="buffer">The buffer to write data from.</param>
/// <param name="callback">The callback to which a System.IO.AsyncStreamOperationState object is passed.</param>
public static void BeginWrite(this Stream stream, byte[] buffer, AsyncCallback callback)
{
stream.BeginWrite(buffer, 0, buffer.Length, callback, new StreamAsyncState(stream, buffer));
}
protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
{
Contract.Assert(stream != null);
// Serialize header
byte[] header = SerializeHeader();
TaskCompletionSource<object> writeTask = new TaskCompletionSource<object>();
try
{
// We don't use TaskFactory.FromAsync as it generates an FxCop CA908 error
Tuple<HttpMessageContent, Stream, TaskCompletionSource<object>> state =
new Tuple<HttpMessageContent, Stream, TaskCompletionSource<object>>(this, stream, writeTask);
IAsyncResult result = stream.BeginWrite(header, 0, header.Length, _onWriteComplete, state);
if (result.CompletedSynchronously)
{
WriteComplete(result, this, stream, writeTask);
}
}
catch (Exception e)
{
writeTask.TrySetException(e);
}
return writeTask.Task;
}
