C# AuthorizationContext类代码示例

 protected override void HandleNonHttpsRequest(AuthorizationContext filterContext)
 {
     if (!filterContext.HttpContext.Request.IsLocal)
     {
         base.HandleNonHttpsRequest(filterContext);
     }
 }

 public async Task HandleAsync(AuthorizationContext context)
 {
     if (await Handler(context))
     {
         context.Succeed(this);
     }
 }

 protected override void OnAuthorization(AuthorizationContext filterContext)
 {
     if(!AuthHelper.IsAllowEnterAdminPlatform)
     {
         throw new HttpException(401, "您没有权限进行此操作！");
     }
 }

        protected override void HandleUnauthorizedRequest(AuthorizationContext filterContext)
        {
            //you can change to any controller or html page.
            //filterContext.Result = new RedirectResult("/Home/NaoAutorizado");
            filterContext.Result = new RedirectResult("/Identificacao/Autenticacao/NaoAutorizado");

        }

 protected override void HandleUnauthorizedRequest(AuthorizationContext context)
 {
     if (context.RequestContext.HttpContext.Request.Headers["X-Requested-With"] != "XMLHttpRequest")
     {
         context.Result = new RedirectResult("/account/sign-in");
     }
 }

        public override bool CheckAccess(AuthorizationContext context)
        {
            var identity = context.Principal.Identity as IClaimsIdentity;
            if (identity == null || !identity.IsAuthenticated)
            {
                return false;
            }

            var nameIdentifier = identity.Claims.FirstOrDefault(c => c.ClaimType == ClaimTypes.NameIdentifier);
            if (nameIdentifier == null)
            {
                return false;
            }

            var resourceUri = new Uri(context.Resource.First().Value, UriKind.RelativeOrAbsolute);
            foreach (var validator in this.storageRequestValidators)
            {
                if (validator.DoesRequestApply(resourceUri))
                {
                    return validator.ValidateRequest(nameIdentifier.Value, HttpContext.Current.Request);
                }
            }

            return base.CheckAccess(context);
        }

        // Override method
        public override void OnAuthorization(AuthorizationContext filterContext)
        {
            // Get a reference to the user
            var user = filterContext.HttpContext.User as ClaimsPrincipal;

            // Matches (below) are case-insensitive

            // Look for claims that match the incoming type
            // The matchingClaims will be a collection of zero or more matching claims
            var matchingClaims = user.Claims
                .Where(c => c.Type.ToLower().Contains(ClaimType.ToLower()));

            // Attempt to locate matching values
            var matchedClaim = false;
            foreach (var claim in matchingClaims)
            {
                if (claim.Value.ToLower() == ClaimValue.ToLower())
                {
                    matchedClaim = true;
                    break;
                }
            }

            if (matchedClaim)
            {
                // Yes, authorized
                base.OnAuthorization(filterContext);
            }
            else
            {
                // No, not authorized
                base.HandleUnauthorizedRequest(filterContext);
            }
        }

        public override void OnAuthorization(AuthorizationContext filterContext)
        {
            var user = HttpContext.Current.User as ClaimsPrincipal;
            var controllerGroup = filterContext.Controller.GetType().GetCustomAttribute<ClaimsGroupAttribute>();

            if (controllerGroup == null)
            {
                return;
            }

            var actionClaim = (ClaimsActionAttribute)filterContext.ActionDescriptor.GetCustomAttributes(typeof(ClaimsActionAttribute), true).FirstOrDefault();

            actionClaim = actionClaim ?? new ClaimsActionAttribute(ClaimsActions.Index);

            var groupId = controllerGroup.GetGroupId();
            var claimValue = actionClaim .Claim.ToString();

            var hasClaim = user.HasClaim(groupId, claimValue);
            if (!hasClaim)
            {
                filterContext.Result = new RedirectToRouteResult(new RouteValueDictionary()
                {
                    { "controller", "errors" },
                    { "action", "Unauthorised" },
                    { "area", "" }
                });
            }
        }

 public async Task HandleAsync(AuthorizationContext context)
 {
     foreach (var handler in context.Requirements.OfType<IAuthorizationHandler>())
     {
         await handler.HandleAsync(context);
     }
 }

 protected ActionResult CreateResult(AuthorizationContext filterContext)
 {
     var viewName = "~/Views/Shared/AccessDenied.cshtml";
     return new PartialViewResult
     {
         ViewName = viewName
     };
 }

 public void OnAuthorization(AuthorizationContext context)
 {
     context.Result = new ContentResult()
     {
         Content = "You are unauthorized!!",
         StatusCode = 401
     };
 }

        public virtual void OnAuthorization(AuthorizationContext filterContext)
        {
            if (filterContext == null)
            {
                throw new ArgumentNullException("filterContext");
            }

            filterContext.Controller.ValidateRequest = EnableValidation;
        }

 public bool Authorize(ClaimsPrincipal user, object resource, [NotNull] IEnumerable<IAuthorizationRequirement> requirements)
 {
     var authContext = new AuthorizationContext(requirements, user, resource);
     foreach (var handler in _handlers)
     {
         handler.Handle(authContext);
     }
     return authContext.HasSucceeded;
 }

        protected virtual void Fail(AuthorizationContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException(nameof(context));
            }

            context.Result = new HttpUnauthorizedResult();
        }

        protected virtual bool HasAllowAnonymous(AuthorizationContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException(nameof(context));
            }

            return context.Filters.Any(item => item is IAllowAnonymousFilter);
        }