C# IOwinContext.Set方法代码示例

 private static Task Success(IOwinContext context)
 {
     context.Response.StatusCode = 200;
     context.Set("test.PathBase", context.Request.PathBase.Value);
     context.Set("test.Path", context.Request.Path.Value);
     return Task.FromResult<object>(null);
 }

        public override Task Invoke(IOwinContext context)
        {
            var rep = context.Response;
            rep.StatusCode = 404;

            //判断调用次数，避免无限递归
            var invokeTimes = context.Get<Int32>(INVOKE_TIMES);
            invokeTimes++;
            if (invokeTimes > 1 || String.IsNullOrEmpty(RewritePath))
            {
                String msg = "404 Not Found";
                rep.ContentLength = msg.Length;
                return rep.WriteAsync(msg);
            }
            context.Set(INVOKE_TIMES, invokeTimes);

            context.Set<String>("owin.RequestPath", RewritePath);
            OwinMiddleware first = server.GetFirstMiddlewareInstance();
            if (first == null)
                throw new ArgumentException($"Middleware '{this.GetType().FullName};{this.GetType().Assembly.GetName().Name}' must not be the first middleware,and recommand to be set to the last one.");

            //清理OwinContext
            foreach (var cleaner in server.GetMiddlewares<IOwinContextCleaner>())
                cleaner.Clean(context);

            return first.Invoke(context);
        }

 public override Task Invoke(IOwinContext context)
 {
     context.Set<string>("p1", p1);
     context.Set<int>("p2", p2);
     context.Set<object>("p3", p3);
     return this.Next.Invoke(context);
 }

 public async override Task Invoke(IOwinContext context)
 {
     using (IDependencyScope scope = Resolver.BeginScope())
     {
         context.Set<IDependencyScope>(scope);
         context.Set<ManahostManagerDAL>((ManahostManagerDAL)scope.GetService(typeof(ManahostManagerDAL)));
         var scopeUnity = scope as UnityResolver;
         scopeUnity.RegisterInstance(new UnityRegisterScope() { Scope = scope });
         await Next.Invoke(context);
     }
 }

 private bool InspectStatusCode(IOwinContext context)
 {
     StatusCodeAction action;
     string link;
     int statusCode = context.Response.StatusCode;
     if (options.StatusCodeActions.TryGetValue(statusCode, out action)
         && action == StatusCodeAction.ReplaceResponseWithKittens
         && links.TryGetValue(statusCode, out link))
     {
         context.Set<bool?>(ReplacementKey, true);
         return action == StatusCodeAction.ReplaceResponseWithKittens;
     }
     context.Set<bool?>(ReplacementKey, false);
     return false;
 }

 public override Task Invoke(IOwinContext context)
 {
     String path = context.Get<String>("owin.RequestPath");
     if (rewriteDict.ContainsKey(path))
         context.Set<String>("owin.RequestPath", rewriteDict[path]);
     return Next.Invoke(context);
 }

 public async override Task Invoke(IOwinContext context)
 {
     context.Set(OriginalStreamKey, context.Response.Body);
     context.Response.Body = new StreamWrapper(context.Response.Body, InspectStatusCode, context);
     await Next.Invoke(context);
     
     StatusCodeAction action;
     string link;
     int statusCode = context.Response.StatusCode;
     bool? replace = context.Get<bool?>(ReplacementKey);
     if (!replace.HasValue)
     {
         // Never evaluated, no response sent yet.
         if (options.StatusCodeActions.TryGetValue(statusCode, out action)
             && links.TryGetValue(statusCode, out link)
             && action != StatusCodeAction.Ignore)
         {
             await SendKitten(context, link);
         }
     }
     else if (replace.Value == true)
     {
         if (links.TryGetValue(statusCode, out link))
         {
             await SendKitten(context, link);
         }
     }
 }

        public override async Task Invoke(IOwinContext context)
        {
            // Determine correlation id.
            var correlationId = context.Get<string>(OwinRequestIdKey);

            // The NuGet Gallery sends us the X-CorrelationId header.
            // If that header is present, override OWIN's owin.RequestId.
            string[] temp = null;
            if (context.Request.Headers.TryGetValue(CorrelationIdHeaderKey, out temp))
            {
                correlationId = temp[0];

                context.Set(OwinRequestIdKey, correlationId);
            }

            // As a bonus, make Serilog aware of this request ID as well.
            if (HttpContext.Current != null)
            {
                HttpContext.Current.Items[SerilogRequestIdItemName] = Guid.Parse(correlationId);
            }

            // Run all the things
            await Next.Invoke(context);

            // Set response header
            context.Response.Headers.Add("X-CorrelationId", new[] { context.Get<string>(OwinRequestIdKey) });
        }

        public override async Task Invoke(IOwinContext context)
        {
            try
            {
                await Next.Invoke(context);
            }
            catch (Exception ex)
            {
                var rep = context.Response;
                rep.StatusCode = 500;
                try
                {
                    if (String.IsNullOrEmpty(RewritePath))
                    {
                        var result = ApiResult.Error("500 内部错误", new ExceptionInfo(ex)).ToString();

                        rep.ContentType = "text/json; charset=UTF-8";
                        byte[] content = encoding.GetBytes(result);
                        rep.ContentLength = content.Length;
                        await context.Response.WriteAsync(content);
                        return;
                    }

                    context.Set("Exception", ex);
                    context.Set("owin.RequestPath", RewritePath);

                    //清理OwinContext
                    foreach (var cleaner in server.GetMiddlewares<IOwinContextCleaner>())
                        cleaner.Clean(context);

                    await Next.Invoke(context);
                    if (rep.StatusCode == 404)
                        throw ex;
                }
                catch (Exception ex2)
                {
                    rep.ContentType = "text/plain; charset=UTF-8";
                    byte[] content = encoding.GetBytes(ex2.ToString());
                    rep.ContentLength = content.Length;
                    await context.Response.WriteAsync(content);
                }
            }
        }

        public override Task Invoke(IOwinContext context)
        {
            String path = context.Get<String>("owin.RequestPath");
            //设置原始请求路径
            context.Set("Quick.OwinMVC.SourceRequestPath", path);
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < path.Split('/').Length - 2; i++)
            {
                if (i > 0)
                    sb.Append("/");
                sb.Append("..");
            }
            var contextPath = sb.ToString();
            if (String.IsNullOrEmpty(contextPath))
                contextPath = ".";

            context.Set("ContextPath", contextPath);
            return Next.Invoke(context);
        }

 public async override Task Invoke(IOwinContext context)
 {
     var timewatch = Stopwatch.StartNew();
     context.Set(RequestStopwatchLogKey, GetLogs());
     await Next.Invoke(context);
     timewatch.Stop();
     lock (_logs)
     {
         _logs.Add(new RequestStopwatchLog(context.Request.Path.ToString(), timewatch.ElapsedMilliseconds));
     }
 }

        public override Task Invoke(IOwinContext context)
        {
            return Task.Factory.StartNew(() =>
            {
                try
                {
                    Next.Invoke(context).Wait();
                }
                catch (Exception ex)
                {
                    var rep = context.Response;
                    rep.StatusCode = 500;
                    try
                    {
                        if (String.IsNullOrEmpty(RewritePath))
                            throw new ArgumentNullException($"Property '{this.GetType().FullName}.{RewritePath}' must be set.");

                        context.Set("Exception", ex);
                        context.Set("owin.RequestPath", RewritePath);

                        //清理OwinContext
                        foreach (var cleaner in server.GetMiddlewares<IOwinContextCleaner>())
                            cleaner.Clean(context);

                        Next.Invoke(context).Wait();
                        if (rep.StatusCode == 404)
                            throw ex;
                    }
                    catch (Exception ex2)
                    {
                        rep.ContentType = "text/plain; charset=UTF-8";
                        byte[] content = encoding.GetBytes(ex2.ToString());
                        rep.ContentLength = content.Length;
                        context.Response.Write(content);
                    }
                }
            });
        }

        public override async Task Invoke(IOwinContext context)
        {
            InitializeOperationIdContext(context);

            try
            {
                await Next.Invoke(context);
            }
            finally
            {
                context.Set<string>(Consts.OperationIdContextKey, null);
                OperationIdContext.Clear();
            }
        }

        /// <summary>
        /// Process an individual request.
        /// </summary>
        public override async Task Invoke(IOwinContext context)
        {
            if (Interlocked.Exchange(ref configurationSaved, 1) == 0) {
                VisualStudioHelper.DumpConfiguration(Configuration, Configuration.ApplicationPhysicalPath);
            }
            // create the context
            var dotvvmContext = new DotvvmRequestContext()
            {
                OwinContext = context,
                Configuration = Configuration,
                ResourceManager = new ResourceManager(Configuration),
                ViewModelSerializer = Configuration.ServiceLocator.GetService<IViewModelSerializer>()
            };
            context.Set(HostingConstants.DotvvmRequestContextOwinKey, dotvvmContext);

            // attempt to translate Googlebot hashbang espaced fragment URL to a plain URL string.
            string url;
            if (!TryParseGooglebotHashbangEscapedFragment(context.Request.QueryString, out url))
            {
                url = context.Request.Path.Value;
            }
            url = url.Trim('/');

            // find the route
            IDictionary<string, object> parameters = null;
            var route = Configuration.RouteTable.FirstOrDefault(r => r.IsMatch(url, out parameters));

            if (route != null)
            {
                // handle the request
                dotvvmContext.Route = route;
                dotvvmContext.Parameters = parameters;
                dotvvmContext.Query = context.Request.Query
                    .ToDictionary(d => d.Key, d => d.Value.Length == 1 ? (object) d.Value[0] : d.Value);

                try
                {
                    await route.ProcessRequest(dotvvmContext);
                    return;
                }
                catch (DotvvmInterruptRequestExecutionException)
                {
                    // the response has already been generated, do nothing
                    return;
                }
            }
            
            // we cannot handle the request, pass it to another component
            await Next.Invoke(context);
        }

        private void InitializeOperationIdContext(IOwinContext context)
        {
            string idContextKey;

            if (_configuration.ShouldTryGetIdFromHeader && 
                TryGetIdFromHeader(context, out idContextKey))
            {
                OperationIdContext.Set(idContextKey);
            }
            else
            {
                OperationIdContext.Create();
            }

            context.Set(Consts.OperationIdContextKey, OperationIdContext.Get());
        }