análisis de código núcleo mvc 3.1 fuente asp.net (d)

AuthorizationApplicationModelProvider

Esto es potencialmente añadir filtros de autorización y autenticación

Buscar propiedades primeros lograron IAuthorizeData de controlador y la acción, y luego crear un filtro basado en IAuthorizeData AuthorizeFilter, añadiendo AuthorizeFilter a la lista de filtros en el controlador y la acción

Específicamente hablando detrás de lógica de autorización separado

interna  de clase AuthorizationApplicationModelProvider: IApplicationModelProvider 
    { 
        privados  de sólo lectura MvcOptions _mvcOptions;
        privada  de sólo lectura _policyProvider IAuthorizationPolicyProvider; 

        público AuthorizationApplicationModelProvider ( 
            IAuthorizationPolicyProvider policyProvider, 
            iOptions <MvcOptions> mvcOptions) 
        { 
            _policyProvider = policyProvider; 
            _mvcOptions = mvcOptions.Value; 
        } 

        Pública  int pedido => - 1000 +10 ; 

        pública  vacío OnProvidersExecuted (contexto ApplicationModelProviderContext) 
        { 
            // intencionalmente vacía. 
        } 

        Pública  vacío OnProvidersExecuting (contexto ApplicationModelProviderContext) 
        { 
            si (== contexto nulo ) 
            { 
                lanzar  nuevos ArgumentNullException (nombredel (contexto)); 
            } 

            Si (_mvcOptions.EnableEndpointRouting) 
            { 
                // Cuando se utiliza el enrutamiento de punto final, la AuthorizationMiddleware hace el trabajo que los filtros Auth sería ejecuten en cualquier forma.
                //En consecuencia, no necesitamos a los atributos de autorización convertir a los filtros. 
                volver ; 
            } 

            Foreach ( var controllerModel en context.Result.Controllers) 
            { 
                var controllerModelAuthData = controllerModel.Attributes.OfType <IAuthorizeData> () .ToArray ();
                si (controllerModelAuthData.Length> 0 ) 
                { 
                    controllerModel.Filters.Add (getFilter (_policyProvider, controllerModelAuthData)); 
                } 
                Foreach ( var atributo encontrollerModel.Attributes.OfType <IAllowAnonymous> ()) 
                { 
                    controllerModel.Filters.Add ( nuevo AllowAnonymousFilter ()); 
                } 

                Foreach ( var actionModel en controllerModel.Actions) 
                { 
                    var actionModelAuthData = actionModel.Attributes.OfType <IAuthorizeData> () .ToArray ();
                    si (actionModelAuthData.Length> 0 ) 
                    { 
                        actionModel.Filters.Add (getFilter (_policyProvider, actionModelAuthData)); 
                    } 

                    foreach( Var atributo en actionModel.Attributes.OfType <IAllowAnonymous> ()) 
                    { 
                        actionModel.Filters.Add ( nuevo AllowAnonymousFilter ()); 
                    } 
                } 
            } 
        } 

        Pública  estática AuthorizeFilter getFilter (IAuthorizationPolicyProvider policyProvider, IEnumerable <IAuthorizeData> authData) 
        { 
            // El proveedor de política por defecto hará que la misma política de entrada dada, de modo que sea sólo una vez.
            // Esto siempre se ejecutará de forma sincrónica. 
            Si(policyProvider.GetType () == typeof (DefaultAuthorizationPolicyProvider)) 
            { 
                var política = AuthorizationPolicy.CombineAsync (policyProvider, authData) .GetAwaiter () GetResult ().;
                volver  nueva AuthorizeFilter (política); 
            } 
            Demás 
            { 
                devolver  nueva AuthorizeFilter (policyProvider, authData); 
            } 
        } 
    }

 

ApiBehaviorApplicationModelProvider

interna  de clase ApiBehaviorApplicationModelProvider: IApplicationModelProvider 
    { 
        público ApiBehaviorApplicationModelProvider ( 
            iOptions <ApiBehaviorOptions> apiBehaviorOptions, 
            IModelMetadataProvider modelMetadataProvider, 
            IClientErrorFactory clientErrorFactory, 
            ILoggerFactory loggerFactory) 
        { 
            var options = apiBehaviorOptions.Value; 

            ActionModelConventions = nueva lista <IActionModelConvention> () 
            { 
                nueva ApiVisibilityConvention (), 
            }; 

            Si(! Options.SuppressMapClientErrors) 
            { 
                ActionModelConventions.Add ( nueva ClientErrorResultFilterConvention ()); 
            } 

            Si (! Options.SuppressModelStateInvalidFilter) 
            { 
                ActionModelConventions.Add ( nueva InvalidModelStateFilterConvention ()); 
            } 

            Si (! Options.SuppressConsumesConstraintForFormFileParameters) 
            { 
                ActionModelConventions.Add ( nueva ConsumesConstraintForFormFileParameterConvention ()); 
            } 

            vardefaultErrorType = options.SuppressMapClientErrors? typeof ( void ): typeof (ProblemDetails);
            var defaultErrorTypeAttribute = nuevo ProducesErrorResponseTypeAttribute (defaultErrorType); 
            ActionModelConventions.Add ( nuevo ApiConventionApplicationModelConvention (defaultErrorTypeAttribute)); 

            si (! options.SuppressInferBindingSourcesForParameters) 
            { 
                ActionModelConventions.Add ( nueva InferParameterBindingInfoConvention (modelMetadataProvider)); 
            } 
        } 

        ///  <observaciones> 
        ///El orden se establece para ejecutar después de la <ver CREF = "DefaultApplicationModelProvider" /> y permitir a cualquier otro usuario
         ///  <ver CREF = "IApplicationModelProvider" /> que configurar el enrutamiento de ejecutar.
        ///  </ observaciones> 
        pública  int pedido => - 1000 + 100 ; 

        pública Lista <IActionModelConvention> ActionModelConventions { llegar ; } 

        Pública  vacío (contexto ApplicationModelProviderContext) OnProvidersExecuted 
        { 
        } 

        pública  vacío OnProvidersExecuting (contexto ApplicationModelProviderContext) 
        {
            foreach ( var controlador en context.Result.Controllers) 
            { 
                si (! IsApiController (controlador)) 
                { 
                    continúe ; 
                } 

                Foreach ( var acción en controller.Actions) 
                { 
                    // Asegúrese ApiController está configurado correctamente 
                    EnsureActionIsAttributeRouted (acción); 

                    foreach ( var convención en ActionModelConventions) 
                    { 
                        convention.Apply (acción);
                    }  
                }
            } 
        } 

        Privada  estática  vacío EnsureActionIsAttributeRouted (ActionModel actionModel) 
        { 
            si (! IsAttributeRouted (actionModel.Controller.Selectors) && 
                ! IsAttributeRouted (actionModel.Selectors)) 
            { 
                // Requerir atributo de enrutamiento con los controladores con anotada ApiControllerAttribute 
                var message = Resources.FormatApiController_AttributeRouteRequired ( 
                     actionModel.DisplayName, 
                    nombredel (ApiControllerAttribute)); 
                arrojar  nueva InvalidOperationException (mensaje);
            }

             bool IsAttributeRouted (IList <SelectorModel> selectorModel) 
            { 
                a ( var i = 0 ; i <selectorModel.Count; i ++ ) 
                { 
                    si (! SelectorModel [i] = .AttributeRouteModel nula ) 
                    { 
                        regrese  verdadera ; 
                    } 
                } 

                Volver  falsa ; 
            } 
        } 

        Privada  estática  bool IsApiController (controlador ControllerModel) 
        { 
            si (controller.Attributes.OfType <IApiBehaviorMetadata>() .Cualquier ()) 
            { 
                retorno  verdadera ; 
            } 

            Var controllerAssembly = controller.ControllerType.Assembly;
            var assemblyAttributes = controllerAssembly.GetCustomAttributes ();
            retorno assemblyAttributes.OfType <IApiBehaviorMetadata> () .Cualquier (); 
        } 
    }

Esta clase implica aspectos WebAPI

 

 ActionModel conjunto de filtros y propiedades relacionadas