Exemplo n.º 1
0
        private static Func<ArraySegment<byte>, Action, bool> GetRequestBodyBuilder(UWebRequestParameters parameters, Action<Exception> errorCallback)
        {
            return (data, continuation) =>
            {
                if (continuation == null)
                {
                    parameters.Body.Write(data.Array, data.Offset, data.Count);
                    return false;
                }

                var asyncState = new AsyncBuilderState(parameters.Body, continuation, errorCallback);
                parameters.Body.BeginWrite(
                    data.Array,
                    data.Offset,
                    data.Count,
                    ar =>
                    {
                        var state = (AsyncBuilderState)ar.AsyncState;

                        try
                        {
                            state.Stream.EndWrite(ar);

                            state.OnComplete();
                        }
                        catch (Exception e)
                        {
                            state.OnError(e);
                        }
                    },
                    asyncState);

                return true;
            };
        }
Exemplo n.º 2
0
        private static Func <ArraySegment <byte>, Action, bool> GetRequestBodyBuilder(NancyRequestParameters parameters, Action <Exception> errorCallback)
        {
            return((data, continuation) =>
            {
                if (continuation == null)
                {
                    // If continuation is null then we must use sync and return false
                    parameters.Body.Write(data.Array, data.Offset, data.Count);
                    return false;
                }

                // Otherwise use begin/end (which may be blocking anyway)
                // and return true.
                // No need to do any locking because the spec states we can't be called again
                // until we call the continuation.
                var asyncState = new AsyncBuilderState(parameters.Body, continuation, errorCallback);
                parameters.Body.BeginWrite(
                    data.Array,
                    data.Offset,
                    data.Count,
                    (ar) =>
                {
                    var state = (AsyncBuilderState)ar.AsyncState;

                    try
                    {
                        state.Stream.EndWrite(ar);

                        state.OnComplete.Invoke();
                    }
                    catch (Exception e)
                    {
                        state.OnError.Invoke(e);
                    }
                },
                    asyncState);

                return true;
            });
        }
        private static Func<ArraySegment<byte>, Action, bool> GetRequestBodyBuilder(NancyRequestParameters parameters, Action<Exception> errorCallback)
        {
            return (data, continuation) =>
            {
                if (continuation == null)
                {
                    // If continuation is null then we must use sync and return false
                    parameters.Body.Write(data.Array, data.Offset, data.Count);
                    return false;
                }

                // Otherwise use begin/end (which may be blocking anyway)
                // and return true.
                // No need to do any locking because the spec states we can't be called again
                // until we call the continuation.
                var asyncState = new AsyncBuilderState(parameters.Body, continuation, errorCallback);
                parameters.Body.BeginWrite(
                    data.Array,
                    data.Offset,
                    data.Count,
                    ar =>
                    {
                        var state = (AsyncBuilderState)ar.AsyncState;

                        try
                        {
                            state.Stream.EndWrite(ar);

                            state.OnComplete.Invoke();
                        }
                        catch (Exception e)
                        {
                            state.OnError.Invoke(e);
                        }
                    },
                    asyncState);

                return true;
            };
        }