Please enable JavaScript.

Coggle requires JavaScript to display documents.

ASP.NET Core (Razor Pages Is a new aspect of ASP.NET Core MVC that makes…

- - - - Makes the file into an MVC action
      - It handles requests directly, without going through a controller
      - Must be the first directive on a page
      - Custom routes
        
        Specify a custom route to a page with @page "/Some/Other/Path"
        
        Append segments to page's default route with @page "item"
        
        Append parameters to a page's default route. For example, an ID parameter, id, can be required for a page with @page "{id}"
        
        You don't like the query string ?handler=JoinList. You can customize the route by adding a route template with @page "{handler?}"
        The ? following handler means the route parameter is optional
  - - - OnGet
      - OnPost
      - OnPostAsync
      - OnGetAsync
      - OnPostDelete
      - OnPostDeleteAsync
      - OnHead
      - OnPut
      - OnPutAsync
      - OnPatch
      - OnPatchAsync
      - OnDelete
      - OnDeleteAsync
  - - - Controls the layout of each page (unless the page opts out of layout)
      - Imports HTML structures such as JavaScript and stylesheets
  - - - Can be used to add log, authorize logic and so on
- - - - View
        
        Include just the data the View requires to display or sending banck to server
      - Binding
        
        Typically just data container. Its a safe way to collect data from the user
      - API
        
        Expose a data to client maybe different from domain data. It helps separete scopes, and cause less impact to clients consuming the API data types. You can change your under layer safelly.
      - Persistence
        
        Maybe useful to separate domain data in different data models, which encapsulate specific business logic
      - Domain
        
        Encapsulate complex business logic, making easy to uint tests. Expose a way to hande states by the view, controller and even services.
  - - - Order of binding
        
        Form value
        
        Route value
        
        Query value
        All stored as name-value paris
        
        Model validation
        
        Abstracted validation inboth side: server and client
        
        Validation attributes
        
        Model state
        Represents validation erros in submitted HTML form values
        
        Cutom Validation
        Inherit ValidationAttribute
        
        Attribute: general porpose
        Override: IsValid
        
        Model: class porpose
        Override: Validate
        
        Client Validation
        
        Remote Validation
        Operate custom validations while user is fulfiling the form
      - Special cases
        
        IFormFile,
        IEnumerable<IFormaFile>,
        CacelationToken
    - - Tag Helpers
        Enable server-side code to participate in creating and rendering HTML elements in Razor files
        
        Why?
        
        IntelliSense support for Tag Helpers
        
        More productive
        
        Produce more robust, reliable, and maintainable code using information only available on the server
        
        Directives
        
        addTagHelper - makes Tag Helpers available
        
        removeTagHelper - remove the Tag Helpers
        
        Scope additive
        
        tagHelperPrefix - to make Tag Helper usage explicit
        Tag Helper will be available just in elements with the prefix
        
        Opting out - disable Tag Helper at the element level
        <!span asp-validation-for="Email" class="text-danger"></!span>
        
        Create Tag Helpers
        
        Use Tag Helpers in forms #
        
        Do not use ViewBag or ViewData with Select Tag Helper; use a View Model for robustness
      - View components
        are similar to partial views in that they allow you to reduce repetitive code, but they're appropriate for view content that requires code to run on the server in order to render the webpage
        
        Also work with Razor Pages #
        
        Why?
        
        Renders a chunk rather than a whole response
        
        Includes the same sepration-of-concerns and testability benefits found between a controller and a view
        
        Can have parameters and business logic
        
        Is typically invoked from a layout page
        
        Does not take part in the controller lifecycle, which means you can't use filters in the view component
        
        View search path
        
        /Pages/Components//<view_name>
        
        Views/<controller_name>/Components/<view_component_name>/<view_name>
        
        Views/Shared/Components/<view_component_name>/<view_name>
      - Razor View Engine
        
        Directives
        
        using
        
        model
        
        inherits
        
        inject
        
        functions
        
        sections
      - Layouts
        provide consistent webpage sections and reduce code repetition
        
        RenderBody() - directive of Layout, renders the content of the view. Every Layout must call RenderBody
        
        Directives shared by many Views
        May be specified in a common _ViewImports.cshtml. Support some directives # # # # # # #
        
        Share Directive Rules
        
        addTagHelper, removeTagHelper: all run, in order
        
        tagHelperPrefix: the closest one to the view overrides any others
        
        model: the closest one to the view overrides any others
        
        inherits: the closest one to the view overrides any others
        
        using: all are included; duplicates are ignored
        
        inject: for each property, the closest one to the view overrides any others with the same property name
        
        Running code before each View
        This should be placed in the _ViewStart.cshtml
      - Partial views
        reduce code duplication by managing reusable parts of views
        
        The best practice is to use asynchronous rendering
        
        Partial Tag Helper - it renders asynchronously
        `<partial name="_AuthorPartial"/>
        
        You can specify a default partial view to use, placing it in the Shared folder, which is overriden by a partial view with the same name in the same folder as the parent view
        
        Partial views can be chained as long as you don't create a loop
      - View
        
        View discovery
        
        Views/[ControllerName]/[ViewName].cshtml
        
        Views/Shared/[ViewName].cshtml
        
        Passing data to views
        Strongly typed data: viewmodel
        Weakly typed data:
        
        ViewData
        
        ViewBag (not available in Razor Pages) #
      - Why?
        
        Simplify the controller
        
        Override previously injected services on page