ASP.NET Core hidden gems

Microsoft’s ASP.NET Core is a brand new web framework, completely open sourced and cross-platform; for building scalable- & cloud-ready web applications. This talk covers some of the features in the framework, that is not that obvious, in my opinion, that we can utilise when building modern and practical APIs. Think REST, dependency injection, application startup, startup filters, custom servers, clients, hosted services, conventions, model binding, application parts, HATEOAS, and more.

Transcript

1. ASP.NET Core hidden gems @FanieReynders
2. #RigaDevDays
3. Fanie Reynders Software Architect - T-Mobile FanieReynders @FanieReynders https://reynders.co
4. http://a.co/bmdye69 https://bit.ly/2IhvWPe
7. Application Startup
8. Inline configuration public static void Main(string[] args) => WebHost .CreateDefaultBuilder(args) .ConfigureServices(services => { }) //optional .Configure(app => { }) //required .Build() .Run();
9. Configuration as class public static void Main(string[] args) => WebHost .CreateDefaultBuilder<Startup>(args) .Build() .Run();
10. Configuration as class public class Startup { // Optional public void ConfigureServices(IServiceCollection services) { } // Required public void Configure(IApplicationBuilder app) { } }
11. Startup filters public interface IStartupFilter { Action<IApplicationBuilder> Configure(Action<IApplicationBuilder> next); }
12. public class AwesomeStartupFilter : IStartupFilter { public Action<IApplicationBuilder> Configure(Action<IApplicationBuilder> next) { return builder => { builder.Use(async (context, _next) => { if (context.Request.Query["key"] != "1234") { await context.Response.WriteAsync("You had one job!"); } else { await _next(); } }); next(builder); }; } }
13. Startup filters public class Startup { public void ConfigureServices(IServiceCollection services) { services.AddTransient<IStartupFilter, AwesomeStartupFilter>(); } // ... }
14. Configuration as class public class Startup { // Optional public void ConfigureServices(IServiceCollection services) { } // Required public void Configure(IApplicationBuilder app) { } }
15. Configuration as class (per environment) public class Startup[Environment] { // Optional public void Configure[Environment]Services(IServiceCollection services) { } // Required public void Configure[Environment](IApplicationBuilder app) { } }
16. ASPNETCORE_ENVIRONMENT=Foo
17. public class Program { public static void Main(string[] args) => WebHost .CreateDefaultBuilder(args) .UseStartup(Assembly.GetExecutingAssembly().FullName); .Build() .Run(); } public class StartupFoo { // Optional public void ConfigureServices(IServiceCollection services) { } // Required public void Configure(IApplicationBuilder app) { } }
18. public class Startup { // Optional public void ConfigureFooServices(IServiceCollection services) { } // Required public void ConfigureFoo(IApplicationBuilder app) { } // Optional public void ConfigureBarServices(IServiceCollection services) { services.AddSingleton<IAwesome, Awesome>(); } // Required public void ConfigureBar(IApplicationBuilder app, IAwesome awesome) { } }
20. Servers & Clients
21. Server definition public interface IServer : IDisposable { IFeatureCollection Features { get; } Task StartAsync<TContext>(IHttpApplication<TContext> application, CancellationToken cancellationToken); Task StopAsync(CancellationToken cancellationToken); }
22. Request map Application host Client Server (Kestrel) Application code HTTP HttpContext
23. Awesome server Application host File Server (Awesome) Application code Text Request Text Response
24. {Method} {Request}
25. Demo: Custom Server
26. HttpClient • IDisposable - object is gone but connection is not • Socket exhaustion • Use singleton, but connections remain open – DNS TTL • Hard* to test
27. HttpClientFactory • Factory for creating HTTP clients – ASP.NET Core 2.1 • Easy to test • Consumption patterns • Direct • Named • Typed • Generated
28. HttpClientFactory - Direct usage // Registration public void ConfigureServices(IServiceCollection services) { services.AddHttpClient(); // ... }
29. // Usage - direct public class MyController : Controller { private readonly IHttpClientFactory _httpClientFactory; public MyController(IHttpClientFactory httpClientFactory) { _httpClientFactory = httpClientFactory; } public async IActionResult Get() { var client = _httpClientFactory.CreateClient(); client.DefaultRequestHeaders.Add("Accept", "application/json"); client.DefaultRequestHeaders.Add("User-Agent", "Awesome"); var result = await client.GetStringAsync("https://api.awesome.io/foo"); return Ok(result); } }
30. HttpClientFactory – Named client // Registration public void ConfigureServices(IServiceCollection services) { services.AddHttpClient("awesome", c => { c.BaseAddress = new Uri("https://api.awesome.io"); c.DefaultRequestHeaders.Add("Accept", "application/json"); c.DefaultRequestHeaders.Add("User-Agent", "Awesome"); }); // ... }
31. // Usage – named client public class MyController : Controller { private readonly IHttpClientFactory _httpClientFactory; public MyController(IHttpClientFactory httpClientFactory) { _httpClientFactory = httpClientFactory; } public async IActionResult Get() { var client = _httpClientFactory.CreateClient("awesome"); var result = await client.GetStringAsync("foo"); return Ok(result); } }
32. HttpClientFactory – Typed client // Registration public void ConfigureServices(IServiceCollection services) { services.AddHttpClient<AwesomeService>(); // ... }
33. public class AwesomeService { public HttpClient _client { get; private set; } public AwesomeService(HttpClient client) { client.BaseAddress = new Uri("https://api.awesome.io"); client.DefaultRequestHeaders.Add("Accept", "application/json"); client.DefaultRequestHeaders.Add("User-Agent", "Awesome"); _client = client; } public async string Foo() { return await _client.GetStringAsync("foo"); } }
34. // Usage – typed client public class MyController : Controller { private readonly AwesomeService _awesomeService; public MyController(AwesomeService awesomeService) { _awesomeService = awesomeService; } public async IActionResult Get() { var result = await awesomeService.Foo(); return Ok(result); } }
35. HttpClientFactory – Generated client public interface IAwesomeService { [Get("/foo")] Task<string> Foo(); } // Registration public void ConfigureServices(IServiceCollection services) { services.AddTypedClient(c => Refit.RestService.For<IAwesomeService>(c)); // ... }
36. // Usage – generated client public class MyController : Controller { private readonly IAwesomeService _awesomeService; public MyController(IAwesomeService awesomeService) { _awesomeService = awesomeService; } public async IActionResult Get() { var result = await awesomeService.Foo(); return Ok(result); } }
37. Hosted Services
38. Hosted Service public interface IHostedService { Task StartAsync(CancellationToken cancellationToken); Task StopAsync(CancellationToken cancellationToken); } // Registration public void ConfigureServices(IServiceCollection services) { services.AddSingleton<IHostedService, AwesomeHostedService>(); // ... }
39. public class AwesomeHostedService : IHostedService { private readonly ITwitterApi twitterApi; private readonly IMemoryCache cache; public AwesomeHostedService(ITwitterApi twitterApi, IMemoryCache cache) { this.twitterApi = twitterApi; this.cache = cache; } public Task StartAsync(CancellationToken cancellationToken) => PullTweets(); public Task StopAsync(CancellationToken cancellationToken) => Task.FromResult(0); // ...
40. // ... private async Task PullTweets() { var sinceId = cache.Get<long>("sinceId"); var tweets = await twitterApi.Search("#RigaDevDays", sinceId); var tweetStrings = new StringBuilder(); foreach (var tweet in tweets) { tweetStrings.AppendLine($"{tweet.Date} {tweet.Text} {tweet.User}"); } await File.AppendAllTextAsync("tweets.csv", tweetStrings.ToString()); } }
41. The RESTy stuff
42. ApiController attribute • Automagically responds with 400 for validation errors • Smarter bindings • [FromBody]  Complex types • [FromRoute]  Route values • [FromQuery]  Query params • Requires Attribute Routing
43. ActionResult<T>
44. public class Numbers { [Required] public int? Number1 { get; set; } [Required, Range(1,100)] public int? Number2 { get; set; } } [Route("api/[controller]")] [ApiController] public class CalculatorController : ControllerBase { public ActionResult<int> Post([Required]Numbers numbers, string key) { if (key != "SecretKey") return Unauthorized(); return (numbers.Number1 * numbers.Number2); } }
45. RFC 7807
46. { "errors": { "Number1": [ "The Number1 field is required.“ ], "Number2": [ "The field Number2 must be between 1 and 100.“ ] }, "type": "https://api.awesome.io", "title": "One or more validation errors occurred.", "status": 400, "detail": "Go read the docs, duh!", "instance": "/api/calculator" }
47. public void ConfigureServices(IServiceCollection services) { services.Configure<ApiBehaviorOptions>(options => { options.InvalidModelStateResponseFactory = context => { var problemDetails = new ValidationProblemDetails(context.ModelState) { Instance = context.HttpContext.Request.Path, Status = StatusCodes.Status400BadRequest, Type = "https://api.awesome.io", Detail = "Go read the docs, duh!" }; return new BadRequestObjectResult(problemDetails) { ContentTypes = { "application/json+problem" } }; }; }); }K
48. Model Binding
49. Model binder definition public interface IModelBinder { Task BindModelAsync(ModelBindingContext bindingContext); }
50. AwesomeModelBinder Awesome ModelBinder Azure Face API Surprise Sad Angry Neutral Happy Photo
51. Demo: Emotional Binder
52. Conventions
53. // GET api/people/names namespace Api.People { [Route("api/people/names")] public class NamesController { public string[] Get([FromServices]IPeopleRepository people) { return people.All; } } }
54. Convention definitions public interface IApplicationModelConvention { void Apply(ApplicationModel application); } public interface IControllerModelConvention { void Apply(ControllerModel controller); } public interface IActionModelConvention { void Apply(ActionModel action); }
55. Application model Application API Explorer Filters Controllers API explorer Filters Actions API explorer Filters Parameters
56. // GET api/people/names namespace Api.People { public class NamesApi { public string[] Get([FromServices]IPeopleRepository people) { return people.All; } } }
57. Demo: Custom Convention
58. Application Parts
59. Load external MVC during runtime // Registration public void ConfigureServices(IServiceCollection services) { var assembly = Assembly.LoadFile(@"c:\random\awesome.dll"); services .AddMvc() .AddApplicationPart(assembly); // ... }
60. Demo: Application Parts
61. HATEOAS
63. Hypermedia as the Engine of Application State
65. HATEOAS Client Server What can you do? OPTIONS /
66. HATEOAS Client Server application/json+hateoas [ { "_self" : "OPTIONS /" } { "list-foo" : "GET /api/foo" }, { "list-bar" : "GET /api/bar" }, { "list-baz" : "GET /api/baz" } ]
67. HATEOAS Client Server list-bar GET /api/bar
68. HATEOAS Client Server [ { "_self" : "GET /api/bar" } { "create-bar" : "POST /api/bar" }, { "data" : { ... } } ] application/json+hateoas
69. HATEOAS Client Server create-bar POST /api/bar { ... }
70. HATEOAS Client Server [ { "_self" : "GET /api/bar/1" }, { "remove-bar" : "DELETE /api/bar/1" }, { "update-bar" : "PUT /api/bar/1" }, { "list-bar" : "GET /api/bar" }, { "data" : { ... } } ] application/json+hateoas
71. HATEOAS Client Server remove-bar DELETE /api/bar/1
72. HATEOAS Client Server [ { "_self" : "OPTIONS /api/bar" }, { "create-bar" : "POST /api/bar" }, { "list-bar" : "GET /api/bar" } ] application/json+hateoas
73. Demo: HATEOAS
74. IStartupFilter Config per environment IServer HttpClientFactory IHostedService [ApiController] ActionResult<T> RFC 7807 IModelBinder Conventions ApplicationPart HATEOAS
75. Fanie Reynders Software Architect - T-Mobile FanieReynders @FanieReynders https://reynders.co Thank you!