Improvements to MVC EventData typess

Improvments to names
- Using EventData suffix
- More clarity for events assocated with filters

Fixes: #12263

We have to report the BeforeActionMethod using its old signature because
it's used by Intellitrace. I added a new pair of events with a better
name to use with strong types since there's no practical way to update
the old ones.

src/Mvc/Mvc.Core/ref/Microsoft.AspNetCore.Mvc.Core.netcoreapp3.0.cs

@@ -1728,279 +1728,279 @@ namespace Microsoft.AspNetCore.Mvc.Core.Infrastructure
 }
 namespace Microsoft.AspNetCore.Mvc.Diagnostics
 {
-    public sealed partial class AfterAction : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    public sealed partial class AfterActionEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
     {
         public const string EventName = "Microsoft.AspNetCore.Mvc.AfterAction";
-        public AfterAction(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Http.HttpContext httpContext, Microsoft.AspNetCore.Routing.RouteData routeData) { }
+        public AfterActionEventData(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Http.HttpContext httpContext, Microsoft.AspNetCore.Routing.RouteData routeData) { }
         public Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor ActionDescriptor { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override int Count { get { throw null; } }
         public Microsoft.AspNetCore.Http.HttpContext HttpContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
         public Microsoft.AspNetCore.Routing.RouteData RouteData { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
     }
-    public sealed partial class AfterActionMethod : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    public sealed partial class AfterActionFilterOnActionExecutedEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
-    {
-        public const string EventName = "Microsoft.AspNetCore.Mvc.AfterActionMethod";
-        public AfterActionMethod(Microsoft.AspNetCore.Mvc.ActionContext actionContext, System.Collections.Generic.IReadOnlyDictionary<string, object> arguments, object controller, Microsoft.AspNetCore.Mvc.IActionResult result) { }
-        public Microsoft.AspNetCore.Mvc.ActionContext ActionContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
-        public System.Collections.Generic.IReadOnlyDictionary<string, object> Arguments { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
-        public object Controller { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
-        protected override int Count { get { throw null; } }
-        protected override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
-        public Microsoft.AspNetCore.Mvc.IActionResult Result { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
-    }
-    public sealed partial class AfterActionResult : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
-    {
-        public const string EventName = "Microsoft.AspNetCore.Mvc.AfterActionResult";
-        public AfterActionResult(Microsoft.AspNetCore.Mvc.ActionContext actionContext, Microsoft.AspNetCore.Mvc.IActionResult result) { }
-        public Microsoft.AspNetCore.Mvc.ActionContext ActionContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
-        protected override int Count { get { throw null; } }
-        protected override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
-        public Microsoft.AspNetCore.Mvc.IActionResult Result { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
-    }
-    public sealed partial class AfterOnActionExecuted : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
     {
         public const string EventName = "Microsoft.AspNetCore.Mvc.AfterOnActionExecuted";
-        public AfterOnActionExecuted(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.ActionExecutedContext actionExecutedContext, Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata filter) { }
+        public AfterActionFilterOnActionExecutedEventData(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.ActionExecutedContext actionExecutedContext, Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata filter) { }
         public Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor ActionDescriptor { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.ActionExecutedContext ActionExecutedContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override int Count { get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata Filter { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
     }
-    public sealed partial class AfterOnActionExecuting : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    public sealed partial class AfterActionFilterOnActionExecutingEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
     {
         public const string EventName = "Microsoft.AspNetCore.Mvc.AfterOnActionExecuting";
-        public AfterOnActionExecuting(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.ActionExecutingContext actionExecutingContext, Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata filter) { }
+        public AfterActionFilterOnActionExecutingEventData(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.ActionExecutingContext actionExecutingContext, Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata filter) { }
         public Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor ActionDescriptor { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.ActionExecutingContext ActionExecutingContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override int Count { get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata Filter { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
     }
-    public sealed partial class AfterOnActionExecution : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    public sealed partial class AfterActionFilterOnActionExecutionEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
     {
         public const string EventName = "Microsoft.AspNetCore.Mvc.AfterOnActionExecution";
-        public AfterOnActionExecution(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.ActionExecutedContext actionExecutedContext, Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata filter) { }
+        public AfterActionFilterOnActionExecutionEventData(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.ActionExecutedContext actionExecutedContext, Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata filter) { }
         public Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor ActionDescriptor { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.ActionExecutedContext ActionExecutedContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override int Count { get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata Filter { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
     }
-    public sealed partial class AfterOnAuthorization : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    public sealed partial class AfterActionResultEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    {
+        public const string EventName = "Microsoft.AspNetCore.Mvc.AfterActionResult";
+        public AfterActionResultEventData(Microsoft.AspNetCore.Mvc.ActionContext actionContext, Microsoft.AspNetCore.Mvc.IActionResult result) { }
+        public Microsoft.AspNetCore.Mvc.ActionContext ActionContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
+        protected override int Count { get { throw null; } }
+        protected override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
+        public Microsoft.AspNetCore.Mvc.IActionResult Result { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
+    }
+    public sealed partial class AfterAuthorizationFilterOnAuthorizationEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
     {
         public const string EventName = "Microsoft.AspNetCore.Mvc.AfterOnAuthorization";
-        public AfterOnAuthorization(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.AuthorizationFilterContext authorizationContext, Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata filter) { }
+        public AfterAuthorizationFilterOnAuthorizationEventData(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.AuthorizationFilterContext authorizationContext, Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata filter) { }
         public Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor ActionDescriptor { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.AuthorizationFilterContext AuthorizationContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override int Count { get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata Filter { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
     }
-    public sealed partial class AfterOnException : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    public sealed partial class AfterControllerActionMethodEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    {
+        public const string EventName = "Microsoft.AspNetCore.Mvc.AfterControllerActionMethod";
+        public AfterControllerActionMethodEventData(Microsoft.AspNetCore.Mvc.ActionContext actionContext, System.Collections.Generic.IReadOnlyDictionary<string, object> arguments, object controller, Microsoft.AspNetCore.Mvc.IActionResult result) { }
+        public Microsoft.AspNetCore.Mvc.ActionContext ActionContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
+        public System.Collections.Generic.IReadOnlyDictionary<string, object> Arguments { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
+        public object Controller { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
+        protected override int Count { get { throw null; } }
+        protected override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
+        public Microsoft.AspNetCore.Mvc.IActionResult Result { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
+    }
+    public sealed partial class AfterExceptionFilterOnExceptionEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
     {
         public const string EventName = "Microsoft.AspNetCore.Mvc.AfterOnException";
-        public AfterOnException(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.ExceptionContext exceptionContext, Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata filter) { }
+        public AfterExceptionFilterOnExceptionEventData(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.ExceptionContext exceptionContext, Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata filter) { }
         public Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor ActionDescriptor { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override int Count { get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.ExceptionContext ExceptionContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata Filter { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
     }
-    public sealed partial class AfterOnResourceExecuted : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    public sealed partial class AfterResourceFilterOnResourceExecutedEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
     {
         public const string EventName = "Microsoft.AspNetCore.Mvc.AfterOnResourceExecuted";
-        public AfterOnResourceExecuted(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.ResourceExecutedContext resourceExecutedContext, Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata filter) { }
+        public AfterResourceFilterOnResourceExecutedEventData(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.ResourceExecutedContext resourceExecutedContext, Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata filter) { }
         public Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor ActionDescriptor { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override int Count { get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata Filter { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.ResourceExecutedContext ResourceExecutedContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
     }
-    public sealed partial class AfterOnResourceExecuting : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    public sealed partial class AfterResourceFilterOnResourceExecutingEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
     {
         public const string EventName = "Microsoft.AspNetCore.Mvc.AfterOnResourceExecuting";
-        public AfterOnResourceExecuting(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.ResourceExecutingContext resourceExecutingContext, Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata filter) { }
+        public AfterResourceFilterOnResourceExecutingEventData(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.ResourceExecutingContext resourceExecutingContext, Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata filter) { }
         public Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor ActionDescriptor { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override int Count { get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata Filter { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.ResourceExecutingContext ResourceExecutingContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
     }
-    public sealed partial class AfterOnResourceExecution : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    public sealed partial class AfterResourceFilterOnResourceExecutionEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
     {
         public const string EventName = "Microsoft.AspNetCore.Mvc.AfterOnResourceExecution";
-        public AfterOnResourceExecution(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.ResourceExecutedContext resourceExecutedContext, Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata filter) { }
+        public AfterResourceFilterOnResourceExecutionEventData(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.ResourceExecutedContext resourceExecutedContext, Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata filter) { }
         public Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor ActionDescriptor { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override int Count { get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata Filter { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.ResourceExecutedContext ResourceExecutedContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
     }
-    public sealed partial class AfterOnResultExecuted : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    public sealed partial class AfterResultFilterOnResultExecutedEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
     {
         public const string EventName = "Microsoft.AspNetCore.Mvc.AfterOnResultExecuted";
-        public AfterOnResultExecuted(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.ResultExecutedContext resultExecutedContext, Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata filter) { }
+        public AfterResultFilterOnResultExecutedEventData(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.ResultExecutedContext resultExecutedContext, Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata filter) { }
         public Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor ActionDescriptor { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override int Count { get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata Filter { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.ResultExecutedContext ResultExecutedContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
     }
-    public sealed partial class AfterOnResultExecuting : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    public sealed partial class AfterResultFilterOnResultExecutingEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
     {
         public const string EventName = "Microsoft.AspNetCore.Mvc.AfterOnResultExecuting";
-        public AfterOnResultExecuting(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.ResultExecutingContext resultExecutingContext, Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata filter) { }
+        public AfterResultFilterOnResultExecutingEventData(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.ResultExecutingContext resultExecutingContext, Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata filter) { }
         public Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor ActionDescriptor { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override int Count { get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata Filter { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.ResultExecutingContext ResultExecutingContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
     }
-    public sealed partial class AfterOnResultExecution : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    public sealed partial class AfterResultFilterOnResultExecutionEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
     {
         public const string EventName = "Microsoft.AspNetCore.Mvc.AfterOnResultExecution";
-        public AfterOnResultExecution(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.ResultExecutedContext resultExecutedContext, Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata filter) { }
+        public AfterResultFilterOnResultExecutionEventData(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.ResultExecutedContext resultExecutedContext, Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata filter) { }
         public Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor ActionDescriptor { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override int Count { get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata Filter { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.ResultExecutedContext ResultExecutedContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
     }
-    public sealed partial class BeforeAction : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    public sealed partial class BeforeActionEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
     {
         public const string EventName = "Microsoft.AspNetCore.Mvc.BeforeAction";
-        public BeforeAction(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Http.HttpContext httpContext, Microsoft.AspNetCore.Routing.RouteData routeData) { }
+        public BeforeActionEventData(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Http.HttpContext httpContext, Microsoft.AspNetCore.Routing.RouteData routeData) { }
         public Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor ActionDescriptor { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override int Count { get { throw null; } }
         public Microsoft.AspNetCore.Http.HttpContext HttpContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
         public Microsoft.AspNetCore.Routing.RouteData RouteData { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
     }
-    public sealed partial class BeforeActionMethod : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    public sealed partial class BeforeActionFilterOnActionExecutedEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
-    {
-        public const string EventName = "Microsoft.AspNetCore.Mvc.BeforeActionMethod";
-        public BeforeActionMethod(Microsoft.AspNetCore.Mvc.ActionContext actionContext, System.Collections.Generic.IReadOnlyDictionary<string, object> arguments, object controller) { }
-        public Microsoft.AspNetCore.Mvc.ActionContext ActionContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
-        public System.Collections.Generic.IReadOnlyDictionary<string, object> Arguments { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
-        public object Controller { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
-        protected override int Count { get { throw null; } }
-        protected override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
-    }
-    public sealed partial class BeforeActionResult : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
-    {
-        public const string EventName = "Microsoft.AspNetCore.Mvc.BeforeActionResult";
-        public BeforeActionResult(Microsoft.AspNetCore.Mvc.ActionContext actionContext, Microsoft.AspNetCore.Mvc.IActionResult result) { }
-        public Microsoft.AspNetCore.Mvc.ActionContext ActionContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
-        protected override int Count { get { throw null; } }
-        protected override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
-        public Microsoft.AspNetCore.Mvc.IActionResult Result { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
-    }
-    public sealed partial class BeforeOnActionExecuted : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
     {
         public const string EventName = "Microsoft.AspNetCore.Mvc.BeforeOnActionExecuted";
-        public BeforeOnActionExecuted(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.ActionExecutedContext actionExecutedContext, Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata filter) { }
+        public BeforeActionFilterOnActionExecutedEventData(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.ActionExecutedContext actionExecutedContext, Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata filter) { }
         public Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor ActionDescriptor { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.ActionExecutedContext ActionExecutedContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override int Count { get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata Filter { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
     }
-    public sealed partial class BeforeOnActionExecuting : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    public sealed partial class BeforeActionFilterOnActionExecutingEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
     {
         public const string EventName = "Microsoft.AspNetCore.Mvc.BeforeOnActionExecuting";
-        public BeforeOnActionExecuting(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.ActionExecutingContext actionExecutingContext, Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata filter) { }
+        public BeforeActionFilterOnActionExecutingEventData(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.ActionExecutingContext actionExecutingContext, Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata filter) { }
         public Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor ActionDescriptor { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.ActionExecutingContext ActionExecutingContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override int Count { get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata Filter { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
     }
-    public sealed partial class BeforeOnActionExecution : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    public sealed partial class BeforeActionFilterOnActionExecutionEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
     {
         public const string EventName = "Microsoft.AspNetCore.Mvc.BeforeOnActionExecution";
-        public BeforeOnActionExecution(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.ActionExecutingContext actionExecutingContext, Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata filter) { }
+        public BeforeActionFilterOnActionExecutionEventData(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.ActionExecutingContext actionExecutingContext, Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata filter) { }
         public Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor ActionDescriptor { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.ActionExecutingContext ActionExecutingContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override int Count { get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata Filter { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
     }
-    public sealed partial class BeforeOnAuthorization : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    public sealed partial class BeforeActionResultEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    {
+        public const string EventName = "Microsoft.AspNetCore.Mvc.BeforeActionResult";
+        public BeforeActionResultEventData(Microsoft.AspNetCore.Mvc.ActionContext actionContext, Microsoft.AspNetCore.Mvc.IActionResult result) { }
+        public Microsoft.AspNetCore.Mvc.ActionContext ActionContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
+        protected override int Count { get { throw null; } }
+        protected override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
+        public Microsoft.AspNetCore.Mvc.IActionResult Result { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
+    }
+    public sealed partial class BeforeAuthorizationFilterOnAuthorizationEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
     {
         public const string EventName = "Microsoft.AspNetCore.Mvc.BeforeOnAuthorization";
-        public BeforeOnAuthorization(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.AuthorizationFilterContext authorizationContext, Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata filter) { }
+        public BeforeAuthorizationFilterOnAuthorizationEventData(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.AuthorizationFilterContext authorizationContext, Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata filter) { }
         public Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor ActionDescriptor { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.AuthorizationFilterContext AuthorizationContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override int Count { get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata Filter { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
     }
-    public sealed partial class BeforeOnException : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    public sealed partial class BeforeControllerActionMethodEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    {
+        public const string EventName = "Microsoft.AspNetCore.Mvc.BeforeControllerActionMethod";
+        public BeforeControllerActionMethodEventData(Microsoft.AspNetCore.Mvc.ActionContext actionContext, System.Collections.Generic.IReadOnlyDictionary<string, object> actionArguments, object controller) { }
+        public System.Collections.Generic.IReadOnlyDictionary<string, object> ActionArguments { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
+        public Microsoft.AspNetCore.Mvc.ActionContext ActionContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
+        public object Controller { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
+        protected sealed override int Count { get { throw null; } }
+        protected sealed override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
+    }
+    public sealed partial class BeforeExceptionFilterOnException : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
     {
         public const string EventName = "Microsoft.AspNetCore.Mvc.BeforeOnException";
-        public BeforeOnException(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.ExceptionContext exceptionContext, Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata filter) { }
+        public BeforeExceptionFilterOnException(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.ExceptionContext exceptionContext, Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata filter) { }
         public Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor ActionDescriptor { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override int Count { get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.ExceptionContext ExceptionContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata Filter { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
     }
-    public sealed partial class BeforeOnResourceExecuted : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    public sealed partial class BeforeResourceFilterOnResourceExecutedEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
     {
         public const string EventName = "Microsoft.AspNetCore.Mvc.BeforeOnResourceExecuted";
-        public BeforeOnResourceExecuted(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.ResourceExecutedContext resourceExecutedContext, Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata filter) { }
+        public BeforeResourceFilterOnResourceExecutedEventData(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.ResourceExecutedContext resourceExecutedContext, Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata filter) { }
         public Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor ActionDescriptor { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override int Count { get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata Filter { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.ResourceExecutedContext ResourceExecutedContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
     }
-    public sealed partial class BeforeOnResourceExecuting : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    public sealed partial class BeforeResourceFilterOnResourceExecutingEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
     {
         public const string EventName = "Microsoft.AspNetCore.Mvc.BeforeOnResourceExecuting";
-        public BeforeOnResourceExecuting(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.ResourceExecutingContext resourceExecutingContext, Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata filter) { }
+        public BeforeResourceFilterOnResourceExecutingEventData(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.ResourceExecutingContext resourceExecutingContext, Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata filter) { }
         public Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor ActionDescriptor { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override int Count { get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata Filter { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.ResourceExecutingContext ResourceExecutingContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
     }
-    public sealed partial class BeforeOnResourceExecution : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    public sealed partial class BeforeResourceFilterOnResourceExecutionEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
     {
         public const string EventName = "Microsoft.AspNetCore.Mvc.BeforeOnResourceExecution";
-        public BeforeOnResourceExecution(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.ResourceExecutingContext resourceExecutingContext, Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata filter) { }
+        public BeforeResourceFilterOnResourceExecutionEventData(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.ResourceExecutingContext resourceExecutingContext, Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata filter) { }
         public Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor ActionDescriptor { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override int Count { get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata Filter { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.ResourceExecutingContext ResourceExecutingContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
     }
-    public sealed partial class BeforeOnResultExecuted : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    public sealed partial class BeforeResultFilterOnResultExecutedEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
     {
         public const string EventName = "Microsoft.AspNetCore.Mvc.BeforeOnResultExecuted";
-        public BeforeOnResultExecuted(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.ResultExecutedContext resultExecutedContext, Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata filter) { }
+        public BeforeResultFilterOnResultExecutedEventData(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.ResultExecutedContext resultExecutedContext, Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata filter) { }
         public Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor ActionDescriptor { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override int Count { get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata Filter { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.ResultExecutedContext ResultExecutedContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
     }
-    public sealed partial class BeforeOnResultExecuting : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    public sealed partial class BeforeResultFilterOnResultExecutingEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
     {
         public const string EventName = "Microsoft.AspNetCore.Mvc.BeforeOnResultExecuting";
-        public BeforeOnResultExecuting(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.ResultExecutingContext resultExecutingContext, Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata filter) { }
+        public BeforeResultFilterOnResultExecutingEventData(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.ResultExecutingContext resultExecutingContext, Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata filter) { }
         public Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor ActionDescriptor { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override int Count { get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata Filter { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.ResultExecutingContext ResultExecutingContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
     }
-    public sealed partial class BeforeOnResultExecution : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    public sealed partial class BeforeResultFilterOnResultExecutionEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
     {
         public const string EventName = "Microsoft.AspNetCore.Mvc.BeforeOnResultExecution";
-        public BeforeOnResultExecution(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.ResultExecutingContext resultExecutingContext, Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata filter) { }
+        public BeforeResultFilterOnResultExecutionEventData(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.ResultExecutingContext resultExecutingContext, Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata filter) { }
         public Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor ActionDescriptor { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override int Count { get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.IFilterMetadata Filter { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }

src/Mvc/Mvc.Core/src/Diagnostics/MvcDiagnostics.cs

@@ -10,10 +10,10 @@ using Microsoft.AspNetCore.Routing;
 
 namespace Microsoft.AspNetCore.Mvc.Diagnostics
 {
-    public sealed class BeforeAction : EventData
+    public sealed class BeforeActionEventData : EventData
     {
-        public const string EventName = EventNamespace + nameof(BeforeAction);
+        public const string EventName = EventNamespace + "BeforeAction";
-        public BeforeAction(ActionDescriptor actionDescriptor, HttpContext httpContext, RouteData routeData)
+        public BeforeActionEventData(ActionDescriptor actionDescriptor, HttpContext httpContext, RouteData routeData)
         {
             ActionDescriptor = actionDescriptor;
             HttpContext = httpContext;
@@ -35,11 +35,11 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         };
     }
 
-    public sealed class AfterAction : EventData
+    public sealed class AfterActionEventData : EventData
     {
-        public const string EventName = EventNamespace + nameof(AfterAction);
+        public const string EventName = EventNamespace + "AfterAction";
 
-        public AfterAction(ActionDescriptor actionDescriptor, HttpContext httpContext, RouteData routeData)
+        public AfterActionEventData(ActionDescriptor actionDescriptor, HttpContext httpContext, RouteData routeData)
         {
             ActionDescriptor = actionDescriptor;
             HttpContext = httpContext;
@@ -61,11 +61,11 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         };
     }
 
-    public sealed class BeforeOnAuthorization : EventData
+    public sealed class BeforeAuthorizationFilterOnAuthorizationEventData : EventData
     {
-        public const string EventName = EventNamespace + nameof(BeforeOnAuthorization);
+        public const string EventName = EventNamespace + "BeforeOnAuthorization";
 
-        public BeforeOnAuthorization(ActionDescriptor actionDescriptor, AuthorizationFilterContext authorizationContext, IFilterMetadata filter)
+        public BeforeAuthorizationFilterOnAuthorizationEventData(ActionDescriptor actionDescriptor, AuthorizationFilterContext authorizationContext, IFilterMetadata filter)
         {
             ActionDescriptor = actionDescriptor;
             AuthorizationContext = authorizationContext;
@@ -87,11 +87,11 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         };
     }
 
-    public sealed class AfterOnAuthorization : EventData
+    public sealed class AfterAuthorizationFilterOnAuthorizationEventData : EventData
     {
-        public const string EventName = EventNamespace + nameof(AfterOnAuthorization);
+        public const string EventName = EventNamespace + "AfterOnAuthorization";
 
-        public AfterOnAuthorization(ActionDescriptor actionDescriptor, AuthorizationFilterContext authorizationContext, IFilterMetadata filter)
+        public AfterAuthorizationFilterOnAuthorizationEventData(ActionDescriptor actionDescriptor, AuthorizationFilterContext authorizationContext, IFilterMetadata filter)
         {
             ActionDescriptor = actionDescriptor;
             AuthorizationContext = authorizationContext;
@@ -113,11 +113,11 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         };
     }
 
-    public sealed class BeforeOnResourceExecution : EventData
+    public sealed class BeforeResourceFilterOnResourceExecutionEventData : EventData
     {
-        public const string EventName = EventNamespace + nameof(BeforeOnResourceExecution);
+        public const string EventName = EventNamespace + "BeforeOnResourceExecution";
 
-        public BeforeOnResourceExecution(ActionDescriptor actionDescriptor, ResourceExecutingContext resourceExecutingContext, IFilterMetadata filter)
+        public BeforeResourceFilterOnResourceExecutionEventData(ActionDescriptor actionDescriptor, ResourceExecutingContext resourceExecutingContext, IFilterMetadata filter)
         {
             ActionDescriptor = actionDescriptor;
             ResourceExecutingContext = resourceExecutingContext;
@@ -139,11 +139,11 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         };
     }
 
-    public sealed class AfterOnResourceExecution : EventData
+    public sealed class AfterResourceFilterOnResourceExecutionEventData : EventData
     {
-        public const string EventName = EventNamespace + nameof(AfterOnResourceExecution);
+        public const string EventName = EventNamespace + "AfterOnResourceExecution";
 
-        public AfterOnResourceExecution(ActionDescriptor actionDescriptor, ResourceExecutedContext resourceExecutedContext, IFilterMetadata filter)
+        public AfterResourceFilterOnResourceExecutionEventData(ActionDescriptor actionDescriptor, ResourceExecutedContext resourceExecutedContext, IFilterMetadata filter)
         {
             ActionDescriptor = actionDescriptor;
             ResourceExecutedContext = resourceExecutedContext;
@@ -165,11 +165,11 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         };
     }
 
-    public sealed class BeforeOnResourceExecuting : EventData
+    public sealed class BeforeResourceFilterOnResourceExecutingEventData : EventData
     {
-        public const string EventName = EventNamespace + nameof(BeforeOnResourceExecuting);
+        public const string EventName = EventNamespace + "BeforeOnResourceExecuting";
 
-        public BeforeOnResourceExecuting(ActionDescriptor actionDescriptor, ResourceExecutingContext resourceExecutingContext, IFilterMetadata filter)
+        public BeforeResourceFilterOnResourceExecutingEventData(ActionDescriptor actionDescriptor, ResourceExecutingContext resourceExecutingContext, IFilterMetadata filter)
         {
             ActionDescriptor = actionDescriptor;
             ResourceExecutingContext = resourceExecutingContext;
@@ -191,11 +191,11 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         };
     }
 
-    public sealed class AfterOnResourceExecuting : EventData
+    public sealed class AfterResourceFilterOnResourceExecutingEventData : EventData
     {
-        public const string EventName = EventNamespace + nameof(AfterOnResourceExecuting);
+        public const string EventName = EventNamespace + "AfterOnResourceExecuting";
 
-        public AfterOnResourceExecuting(ActionDescriptor actionDescriptor, ResourceExecutingContext resourceExecutingContext, IFilterMetadata filter)
+        public AfterResourceFilterOnResourceExecutingEventData(ActionDescriptor actionDescriptor, ResourceExecutingContext resourceExecutingContext, IFilterMetadata filter)
         {
             ActionDescriptor = actionDescriptor;
             ResourceExecutingContext = resourceExecutingContext;
@@ -217,11 +217,11 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         };
     }
 
-    public sealed class BeforeOnResourceExecuted : EventData
+    public sealed class BeforeResourceFilterOnResourceExecutedEventData : EventData
     {
-        public const string EventName = EventNamespace + nameof(BeforeOnResourceExecuted);
+        public const string EventName = EventNamespace + "BeforeOnResourceExecuted";
 
-        public BeforeOnResourceExecuted(ActionDescriptor actionDescriptor, ResourceExecutedContext resourceExecutedContext, IFilterMetadata filter)
+        public BeforeResourceFilterOnResourceExecutedEventData(ActionDescriptor actionDescriptor, ResourceExecutedContext resourceExecutedContext, IFilterMetadata filter)
         {
             ActionDescriptor = actionDescriptor;
             ResourceExecutedContext = resourceExecutedContext;
@@ -243,11 +243,11 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         };
     }
 
-    public sealed class AfterOnResourceExecuted : EventData
+    public sealed class AfterResourceFilterOnResourceExecutedEventData : EventData
     {
-        public const string EventName = EventNamespace + nameof(AfterOnResourceExecuted);
+        public const string EventName = EventNamespace + "AfterOnResourceExecuted";
 
-        public AfterOnResourceExecuted(ActionDescriptor actionDescriptor, ResourceExecutedContext resourceExecutedContext, IFilterMetadata filter)
+        public AfterResourceFilterOnResourceExecutedEventData(ActionDescriptor actionDescriptor, ResourceExecutedContext resourceExecutedContext, IFilterMetadata filter)
         {
             ActionDescriptor = actionDescriptor;
             ResourceExecutedContext = resourceExecutedContext;
@@ -269,11 +269,11 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         };
     }
 
-    public sealed class BeforeOnException : EventData
+    public sealed class BeforeExceptionFilterOnException : EventData
     {
-        public const string EventName = EventNamespace + nameof(BeforeOnException);
+        public const string EventName = EventNamespace + "BeforeOnException";
 
-        public BeforeOnException(ActionDescriptor actionDescriptor, ExceptionContext exceptionContext, IFilterMetadata filter)
+        public BeforeExceptionFilterOnException(ActionDescriptor actionDescriptor, ExceptionContext exceptionContext, IFilterMetadata filter)
         {
             ActionDescriptor = actionDescriptor;
             ExceptionContext = exceptionContext;
@@ -295,11 +295,11 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         };
     }
 
-    public sealed class AfterOnException : EventData
+    public sealed class AfterExceptionFilterOnExceptionEventData : EventData
     {
-        public const string EventName = EventNamespace + nameof(AfterOnException);
+        public const string EventName = EventNamespace + "AfterOnException";
 
-        public AfterOnException(ActionDescriptor actionDescriptor, ExceptionContext exceptionContext, IFilterMetadata filter)
+        public AfterExceptionFilterOnExceptionEventData(ActionDescriptor actionDescriptor, ExceptionContext exceptionContext, IFilterMetadata filter)
         {
             ActionDescriptor = actionDescriptor;
             ExceptionContext = exceptionContext;
@@ -321,11 +321,11 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         };
     }
 
-    public sealed class BeforeOnActionExecution : EventData
+    public sealed class BeforeActionFilterOnActionExecutionEventData : EventData
     {
-        public const string EventName = EventNamespace + nameof(BeforeOnActionExecution);
+        public const string EventName = EventNamespace + "BeforeOnActionExecution";
 
-        public BeforeOnActionExecution(ActionDescriptor actionDescriptor, ActionExecutingContext actionExecutingContext, IFilterMetadata filter)
+        public BeforeActionFilterOnActionExecutionEventData(ActionDescriptor actionDescriptor, ActionExecutingContext actionExecutingContext, IFilterMetadata filter)
         {
             ActionDescriptor = actionDescriptor;
             ActionExecutingContext = actionExecutingContext;
@@ -347,11 +347,11 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         };
     }
 
-    public sealed class AfterOnActionExecution : EventData
+    public sealed class AfterActionFilterOnActionExecutionEventData : EventData
     {
-        public const string EventName = EventNamespace + nameof(AfterOnActionExecution);
+        public const string EventName = EventNamespace + "AfterOnActionExecution";
 
-        public AfterOnActionExecution(ActionDescriptor actionDescriptor, ActionExecutedContext actionExecutedContext, IFilterMetadata filter)
+        public AfterActionFilterOnActionExecutionEventData(ActionDescriptor actionDescriptor, ActionExecutedContext actionExecutedContext, IFilterMetadata filter)
         {
             ActionDescriptor = actionDescriptor;
             ActionExecutedContext = actionExecutedContext;
@@ -373,11 +373,11 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         };
     }
 
-    public sealed class BeforeOnActionExecuting : EventData
+    public sealed class BeforeActionFilterOnActionExecutingEventData : EventData
     {
-        public const string EventName = EventNamespace + nameof(BeforeOnActionExecuting);
+        public const string EventName = EventNamespace + "BeforeOnActionExecuting";
 
-        public BeforeOnActionExecuting(ActionDescriptor actionDescriptor, ActionExecutingContext actionExecutingContext, IFilterMetadata filter)
+        public BeforeActionFilterOnActionExecutingEventData(ActionDescriptor actionDescriptor, ActionExecutingContext actionExecutingContext, IFilterMetadata filter)
         {
             ActionDescriptor = actionDescriptor;
             ActionExecutingContext = actionExecutingContext;
@@ -399,11 +399,11 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         };
     }
 
-    public sealed class AfterOnActionExecuting : EventData
+    public sealed class AfterActionFilterOnActionExecutingEventData : EventData
     {
-        public const string EventName = EventNamespace + nameof(AfterOnActionExecuting);
+        public const string EventName = EventNamespace + "AfterOnActionExecuting";
 
-        public AfterOnActionExecuting(ActionDescriptor actionDescriptor, ActionExecutingContext actionExecutingContext, IFilterMetadata filter)
+        public AfterActionFilterOnActionExecutingEventData(ActionDescriptor actionDescriptor, ActionExecutingContext actionExecutingContext, IFilterMetadata filter)
         {
             ActionDescriptor = actionDescriptor;
             ActionExecutingContext = actionExecutingContext;
@@ -425,11 +425,11 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         };
     }
 
-    public sealed class BeforeOnActionExecuted : EventData
+    public sealed class BeforeActionFilterOnActionExecutedEventData : EventData
     {
-        public const string EventName = EventNamespace + nameof(BeforeOnActionExecuted);
+        public const string EventName = EventNamespace + "BeforeOnActionExecuted";
 
-        public BeforeOnActionExecuted(ActionDescriptor actionDescriptor, ActionExecutedContext actionExecutedContext, IFilterMetadata filter)
+        public BeforeActionFilterOnActionExecutedEventData(ActionDescriptor actionDescriptor, ActionExecutedContext actionExecutedContext, IFilterMetadata filter)
         {
             ActionDescriptor = actionDescriptor;
             ActionExecutedContext = actionExecutedContext;
@@ -451,11 +451,11 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         };
     }
 
-    public sealed class AfterOnActionExecuted : EventData
+    public sealed class AfterActionFilterOnActionExecutedEventData : EventData
     {
-        public const string EventName = EventNamespace + nameof(AfterOnActionExecuted);
+        public const string EventName = EventNamespace + "AfterOnActionExecuted";
 
-        public AfterOnActionExecuted(ActionDescriptor actionDescriptor, ActionExecutedContext actionExecutedContext, IFilterMetadata filter)
+        public AfterActionFilterOnActionExecutedEventData(ActionDescriptor actionDescriptor, ActionExecutedContext actionExecutedContext, IFilterMetadata filter)
         {
             ActionDescriptor = actionDescriptor;
             ActionExecutedContext = actionExecutedContext;
@@ -477,37 +477,37 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         };
     }
 
-    public sealed class BeforeActionMethod : EventData
+    public sealed class BeforeControllerActionMethodEventData : EventData
     {
-        public const string EventName = EventNamespace + nameof(BeforeActionMethod);
+        public const string EventName = EventNamespace + "BeforeControllerActionMethod";
 
-        public BeforeActionMethod(ActionContext actionContext, IReadOnlyDictionary<string, object> arguments, object controller)
+        public BeforeControllerActionMethodEventData(ActionContext actionContext, IReadOnlyDictionary<string, object> actionArguments, object controller)
         {
             ActionContext = actionContext;
-            Arguments = arguments;
+            ActionArguments = actionArguments;
             Controller = controller;
         }
 
         public ActionContext ActionContext { get; }
-        public IReadOnlyDictionary<string, object> Arguments { get; }
+        public IReadOnlyDictionary<string, object> ActionArguments { get; }
         public object Controller { get; }
 
-        protected override int Count => 3;
+        protected sealed override int Count => 3;
 
-        protected override KeyValuePair<string, object> this[int index] => index switch
+        protected sealed override KeyValuePair<string, object> this[int index] => index switch
         {
             0 => new KeyValuePair<string, object>(nameof(ActionContext), ActionContext),
-            1 => new KeyValuePair<string, object>(nameof(Arguments), Arguments),
+            1 => new KeyValuePair<string, object>(nameof(ActionArguments), ActionArguments),
             2 => new KeyValuePair<string, object>(nameof(Controller), Controller),
             _ => throw new IndexOutOfRangeException(nameof(index))
         };
     }
 
-    public sealed class AfterActionMethod : EventData
+    public sealed class AfterControllerActionMethodEventData : EventData
     {
-        public const string EventName = EventNamespace + nameof(AfterActionMethod);
+        public const string EventName = EventNamespace + "AfterControllerActionMethod";
 
-        public AfterActionMethod(ActionContext actionContext, IReadOnlyDictionary<string, object> arguments, object controller, IActionResult result)
+        public AfterControllerActionMethodEventData(ActionContext actionContext, IReadOnlyDictionary<string, object> arguments, object controller, IActionResult result)
         {
             ActionContext = actionContext;
             Arguments = arguments;
@@ -532,11 +532,11 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         };
     }
 
-    public sealed class BeforeOnResultExecution : EventData
+    public sealed class BeforeResultFilterOnResultExecutionEventData : EventData
     {
-        public const string EventName = EventNamespace + nameof(BeforeOnResultExecution);
+        public const string EventName = EventNamespace + "BeforeOnResultExecution";
 
-        public BeforeOnResultExecution(ActionDescriptor actionDescriptor, ResultExecutingContext resultExecutingContext, IFilterMetadata filter)
+        public BeforeResultFilterOnResultExecutionEventData(ActionDescriptor actionDescriptor, ResultExecutingContext resultExecutingContext, IFilterMetadata filter)
         {
             ActionDescriptor = actionDescriptor;
             ResultExecutingContext = resultExecutingContext;
@@ -558,11 +558,11 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         };
     }
 
-    public sealed class AfterOnResultExecution : EventData
+    public sealed class AfterResultFilterOnResultExecutionEventData : EventData
     {
-        public const string EventName = EventNamespace + nameof(AfterOnResultExecution);
+        public const string EventName = EventNamespace + "AfterOnResultExecution";
 
-        public AfterOnResultExecution(ActionDescriptor actionDescriptor, ResultExecutedContext resultExecutedContext, IFilterMetadata filter)
+        public AfterResultFilterOnResultExecutionEventData(ActionDescriptor actionDescriptor, ResultExecutedContext resultExecutedContext, IFilterMetadata filter)
         {
             ActionDescriptor = actionDescriptor;
             ResultExecutedContext = resultExecutedContext;
@@ -584,11 +584,11 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         };
     }
 
-    public sealed class BeforeOnResultExecuting : EventData
+    public sealed class BeforeResultFilterOnResultExecutingEventData : EventData
     {
-        public const string EventName = EventNamespace + nameof(BeforeOnResultExecuting);
+        public const string EventName = EventNamespace + "BeforeOnResultExecuting";
 
-        public BeforeOnResultExecuting(ActionDescriptor actionDescriptor, ResultExecutingContext resultExecutingContext, IFilterMetadata filter)
+        public BeforeResultFilterOnResultExecutingEventData(ActionDescriptor actionDescriptor, ResultExecutingContext resultExecutingContext, IFilterMetadata filter)
         {
             ActionDescriptor = actionDescriptor;
             ResultExecutingContext = resultExecutingContext;
@@ -610,11 +610,11 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         };
     }
 
-    public sealed class AfterOnResultExecuting : EventData
+    public sealed class AfterResultFilterOnResultExecutingEventData : EventData
     {
-        public const string EventName = EventNamespace + nameof(AfterOnResultExecuting);
+        public const string EventName = EventNamespace + "AfterOnResultExecuting";
 
-        public AfterOnResultExecuting(ActionDescriptor actionDescriptor, ResultExecutingContext resultExecutingContext, IFilterMetadata filter)
+        public AfterResultFilterOnResultExecutingEventData(ActionDescriptor actionDescriptor, ResultExecutingContext resultExecutingContext, IFilterMetadata filter)
         {
             ActionDescriptor = actionDescriptor;
             ResultExecutingContext = resultExecutingContext;
@@ -636,11 +636,11 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         };
     }
 
-    public sealed class BeforeOnResultExecuted : EventData
+    public sealed class BeforeResultFilterOnResultExecutedEventData : EventData
     {
-        public const string EventName = EventNamespace + nameof(BeforeOnResultExecuted);
+        public const string EventName = EventNamespace + "BeforeOnResultExecuted";
 
-        public BeforeOnResultExecuted(ActionDescriptor actionDescriptor, ResultExecutedContext resultExecutedContext, IFilterMetadata filter)
+        public BeforeResultFilterOnResultExecutedEventData(ActionDescriptor actionDescriptor, ResultExecutedContext resultExecutedContext, IFilterMetadata filter)
         {
             ActionDescriptor = actionDescriptor;
             ResultExecutedContext = resultExecutedContext;
@@ -662,11 +662,11 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         };
     }
 
-    public sealed class AfterOnResultExecuted : EventData
+    public sealed class AfterResultFilterOnResultExecutedEventData : EventData
     {
-        public const string EventName = EventNamespace + nameof(AfterOnResultExecuted);
+        public const string EventName = EventNamespace + "AfterOnResultExecuted";
 
-        public AfterOnResultExecuted(ActionDescriptor actionDescriptor, ResultExecutedContext resultExecutedContext, IFilterMetadata filter)
+        public AfterResultFilterOnResultExecutedEventData(ActionDescriptor actionDescriptor, ResultExecutedContext resultExecutedContext, IFilterMetadata filter)
         {
             ActionDescriptor = actionDescriptor;
             ResultExecutedContext = resultExecutedContext;
@@ -688,11 +688,11 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         };
     }
 
-    public sealed class BeforeActionResult : EventData
+    public sealed class BeforeActionResultEventData : EventData
     {
-        public const string EventName = EventNamespace + nameof(BeforeActionResult);
+        public const string EventName = EventNamespace + "BeforeActionResult";
 
-        public BeforeActionResult(ActionContext actionContext, IActionResult result)
+        public BeforeActionResultEventData(ActionContext actionContext, IActionResult result)
         {
             ActionContext = actionContext;
             Result = result;
@@ -711,11 +711,11 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         };
     }
 
-    public sealed class AfterActionResult : EventData
+    public sealed class AfterActionResultEventData : EventData
     {
-        public const string EventName = EventNamespace + nameof(AfterActionResult);
+        public const string EventName = EventNamespace + "AfterActionResult";
 
-        public AfterActionResult(ActionContext actionContext, IActionResult result)
+        public AfterActionResultEventData(ActionContext actionContext, IActionResult result)
         {
             ActionContext = actionContext;
             Result = result;

src/Mvc/Mvc.Core/src/Infrastructure/ControllerActionInvoker.cs

@@ -419,7 +419,7 @@ namespace Microsoft.AspNetCore.Mvc.Infrastructure
                 IActionResult result = null;
                 try
                 {
-                    diagnosticListener.BeforeActionMethod(
+                    diagnosticListener.BeforeControllerActionMethod(
                         controllerContext,
                         arguments,
                         controller);
@@ -440,7 +440,7 @@ namespace Microsoft.AspNetCore.Mvc.Infrastructure
                 }
                 finally
                 {
-                    diagnosticListener.AfterActionMethod(
+                    diagnosticListener.AfterControllerActionMethod(
                         controllerContext,
                         arguments,
                         controllerContext,

src/Mvc/Mvc.Core/src/MvcCoreDiagnosticListenerExtensions.cs

@@ -27,7 +27,7 @@ namespace Microsoft.AspNetCore.Mvc
             Debug.Assert(httpContext != null);
             Debug.Assert(routeData != null);
 
-            // Inlinable fast-path check if Diagnositcs is enabled
+            // Inlinable fast-path check if diagnostic listener is enabled
             if (diagnosticListener.IsEnabled())
             {
                 BeforeActionImpl(diagnosticListener, actionDescriptor, httpContext, routeData);
@@ -36,11 +36,11 @@ namespace Microsoft.AspNetCore.Mvc
 
         private static void BeforeActionImpl(DiagnosticListener diagnosticListener, ActionDescriptor actionDescriptor, HttpContext httpContext, RouteData routeData)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.BeforeAction.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.BeforeActionEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.BeforeAction.EventName,
+                    Diagnostics.BeforeActionEventData.EventName,
-                    new BeforeAction(actionDescriptor, httpContext, routeData));
+                    new BeforeActionEventData(actionDescriptor, httpContext, routeData));
             }
         }
 
@@ -55,7 +55,7 @@ namespace Microsoft.AspNetCore.Mvc
             Debug.Assert(httpContext != null);
             Debug.Assert(routeData != null);
 
-            // Inlinable fast-path check if Diagnositcs is enabled
+            // Inlinable fast-path check if diagnostic listener is enabled
             if (diagnosticListener.IsEnabled())
             {
                 AfterActionImpl(diagnosticListener, actionDescriptor, httpContext, routeData);
@@ -64,11 +64,11 @@ namespace Microsoft.AspNetCore.Mvc
 
         private static void AfterActionImpl(DiagnosticListener diagnosticListener, ActionDescriptor actionDescriptor, HttpContext httpContext, RouteData routeData)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.AfterAction.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.AfterActionEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.AfterAction.EventName,
+                    Diagnostics.AfterActionEventData.EventName,
-                    new AfterAction(actionDescriptor, httpContext, routeData));
+                    new AfterActionEventData(actionDescriptor, httpContext, routeData));
             }
         }
 
@@ -81,7 +81,7 @@ namespace Microsoft.AspNetCore.Mvc
             Debug.Assert(authorizationContext != null);
             Debug.Assert(filter != null);
 
-            // Inlinable fast-path check if Diagnositcs is enabled
+            // Inlinable fast-path check if diagnostic listener is enabled
             if (diagnosticListener.IsEnabled())
             {
                 BeforeOnAuthorizationAsyncImpl(diagnosticListener, authorizationContext, filter);
@@ -90,11 +90,11 @@ namespace Microsoft.AspNetCore.Mvc
 
         private static void BeforeOnAuthorizationAsyncImpl(DiagnosticListener diagnosticListener, AuthorizationFilterContext authorizationContext, IAsyncAuthorizationFilter filter)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.BeforeOnAuthorization.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.BeforeAuthorizationFilterOnAuthorizationEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.BeforeOnAuthorization.EventName,
+                    Diagnostics.BeforeAuthorizationFilterOnAuthorizationEventData.EventName,
-                    new BeforeOnAuthorization(
+                    new BeforeAuthorizationFilterOnAuthorizationEventData(
                         authorizationContext.ActionDescriptor,
                         authorizationContext,
                         filter
@@ -111,7 +111,7 @@ namespace Microsoft.AspNetCore.Mvc
             Debug.Assert(authorizationContext != null);
             Debug.Assert(filter != null);
 
-            // Inlinable fast-path check if Diagnositcs is enabled
+            // Inlinable fast-path check if diagnostic listener is enabled
             if (diagnosticListener.IsEnabled())
             {
                 AfterOnAuthorizationAsyncImpl(diagnosticListener, authorizationContext, filter);
@@ -120,11 +120,11 @@ namespace Microsoft.AspNetCore.Mvc
 
         private static void AfterOnAuthorizationAsyncImpl(DiagnosticListener diagnosticListener, AuthorizationFilterContext authorizationContext, IAsyncAuthorizationFilter filter)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.AfterOnAuthorization.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.AfterAuthorizationFilterOnAuthorizationEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.AfterOnAuthorization.EventName,
+                    Diagnostics.AfterAuthorizationFilterOnAuthorizationEventData.EventName,
-                    new AfterOnAuthorization(
+                    new AfterAuthorizationFilterOnAuthorizationEventData(
                         authorizationContext.ActionDescriptor,
                         authorizationContext,
                         filter
@@ -141,7 +141,7 @@ namespace Microsoft.AspNetCore.Mvc
             Debug.Assert(authorizationContext != null);
             Debug.Assert(filter != null);
 
-            // Inlinable fast-path check if Diagnositcs is enabled
+            // Inlinable fast-path check if diagnostic listener is enabled
             if (diagnosticListener.IsEnabled())
             {
                 BeforeOnAuthorizationImpl(diagnosticListener, authorizationContext, filter);
@@ -150,11 +150,11 @@ namespace Microsoft.AspNetCore.Mvc
 
         private static void BeforeOnAuthorizationImpl(DiagnosticListener diagnosticListener, AuthorizationFilterContext authorizationContext, IAuthorizationFilter filter)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.BeforeOnAuthorization.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.BeforeAuthorizationFilterOnAuthorizationEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.BeforeOnAuthorization.EventName,
+                    Diagnostics.BeforeAuthorizationFilterOnAuthorizationEventData.EventName,
-                    new BeforeOnAuthorization(
+                    new BeforeAuthorizationFilterOnAuthorizationEventData(
                         authorizationContext.ActionDescriptor,
                         authorizationContext,
                         filter
@@ -171,7 +171,7 @@ namespace Microsoft.AspNetCore.Mvc
             Debug.Assert(authorizationContext != null);
             Debug.Assert(filter != null);
 
-            // Inlinable fast-path check if Diagnositcs is enabled
+            // Inlinable fast-path check if diagnostic listener is enabled
             if (diagnosticListener.IsEnabled())
             {
                 AfterOnAuthorizationImpl(diagnosticListener, authorizationContext, filter);
@@ -180,11 +180,11 @@ namespace Microsoft.AspNetCore.Mvc
 
         private static void AfterOnAuthorizationImpl(DiagnosticListener diagnosticListener, AuthorizationFilterContext authorizationContext, IAuthorizationFilter filter)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.AfterOnAuthorization.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.AfterAuthorizationFilterOnAuthorizationEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.AfterOnAuthorization.EventName,
+                    Diagnostics.AfterAuthorizationFilterOnAuthorizationEventData.EventName,
-                    new AfterOnAuthorization(
+                    new AfterAuthorizationFilterOnAuthorizationEventData(
                         authorizationContext.ActionDescriptor,
                         authorizationContext,
                         filter
@@ -201,7 +201,7 @@ namespace Microsoft.AspNetCore.Mvc
             Debug.Assert(resourceExecutingContext != null);
             Debug.Assert(filter != null);
 
-            // Inlinable fast-path check if Diagnositcs is enabled
+            // Inlinable fast-path check if diagnostic listener is enabled
             if (diagnosticListener.IsEnabled())
             {
                 BeforeOnResourceExecutionImpl(diagnosticListener, resourceExecutingContext, filter);
@@ -210,11 +210,11 @@ namespace Microsoft.AspNetCore.Mvc
 
         private static void BeforeOnResourceExecutionImpl(DiagnosticListener diagnosticListener, ResourceExecutingContext resourceExecutingContext, IAsyncResourceFilter filter)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.BeforeOnResourceExecution.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.BeforeResourceFilterOnResourceExecutionEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.BeforeOnResourceExecution.EventName,
+                    Diagnostics.BeforeResourceFilterOnResourceExecutionEventData.EventName,
-                    new BeforeOnResourceExecution(
+                    new BeforeResourceFilterOnResourceExecutionEventData(
                         resourceExecutingContext.ActionDescriptor,
                         resourceExecutingContext,
                         filter
@@ -231,7 +231,7 @@ namespace Microsoft.AspNetCore.Mvc
             Debug.Assert(resourceExecutedContext != null);
             Debug.Assert(filter != null);
 
-            // Inlinable fast-path check if Diagnositcs is enabled
+            // Inlinable fast-path check if diagnostic listener is enabled
             if (diagnosticListener.IsEnabled())
             {
                 AfterOnResourceExecutionImpl(diagnosticListener, resourceExecutedContext, filter);
@@ -240,11 +240,11 @@ namespace Microsoft.AspNetCore.Mvc
 
         private static void AfterOnResourceExecutionImpl(DiagnosticListener diagnosticListener, ResourceExecutedContext resourceExecutedContext, IAsyncResourceFilter filter)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.AfterOnResourceExecution.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.AfterResourceFilterOnResourceExecutionEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.AfterOnResourceExecution.EventName,
+                    Diagnostics.AfterResourceFilterOnResourceExecutionEventData.EventName,
-                    new AfterOnResourceExecution(
+                    new AfterResourceFilterOnResourceExecutionEventData(
                         resourceExecutedContext.ActionDescriptor,
                         resourceExecutedContext,
                         filter
@@ -261,7 +261,7 @@ namespace Microsoft.AspNetCore.Mvc
             Debug.Assert(resourceExecutingContext != null);
             Debug.Assert(filter != null);
 
-            // Inlinable fast-path check if Diagnositcs is enabled
+            // Inlinable fast-path check if diagnostic listener is enabled
             if (diagnosticListener.IsEnabled())
             {
                 BeforeOnResourceExecutingImpl(diagnosticListener, resourceExecutingContext, filter);
@@ -270,11 +270,11 @@ namespace Microsoft.AspNetCore.Mvc
 
         private static void BeforeOnResourceExecutingImpl(DiagnosticListener diagnosticListener, ResourceExecutingContext resourceExecutingContext, IResourceFilter filter)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.BeforeOnResourceExecuting.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.BeforeResourceFilterOnResourceExecutingEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.BeforeOnResourceExecuting.EventName,
+                    Diagnostics.BeforeResourceFilterOnResourceExecutingEventData.EventName,
-                    new BeforeOnResourceExecuting(
+                    new BeforeResourceFilterOnResourceExecutingEventData(
                         resourceExecutingContext.ActionDescriptor,
                         resourceExecutingContext,
                         filter
@@ -291,7 +291,7 @@ namespace Microsoft.AspNetCore.Mvc
             Debug.Assert(resourceExecutingContext != null);
             Debug.Assert(filter != null);
 
-            // Inlinable fast-path check if Diagnositcs is enabled
+            // Inlinable fast-path check if diagnostic listener is enabled
             if (diagnosticListener.IsEnabled())
             {
                 AfterOnResourceExecutingImpl(diagnosticListener, resourceExecutingContext, filter);
@@ -300,11 +300,11 @@ namespace Microsoft.AspNetCore.Mvc
 
         private static void AfterOnResourceExecutingImpl(DiagnosticListener diagnosticListener, ResourceExecutingContext resourceExecutingContext, IResourceFilter filter)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.AfterOnResourceExecuting.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.AfterResourceFilterOnResourceExecutingEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.AfterOnResourceExecuting.EventName,
+                    Diagnostics.AfterResourceFilterOnResourceExecutingEventData.EventName,
-                    new AfterOnResourceExecuting(
+                    new AfterResourceFilterOnResourceExecutingEventData(
                         resourceExecutingContext.ActionDescriptor,
                         resourceExecutingContext,
                         filter
@@ -321,7 +321,7 @@ namespace Microsoft.AspNetCore.Mvc
             Debug.Assert(resourceExecutedContext != null);
             Debug.Assert(filter != null);
 
-            // Inlinable fast-path check if Diagnositcs is enabled
+            // Inlinable fast-path check if diagnostic listener is enabled
             if (diagnosticListener.IsEnabled())
             {
                 BeforeOnResourceExecutedImpl(diagnosticListener, resourceExecutedContext, filter);
@@ -330,11 +330,11 @@ namespace Microsoft.AspNetCore.Mvc
 
         private static void BeforeOnResourceExecutedImpl(DiagnosticListener diagnosticListener, ResourceExecutedContext resourceExecutedContext, IResourceFilter filter)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.BeforeOnResourceExecuted.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.BeforeResourceFilterOnResourceExecutedEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.BeforeOnResourceExecuted.EventName,
+                    Diagnostics.BeforeResourceFilterOnResourceExecutedEventData.EventName,
-                    new BeforeOnResourceExecuted(
+                    new BeforeResourceFilterOnResourceExecutedEventData(
                         resourceExecutedContext.ActionDescriptor,
                         resourceExecutedContext,
                         filter
@@ -351,7 +351,7 @@ namespace Microsoft.AspNetCore.Mvc
             Debug.Assert(resourceExecutedContext != null);
             Debug.Assert(filter != null);
 
-            // Inlinable fast-path check if Diagnositcs is enabled
+            // Inlinable fast-path check if diagnostic listener is enabled
             if (diagnosticListener.IsEnabled())
             {
                 AfterOnResourceExecutedImpl(diagnosticListener, resourceExecutedContext, filter);
@@ -360,11 +360,11 @@ namespace Microsoft.AspNetCore.Mvc
 
         private static void AfterOnResourceExecutedImpl(DiagnosticListener diagnosticListener, ResourceExecutedContext resourceExecutedContext, IResourceFilter filter)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.AfterOnResourceExecuted.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.AfterResourceFilterOnResourceExecutedEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.AfterOnResourceExecuted.EventName,
+                    Diagnostics.AfterResourceFilterOnResourceExecutedEventData.EventName,
-                    new AfterOnResourceExecuted(
+                    new AfterResourceFilterOnResourceExecutedEventData(
                         resourceExecutedContext.ActionDescriptor,
                         resourceExecutedContext,
                         filter
@@ -381,7 +381,7 @@ namespace Microsoft.AspNetCore.Mvc
             Debug.Assert(exceptionContext != null);
             Debug.Assert(filter != null);
 
-            // Inlinable fast-path check if Diagnositcs is enabled
+            // Inlinable fast-path check if diagnostic listener is enabled
             if (diagnosticListener.IsEnabled())
             {
                 BeforeOnExceptionAsyncImpl(diagnosticListener, exceptionContext, filter);
@@ -390,11 +390,11 @@ namespace Microsoft.AspNetCore.Mvc
 
         private static void BeforeOnExceptionAsyncImpl(DiagnosticListener diagnosticListener, ExceptionContext exceptionContext, IAsyncExceptionFilter filter)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.BeforeOnException.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.BeforeExceptionFilterOnException.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.BeforeOnException.EventName,
+                    Diagnostics.BeforeExceptionFilterOnException.EventName,
-                    new BeforeOnException(
+                    new BeforeExceptionFilterOnException(
                         exceptionContext.ActionDescriptor,
                         exceptionContext,
                         filter
@@ -411,7 +411,7 @@ namespace Microsoft.AspNetCore.Mvc
             Debug.Assert(exceptionContext != null);
             Debug.Assert(filter != null);
 
-            // Inlinable fast-path check if Diagnositcs is enabled
+            // Inlinable fast-path check if diagnostic listener is enabled
             if (diagnosticListener.IsEnabled())
             {
                 AfterOnExceptionAsyncImpl(diagnosticListener, exceptionContext, filter);
@@ -420,11 +420,11 @@ namespace Microsoft.AspNetCore.Mvc
 
         private static void AfterOnExceptionAsyncImpl(DiagnosticListener diagnosticListener, ExceptionContext exceptionContext, IAsyncExceptionFilter filter)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.AfterOnException.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.AfterExceptionFilterOnExceptionEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.AfterOnException.EventName,
+                    Diagnostics.AfterExceptionFilterOnExceptionEventData.EventName,
-                    new AfterOnException(
+                    new AfterExceptionFilterOnExceptionEventData(
                         exceptionContext.ActionDescriptor,
                         exceptionContext,
                         filter
@@ -441,7 +441,7 @@ namespace Microsoft.AspNetCore.Mvc
             Debug.Assert(exceptionContext != null);
             Debug.Assert(filter != null);
 
-            // Inlinable fast-path check if Diagnositcs is enabled
+            // Inlinable fast-path check if diagnostic listener is enabled
             if (diagnosticListener.IsEnabled())
             {
                 BeforeOnExceptionImpl(diagnosticListener, exceptionContext, filter);
@@ -450,11 +450,11 @@ namespace Microsoft.AspNetCore.Mvc
 
         private static void BeforeOnExceptionImpl(DiagnosticListener diagnosticListener, ExceptionContext exceptionContext, IExceptionFilter filter)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.BeforeOnException.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.BeforeExceptionFilterOnException.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.BeforeOnException.EventName,
+                    Diagnostics.BeforeExceptionFilterOnException.EventName,
-                    new BeforeOnException(
+                    new BeforeExceptionFilterOnException(
                         exceptionContext.ActionDescriptor,
                         exceptionContext,
                         filter
@@ -471,7 +471,7 @@ namespace Microsoft.AspNetCore.Mvc
             Debug.Assert(exceptionContext != null);
             Debug.Assert(filter != null);
 
-            // Inlinable fast-path check if Diagnositcs is enabled
+            // Inlinable fast-path check if diagnostic listener is enabled
             if (diagnosticListener.IsEnabled())
             {
                 AfterOnExceptionImpl(diagnosticListener, exceptionContext, filter);
@@ -480,11 +480,11 @@ namespace Microsoft.AspNetCore.Mvc
 
         private static void AfterOnExceptionImpl(DiagnosticListener diagnosticListener, ExceptionContext exceptionContext, IExceptionFilter filter)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.AfterOnException.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.AfterExceptionFilterOnExceptionEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.AfterOnException.EventName,
+                    Diagnostics.AfterExceptionFilterOnExceptionEventData.EventName,
-                    new AfterOnException(
+                    new AfterExceptionFilterOnExceptionEventData(
                         exceptionContext.ActionDescriptor,
                         exceptionContext,
                         filter
@@ -501,7 +501,7 @@ namespace Microsoft.AspNetCore.Mvc
             Debug.Assert(actionExecutingContext != null);
             Debug.Assert(filter != null);
 
-            // Inlinable fast-path check if Diagnositcs is enabled
+            // Inlinable fast-path check if diagnostic listener is enabled
             if (diagnosticListener.IsEnabled())
             {
                 BeforeOnActionExecutionImpl(diagnosticListener, actionExecutingContext, filter);
@@ -510,11 +510,11 @@ namespace Microsoft.AspNetCore.Mvc
 
         private static void BeforeOnActionExecutionImpl(DiagnosticListener diagnosticListener, ActionExecutingContext actionExecutingContext, IAsyncActionFilter filter)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.BeforeOnActionExecution.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.BeforeActionFilterOnActionExecutionEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.BeforeOnActionExecution.EventName,
+                    Diagnostics.BeforeActionFilterOnActionExecutionEventData.EventName,
-                    new BeforeOnActionExecution(
+                    new BeforeActionFilterOnActionExecutionEventData(
                         actionExecutingContext.ActionDescriptor,
                         actionExecutingContext,
                         filter
@@ -531,7 +531,7 @@ namespace Microsoft.AspNetCore.Mvc
             Debug.Assert(actionExecutedContext != null);
             Debug.Assert(filter != null);
 
-            // Inlinable fast-path check if Diagnositcs is enabled
+            // Inlinable fast-path check if diagnostic listener is enabled
             if (diagnosticListener.IsEnabled())
             {
                 AfterOnActionExecutionImpl(diagnosticListener, actionExecutedContext, filter);
@@ -540,11 +540,11 @@ namespace Microsoft.AspNetCore.Mvc
 
         private static void AfterOnActionExecutionImpl(DiagnosticListener diagnosticListener, ActionExecutedContext actionExecutedContext, IAsyncActionFilter filter)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.AfterOnActionExecution.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.AfterActionFilterOnActionExecutionEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.AfterOnActionExecution.EventName,
+                    Diagnostics.AfterActionFilterOnActionExecutionEventData.EventName,
-                    new AfterOnActionExecution(
+                    new AfterActionFilterOnActionExecutionEventData(
                         actionExecutedContext.ActionDescriptor,
                         actionExecutedContext,
                         filter
@@ -561,7 +561,7 @@ namespace Microsoft.AspNetCore.Mvc
             Debug.Assert(actionExecutingContext != null);
             Debug.Assert(filter != null);
 
-            // Inlinable fast-path check if Diagnositcs is enabled
+            // Inlinable fast-path check if diagnostic listener is enabled
             if (diagnosticListener.IsEnabled())
             {
                 BeforeOnActionExecutingImpl(diagnosticListener, actionExecutingContext, filter);
@@ -570,11 +570,11 @@ namespace Microsoft.AspNetCore.Mvc
 
         private static void BeforeOnActionExecutingImpl(DiagnosticListener diagnosticListener, ActionExecutingContext actionExecutingContext, IActionFilter filter)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.BeforeOnActionExecuting.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.BeforeActionFilterOnActionExecutingEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.BeforeOnActionExecuting.EventName,
+                    Diagnostics.BeforeActionFilterOnActionExecutingEventData.EventName,
-                    new BeforeOnActionExecuting(
+                    new BeforeActionFilterOnActionExecutingEventData(
                         actionExecutingContext.ActionDescriptor,
                         actionExecutingContext,
                         filter
@@ -591,7 +591,7 @@ namespace Microsoft.AspNetCore.Mvc
             Debug.Assert(actionExecutingContext != null);
             Debug.Assert(filter != null);
 
-            // Inlinable fast-path check if Diagnositcs is enabled
+            // Inlinable fast-path check if diagnostic listener is enabled
             if (diagnosticListener.IsEnabled())
             {
                 AfterOnActionExecutingImpl(diagnosticListener, actionExecutingContext, filter);
@@ -600,11 +600,11 @@ namespace Microsoft.AspNetCore.Mvc
 
         private static void AfterOnActionExecutingImpl(DiagnosticListener diagnosticListener, ActionExecutingContext actionExecutingContext, IActionFilter filter)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.AfterOnActionExecuting.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.AfterActionFilterOnActionExecutingEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.AfterOnActionExecuting.EventName,
+                    Diagnostics.AfterActionFilterOnActionExecutingEventData.EventName,
-                    new AfterOnActionExecuting(
+                    new AfterActionFilterOnActionExecutingEventData(
                         actionExecutingContext.ActionDescriptor,
                         actionExecutingContext,
                         filter
@@ -621,7 +621,7 @@ namespace Microsoft.AspNetCore.Mvc
             Debug.Assert(actionExecutedContext != null);
             Debug.Assert(filter != null);
 
-            // Inlinable fast-path check if Diagnositcs is enabled
+            // Inlinable fast-path check if diagnostic listener is enabled
             if (diagnosticListener.IsEnabled())
             {
                 BeforeOnActionExecutedImpl(diagnosticListener, actionExecutedContext, filter);
@@ -630,11 +630,11 @@ namespace Microsoft.AspNetCore.Mvc
 
         private static void BeforeOnActionExecutedImpl(DiagnosticListener diagnosticListener, ActionExecutedContext actionExecutedContext, IActionFilter filter)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.BeforeOnActionExecuted.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.BeforeActionFilterOnActionExecutedEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.BeforeOnActionExecuted.EventName,
+                    Diagnostics.BeforeActionFilterOnActionExecutedEventData.EventName,
-                    new BeforeOnActionExecuted(
+                    new BeforeActionFilterOnActionExecutedEventData(
                         actionExecutedContext.ActionDescriptor,
                         actionExecutedContext,
                         filter
@@ -651,7 +651,7 @@ namespace Microsoft.AspNetCore.Mvc
             Debug.Assert(actionExecutedContext != null);
             Debug.Assert(filter != null);
 
-            // Inlinable fast-path check if Diagnositcs is enabled
+            // Inlinable fast-path check if diagnostic listener is enabled
             if (diagnosticListener.IsEnabled())
             {
                 AfterOnActionExecutedImpl(diagnosticListener, actionExecutedContext, filter);
@@ -660,11 +660,11 @@ namespace Microsoft.AspNetCore.Mvc
 
         private static void AfterOnActionExecutedImpl(DiagnosticListener diagnosticListener, ActionExecutedContext actionExecutedContext, IActionFilter filter)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.AfterOnActionExecuted.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.AfterActionFilterOnActionExecutedEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.AfterOnActionExecuted.EventName,
+                    Diagnostics.AfterActionFilterOnActionExecutedEventData.EventName,
-                    new AfterOnActionExecuted(
+                    new AfterActionFilterOnActionExecutedEventData(
                         actionExecutedContext.ActionDescriptor,
                         actionExecutedContext,
                         filter
@@ -672,7 +672,7 @@ namespace Microsoft.AspNetCore.Mvc
             }
         }
 
-        public static void BeforeActionMethod(
+        public static void BeforeControllerActionMethod(
             this DiagnosticListener diagnosticListener,
             ActionContext actionContext,
             IReadOnlyDictionary<string, object> actionArguments,
@@ -683,7 +683,7 @@ namespace Microsoft.AspNetCore.Mvc
             Debug.Assert(actionArguments != null);
             Debug.Assert(controller != null);
 
-            // Inlinable fast-path check if Diagnositcs is enabled
+            // Inlinable fast-path check if diagnostic listener is enabled
             if (diagnosticListener.IsEnabled())
             {
                 BeforeActionMethodImpl(diagnosticListener, actionContext, actionArguments, controller);
@@ -692,11 +692,24 @@ namespace Microsoft.AspNetCore.Mvc
 
         private static void BeforeActionMethodImpl(DiagnosticListener diagnosticListener, ActionContext actionContext, IReadOnlyDictionary<string, object> actionArguments, object controller)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.BeforeActionMethod.EventName))
+            // Intellitrace uses this in VS, so we fire the old event with camelCase event names.
+            if (diagnosticListener.IsEnabled("Microsoft.AspNetCore.Mvc.BeforeActionMethod"))
             {
                 diagnosticListener.Write(
-                    Diagnostics.BeforeActionMethod.EventName,
+                 "Microsoft.AspNetCore.Mvc.BeforeActionMethod",
-                    new BeforeActionMethod(
+                 new
+                 {
+                     actionContext,
+                     actionArguments,
+                     controller
+                 });
+            }
+
+            if (diagnosticListener.IsEnabled(Diagnostics.BeforeControllerActionMethodEventData.EventName))
+            {
+                diagnosticListener.Write(
+                    Diagnostics.BeforeControllerActionMethodEventData.EventName,
+                    new BeforeControllerActionMethodEventData(
                         actionContext,
                         actionArguments,
                         controller
@@ -704,7 +717,7 @@ namespace Microsoft.AspNetCore.Mvc
             }
         }
 
-        public static void AfterActionMethod(
+        public static void AfterControllerActionMethod(
             this DiagnosticListener diagnosticListener,
             ActionContext actionContext,
             IReadOnlyDictionary<string, object> actionArguments,
@@ -716,7 +729,7 @@ namespace Microsoft.AspNetCore.Mvc
             Debug.Assert(actionArguments != null);
             Debug.Assert(controller != null);
 
-            // Inlinable fast-path check if Diagnositcs is enabled
+            // Inlinable fast-path check if diagnostic listener is enabled
             if (diagnosticListener.IsEnabled())
             {
                 AfterActionMethodImpl(diagnosticListener, actionContext, actionArguments, controller, result);
@@ -725,17 +738,31 @@ namespace Microsoft.AspNetCore.Mvc
 
         private static void AfterActionMethodImpl(DiagnosticListener diagnosticListener, ActionContext actionContext, IReadOnlyDictionary<string, object> actionArguments, object controller, IActionResult result)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.AfterActionMethod.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.AfterControllerActionMethodEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.AfterActionMethod.EventName,
+                    Diagnostics.AfterControllerActionMethodEventData.EventName,
-                    new AfterActionMethod(
+                    new AfterControllerActionMethodEventData(
                         actionContext,
                         actionArguments,
                         controller,
                         result
                     ));
             }
+
+            // Firing the old event for compat.
+            if (diagnosticListener.IsEnabled("Microsoft.AspNetCore.Mvc.AfterActionMethod"))
+            {
+                diagnosticListener.Write(
+                 "Microsoft.AspNetCore.Mvc.AfterActionMethod",
+                 new
+                 {
+                     actionContext,
+                     actionArguments,
+                     controller,
+                     result
+                 });
+            }
         }
 
         public static void BeforeOnResultExecution(
@@ -747,7 +774,7 @@ namespace Microsoft.AspNetCore.Mvc
             Debug.Assert(resultExecutingContext != null);
             Debug.Assert(filter != null);
 
-            // Inlinable fast-path check if Diagnositcs is enabled
+            // Inlinable fast-path check if diagnostic listener is enabled
             if (diagnosticListener.IsEnabled())
             {
                 BeforeOnResultExecutionImpl(diagnosticListener, resultExecutingContext, filter);
@@ -756,11 +783,11 @@ namespace Microsoft.AspNetCore.Mvc
 
         private static void BeforeOnResultExecutionImpl(DiagnosticListener diagnosticListener, ResultExecutingContext resultExecutingContext, IAsyncResultFilter filter)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.BeforeOnResultExecution.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.BeforeResultFilterOnResultExecutionEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.BeforeOnResultExecution.EventName,
+                    Diagnostics.BeforeResultFilterOnResultExecutionEventData.EventName,
-                    new BeforeOnResultExecution(
+                    new BeforeResultFilterOnResultExecutionEventData(
                         resultExecutingContext.ActionDescriptor,
                         resultExecutingContext,
                         filter
@@ -777,7 +804,7 @@ namespace Microsoft.AspNetCore.Mvc
             Debug.Assert(resultExecutedContext != null);
             Debug.Assert(filter != null);
 
-            // Inlinable fast-path check if Diagnositcs is enabled
+            // Inlinable fast-path check if diagnostic listener is enabled
             if (diagnosticListener.IsEnabled())
             {
                 AfterOnResultExecutionImpl(diagnosticListener, resultExecutedContext, filter);
@@ -786,11 +813,11 @@ namespace Microsoft.AspNetCore.Mvc
 
         private static void AfterOnResultExecutionImpl(DiagnosticListener diagnosticListener, ResultExecutedContext resultExecutedContext, IAsyncResultFilter filter)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.AfterOnResultExecution.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.AfterResultFilterOnResultExecutionEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.AfterOnResultExecution.EventName,
+                    Diagnostics.AfterResultFilterOnResultExecutionEventData.EventName,
-                    new AfterOnResultExecution(
+                    new AfterResultFilterOnResultExecutionEventData(
                         resultExecutedContext.ActionDescriptor,
                         resultExecutedContext,
                         filter
@@ -807,7 +834,7 @@ namespace Microsoft.AspNetCore.Mvc
             Debug.Assert(resultExecutingContext != null);
             Debug.Assert(filter != null);
 
-            // Inlinable fast-path check if Diagnositcs is enabled
+            // Inlinable fast-path check if diagnostic listener is enabled
             if (diagnosticListener.IsEnabled())
             {
                 BeforeOnResultExecutingImpl(diagnosticListener, resultExecutingContext, filter);
@@ -816,11 +843,11 @@ namespace Microsoft.AspNetCore.Mvc
 
         private static void BeforeOnResultExecutingImpl(DiagnosticListener diagnosticListener, ResultExecutingContext resultExecutingContext, IResultFilter filter)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.BeforeOnResultExecuting.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.BeforeResultFilterOnResultExecutingEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.BeforeOnResultExecuting.EventName,
+                    Diagnostics.BeforeResultFilterOnResultExecutingEventData.EventName,
-                    new BeforeOnResultExecuting(
+                    new BeforeResultFilterOnResultExecutingEventData(
                         resultExecutingContext.ActionDescriptor,
                         resultExecutingContext,
                         filter
@@ -837,7 +864,7 @@ namespace Microsoft.AspNetCore.Mvc
             Debug.Assert(resultExecutingContext != null);
             Debug.Assert(filter != null);
 
-            // Inlinable fast-path check if Diagnositcs is enabled
+            // Inlinable fast-path check if diagnostic listener is enabled
             if (diagnosticListener.IsEnabled())
             {
                 AfterOnResultExecutingImpl(diagnosticListener, resultExecutingContext, filter);
@@ -846,11 +873,11 @@ namespace Microsoft.AspNetCore.Mvc
 
         private static void AfterOnResultExecutingImpl(DiagnosticListener diagnosticListener, ResultExecutingContext resultExecutingContext, IResultFilter filter)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.AfterOnResultExecuting.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.AfterResultFilterOnResultExecutingEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.AfterOnResultExecuting.EventName,
+                    Diagnostics.AfterResultFilterOnResultExecutingEventData.EventName,
-                    new AfterOnResultExecuting(
+                    new AfterResultFilterOnResultExecutingEventData(
                         resultExecutingContext.ActionDescriptor,
                         resultExecutingContext,
                         filter
@@ -867,7 +894,7 @@ namespace Microsoft.AspNetCore.Mvc
             Debug.Assert(resultExecutedContext != null);
             Debug.Assert(filter != null);
 
-            // Inlinable fast-path check if Diagnositcs is enabled
+            // Inlinable fast-path check if diagnostic listener is enabled
             if (diagnosticListener.IsEnabled())
             {
                 BeforeOnResultExecutedImpl(diagnosticListener, resultExecutedContext, filter);
@@ -876,11 +903,11 @@ namespace Microsoft.AspNetCore.Mvc
 
         private static void BeforeOnResultExecutedImpl(DiagnosticListener diagnosticListener, ResultExecutedContext resultExecutedContext, IResultFilter filter)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.BeforeOnResultExecuted.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.BeforeResultFilterOnResultExecutedEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.BeforeOnResultExecuted.EventName,
+                    Diagnostics.BeforeResultFilterOnResultExecutedEventData.EventName,
-                    new BeforeOnResultExecuted(
+                    new BeforeResultFilterOnResultExecutedEventData(
                         resultExecutedContext.ActionDescriptor,
                         resultExecutedContext,
                         filter
@@ -897,7 +924,7 @@ namespace Microsoft.AspNetCore.Mvc
             Debug.Assert(resultExecutedContext != null);
             Debug.Assert(filter != null);
 
-            // Inlinable fast-path check if Diagnositcs is enabled
+            // Inlinable fast-path check if diagnostic listener is enabled
             if (diagnosticListener.IsEnabled())
             {
                 AfterOnResultExecutedImpl(diagnosticListener, resultExecutedContext, filter);
@@ -906,11 +933,11 @@ namespace Microsoft.AspNetCore.Mvc
 
         private static void AfterOnResultExecutedImpl(DiagnosticListener diagnosticListener, ResultExecutedContext resultExecutedContext, IResultFilter filter)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.AfterOnResultExecuted.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.AfterResultFilterOnResultExecutedEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.AfterOnResultExecuted.EventName,
+                    Diagnostics.AfterResultFilterOnResultExecutedEventData.EventName,
-                    new AfterOnResultExecuted(
+                    new AfterResultFilterOnResultExecutedEventData(
                         resultExecutedContext.ActionDescriptor,
                         resultExecutedContext,
                         filter
@@ -927,7 +954,7 @@ namespace Microsoft.AspNetCore.Mvc
             Debug.Assert(actionContext != null);
             Debug.Assert(result != null);
 
-            // Inlinable fast-path check if Diagnositcs is enabled
+            // Inlinable fast-path check if diagnostic listener is enabled
             if (diagnosticListener.IsEnabled())
             {
                 BeforeActionResultImpl(diagnosticListener, actionContext, result);
@@ -936,11 +963,11 @@ namespace Microsoft.AspNetCore.Mvc
 
         private static void BeforeActionResultImpl(DiagnosticListener diagnosticListener, ActionContext actionContext, IActionResult result)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.BeforeActionResult.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.BeforeActionResultEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.BeforeActionResult.EventName,
+                    Diagnostics.BeforeActionResultEventData.EventName,
-                    new BeforeActionResult(actionContext, result));
+                    new BeforeActionResultEventData(actionContext, result));
             }
         }
 
@@ -953,7 +980,7 @@ namespace Microsoft.AspNetCore.Mvc
             Debug.Assert(actionContext != null);
             Debug.Assert(result != null);
 
-            // Inlinable fast-path check if Diagnositcs is enabled
+            // Inlinable fast-path check if diagnostic listener is enabled
             if (diagnosticListener.IsEnabled())
             {
                 AfterActionResultImpl(diagnosticListener, actionContext, result);
@@ -962,11 +989,11 @@ namespace Microsoft.AspNetCore.Mvc
 
         private static void AfterActionResultImpl(DiagnosticListener diagnosticListener, ActionContext actionContext, IActionResult result)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.AfterActionResult.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.AfterActionResultEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.AfterActionResult.EventName,
+                    Diagnostics.AfterActionResultEventData.EventName,
-                    new AfterActionResult(actionContext, result));
+                    new AfterActionResultEventData(actionContext, result));
             }
         }
     }

src/Mvc/Mvc.Razor/ref/Microsoft.AspNetCore.Mvc.Razor.netcoreapp3.0.cs

@@ -23,10 +23,10 @@ namespace Microsoft.AspNetCore.Mvc.ApplicationParts
 }
 namespace Microsoft.AspNetCore.Mvc.Diagnostics
 {
-    public sealed partial class AfterViewPage : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    public sealed partial class AfterViewPageEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
     {
         public const string EventName = "Microsoft.AspNetCore.Mvc.Razor.AfterViewPage";
-        public AfterViewPage(Microsoft.AspNetCore.Mvc.Razor.IRazorPage page, Microsoft.AspNetCore.Mvc.Rendering.ViewContext viewContext, Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Http.HttpContext httpContext) { }
+        public AfterViewPageEventData(Microsoft.AspNetCore.Mvc.Razor.IRazorPage page, Microsoft.AspNetCore.Mvc.Rendering.ViewContext viewContext, Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Http.HttpContext httpContext) { }
         public Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor ActionDescriptor { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override int Count { get { throw null; } }
         public Microsoft.AspNetCore.Http.HttpContext HttpContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
@@ -34,10 +34,10 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         public Microsoft.AspNetCore.Mvc.Razor.IRazorPage Page { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Rendering.ViewContext ViewContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
     }
-    public sealed partial class BeforeViewPage : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    public sealed partial class BeforeViewPageEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
     {
         public const string EventName = "Microsoft.AspNetCore.Mvc.Razor.BeforeViewPage";
-        public BeforeViewPage(Microsoft.AspNetCore.Mvc.Razor.IRazorPage page, Microsoft.AspNetCore.Mvc.Rendering.ViewContext viewContext, Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Http.HttpContext httpContext) { }
+        public BeforeViewPageEventData(Microsoft.AspNetCore.Mvc.Razor.IRazorPage page, Microsoft.AspNetCore.Mvc.Rendering.ViewContext viewContext, Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Http.HttpContext httpContext) { }
         public Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor ActionDescriptor { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override int Count { get { throw null; } }
         public Microsoft.AspNetCore.Http.HttpContext HttpContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }

src/Mvc/Mvc.Razor/src/Diagnostics/MvcDiagnostics.cs

@@ -10,13 +10,13 @@ using Microsoft.AspNetCore.Mvc.Rendering;
 
 namespace Microsoft.AspNetCore.Mvc.Diagnostics
 {
-    public sealed class BeforeViewPage : EventData
+    public sealed class BeforeViewPageEventData : EventData
     {
         public const string EventName = EventNamespace + 
             "Razor." +
-            nameof(BeforeViewPage);
+            "BeforeViewPage";
 
-        public BeforeViewPage(IRazorPage page, ViewContext viewContext, ActionDescriptor actionDescriptor, HttpContext httpContext)
+        public BeforeViewPageEventData(IRazorPage page, ViewContext viewContext, ActionDescriptor actionDescriptor, HttpContext httpContext)
         {
             Page = page;
             ViewContext = viewContext;
@@ -41,13 +41,13 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         };
     }
 
-    public sealed class AfterViewPage : EventData
+    public sealed class AfterViewPageEventData : EventData
     {
         public const string EventName = EventNamespace +
             "Razor." +
-            nameof(AfterViewPage);
+            "AfterViewPage";
 
-        public AfterViewPage(IRazorPage page, ViewContext viewContext, ActionDescriptor actionDescriptor, HttpContext httpContext)
+        public AfterViewPageEventData(IRazorPage page, ViewContext viewContext, ActionDescriptor actionDescriptor, HttpContext httpContext)
         {
             Page = page;
             ViewContext = viewContext;

src/Mvc/Mvc.Razor/src/MvcRazorDiagnosticListenerExtensions.cs

@@ -27,11 +27,11 @@ namespace Microsoft.AspNetCore.Mvc.Razor
             IRazorPage page,
             ViewContext viewContext)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.BeforeViewPage.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.BeforeViewPageEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.BeforeViewPage.EventName,
+                    Diagnostics.BeforeViewPageEventData.EventName,
-                    new BeforeViewPage(
+                    new BeforeViewPageEventData(
                         page,
                         viewContext,
                         viewContext.ActionDescriptor,
@@ -57,11 +57,11 @@ namespace Microsoft.AspNetCore.Mvc.Razor
             IRazorPage page,
             ViewContext viewContext)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.AfterViewPage.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.AfterViewPageEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.AfterViewPage.EventName,
+                    Diagnostics.AfterViewPageEventData.EventName,
-                    new AfterViewPage(
+                    new AfterViewPageEventData(
                         page,
                         viewContext,
                         viewContext.ActionDescriptor,

src/Mvc/Mvc.RazorPages/ref/Microsoft.AspNetCore.Mvc.RazorPages.netcoreapp3.0.cs

@@ -145,10 +145,10 @@ namespace Microsoft.AspNetCore.Mvc.ApplicationModels
 }
 namespace Microsoft.AspNetCore.Mvc.Diagnostics
 {
-    public sealed partial class AfterHandlerMethod : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    public sealed partial class AfterHandlerMethodEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
     {
         public const string EventName = "Microsoft.AspNetCore.Mvc.AfterHandlerMethod";
-        public AfterHandlerMethod(Microsoft.AspNetCore.Mvc.ActionContext actionContext, System.Collections.Generic.IReadOnlyDictionary<string, object> arguments, Microsoft.AspNetCore.Mvc.RazorPages.Infrastructure.HandlerMethodDescriptor handlerMethodDescriptor, object instance, Microsoft.AspNetCore.Mvc.IActionResult result) { }
+        public AfterHandlerMethodEventData(Microsoft.AspNetCore.Mvc.ActionContext actionContext, System.Collections.Generic.IReadOnlyDictionary<string, object> arguments, Microsoft.AspNetCore.Mvc.RazorPages.Infrastructure.HandlerMethodDescriptor handlerMethodDescriptor, object instance, Microsoft.AspNetCore.Mvc.IActionResult result) { }
         public Microsoft.AspNetCore.Mvc.ActionContext ActionContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         public System.Collections.Generic.IReadOnlyDictionary<string, object> Arguments { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override int Count { get { throw null; } }
@@ -157,60 +157,60 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         protected override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
         public Microsoft.AspNetCore.Mvc.IActionResult Result { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
     }
-    public sealed partial class AfterOnPageHandlerExecuted : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    public sealed partial class AfterPageFilterOnPageHandlerExecutedEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
     {
         public const string EventName = "Microsoft.AspNetCore.Mvc.AfterOnPageHandlerExecuted";
-        public AfterOnPageHandlerExecuted(Microsoft.AspNetCore.Mvc.RazorPages.CompiledPageActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.PageHandlerExecutedContext handlerExecutedContext, Microsoft.AspNetCore.Mvc.Filters.IPageFilter filter) { }
+        public AfterPageFilterOnPageHandlerExecutedEventData(Microsoft.AspNetCore.Mvc.RazorPages.CompiledPageActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.PageHandlerExecutedContext handlerExecutedContext, Microsoft.AspNetCore.Mvc.Filters.IPageFilter filter) { }
         public Microsoft.AspNetCore.Mvc.RazorPages.CompiledPageActionDescriptor ActionDescriptor { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override int Count { get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.IPageFilter Filter { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.PageHandlerExecutedContext HandlerExecutedContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
     }
-    public sealed partial class AfterOnPageHandlerExecuting : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    public sealed partial class AfterPageFilterOnPageHandlerExecutingEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
     {
         public const string EventName = "Microsoft.AspNetCore.Mvc.AfterOnPageHandlerExecuting";
-        public AfterOnPageHandlerExecuting(Microsoft.AspNetCore.Mvc.RazorPages.CompiledPageActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.PageHandlerExecutingContext handlerExecutingContext, Microsoft.AspNetCore.Mvc.Filters.IPageFilter filter) { }
+        public AfterPageFilterOnPageHandlerExecutingEventData(Microsoft.AspNetCore.Mvc.RazorPages.CompiledPageActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.PageHandlerExecutingContext handlerExecutingContext, Microsoft.AspNetCore.Mvc.Filters.IPageFilter filter) { }
         public Microsoft.AspNetCore.Mvc.RazorPages.CompiledPageActionDescriptor ActionDescriptor { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override int Count { get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.IPageFilter Filter { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.PageHandlerExecutingContext HandlerExecutingContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
     }
-    public sealed partial class AfterOnPageHandlerExecution : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    public sealed partial class AfterPageFilterOnPageHandlerExecutionEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
     {
         public const string EventName = "Microsoft.AspNetCore.Mvc.AfterOnPageHandlerExecution";
-        public AfterOnPageHandlerExecution(Microsoft.AspNetCore.Mvc.RazorPages.CompiledPageActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.PageHandlerExecutedContext handlerExecutedContext, Microsoft.AspNetCore.Mvc.Filters.IAsyncPageFilter filter) { }
+        public AfterPageFilterOnPageHandlerExecutionEventData(Microsoft.AspNetCore.Mvc.RazorPages.CompiledPageActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.PageHandlerExecutedContext handlerExecutedContext, Microsoft.AspNetCore.Mvc.Filters.IAsyncPageFilter filter) { }
         public Microsoft.AspNetCore.Mvc.RazorPages.CompiledPageActionDescriptor ActionDescriptor { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override int Count { get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.IAsyncPageFilter Filter { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.PageHandlerExecutedContext HandlerExecutedContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
     }
-    public sealed partial class AfterOnPageHandlerSelected : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    public sealed partial class AfterPageFilterOnPageHandlerSelectedEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
     {
         public const string EventName = "Microsoft.AspNetCore.Mvc.AfterOnPageHandlerSelected";
-        public AfterOnPageHandlerSelected(Microsoft.AspNetCore.Mvc.RazorPages.CompiledPageActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.PageHandlerSelectedContext handlerSelectedContext, Microsoft.AspNetCore.Mvc.Filters.IPageFilter filter) { }
+        public AfterPageFilterOnPageHandlerSelectedEventData(Microsoft.AspNetCore.Mvc.RazorPages.CompiledPageActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.PageHandlerSelectedContext handlerSelectedContext, Microsoft.AspNetCore.Mvc.Filters.IPageFilter filter) { }
         public Microsoft.AspNetCore.Mvc.RazorPages.CompiledPageActionDescriptor ActionDescriptor { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override int Count { get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.IPageFilter Filter { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.PageHandlerSelectedContext HandlerSelectedContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
     }
-    public sealed partial class AfterOnPageHandlerSelection : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    public sealed partial class AfterPageFilterOnPageHandlerSelectionEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
     {
         public const string EventName = "Microsoft.AspNetCore.Mvc.AfterOnPageHandlerSelection";
-        public AfterOnPageHandlerSelection(Microsoft.AspNetCore.Mvc.RazorPages.CompiledPageActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.PageHandlerSelectedContext handlerSelectedContext, Microsoft.AspNetCore.Mvc.Filters.IAsyncPageFilter filter) { }
+        public AfterPageFilterOnPageHandlerSelectionEventData(Microsoft.AspNetCore.Mvc.RazorPages.CompiledPageActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.PageHandlerSelectedContext handlerSelectedContext, Microsoft.AspNetCore.Mvc.Filters.IAsyncPageFilter filter) { }
         public Microsoft.AspNetCore.Mvc.RazorPages.CompiledPageActionDescriptor ActionDescriptor { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override int Count { get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.IAsyncPageFilter Filter { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.PageHandlerSelectedContext HandlerSelectedContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
     }
-    public sealed partial class BeforeHandlerMethod : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    public sealed partial class BeforeHandlerMethodEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
     {
         public const string EventName = "Microsoft.AspNetCore.Mvc.BeforeHandlerMethod";
-        public BeforeHandlerMethod(Microsoft.AspNetCore.Mvc.ActionContext actionContext, System.Collections.Generic.IReadOnlyDictionary<string, object> arguments, Microsoft.AspNetCore.Mvc.RazorPages.Infrastructure.HandlerMethodDescriptor handlerMethodDescriptor, object instance) { }
+        public BeforeHandlerMethodEventData(Microsoft.AspNetCore.Mvc.ActionContext actionContext, System.Collections.Generic.IReadOnlyDictionary<string, object> arguments, Microsoft.AspNetCore.Mvc.RazorPages.Infrastructure.HandlerMethodDescriptor handlerMethodDescriptor, object instance) { }
         public Microsoft.AspNetCore.Mvc.ActionContext ActionContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         public System.Collections.Generic.IReadOnlyDictionary<string, object> Arguments { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override int Count { get { throw null; } }
@@ -218,50 +218,50 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         public object Instance { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
     }
-    public sealed partial class BeforeOnPageHandlerExecuted : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    public sealed partial class BeforePageFilterOnPageHandlerExecutedEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
     {
         public const string EventName = "Microsoft.AspNetCore.Mvc.BeforeOnPageHandlerExecuted";
-        public BeforeOnPageHandlerExecuted(Microsoft.AspNetCore.Mvc.RazorPages.CompiledPageActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.PageHandlerExecutedContext handlerExecutedContext, Microsoft.AspNetCore.Mvc.Filters.IPageFilter filter) { }
+        public BeforePageFilterOnPageHandlerExecutedEventData(Microsoft.AspNetCore.Mvc.RazorPages.CompiledPageActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.PageHandlerExecutedContext handlerExecutedContext, Microsoft.AspNetCore.Mvc.Filters.IPageFilter filter) { }
         public Microsoft.AspNetCore.Mvc.RazorPages.CompiledPageActionDescriptor ActionDescriptor { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override int Count { get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.IPageFilter Filter { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.PageHandlerExecutedContext HandlerExecutedContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
     }
-    public sealed partial class BeforeOnPageHandlerExecuting : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    public sealed partial class BeforePageFilterOnPageHandlerExecutingEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
     {
         public const string EventName = "Microsoft.AspNetCore.Mvc.BeforeOnPageHandlerExecuting";
-        public BeforeOnPageHandlerExecuting(Microsoft.AspNetCore.Mvc.RazorPages.CompiledPageActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.PageHandlerExecutingContext handlerExecutingContext, Microsoft.AspNetCore.Mvc.Filters.IPageFilter filter) { }
+        public BeforePageFilterOnPageHandlerExecutingEventData(Microsoft.AspNetCore.Mvc.RazorPages.CompiledPageActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.PageHandlerExecutingContext handlerExecutingContext, Microsoft.AspNetCore.Mvc.Filters.IPageFilter filter) { }
         public Microsoft.AspNetCore.Mvc.RazorPages.CompiledPageActionDescriptor ActionDescriptor { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override int Count { get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.IPageFilter Filter { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.PageHandlerExecutingContext HandlerExecutingContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
     }
-    public sealed partial class BeforeOnPageHandlerExecution : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    public sealed partial class BeforePageFilterOnPageHandlerExecutionEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
     {
         public const string EventName = "Microsoft.AspNetCore.Mvc.BeforeOnPageHandlerExecution";
-        public BeforeOnPageHandlerExecution(Microsoft.AspNetCore.Mvc.RazorPages.CompiledPageActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.PageHandlerExecutingContext handlerExecutionContext, Microsoft.AspNetCore.Mvc.Filters.IAsyncPageFilter filter) { }
+        public BeforePageFilterOnPageHandlerExecutionEventData(Microsoft.AspNetCore.Mvc.RazorPages.CompiledPageActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.PageHandlerExecutingContext handlerExecutionContext, Microsoft.AspNetCore.Mvc.Filters.IAsyncPageFilter filter) { }
         public Microsoft.AspNetCore.Mvc.RazorPages.CompiledPageActionDescriptor ActionDescriptor { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override int Count { get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.IAsyncPageFilter Filter { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.PageHandlerExecutingContext HandlerExecutionContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
     }
-    public sealed partial class BeforeOnPageHandlerSelected : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    public sealed partial class BeforePageFilterOnPageHandlerSelectedEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
     {
         public const string EventName = "Microsoft.AspNetCore.Mvc.BeforeOnPageHandlerSelected";
-        public BeforeOnPageHandlerSelected(Microsoft.AspNetCore.Mvc.RazorPages.CompiledPageActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.PageHandlerSelectedContext handlerSelectedContext, Microsoft.AspNetCore.Mvc.Filters.IPageFilter filter) { }
+        public BeforePageFilterOnPageHandlerSelectedEventData(Microsoft.AspNetCore.Mvc.RazorPages.CompiledPageActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.PageHandlerSelectedContext handlerSelectedContext, Microsoft.AspNetCore.Mvc.Filters.IPageFilter filter) { }
         public Microsoft.AspNetCore.Mvc.RazorPages.CompiledPageActionDescriptor ActionDescriptor { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override int Count { get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.IPageFilter Filter { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.PageHandlerSelectedContext HandlerSelectedContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
     }
-    public sealed partial class BeforeOnPageHandlerSelection : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    public sealed partial class BeforePageFilterOnPageHandlerSelectionEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
     {
         public const string EventName = "Microsoft.AspNetCore.Mvc.BeforeOnPageHandlerSelection";
-        public BeforeOnPageHandlerSelection(Microsoft.AspNetCore.Mvc.RazorPages.CompiledPageActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.PageHandlerSelectedContext handlerSelectedContext, Microsoft.AspNetCore.Mvc.Filters.IAsyncPageFilter filter) { }
+        public BeforePageFilterOnPageHandlerSelectionEventData(Microsoft.AspNetCore.Mvc.RazorPages.CompiledPageActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.Filters.PageHandlerSelectedContext handlerSelectedContext, Microsoft.AspNetCore.Mvc.Filters.IAsyncPageFilter filter) { }
         public Microsoft.AspNetCore.Mvc.RazorPages.CompiledPageActionDescriptor ActionDescriptor { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override int Count { get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Filters.IAsyncPageFilter Filter { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }

src/Mvc/Mvc.RazorPages/src/Diagnostics/MvcDiagnostics.cs

@@ -4,17 +4,16 @@
 using System;
 using System.Collections.Generic;
 using Microsoft.AspNetCore.Mvc.Filters;
-using Microsoft.AspNetCore.Mvc.RazorPages.Infrastructure;
 using Microsoft.AspNetCore.Mvc.RazorPages;
-using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc.RazorPages.Infrastructure;
 
 namespace Microsoft.AspNetCore.Mvc.Diagnostics
 {
-    public sealed class BeforeHandlerMethod : EventData
+    public sealed class BeforeHandlerMethodEventData : EventData
     {
-        public const string EventName = EventNamespace + nameof(BeforeHandlerMethod);
+        public const string EventName = EventNamespace + "BeforeHandlerMethod";
 
-        public BeforeHandlerMethod(ActionContext actionContext, IReadOnlyDictionary<string, object> arguments, HandlerMethodDescriptor handlerMethodDescriptor, object instance)
+        public BeforeHandlerMethodEventData(ActionContext actionContext, IReadOnlyDictionary<string, object> arguments, HandlerMethodDescriptor handlerMethodDescriptor, object instance)
         {
             ActionContext = actionContext;
             Arguments = arguments;
@@ -39,11 +38,11 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         };
     }
 
-    public sealed class AfterHandlerMethod : EventData
+    public sealed class AfterHandlerMethodEventData : EventData
     {
-        public const string EventName = EventNamespace + nameof(AfterHandlerMethod);
+        public const string EventName = EventNamespace + "AfterHandlerMethod";
 
-        public AfterHandlerMethod(ActionContext actionContext, IReadOnlyDictionary<string, object> arguments, HandlerMethodDescriptor handlerMethodDescriptor, object instance, IActionResult result)
+        public AfterHandlerMethodEventData(ActionContext actionContext, IReadOnlyDictionary<string, object> arguments, HandlerMethodDescriptor handlerMethodDescriptor, object instance, IActionResult result)
         {
             ActionContext = actionContext;
             Arguments = arguments;
@@ -71,11 +70,11 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         };
     }
 
-    public sealed class BeforeOnPageHandlerExecution : EventData
+    public sealed class BeforePageFilterOnPageHandlerExecutionEventData : EventData
     {
-        public const string EventName = EventNamespace + nameof(BeforeOnPageHandlerExecution);
+        public const string EventName = EventNamespace + "BeforeOnPageHandlerExecution";
 
-        public BeforeOnPageHandlerExecution(CompiledPageActionDescriptor actionDescriptor, PageHandlerExecutingContext handlerExecutionContext, IAsyncPageFilter filter)
+        public BeforePageFilterOnPageHandlerExecutionEventData(CompiledPageActionDescriptor actionDescriptor, PageHandlerExecutingContext handlerExecutionContext, IAsyncPageFilter filter)
         {
             ActionDescriptor = actionDescriptor;
             HandlerExecutionContext = handlerExecutionContext;
@@ -97,11 +96,11 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         };
     }
 
-    public sealed class AfterOnPageHandlerExecution : EventData
+    public sealed class AfterPageFilterOnPageHandlerExecutionEventData : EventData
     {
-        public const string EventName = EventNamespace + nameof(AfterOnPageHandlerExecution);
+        public const string EventName = EventNamespace + "AfterOnPageHandlerExecution";
 
-        public AfterOnPageHandlerExecution(CompiledPageActionDescriptor actionDescriptor, PageHandlerExecutedContext handlerExecutedContext, IAsyncPageFilter filter)
+        public AfterPageFilterOnPageHandlerExecutionEventData(CompiledPageActionDescriptor actionDescriptor, PageHandlerExecutedContext handlerExecutedContext, IAsyncPageFilter filter)
         {
             ActionDescriptor = actionDescriptor;
             HandlerExecutedContext = handlerExecutedContext;
@@ -123,11 +122,11 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         };
     }
 
-    public sealed class BeforeOnPageHandlerExecuting : EventData
+    public sealed class BeforePageFilterOnPageHandlerExecutingEventData : EventData
     {
-        public const string EventName = EventNamespace + nameof(BeforeOnPageHandlerExecuting);
+        public const string EventName = EventNamespace + "BeforeOnPageHandlerExecuting";
 
-        public BeforeOnPageHandlerExecuting(CompiledPageActionDescriptor actionDescriptor, PageHandlerExecutingContext handlerExecutingContext, IPageFilter filter)
+        public BeforePageFilterOnPageHandlerExecutingEventData(CompiledPageActionDescriptor actionDescriptor, PageHandlerExecutingContext handlerExecutingContext, IPageFilter filter)
         {
             ActionDescriptor = actionDescriptor;
             HandlerExecutingContext = handlerExecutingContext;
@@ -149,11 +148,11 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         };
     }
 
-    public sealed class AfterOnPageHandlerExecuting : EventData
+    public sealed class AfterPageFilterOnPageHandlerExecutingEventData : EventData
     {
-        public const string EventName = EventNamespace + nameof(AfterOnPageHandlerExecuting);
+        public const string EventName = EventNamespace + "AfterOnPageHandlerExecuting";
 
-        public AfterOnPageHandlerExecuting(CompiledPageActionDescriptor actionDescriptor, PageHandlerExecutingContext handlerExecutingContext, IPageFilter filter)
+        public AfterPageFilterOnPageHandlerExecutingEventData(CompiledPageActionDescriptor actionDescriptor, PageHandlerExecutingContext handlerExecutingContext, IPageFilter filter)
         {
             ActionDescriptor = actionDescriptor;
             HandlerExecutingContext = handlerExecutingContext;
@@ -175,11 +174,11 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         };
     }
 
-    public sealed class BeforeOnPageHandlerExecuted : EventData
+    public sealed class BeforePageFilterOnPageHandlerExecutedEventData : EventData
     {
-        public const string EventName = EventNamespace + nameof(BeforeOnPageHandlerExecuted);
+        public const string EventName = EventNamespace + "BeforeOnPageHandlerExecuted";
 
-        public BeforeOnPageHandlerExecuted(CompiledPageActionDescriptor actionDescriptor, PageHandlerExecutedContext handlerExecutedContext, IPageFilter filter)
+        public BeforePageFilterOnPageHandlerExecutedEventData(CompiledPageActionDescriptor actionDescriptor, PageHandlerExecutedContext handlerExecutedContext, IPageFilter filter)
         {
             ActionDescriptor = actionDescriptor;
             HandlerExecutedContext = handlerExecutedContext;
@@ -201,11 +200,11 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         };
     }
 
-    public sealed class AfterOnPageHandlerExecuted : EventData
+    public sealed class AfterPageFilterOnPageHandlerExecutedEventData : EventData
     {
-        public const string EventName = EventNamespace + nameof(AfterOnPageHandlerExecuted);
+        public const string EventName = EventNamespace + "AfterOnPageHandlerExecuted";
 
-        public AfterOnPageHandlerExecuted(CompiledPageActionDescriptor actionDescriptor, PageHandlerExecutedContext handlerExecutedContext, IPageFilter filter)
+        public AfterPageFilterOnPageHandlerExecutedEventData(CompiledPageActionDescriptor actionDescriptor, PageHandlerExecutedContext handlerExecutedContext, IPageFilter filter)
         {
             ActionDescriptor = actionDescriptor;
             HandlerExecutedContext = handlerExecutedContext;
@@ -227,11 +226,11 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         };
     }
 
-    public sealed class BeforeOnPageHandlerSelection : EventData
+    public sealed class BeforePageFilterOnPageHandlerSelectionEventData : EventData
     {
-        public const string EventName = EventNamespace + nameof(BeforeOnPageHandlerSelection);
+        public const string EventName = EventNamespace + "BeforeOnPageHandlerSelection";
 
-        public BeforeOnPageHandlerSelection(CompiledPageActionDescriptor actionDescriptor, PageHandlerSelectedContext handlerSelectedContext, IAsyncPageFilter filter)
+        public BeforePageFilterOnPageHandlerSelectionEventData(CompiledPageActionDescriptor actionDescriptor, PageHandlerSelectedContext handlerSelectedContext, IAsyncPageFilter filter)
         {
             ActionDescriptor = actionDescriptor;
             HandlerSelectedContext = handlerSelectedContext;
@@ -253,11 +252,11 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         };
     }
 
-    public sealed class AfterOnPageHandlerSelection : EventData
+    public sealed class AfterPageFilterOnPageHandlerSelectionEventData : EventData
     {
-        public const string EventName = EventNamespace + nameof(AfterOnPageHandlerSelection);
+        public const string EventName = EventNamespace + "AfterOnPageHandlerSelection";
 
-        public AfterOnPageHandlerSelection(CompiledPageActionDescriptor actionDescriptor, PageHandlerSelectedContext handlerSelectedContext, IAsyncPageFilter filter)
+        public AfterPageFilterOnPageHandlerSelectionEventData(CompiledPageActionDescriptor actionDescriptor, PageHandlerSelectedContext handlerSelectedContext, IAsyncPageFilter filter)
         {
             ActionDescriptor = actionDescriptor;
             HandlerSelectedContext = handlerSelectedContext;
@@ -279,11 +278,11 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         };
     }
 
-    public sealed class BeforeOnPageHandlerSelected : EventData
+    public sealed class BeforePageFilterOnPageHandlerSelectedEventData : EventData
     {
-        public const string EventName = EventNamespace + nameof(BeforeOnPageHandlerSelected);
+        public const string EventName = EventNamespace + "BeforeOnPageHandlerSelected";
 
-        public BeforeOnPageHandlerSelected(CompiledPageActionDescriptor actionDescriptor, PageHandlerSelectedContext handlerSelectedContext, IPageFilter filter)
+        public BeforePageFilterOnPageHandlerSelectedEventData(CompiledPageActionDescriptor actionDescriptor, PageHandlerSelectedContext handlerSelectedContext, IPageFilter filter)
         {
             ActionDescriptor = actionDescriptor;
             HandlerSelectedContext = handlerSelectedContext;
@@ -305,11 +304,11 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         };
     }
 
-    public sealed class AfterOnPageHandlerSelected : EventData
+    public sealed class AfterPageFilterOnPageHandlerSelectedEventData : EventData
     {
-        public const string EventName = EventNamespace + nameof(AfterOnPageHandlerSelected);
+        public const string EventName = EventNamespace + "AfterOnPageHandlerSelected";
 
-        public AfterOnPageHandlerSelected(CompiledPageActionDescriptor actionDescriptor, PageHandlerSelectedContext handlerSelectedContext, IPageFilter filter)
+        public AfterPageFilterOnPageHandlerSelectedEventData(CompiledPageActionDescriptor actionDescriptor, PageHandlerSelectedContext handlerSelectedContext, IPageFilter filter)
         {
             ActionDescriptor = actionDescriptor;
             HandlerSelectedContext = handlerSelectedContext;

src/Mvc/Mvc.RazorPages/src/MvcRazorPagesDiagnosticListenerExtensions.cs

@@ -33,11 +33,11 @@ namespace Microsoft.AspNetCore.Mvc.RazorPages
 
         private static void BeforeHandlerMethodImpl(DiagnosticListener diagnosticListener, ActionContext actionContext, HandlerMethodDescriptor handlerMethodDescriptor, IReadOnlyDictionary<string, object> arguments, object instance)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.BeforeHandlerMethod.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.BeforeHandlerMethodEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.BeforeHandlerMethod.EventName,
+                    Diagnostics.BeforeHandlerMethodEventData.EventName,
-                    new BeforeHandlerMethod(
+                    new BeforeHandlerMethodEventData(
                         actionContext,
                         arguments,
                         handlerMethodDescriptor,
@@ -69,11 +69,11 @@ namespace Microsoft.AspNetCore.Mvc.RazorPages
 
         private static void AfterHandlerMethodImpl(DiagnosticListener diagnosticListener, ActionContext actionContext, HandlerMethodDescriptor handlerMethodDescriptor, IReadOnlyDictionary<string, object> arguments, object instance, IActionResult result)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.AfterHandlerMethod.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.AfterHandlerMethodEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.AfterHandlerMethod.EventName,
+                    Diagnostics.AfterHandlerMethodEventData.EventName,
-                    new AfterHandlerMethod(
+                    new AfterHandlerMethodEventData(
                         actionContext,
                         arguments,
                         handlerMethodDescriptor,
@@ -101,11 +101,11 @@ namespace Microsoft.AspNetCore.Mvc.RazorPages
 
         private static void BeforeOnPageHandlerExecutionImpl(DiagnosticListener diagnosticListener, PageHandlerExecutingContext handlerExecutionContext, IAsyncPageFilter filter)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.BeforeOnPageHandlerExecution.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.BeforePageFilterOnPageHandlerExecutionEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.BeforeOnPageHandlerExecution.EventName,
+                    Diagnostics.BeforePageFilterOnPageHandlerExecutionEventData.EventName,
-                    new BeforeOnPageHandlerExecution(
+                    new BeforePageFilterOnPageHandlerExecutionEventData(
                         handlerExecutionContext.ActionDescriptor,
                         handlerExecutionContext,
                         filter
@@ -131,11 +131,11 @@ namespace Microsoft.AspNetCore.Mvc.RazorPages
 
         private static void AfterOnPageHandlerExecutionImpl(DiagnosticListener diagnosticListener, PageHandlerExecutedContext handlerExecutedContext, IAsyncPageFilter filter)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.AfterOnPageHandlerExecution.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.AfterPageFilterOnPageHandlerExecutionEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.AfterOnPageHandlerExecution.EventName,
+                    Diagnostics.AfterPageFilterOnPageHandlerExecutionEventData.EventName,
-                    new AfterOnPageHandlerExecution(
+                    new AfterPageFilterOnPageHandlerExecutionEventData(
                         handlerExecutedContext.ActionDescriptor,
                         handlerExecutedContext,
                         filter
@@ -161,11 +161,11 @@ namespace Microsoft.AspNetCore.Mvc.RazorPages
 
         private static void BeforeOnPageHandlerExecutingImpl(DiagnosticListener diagnosticListener, PageHandlerExecutingContext handlerExecutingContext, IPageFilter filter)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.BeforeOnPageHandlerExecuting.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.BeforePageFilterOnPageHandlerExecutingEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.BeforeOnPageHandlerExecuting.EventName,
+                    Diagnostics.BeforePageFilterOnPageHandlerExecutingEventData.EventName,
-                    new BeforeOnPageHandlerExecuting(
+                    new BeforePageFilterOnPageHandlerExecutingEventData(
                         handlerExecutingContext.ActionDescriptor,
                         handlerExecutingContext,
                         filter
@@ -191,11 +191,11 @@ namespace Microsoft.AspNetCore.Mvc.RazorPages
 
         private static void AfterOnPageHandlerExecutingImpl(DiagnosticListener diagnosticListener, PageHandlerExecutingContext handlerExecutingContext, IPageFilter filter)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.AfterOnPageHandlerExecuting.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.AfterPageFilterOnPageHandlerExecutingEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.AfterOnPageHandlerExecuting.EventName,
+                    Diagnostics.AfterPageFilterOnPageHandlerExecutingEventData.EventName,
-                    new AfterOnPageHandlerExecuting(
+                    new AfterPageFilterOnPageHandlerExecutingEventData(
                         handlerExecutingContext.ActionDescriptor,
                         handlerExecutingContext,
                         filter
@@ -221,11 +221,11 @@ namespace Microsoft.AspNetCore.Mvc.RazorPages
 
         private static void BeforeOnPageHandlerExecutedImpl(DiagnosticListener diagnosticListener, PageHandlerExecutedContext handlerExecutedContext, IPageFilter filter)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.BeforeOnPageHandlerExecuted.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.BeforePageFilterOnPageHandlerExecutedEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.BeforeOnPageHandlerExecuted.EventName,
+                    Diagnostics.BeforePageFilterOnPageHandlerExecutedEventData.EventName,
-                    new BeforeOnPageHandlerExecuted(
+                    new BeforePageFilterOnPageHandlerExecutedEventData(
                         handlerExecutedContext.ActionDescriptor,
                         handlerExecutedContext,
                         filter
@@ -251,11 +251,11 @@ namespace Microsoft.AspNetCore.Mvc.RazorPages
 
         private static void AfterOnPageHandlerExecutedImpl(DiagnosticListener diagnosticListener, PageHandlerExecutedContext handlerExecutedContext, IPageFilter filter)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.AfterOnPageHandlerExecuted.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.AfterPageFilterOnPageHandlerExecutedEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.AfterOnPageHandlerExecuted.EventName,
+                    Diagnostics.AfterPageFilterOnPageHandlerExecutedEventData.EventName,
-                    new AfterOnPageHandlerExecuted(
+                    new AfterPageFilterOnPageHandlerExecutedEventData(
                         handlerExecutedContext.ActionDescriptor,
                         handlerExecutedContext,
                         filter
@@ -281,11 +281,11 @@ namespace Microsoft.AspNetCore.Mvc.RazorPages
 
         private static void BeforeOnPageHandlerSelectionImpl(DiagnosticListener diagnosticListener, PageHandlerSelectedContext handlerSelectedContext, IAsyncPageFilter filter)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.BeforeOnPageHandlerSelection.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.BeforePageFilterOnPageHandlerSelectionEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.BeforeOnPageHandlerSelection.EventName,
+                    Diagnostics.BeforePageFilterOnPageHandlerSelectionEventData.EventName,
-                    new BeforeOnPageHandlerSelection(
+                    new BeforePageFilterOnPageHandlerSelectionEventData(
                         handlerSelectedContext.ActionDescriptor,
                         handlerSelectedContext,
                         filter
@@ -311,11 +311,11 @@ namespace Microsoft.AspNetCore.Mvc.RazorPages
 
         private static void AfterOnPageHandlerSelectionImpl(DiagnosticListener diagnosticListener, PageHandlerSelectedContext handlerSelectedContext, IAsyncPageFilter filter)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.AfterOnPageHandlerSelection.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.AfterPageFilterOnPageHandlerSelectionEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.AfterOnPageHandlerSelection.EventName,
+                    Diagnostics.AfterPageFilterOnPageHandlerSelectionEventData.EventName,
-                    new AfterOnPageHandlerSelection(
+                    new AfterPageFilterOnPageHandlerSelectionEventData(
                         handlerSelectedContext.ActionDescriptor,
                         handlerSelectedContext,
                         filter
@@ -341,11 +341,11 @@ namespace Microsoft.AspNetCore.Mvc.RazorPages
 
         private static void BeforeOnPageHandlerSelectedImpl(DiagnosticListener diagnosticListener, PageHandlerSelectedContext handlerSelectedContext, IPageFilter filter)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.BeforeOnPageHandlerSelected.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.BeforePageFilterOnPageHandlerSelectedEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.BeforeOnPageHandlerSelected.EventName,
+                    Diagnostics.BeforePageFilterOnPageHandlerSelectedEventData.EventName,
-                    new BeforeOnPageHandlerSelected(
+                    new BeforePageFilterOnPageHandlerSelectedEventData(
                         handlerSelectedContext.ActionDescriptor,
                         handlerSelectedContext,
                         filter
@@ -371,11 +371,11 @@ namespace Microsoft.AspNetCore.Mvc.RazorPages
 
         private static void AfterOnPageHandlerSelectedImpl(DiagnosticListener diagnosticListener, PageHandlerSelectedContext handlerSelectedContext, IPageFilter filter)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.AfterOnPageHandlerSelected.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.AfterPageFilterOnPageHandlerSelectedEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.AfterOnPageHandlerSelected.EventName,
+                    Diagnostics.AfterPageFilterOnPageHandlerSelectedEventData.EventName,
-                    new AfterOnPageHandlerSelected(
+                    new AfterPageFilterOnPageHandlerSelectedEventData(
                         handlerSelectedContext.ActionDescriptor,
                         handlerSelectedContext,
                         filter

src/Mvc/Mvc.ViewFeatures/ref/Microsoft.AspNetCore.Mvc.ViewFeatures.netcoreapp3.0.cs

@@ -215,19 +215,10 @@ namespace Microsoft.AspNetCore.Mvc
 }
 namespace Microsoft.AspNetCore.Mvc.Diagnostics
 {
-    public sealed partial class AfterView : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    public sealed partial class AfterViewComponentEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
-    {
-        public const string EventName = "Microsoft.AspNetCore.Mvc.AfterView";
-        public AfterView(Microsoft.AspNetCore.Mvc.ViewEngines.IView view, Microsoft.AspNetCore.Mvc.Rendering.ViewContext viewContext) { }
-        protected override int Count { get { throw null; } }
-        protected override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
-        public Microsoft.AspNetCore.Mvc.ViewEngines.IView View { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
-        public Microsoft.AspNetCore.Mvc.Rendering.ViewContext ViewContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
-    }
-    public sealed partial class AfterViewComponent : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
     {
         public const string EventName = "Microsoft.AspNetCore.Mvc.AfterViewComponent";
-        public AfterViewComponent(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.ViewComponents.ViewComponentContext viewComponentContext, Microsoft.AspNetCore.Mvc.IViewComponentResult viewComponentResult, object viewComponent) { }
+        public AfterViewComponentEventData(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.ViewComponents.ViewComponentContext viewComponentContext, Microsoft.AspNetCore.Mvc.IViewComponentResult viewComponentResult, object viewComponent) { }
         public Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor ActionDescriptor { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override int Count { get { throw null; } }
         protected override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
@@ -235,49 +226,58 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         public Microsoft.AspNetCore.Mvc.ViewComponents.ViewComponentContext ViewComponentContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         public Microsoft.AspNetCore.Mvc.IViewComponentResult ViewComponentResult { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
     }
-    public sealed partial class BeforeView : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    public sealed partial class AfterViewEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
     {
-        public const string EventName = "Microsoft.AspNetCore.Mvc.BeforeView";
+        public const string EventName = "Microsoft.AspNetCore.Mvc.AfterView";
-        public BeforeView(Microsoft.AspNetCore.Mvc.ViewEngines.IView view, Microsoft.AspNetCore.Mvc.Rendering.ViewContext viewContext) { }
+        public AfterViewEventData(Microsoft.AspNetCore.Mvc.ViewEngines.IView view, Microsoft.AspNetCore.Mvc.Rendering.ViewContext viewContext) { }
         protected override int Count { get { throw null; } }
         protected override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
         public Microsoft.AspNetCore.Mvc.ViewEngines.IView View { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         public Microsoft.AspNetCore.Mvc.Rendering.ViewContext ViewContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
     }
-    public sealed partial class BeforeViewComponent : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    public sealed partial class BeforeViewComponentEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
     {
         public const string EventName = "Microsoft.AspNetCore.Mvc.BeforeViewComponent";
-        public BeforeViewComponent(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.ViewComponents.ViewComponentContext viewComponentContext, object viewComponent) { }
+        public BeforeViewComponentEventData(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.ViewComponents.ViewComponentContext viewComponentContext, object viewComponent) { }
         public Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor ActionDescriptor { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override int Count { get { throw null; } }
         protected override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
         public object ViewComponent { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         public Microsoft.AspNetCore.Mvc.ViewComponents.ViewComponentContext ViewComponentContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
     }
-    public sealed partial class ViewComponentAfterViewExecute : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    public sealed partial class BeforeViewEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    {
+        public const string EventName = "Microsoft.AspNetCore.Mvc.BeforeView";
+        public BeforeViewEventData(Microsoft.AspNetCore.Mvc.ViewEngines.IView view, Microsoft.AspNetCore.Mvc.Rendering.ViewContext viewContext) { }
+        protected override int Count { get { throw null; } }
+        protected override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
+        public Microsoft.AspNetCore.Mvc.ViewEngines.IView View { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
+        public Microsoft.AspNetCore.Mvc.Rendering.ViewContext ViewContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
+    }
+    public sealed partial class ViewComponentAfterViewExecuteEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
     {
         public const string EventName = "Microsoft.AspNetCore.Mvc.ViewComponentAfterViewExecute";
-        public ViewComponentAfterViewExecute(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.ViewComponents.ViewComponentContext viewComponentContext, Microsoft.AspNetCore.Mvc.ViewEngines.IView view) { }
+        public ViewComponentAfterViewExecuteEventData(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.ViewComponents.ViewComponentContext viewComponentContext, Microsoft.AspNetCore.Mvc.ViewEngines.IView view) { }
         public Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor ActionDescriptor { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override int Count { get { throw null; } }
         protected override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
         public Microsoft.AspNetCore.Mvc.ViewEngines.IView View { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         public Microsoft.AspNetCore.Mvc.ViewComponents.ViewComponentContext ViewComponentContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
     }
-    public sealed partial class ViewComponentBeforeViewExecute : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    public sealed partial class ViewComponentBeforeViewExecuteEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
     {
         public const string EventName = "Microsoft.AspNetCore.Mvc.ViewComponentBeforeViewExecute";
-        public ViewComponentBeforeViewExecute(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.ViewComponents.ViewComponentContext viewComponentContext, Microsoft.AspNetCore.Mvc.ViewEngines.IView view) { }
+        public ViewComponentBeforeViewExecuteEventData(Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor actionDescriptor, Microsoft.AspNetCore.Mvc.ViewComponents.ViewComponentContext viewComponentContext, Microsoft.AspNetCore.Mvc.ViewEngines.IView view) { }
         public Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor ActionDescriptor { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override int Count { get { throw null; } }
         protected override System.Collections.Generic.KeyValuePair<string, object> this[int index] { get { throw null; } }
         public Microsoft.AspNetCore.Mvc.ViewEngines.IView View { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         public Microsoft.AspNetCore.Mvc.ViewComponents.ViewComponentContext ViewComponentContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
     }
-    public sealed partial class ViewFound : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    public sealed partial class ViewFoundEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
     {
         public const string EventName = "Microsoft.AspNetCore.Mvc.ViewFound";
-        public ViewFound(Microsoft.AspNetCore.Mvc.ActionContext actionContext, bool isMainPage, Microsoft.AspNetCore.Mvc.ActionResult result, string viewName, Microsoft.AspNetCore.Mvc.ViewEngines.IView view) { }
+        public ViewFoundEventData(Microsoft.AspNetCore.Mvc.ActionContext actionContext, bool isMainPage, Microsoft.AspNetCore.Mvc.ActionResult result, string viewName, Microsoft.AspNetCore.Mvc.ViewEngines.IView view) { }
         public Microsoft.AspNetCore.Mvc.ActionContext ActionContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override int Count { get { throw null; } }
         public bool IsMainPage { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
@@ -286,10 +286,10 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         public Microsoft.AspNetCore.Mvc.ViewEngines.IView View { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         public string ViewName { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
     }
-    public sealed partial class ViewNotFound : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
+    public sealed partial class ViewNotFoundEventData : Microsoft.AspNetCore.Mvc.Diagnostics.EventData
     {
         public const string EventName = "Microsoft.AspNetCore.Mvc.ViewNotFound";
-        public ViewNotFound(Microsoft.AspNetCore.Mvc.ActionContext actionContext, bool isMainPage, Microsoft.AspNetCore.Mvc.ActionResult result, string viewName, System.Collections.Generic.IEnumerable<string> searchedLocations) { }
+        public ViewNotFoundEventData(Microsoft.AspNetCore.Mvc.ActionContext actionContext, bool isMainPage, Microsoft.AspNetCore.Mvc.ActionResult result, string viewName, System.Collections.Generic.IEnumerable<string> searchedLocations) { }
         public Microsoft.AspNetCore.Mvc.ActionContext ActionContext { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         protected override int Count { get { throw null; } }
         public bool IsMainPage { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }

src/Mvc/Mvc.ViewFeatures/src/Diagnostics/MvcDiagnostics.cs

@@ -10,11 +10,11 @@ using Microsoft.AspNetCore.Mvc.ViewEngines;
 
 namespace Microsoft.AspNetCore.Mvc.Diagnostics
 {
-    public sealed class BeforeViewComponent : EventData
+    public sealed class BeforeViewComponentEventData : EventData
     {
-        public const string EventName = EventNamespace + nameof(BeforeViewComponent);
+        public const string EventName = EventNamespace + "BeforeViewComponent";
 
-        public BeforeViewComponent(ActionDescriptor actionDescriptor, ViewComponentContext viewComponentContext, object viewComponent)
+        public BeforeViewComponentEventData(ActionDescriptor actionDescriptor, ViewComponentContext viewComponentContext, object viewComponent)
         {
             ActionDescriptor = actionDescriptor;
             ViewComponentContext = viewComponentContext;
@@ -36,11 +36,11 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         };
     }
 
-    public sealed class AfterViewComponent : EventData
+    public sealed class AfterViewComponentEventData : EventData
     {
-        public const string EventName = EventNamespace + nameof(AfterViewComponent);
+        public const string EventName = EventNamespace + "AfterViewComponent";
 
-        public AfterViewComponent(ActionDescriptor actionDescriptor, ViewComponentContext viewComponentContext, IViewComponentResult viewComponentResult, object viewComponent)
+        public AfterViewComponentEventData(ActionDescriptor actionDescriptor, ViewComponentContext viewComponentContext, IViewComponentResult viewComponentResult, object viewComponent)
         {
             ActionDescriptor = actionDescriptor;
             ViewComponentContext = viewComponentContext;
@@ -65,11 +65,11 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         };
     }
 
-    public sealed class ViewComponentBeforeViewExecute : EventData
+    public sealed class ViewComponentBeforeViewExecuteEventData : EventData
     {
-        public const string EventName = EventNamespace + nameof(ViewComponentBeforeViewExecute);
+        public const string EventName = EventNamespace + "ViewComponentBeforeViewExecute";
 
-        public ViewComponentBeforeViewExecute(ActionDescriptor actionDescriptor, ViewComponentContext viewComponentContext, IView view)
+        public ViewComponentBeforeViewExecuteEventData(ActionDescriptor actionDescriptor, ViewComponentContext viewComponentContext, IView view)
         {
             ActionDescriptor = actionDescriptor;
             ViewComponentContext = viewComponentContext;
@@ -90,11 +90,11 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         };
     }
 
-    public sealed class ViewComponentAfterViewExecute : EventData
+    public sealed class ViewComponentAfterViewExecuteEventData : EventData
     {
-        public const string EventName = EventNamespace + nameof(ViewComponentAfterViewExecute);
+        public const string EventName = EventNamespace + "ViewComponentAfterViewExecute";
 
-        public ViewComponentAfterViewExecute(ActionDescriptor actionDescriptor, ViewComponentContext viewComponentContext, IView view)
+        public ViewComponentAfterViewExecuteEventData(ActionDescriptor actionDescriptor, ViewComponentContext viewComponentContext, IView view)
         {
             ActionDescriptor = actionDescriptor;
             ViewComponentContext = viewComponentContext;
@@ -116,11 +116,11 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         };
     }
 
-    public sealed class BeforeView : EventData
+    public sealed class BeforeViewEventData : EventData
     {
-        public const string EventName = EventNamespace + nameof(BeforeView);
+        public const string EventName = EventNamespace + "BeforeView";
 
-        public BeforeView(IView view, ViewContext viewContext)
+        public BeforeViewEventData(IView view, ViewContext viewContext)
         {
             View = view;
             ViewContext = viewContext;
@@ -139,11 +139,11 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         };
     }
 
-    public sealed class AfterView : EventData
+    public sealed class AfterViewEventData : EventData
     {
-        public const string EventName = EventNamespace + nameof(AfterView);
+        public const string EventName = EventNamespace + "AfterView";
 
-        public AfterView(IView view, ViewContext viewContext)
+        public AfterViewEventData(IView view, ViewContext viewContext)
         {
             View = view;
             ViewContext = viewContext;
@@ -162,11 +162,11 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         };
     }
 
-    public sealed class ViewFound : EventData
+    public sealed class ViewFoundEventData : EventData
     {
-        public const string EventName = EventNamespace + nameof(ViewFound);
+        public const string EventName = EventNamespace + "ViewFound";
 
-        public ViewFound(ActionContext actionContext, bool isMainPage, ActionResult result, string viewName, IView view)
+        public ViewFoundEventData(ActionContext actionContext, bool isMainPage, ActionResult result, string viewName, IView view)
         {
             ActionContext = actionContext;
             IsMainPage = isMainPage;
@@ -194,11 +194,11 @@ namespace Microsoft.AspNetCore.Mvc.Diagnostics
         };
     }
 
-    public sealed class ViewNotFound : EventData
+    public sealed class ViewNotFoundEventData : EventData
     {
-        public const string EventName = EventNamespace + nameof(ViewNotFound);
+        public const string EventName = EventNamespace + "ViewNotFound";
 
-        public ViewNotFound(ActionContext actionContext, bool isMainPage, ActionResult result, string viewName, IEnumerable<string> searchedLocations)
+        public ViewNotFoundEventData(ActionContext actionContext, bool isMainPage, ActionResult result, string viewName, IEnumerable<string> searchedLocations)
         {
             ActionContext = actionContext;
             IsMainPage = isMainPage;

src/Mvc/Mvc.ViewFeatures/src/MvcViewFeaturesDiagnosticListenerExtensions.cs

@@ -26,11 +26,11 @@ namespace Microsoft.AspNetCore.Mvc.ViewFeatures
 
         private static void BeforeViewComponentImpl(DiagnosticListener diagnosticListener, ViewComponentContext context, object viewComponent)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.BeforeViewComponent.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.BeforeViewComponentEventData.EventName))
             {
                 diagnosticListener.Write(
-                Diagnostics.BeforeViewComponent.EventName,
+                Diagnostics.BeforeViewComponentEventData.EventName,
-                new BeforeViewComponent(
+                new BeforeViewComponentEventData(
                     context.ViewContext.ActionDescriptor,
                     context,
                     viewComponent
@@ -53,11 +53,11 @@ namespace Microsoft.AspNetCore.Mvc.ViewFeatures
 
         private static void AfterViewComponentImpl(DiagnosticListener diagnosticListener, ViewComponentContext context, IViewComponentResult result, object viewComponent)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.AfterViewComponent.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.AfterViewComponentEventData.EventName))
             {
                 diagnosticListener.Write(
-                Diagnostics.AfterViewComponent.EventName,
+                Diagnostics.AfterViewComponentEventData.EventName,
-                new AfterViewComponent(
+                new AfterViewComponentEventData(
                     context.ViewContext.ActionDescriptor,
                     context,
                     result,
@@ -80,11 +80,11 @@ namespace Microsoft.AspNetCore.Mvc.ViewFeatures
 
         private static void ViewComponentBeforeViewExecuteImpl(DiagnosticListener diagnosticListener, ViewComponentContext context, IView view)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.ViewComponentBeforeViewExecute.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.ViewComponentBeforeViewExecuteEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.ViewComponentBeforeViewExecute.EventName,
+                    Diagnostics.ViewComponentBeforeViewExecuteEventData.EventName,
-                    new ViewComponentBeforeViewExecute(
+                    new ViewComponentBeforeViewExecuteEventData(
                         context.ViewContext.ActionDescriptor,
                         context,
                         view
@@ -106,11 +106,11 @@ namespace Microsoft.AspNetCore.Mvc.ViewFeatures
 
         private static void ViewComponentAfterViewExecuteImpl(DiagnosticListener diagnosticListener, ViewComponentContext context, IView view)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.ViewComponentAfterViewExecute.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.ViewComponentAfterViewExecuteEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.ViewComponentAfterViewExecute.EventName,
+                    Diagnostics.ViewComponentAfterViewExecuteEventData.EventName,
-                    new ViewComponentAfterViewExecute(
+                    new ViewComponentAfterViewExecuteEventData(
                         context.ViewContext.ActionDescriptor,
                         context,
                         view
@@ -132,11 +132,11 @@ namespace Microsoft.AspNetCore.Mvc.ViewFeatures
 
         private static void BeforeViewImpl(DiagnosticListener diagnosticListener, IView view, ViewContext viewContext)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.BeforeView.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.BeforeViewEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.BeforeView.EventName,
+                    Diagnostics.BeforeViewEventData.EventName,
-                    new BeforeView(view, viewContext));
+                    new BeforeViewEventData(view, viewContext));
             }
         }
 
@@ -154,11 +154,11 @@ namespace Microsoft.AspNetCore.Mvc.ViewFeatures
 
         private static void AfterViewImpl(DiagnosticListener diagnosticListener, IView view, ViewContext viewContext)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.AfterView.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.AfterViewEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.AfterView.EventName,
+                    Diagnostics.AfterViewEventData.EventName,
-                    new AfterView(view, viewContext));
+                    new AfterViewEventData(view, viewContext));
             }
         }
 
@@ -179,11 +179,11 @@ namespace Microsoft.AspNetCore.Mvc.ViewFeatures
 
         private static void ViewFoundImpl(DiagnosticListener diagnosticListener, ActionContext actionContext, bool isMainPage, ActionResult viewResult, string viewName, IView view)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.ViewFound.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.ViewFoundEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.ViewFound.EventName,
+                    Diagnostics.ViewFoundEventData.EventName,
-                    new ViewFound(
+                    new ViewFoundEventData(
                         actionContext,
                         isMainPage,
                         viewResult,
@@ -210,11 +210,11 @@ namespace Microsoft.AspNetCore.Mvc.ViewFeatures
 
         private static void ViewNotFoundImpl(DiagnosticListener diagnosticListener, ActionContext actionContext, bool isMainPage, ActionResult viewResult, string viewName, IEnumerable<string> searchedLocations)
         {
-            if (diagnosticListener.IsEnabled(Diagnostics.ViewNotFound.EventName))
+            if (diagnosticListener.IsEnabled(Diagnostics.ViewNotFoundEventData.EventName))
             {
                 diagnosticListener.Write(
-                    Diagnostics.ViewNotFound.EventName,
+                    Diagnostics.ViewNotFoundEventData.EventName,
-                    new ViewNotFound(
+                    new ViewNotFoundEventData(
                         actionContext,
                         isMainPage,
                         viewResult,