C# DreamMessage.Close方法代码示例

        private void Handler_DreamMessage(DreamMessage request)
        {
            try {

                // grabbing context from FeatureChain (must remove it again from env before env completes, so that it doesn't get disposed)
                if(_context.IsTaskEnvDisposed) {
                    throw new InvalidOperationException("cannot go to next feature state with disposed context");
                }
                _context.AttachToCurrentTaskEnv();

                // check if request is authorized for service
                if((_stage.Access != DreamAccess.Public) && (_context.Feature.Service.Self != null) && (_stage.Access > _context.Feature.Service.DetermineAccess(_context, request))) {
                    request.Close();
                    _log.WarnFormat("access '{0}' to feature '{1}' denied for '{2}'",
                        _stage.Access,
                        _context.Uri.AsPublicUri(),
                        request.Headers.DreamService
                    );
                    if(_log.IsDebugEnabled) {
                        _log.DebugFormat("with service keys:");
                        foreach(DreamCookie c in request.Cookies) {
                            if(c.Name != "service-key") {
                                continue;
                            }
                            _log.DebugFormat("  path: {0}, key: {1}", c.Path, c.Value);
                        }
                    }

                    // removing context from env so that shared context is not disposed
                    _context.DetachFromTaskEnv();
                    _response.Return(DreamMessage.Forbidden("insufficient access privileges"));
                } else {

                    // invoke handler
                    Result<DreamMessage> inner = new Result<DreamMessage>(_response.Timeout, TaskEnv.Current).WhenDone(delegate(DreamMessage value) {

                        // removing context from env so that shared context is not disposed
                        _context.DetachFromTaskEnv();

                        // forward result to recipient
                        _response.Return(value);
                    }, delegate(Exception exception) {

                        // removing context from env so that shared context is not disposed
                        _context.DetachFromTaskEnv();

                        // forward exception to recipient
                        _response.Throw(exception);
                    });
                    _stage.Invoke(_context, request, inner);
                }
            } catch(Exception ex) {
                _response.Throw(ex);
            }
        }

        /// <summary>
        /// Invoke the plug, but leave the stream unread so that the returned <see cref="DreamMessage"/> can be streamed.
        /// </summary>
        /// <param name="verb">Request verb.</param>
        /// <param name="request">Request message.</param>
        /// <param name="result">The <see cref="Result{DreamMessage}"/>instance to be returned by this method.</param>
        /// <returns>Synchronization handle.</returns>
        public Result<DreamMessage> InvokeEx(string verb, DreamMessage request, Result<DreamMessage> result) {
            if(verb == null) {
                throw new ArgumentNullException("verb");
            }
            if(request == null) {
                throw new ArgumentNullException("request");
            }
            if(request.Status != DreamStatus.Ok) {
                throw new ArgumentException("request status must be 200 (Ok)");
            }
            if(result == null) {
                throw new ArgumentNullException("response");
            }

            // determine which factory has the best match
            IPlugEndpoint match;
            XUri normalizedUri;
            FindPlugEndpoint(Uri, out match, out normalizedUri);

            // check if we found a match
            if(match == null) {
                request.Close();
                result.Return(new DreamMessage(DreamStatus.NoEndpointFound, null, XDoc.Empty));
                return result;
            }

            // add matching cookies from service or from global cookie jar
            DreamCookieJar cookies = CookieJar;

            // prepare request
            try {
                request = PreProcess(verb, Uri, normalizedUri, _headers, cookies, request);

                // check if custom pre-processing handlers are registered
                if(_preHandlers != null) {
                    foreach(var handler in _preHandlers) {
                        request = handler(verb, Uri, normalizedUri, request) ?? new DreamMessage(DreamStatus.RequestIsNull, null, XDoc.Empty);
                        if(request.Status != DreamStatus.Ok) {
                            result.Return(request);
                            return result;
                        }
                    }
                }
            } catch(Exception e) {
                request.Close();
                result.Return(new DreamMessage(DreamStatus.RequestFailed, null, new XException(e)));
                return result;
            }

            // Note (arnec): Plug never throws, so we usurp the passed result if it has a timeout
            // setting the result timeout on inner result manually
            var outerTimeout = result.Timeout;
            if(outerTimeout != TimeSpan.MaxValue) {
                result.Timeout = TimeSpan.MaxValue;
            }

            // if the governing result has a shorter timeout than the plug, it superceeds the plug timeout
            var timeout = outerTimeout < Timeout ? outerTimeout : Timeout;

            // prepare response handler
            var inner = new Result<DreamMessage>(timeout, TaskEnv.None).WhenDone(
                v => {
                    try {
                        var message = PostProcess(verb, Uri, normalizedUri, _headers, cookies, v);

                        // check if custom post-processing handlers are registered
                        if((message.Status == DreamStatus.MovedPermanently ||
                            message.Status == DreamStatus.Found ||
                            message.Status == DreamStatus.TemporaryRedirect) &&
                           AutoRedirect &&
                           request.IsCloneable
                        ) {
                            var redirectPlug = new Plug(message.Headers.Location, Timeout, Headers, null, null, null, CookieJar, (ushort)(MaxAutoRedirects - 1));
                            var redirectMessage = request.Clone();
                            request.Close();
                            redirectPlug.InvokeEx(verb, redirectMessage, new Result<DreamMessage>()).WhenDone(result.Return);
                        } else {
                            request.Close();
                            if(_postHandlers != null) {
                                foreach(var handler in _postHandlers) {
                                    message = handler(verb, Uri, normalizedUri, message) ?? new DreamMessage(DreamStatus.ResponseIsNull, null, XDoc.Empty);
                                }
                            }
                            result.Return(message);
                        }
                    } catch(Exception e) {
                        request.Close();
                        result.Return(new DreamMessage(DreamStatus.ResponseFailed, null, new XException(e)));
                    }
                },
                e => {

                    // an exception occurred somewhere during processing (not expected, but it could happen)
//.........这里部分代码省略.........