Make AuthorizationHandler<TReq> async only

src/Microsoft.AspNetCore.Authorization/AuthorizationHandler.cs

@@ -6,65 +6,63 @@ using System.Threading.Tasks;
 
 namespace Microsoft.AspNetCore.Authorization
 {
+    /// <summary>
+    /// Base class for authorization handlers that need to be called for a specific requirement type.
+    /// </summary>
+    /// <typeparam name="TRequirement">The type of the requirement to handle.</typeparam>
     public abstract class AuthorizationHandler<TRequirement> : IAuthorizationHandler
-        where TRequirement : IAuthorizationRequirement
+            where TRequirement : IAuthorizationRequirement
     {
-        public void Handle(AuthorizationHandlerContext context)
+        /// <summary>
-        {
+        /// Makes a decision if authorization is allowed.
-            foreach (var req in context.Requirements.OfType<TRequirement>())
+        /// </summary>
-            {
+        /// <param name="context">The authorization information.</param>
-                Handle(context, req);
-            }
-        }
-
         public virtual async Task HandleAsync(AuthorizationHandlerContext context)
         {
             foreach (var req in context.Requirements.OfType<TRequirement>())
             {
-                await HandleAsync(context, req);
+                await HandleRequirementAsync(context, req);
             }
         }
 
-        protected abstract void Handle(AuthorizationHandlerContext context, TRequirement requirement);
+        /// <summary>
-
+        /// Makes a decision if authorization is allowed based on a specific requirement.
-        protected virtual Task HandleAsync(AuthorizationHandlerContext context, TRequirement requirement)
+        /// </summary>
-        {
+        /// <param name="context">The authorization information.</param>
-            Handle(context, requirement);
+        /// <param name="requirement">The requirement to evaluate.</param>
-            return Task.FromResult(0);
+        protected abstract Task HandleRequirementAsync(AuthorizationHandlerContext context, TRequirement requirement);
-        }
     }
 
+    /// <summary>
+    /// Base class for authorization handlers that need to be called for specific requirement and
+    /// resource types.
+    /// </summary>
+    /// <typeparam name="TRequirement">The type of the requirement to evaluate.</typeparam>
+    /// <typeparam name="TResource">The type of the resource to evaluate.</typeparam>
     public abstract class AuthorizationHandler<TRequirement, TResource> : IAuthorizationHandler
         where TRequirement : IAuthorizationRequirement
     {
+        /// <summary>
+        /// Makes a decision if authorization is allowed.
+        /// </summary>
+        /// <param name="context">The authorization information.</param>
         public virtual async Task HandleAsync(AuthorizationHandlerContext context)
         {
             if (context.Resource is TResource)
             {
                 foreach (var req in context.Requirements.OfType<TRequirement>())
                 {
-                    await HandleAsync(context, req, (TResource)context.Resource);
+                    await HandleRequirementAsync(context, req, (TResource)context.Resource);
                 }
             }
         }
 
-        protected virtual Task HandleAsync(AuthorizationHandlerContext context, TRequirement requirement, TResource resource)
+        /// <summary>
-        {
+        /// Makes a decision if authorization is allowed based on a specific requirement and resource.
-            Handle(context, requirement, resource);
+        /// </summary>
-            return Task.FromResult(0);
+        /// <param name="context">The authorization information.</param>
-        }
+        /// <param name="requirement">The requirement to evaluate.</param>
-
+        /// <param name="resource">The resource to evaluate.</param>
-        public virtual void Handle(AuthorizationHandlerContext context)
+        protected abstract Task HandleRequirementAsync(AuthorizationHandlerContext context, TRequirement requirement, TResource resource);
-        {
-            if (context.Resource is TResource)
-            {
-                foreach (var req in context.Requirements.OfType<TRequirement>())
-                {
-                    Handle(context, req, (TResource)context.Resource);
-                }
-            }
-        }
-
-        protected abstract void Handle(AuthorizationHandlerContext context, TRequirement requirement, TResource resource);
     }
 }

src/Microsoft.AspNetCore.Authorization/IAuthorizationHandler.cs

@@ -5,8 +5,15 @@ using System.Threading.Tasks;
 
 namespace Microsoft.AspNetCore.Authorization
 {
+    /// <summary>
+    /// Classes implementing this interface are able to make a decision if authorization is allowed.
+    /// </summary>
     public interface IAuthorizationHandler
     {
+        /// <summary>
+        /// Makes a decision if authorization is allowed.
+        /// </summary>
+        /// <param name="context">The authorization information.</param>
         Task HandleAsync(AuthorizationHandlerContext context);
     }
 }

src/Microsoft.AspNetCore.Authorization/Infrastructure/ClaimsAuthorizationRequirement.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading.Tasks;
 
 namespace Microsoft.AspNetCore.Authorization.Infrastructure
 {
@@ -25,7 +26,7 @@ namespace Microsoft.AspNetCore.Authorization.Infrastructure
         public string ClaimType { get; }
         public IEnumerable<string> AllowedValues { get; }
 
-        protected override void Handle(AuthorizationHandlerContext context, ClaimsAuthorizationRequirement requirement)
+        protected override Task HandleRequirementAsync(AuthorizationHandlerContext context, ClaimsAuthorizationRequirement requirement)
         {
             if (context.User != null)
             {
@@ -44,6 +45,7 @@ namespace Microsoft.AspNetCore.Authorization.Infrastructure
                     context.Succeed(requirement);
                 }
             }
+            return Task.FromResult(0);
         }
     }
 }

src/Microsoft.AspNetCore.Authorization/Infrastructure/DenyAnonymousAuthorizationRequirement.cs

@@ -2,12 +2,13 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System.Linq;
+using System.Threading.Tasks;
 
 namespace Microsoft.AspNetCore.Authorization.Infrastructure
 {
     public class DenyAnonymousAuthorizationRequirement : AuthorizationHandler<DenyAnonymousAuthorizationRequirement>, IAuthorizationRequirement
     {
-        protected override void Handle(AuthorizationHandlerContext context, DenyAnonymousAuthorizationRequirement requirement)
+        protected override Task HandleRequirementAsync(AuthorizationHandlerContext context, DenyAnonymousAuthorizationRequirement requirement)
         {
             var user = context.User;
             var userIsAnonymous =
@@ -17,6 +18,7 @@ namespace Microsoft.AspNetCore.Authorization.Infrastructure
             {
                 context.Succeed(requirement);
             }
+            return Task.FromResult(0);
         }
     }
 }

src/Microsoft.AspNetCore.Authorization/Infrastructure/NameAuthorizationRequirement.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Linq;
+using System.Threading.Tasks;
 
 namespace Microsoft.AspNetCore.Authorization.Infrastructure
 {
@@ -23,7 +24,7 @@ namespace Microsoft.AspNetCore.Authorization.Infrastructure
 
         public string RequiredName { get; }
 
-        protected override void Handle(AuthorizationHandlerContext context, NameAuthorizationRequirement requirement)
+        protected override Task HandleRequirementAsync(AuthorizationHandlerContext context, NameAuthorizationRequirement requirement)
         {
             if (context.User != null)
             {
@@ -33,6 +34,7 @@ namespace Microsoft.AspNetCore.Authorization.Infrastructure
                     context.Succeed(requirement);
                 }
             }
+            return Task.FromResult(0);
         }
     }
 }

src/Microsoft.AspNetCore.Authorization/Infrastructure/RolesAuthorizationRequirement.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading.Tasks;
 
 namespace Microsoft.AspNetCore.Authorization.Infrastructure
 {
@@ -27,7 +28,7 @@ namespace Microsoft.AspNetCore.Authorization.Infrastructure
 
         public IEnumerable<string> AllowedRoles { get; }
 
-        protected override void Handle(AuthorizationHandlerContext context, RolesAuthorizationRequirement requirement)
+        protected override Task HandleRequirementAsync(AuthorizationHandlerContext context, RolesAuthorizationRequirement requirement)
         {
             if (context.User != null)
             {
@@ -45,6 +46,7 @@ namespace Microsoft.AspNetCore.Authorization.Infrastructure
                     context.Succeed(requirement);
                 }
             }
+            return Task.FromResult(0);
         }
 
     }

test/Microsoft.AspNetCore.Authorization.Test/DefaultAuthorizationServiceTests.cs

@@ -584,9 +584,10 @@ namespace Microsoft.AspNetCore.Authorization.Test
         public class CustomRequirement : IAuthorizationRequirement { }
         public class CustomHandler : AuthorizationHandler<CustomRequirement>
         {
-            protected override void Handle(AuthorizationHandlerContext context, CustomRequirement requirement)
+            protected override Task HandleRequirementAsync(AuthorizationHandlerContext context, CustomRequirement requirement)
             {
                 context.Succeed(requirement);
+                return Task.FromResult(0);
             }
         }
 
@@ -640,11 +641,12 @@ namespace Microsoft.AspNetCore.Authorization.Test
 
             public bool Succeed { get; set; }
 
-            protected override void Handle(AuthorizationHandlerContext context, PassThroughRequirement requirement)
+            protected override Task HandleRequirementAsync(AuthorizationHandlerContext context, PassThroughRequirement requirement)
             {
                 if (Succeed) {
                     context.Succeed(requirement);
                 }
+                return Task.FromResult(0);
             }
         }
 
@@ -770,23 +772,25 @@ namespace Microsoft.AspNetCore.Authorization.Test
 
             private IEnumerable<OperationAuthorizationRequirement> _allowed;
 
-            protected override void Handle(AuthorizationHandlerContext context, OperationAuthorizationRequirement requirement, ExpenseReport resource)
+            protected override Task HandleRequirementAsync(AuthorizationHandlerContext context, OperationAuthorizationRequirement requirement, ExpenseReport resource)
             {
                 if (_allowed.Contains(requirement))
                 {
                     context.Succeed(requirement);
                 }
+                return Task.FromResult(0);
             }
         }
 
         public class SuperUserHandler : AuthorizationHandler<OperationAuthorizationRequirement>
         {
-            protected override void Handle(AuthorizationHandlerContext context, OperationAuthorizationRequirement requirement)
+            protected override Task HandleRequirementAsync(AuthorizationHandlerContext context, OperationAuthorizationRequirement requirement)
             {
                 if (context.User.HasClaim("SuperUser", "yes"))
                 {
                     context.Succeed(requirement);
                 }
+                return Task.FromResult(0);
             }
         }
 
@@ -816,7 +820,7 @@ namespace Microsoft.AspNetCore.Authorization.Test
 
         public class NotCalledHandler : AuthorizationHandler<OperationAuthorizationRequirement, string>
         {
-            protected override void Handle(AuthorizationHandlerContext context, OperationAuthorizationRequirement requirement, string resource)
+            protected override Task HandleRequirementAsync(AuthorizationHandlerContext context, OperationAuthorizationRequirement requirement, string resource)
             {
                 throw new NotImplementedException();
             }
@@ -824,12 +828,13 @@ namespace Microsoft.AspNetCore.Authorization.Test
 
         public class EvenHandler : AuthorizationHandler<OperationAuthorizationRequirement, int>
         {
-            protected override void Handle(AuthorizationHandlerContext context, OperationAuthorizationRequirement requirement, int id)
+            protected override Task HandleRequirementAsync(AuthorizationHandlerContext context, OperationAuthorizationRequirement requirement, int id)
             {
                 if (id % 2 == 0)
                 {
                     context.Succeed(requirement);
                 }
+                return Task.FromResult(0);
             }
         }