static void GetBufferFlushComplete(IAsyncEventArgs completionState)
        {
            XmlStreamNodeWriter     thisPtr        = (XmlStreamNodeWriter)completionState.AsyncState;
            GetBufferAsyncEventArgs getBufferState = (GetBufferAsyncEventArgs)thisPtr.flushBufferState.Arguments;

            getBufferState.Result        = getBufferState.Result ?? new GetBufferEventResult();
            getBufferState.Result.Buffer = thisPtr.buffer;
            getBufferState.Result.Offset = 0;
            getBufferState.Complete(false, completionState.Exception);
        }
        internal AsyncCompletionResult GetBufferAsync(GetBufferAsyncEventArgs getBufferState)
        {
            Fx.Assert(getBufferState != null, "GetBufferAsyncEventArgs cannot be null.");
            int count = getBufferState.Arguments.Count;

            Fx.Assert(count >= 0 && count <= bufferLength, String.Empty);
            int finalOffset = 0;

            int bufferOffset = this.offset;

            if (bufferOffset + count <= bufferLength)
            {
                finalOffset = bufferOffset;
            }
            else
            {
                if (onGetFlushComplete == null)
                {
                    onGetFlushComplete = new AsyncEventArgsCallback(GetBufferFlushComplete);
                }
                if (flushBufferState == null)
                {
                    this.flushBufferState = new AsyncEventArgs <object>();
                }

                this.flushBufferState.Set(onGetFlushComplete, getBufferState, this);
                if (FlushBufferAsync(this.flushBufferState) == AsyncCompletionResult.Completed)
                {
                    finalOffset = 0;
                    this.flushBufferState.Complete(true);
                }
                else
                {
                    return(AsyncCompletionResult.Queued);
                }
            }
#if DEBUG
            Fx.Assert(finalOffset + count <= bufferLength, "");
            for (int i = 0; i < count; i++)
            {
                buffer[finalOffset + i] = (byte)'<';
            }
#endif
            //return the buffer and finalOffset;
            getBufferState.Result        = getBufferState.Result ?? new GetBufferEventResult();
            getBufferState.Result.Buffer = this.buffer;
            getBufferState.Result.Offset = finalOffset;
            return(AsyncCompletionResult.Completed);
        }
            AsyncCompletionResult InternalWriteBase64TextAsync(AsyncEventArgs<XmlWriteBase64AsyncArguments> writerState)
            {
                GetBufferAsyncEventArgs bufferState = this.getBufferState;
                GetBufferArgs bufferArgs = this.getBufferArgs;
                XmlWriteBase64AsyncArguments writerArgs = writerState.Arguments;

                if (bufferState == null)
                {
                    // Need to initialize the cached getBufferState 
                    // used to call GetBufferAsync() multiple times.
                    bufferState = new GetBufferAsyncEventArgs();
                    bufferArgs = new GetBufferArgs();
                    this.getBufferState = bufferState;
                    this.getBufferArgs = bufferArgs;
                }

                Base64Encoding encoding = XmlConverter.Base64Encoding;

                while (writerArgs.Count >= 3)
                {
                    int byteCount = Math.Min(bufferLength / 4 * 3, writerArgs.Count - writerArgs.Count % 3);
                    int charCount = byteCount / 3 * 4;

                    bufferArgs.Count = charCount;
                    bufferState.Set(onGetBufferComplete, bufferArgs, this);
                    if (writer.GetBufferAsync(bufferState) == AsyncCompletionResult.Completed)
                    {
                        GetBufferEventResult getbufferResult = bufferState.Result;
                        bufferState.Complete(true);
                        writer.Advance(encoding.GetChars(
                            writerArgs.Buffer,
                            writerArgs.Offset,
                            byteCount,
                            getbufferResult.Buffer,
                            getbufferResult.Offset));
                        writerArgs.Offset += byteCount;
                        writerArgs.Count -= byteCount;
                    }
                    else
                    {
                        return AsyncCompletionResult.Queued;
                    }
                }

                if (writerArgs.Count > 0)
                {
                    bufferArgs.Count = 4;
                    bufferState.Set(onGetBufferComplete, bufferArgs, this);
                    if (writer.GetBufferAsync(bufferState) == AsyncCompletionResult.Completed)
                    {
                        GetBufferEventResult getbufferResult = bufferState.Result;
                        bufferState.Complete(true);
                        writer.Advance(encoding.GetChars(
                            writerArgs.Buffer,
                            writerArgs.Offset,
                            writerArgs.Count,
                            getbufferResult.Buffer,
                            getbufferResult.Offset));
                    }
                    else
                    {
                        return AsyncCompletionResult.Queued;
                    }
                }

                return AsyncCompletionResult.Completed;
            }
Esempio n. 4
0
            AsyncCompletionResult InternalWriteBase64TextAsync(AsyncEventArgs <XmlWriteBase64AsyncArguments> writerState)
            {
                GetBufferAsyncEventArgs      bufferState = this.getBufferState;
                GetBufferArgs                bufferArgs  = this.getBufferArgs;
                XmlWriteBase64AsyncArguments writerArgs  = writerState.Arguments;

                if (bufferState == null)
                {
                    // Need to initialize the cached getBufferState
                    // used to call GetBufferAsync() multiple times.
                    bufferState         = new GetBufferAsyncEventArgs();
                    bufferArgs          = new GetBufferArgs();
                    this.getBufferState = bufferState;
                    this.getBufferArgs  = bufferArgs;
                }

                Base64Encoding encoding = XmlConverter.Base64Encoding;

                while (writerArgs.Count >= 3)
                {
                    int byteCount = Math.Min(bufferLength / 4 * 3, writerArgs.Count - writerArgs.Count % 3);
                    int charCount = byteCount / 3 * 4;

                    bufferArgs.Count = charCount;
                    bufferState.Set(onGetBufferComplete, bufferArgs, this);
                    if (writer.GetBufferAsync(bufferState) == AsyncCompletionResult.Completed)
                    {
                        GetBufferEventResult getbufferResult = bufferState.Result;
                        bufferState.Complete(true);
                        writer.Advance(encoding.GetChars(
                                           writerArgs.Buffer,
                                           writerArgs.Offset,
                                           byteCount,
                                           getbufferResult.Buffer,
                                           getbufferResult.Offset));
                        writerArgs.Offset += byteCount;
                        writerArgs.Count  -= byteCount;
                    }
                    else
                    {
                        return(AsyncCompletionResult.Queued);
                    }
                }

                if (writerArgs.Count > 0)
                {
                    bufferArgs.Count = 4;
                    bufferState.Set(onGetBufferComplete, bufferArgs, this);
                    if (writer.GetBufferAsync(bufferState) == AsyncCompletionResult.Completed)
                    {
                        GetBufferEventResult getbufferResult = bufferState.Result;
                        bufferState.Complete(true);
                        writer.Advance(encoding.GetChars(
                                           writerArgs.Buffer,
                                           writerArgs.Offset,
                                           writerArgs.Count,
                                           getbufferResult.Buffer,
                                           getbufferResult.Offset));
                    }
                    else
                    {
                        return(AsyncCompletionResult.Queued);
                    }
                }

                return(AsyncCompletionResult.Completed);
            }