BỜM TẬP CODE

A sample of applying options pattern

This part shows how to use configuration and how to use Options patterns.

Default configuration

a. ChaninedConfigurationProvider

b. appsettings.json

c. appsettings.[environment].json

d. app secrets

e. environment variables

f. command-line arguments.

Configuration providers that are added later override the previous key setting.

JsonConfigurationProvider loads configuration in the following order:

appsettings.json
appsetings.{Environment}.json

=> appsetings.{Environment}.json values override keys in appsettings.json

private readonly IConfiguration _configuration; 
public WeatherForecastController(ILogger<WeatherForecastController> logger, IConfiguration configuration)
{
......
}

public WeatherForecast Get() 
{ 
    var a = new WeatherForecast 
    { 
        // Get value from configureation
        Name = _configuration["Name"], 
        NickName = _configuration["NickName"] 
    }; 
    return a; 
}

Options pattern to read a related configuration

public class PositionOptions 
{
    public string Title { get; set; } 
    public string Name { get; set; } 
}
...
var positionOptions = new PositionOptions(); 
Configuration.GetSection("JsonKeySection").Bind(positionOptions);

OR:
positionOptions = Configuration.GetSection(PositionOptions.Position) 
                                                     .Get<PositionOptions>();

Combining service collection

a. How to register configures option in ConfigureServices method

step 0: create Option class
step 1: create extension method:

first param: IServiveCollection
second param: IConfiguration/ or Action<OptionClass>
Use: services.Configure method to register configuration

step 2: use extension method to register the service.

services.Configure<PositionOptions>( config.GetSection(PositionOptions.Position)); 
services.Configure<ColorOptions>( config.GetSection(ColorOptions.Color));

b. How to get value of Option at another places

Method 1: Use: IServiceProvider serviceProvider to get option value,

Name = _serviceProvider.GetRequiredService<IOptions<PositionOption>>().Value.Name, 
NickName = _serviceProvider.GetRequiredService<IOptions<PositionOption>>().Value.Position

Method 2:

IOptions<PositionOption> _optionDelegate;
....
// Get value from Option
Name = _optionDelegate.Value.Name, 
NickName = _optionDelegate.Value.Position

File configuration provider

Json configuration provider

use: config.AddJsonFile("MyConfig.json", optional: true, reloadOnChange: true)

to add custom config json file
This file override settings in the default configuration providers (include environment vars and command-line)

XML configuration provider

use: AddXmlFile

Others config

a. launchsetting.json

b. web.config

References:

[Microsoft Learn] - Configuration

[Microsoft Learn] - Options

4. ASP .Net core - Fundamentals - Host and Server

tháng 8 21, 2021.Net Technology, ASP .Net core Không có nhận xét nào

This series is a collection of knowledge about ASP .NET Core. It just is my notes.

Part 1: Startup file.

Part 2: Dependency injection.

[Microsoft Learn] - Server

In this part, I got some knowledge about Host and Servers in ASP .Net core

4.1 Host

Generic host
Web host

- Host is an object that encapsulates:

DI
Logging
Configuration
IHostedService implementations

- How to set up a host: Program, Main, CreateHostBuilder

- Default builder setting:

CreateDefaultBuilder: content root, host configs, app configs, add logging providers
ConfigureWebHostDefault: host configs, set kestrel server....

- Host configuration: how to do? => ConfigureHostConfiguration

- App configuration: how to do? => ConfigurAppConfiguration

4.2 Server

Kestrel
Http.sys
Hosting model:

in-process hosting
out-of-process hosting

References:

[Microsoft Learn] - Host

3. Asp.net core - fundamentals - Middleware

tháng 8 21, 2021.Net Technology, ASP .Net core Không có nhận xét nào

This series is a collection of knowledge about ASP .NET Core. It just is my notes.

Part 1: Startup file.

Part 2: Dependency Injection.

[Microsoft Learn] - ASP.NET Core Middleware

This part is to summarise some knowledge concerning the Middleware in Asp .net core.

a. What is middleware

Middleware is software added to the pipeline to process requests and responses.
When a request comes, it goes through one by one middleware (you can think that all middleware do the common process for each request, response)
To use middleware in IApplicationBuilder, use:

Run: param: context
Use: param: context, next -> to invoke next middleware
Map: to branch middleware

We have some built-in middleware, we can use them in configure method.
Of course, we can also create custom middleware.

b. Order of middleware

--> Endpoint middleware to turn the request into an action method in the controller.

c. How to create a custom middleware

step 1: Encapsulate custom middleware in class

Convention: {Name}Middleware
Include:

a constructor with parameter type is "ContextDelegate".
A public method is named Invoke or InvokeAsync. This method must:

Return a Task.
Accept the first parameter of type HttpContext.
Additional parameters for the constructor and Invoke/InvokeAsync are populated by dependency injection (DI).

For example:

public class CustomMiddleware 
{ 
    private readonly RequestDelegate _next; 
    public CustomMiddleware(RequestDelegate next) 
    { 
        _next = next; 
    } 
    // IMyScopedService is injected into Invoke 
    public async Task Invoke(HttpContext httpContext, IMyScopedService svc) 
    { 
        svc.MyProperty = 1000; 
        await _next(httpContext); 
    } 
}

step 2: create a middleware extension method through IApplicationBuilder:

Name convention: Use{MiddlewareName}

using Microsoft.AspNetCore.Builder; 
namespace Culture 
{ 
    public static class RequestCultureMiddlewareExtensions 
    { 
        public static IApplicationBuilder UseRequestCulture( 
            this IApplicationBuilder builder) 
        { 
            return builder.UseMiddleware<RequestCultureMiddleware>(); 
        } 
    } 
}

step 3: Call middleware in Configure method

public class Startup 
{ 
    public void Configure(IApplicationBuilder app) 
    { 
        app.UseRequestCulture(); 
        app.Run(async (context) => 
        { 
            await context.Response.WriteAsync( 
                $"Hello {CultureInfo.CurrentCulture.DisplayName}"); 
        }); 
    } 
}

References:

2 - [Updated] - ASP .Net core - Fundamentals - Dependency injection

tháng 8 20, 2021.Net Technology, ASP .Net core Không có nhận xét nào

This series is a collection of knowledge about ASP .NET Core. It just is my notes.

Part 1: Startup file in ASP .Net core.

[Microsoft Learn] - Dependency injection in ASP.NET Core

In this note, I want to summary some knowledge about DI in Asp.net core.

First, DI is to archive Inversion of Control, solid principle.

We have 3 types of DI: constructor injection, method injection, property injection

The built-in DI of the .net core base on constructor injection.

a. How to register services

Register a service in method 'ConfigureServices'
Use the "services.Configure" method to config/binding our configuration to option
also can create an extension method of IServicesCollection to compute a group of related service

Note: convention : Add{OurServiceName}, for example: AddDataAcessLayer, AddBusinessServices...

b. Service lifetime

Transient: short lifetime, create when service container request, disposed at the end of the request
Scoped: create per client request, AddDbContext for example.
Singleton: create at the first time that they're requested; disposed of an object only when app shutdown, should consider if we use it, since memory performance

c. Design service for dependency injection

When designing services for dependency injection:

Avoid stateful, static classes and members. Avoid creating a global state by designing apps to use singleton services instead.
Avoid use Service Locator anti-pattern.
Avoid direct instantiation of dependent classes within services. Direct instantiation couples the code to a particular implementation.
Make services small, well-factored, and easily tested.

d. Dispose of services: Container takes this responsibility

e. Keyed Service (From ASP.NET Core 8)

When using keyed services:

Have an interface with multiple implementations
And need to use one of those implementations in different places in your application

Add services by using: AddKeyedSingleton (or AddKeyedScoped or AddKeyedTransient)

builder.Services.AddKeyedSingleton<ICache, BigCache>("big");

builder.Services.AddKeyedSingleton<ICache, SmallCache>("small");

Access a registered service by specifying the key with the [FromKeyedServices]

[HttpGet("big-cache")]

public ActionResult<object> GetOk([FromKeyedServices("big")] ICache cache)

{

return cache.Get("data-mvc");

}

DI Keyed Service Sample

Ref:

1 - [Updated] - ASP .Net core - Fundamentals - Startup

tháng 8 20, 2021.Net Technology, ASP .Net core Không có nhận xét nào

This series is a collection of knowledge about ASP .NET Core. It just is my notes.

Part 2: Dependency Injection.