.NET Core From Scratch - Start Fom Zero(Blank Console)

Set up a web host to run your application and define a request delegate to handle http requests. Use an http context to write hello world to the response.

Start a .NET core web host and write a hello world response to http requests. See how server processes each request and explore defaults to do more than hello world.

Use the default builder to configure an IWebHostBuilder, supply the startup class, and assemble the startup configuration for a web host in a blank console app.

Learn how to pass configuration to the IWebHostBuilder by using a startup class via the fluent API, guiding startup configuration with the class name.

Configure and build an IWebHost using the IWebHostBuilder, then run the web host to handle HTTP requests indefinitely until you stop the application.

Learn how to wire up the startup class and configure the web host using startup and configure methods, enabling the application builder to set up routing, middleware, and endpoints.

Explore how dependency injection supplies an application builder via the host, enabling startup configuration and the application pipeline to respond to http requests through the http context.

Explore how middleware sits in the middle of a request and response, using the application builder and http context to configure and handle requests with run and use.

Learn how to build a local-level component pipeline using the use method and next in middleware-style flows, passing the HGP context through each component and invoking subsequent steps.

Chain two middleware components to handle an http request, writing 'hello from component one' then delegating to the next component in the pipeline.

Understand how a request flows through components and middleware, passes to the next function, and returns a composed response on the way back.

Learn how to use the map extension to route-specific middleware in a .NET Core app, orchestrating the app builder and use methods to respond to a chosen path.

Explore how map behaves in a .NET core pipeline, routing to a localhost special road and using the application builder to return hello from the road.

Compare the run method with map in .NET core from scratch, showing how run processes the request as an endpoint on the way back.

Pass data between components using the context items in a middleware pipeline, decode the information in component two, and leverage framework extension methods instead of writing custom middleware.

Define a custom middleware class, wire it into the app with a use extension method, and implement an asynchronous invoke method that receives an HTTP context and calls next delegate.

Implement a static extensions class with UseMyMiddleware(this IApplicationBuilder app) to wire a custom middleware, illustrating how extension methods on the application builder configure middleware behind the scenes.

Add IHostingEnvironment to the project to access environment information; use it to conditionally apply middleware, showing a dedicated exception page in development while hiding details in production for security.

Build a web application using a model-view-controller structure with Natcore, configuring controllers, models, and repositories to handle requests and database interactions step by step.

learn to add our first controller in a net core project, configure startup and routing, and create a home controller that inherits from the framework's controller base.

Explore creating your first action on an MVC controller in .NET Core, returning a string for demonstration, wiring middleware, and testing the endpoint at localhost with the configured port.

Explore how the routing extension method on the application builder verifies routing services via the routing marker service, and how dependency injection wires application services for an ok check.

Explore how dependency injection works in .NET Core by adding services to the app's DI container via the configure services method, and see how middleware uses these app services.

Register and configure services in the ConfigureServices method by accessing the service collection, enabling dependency injection to register application services before routing and middleware execution.

Add and configure services in the service collection, then retrieve them via the service provider to enable routing with middleware and endpoints.

Wire routing in middleware by adding routing services and defining an endpoint. Map the default controller route to enable the first action in a .NET Core app.

Configure routing in .NET Core from scratch by wiring middleware, using extension methods, adding controllers via dependency injection, and mapping a default route endpoint to the home controller's first action.

Create the first view by updating the home controller's index action to return a view, and set up views/home/index as a partial and a full view with no layout.

Return a view from the home controller’s index action, loaded from views/home/index, using ActionResult to offer flexible returns such as a view or bad request.

Register mvc services on the services collection using the add mvc extension to enable mvc workflow, view rendering, and controller-driven endpoints with associated views.

Create a simple customer model and pass a sample enumerable to the view to establish a basic model view controller flow, preparing for repository pattern and entity framework.

Create and edit an appsettings.json file to hold configuration settings, including a connection string for SQL Server, read via IConfiguration in startup to configure the web host.

Explore using the IConfiguration object to read connection strings from sections and subsections, via GetConnectionString, GetSection, and direct value access, all injected in startup.