My ASP.NET Core 1.0 session from VSLive Redmond 2016

1. ASP.NET Core: Reimagining Web
Application Development in .NET
Ido Flatow
Senior Architect
Microsoft MVP & RD
Sela Group
@idoflatow

2. Agenda
• ASP.NET History
• ASP.NET Core 1.0 and .NET
• ASP.NET Core 1.0 Features
• ASP.NET Core MVC

3. ASP.NET, THEN AND NOW

4. History of ASP (20 years)
• 1996 - Active Server Pages (ASP)
• 2002 – ASP.NET
• 2005 – ASP.NET 2
• 2008 – ASP.NET MVC
• 2012 – ASP.NET Web API
• 2014 – ASP.NET vNext
– 2015 – ASP.NET 5 RC1
– 2016 – ASP.NET Core 1.0 (June 27th, 2016)

5. Problems with ASP.NET Architecture
• Limited hosting possibilities (IIS only)
• Dependency on IIS environment (System.Web)
• Web evolves faster than the .NET Framework
• Requires full-blown .NET Framework
• Resource intensive and not web-friendly
• Hard to optimize for lightweight high-performance apps
• Not completely cloud-optimized

6. Introducing ASP.NET Core 1.0
(Tools in Preview 2)
OS
.NET CLR
ASP.NET
MVC
(UI + API)
Host
Self-HostedIIS
.NET Core CLR
Middleware

7. What is Tooling?
• Everything that is part of the framework
• Command line tools
– dotnet CLI
• Project tools
– ASP.NET templates
– xproj / csproj
• Visual Studio tools
– Configuration IntelliSense
– Debugger support

8. Two Runtimes
• .NET Full Framework (4.6)
– Not going away…
– Windows hosting with full .NET APIs
• .NET Core 1.0
– Subset of the full framework
• No Windows Forms, WPF, Silverlight
• No System.Web (WebForms)
– Implemented as set of NuGet packages
– Cross-platform and Nano server support

9. GETTING TO KNOW ASP.NET
CORE

10. ASP.NET Core Features
• Flexible and cross-platform runtime
• Modular HTTP request pipeline
• Unifying MVC, Web API, and Web Pages
• Side-by-side versioning with .NET Core
• Built-in Dependency Injection
• Self-host and IIS-hosted (sort of…)
• Open source on GitHub

11. CREATING A NEW ASP.NET
CORE PROJECT
Demo

12. Solution and Projects
• global.json
Project references (in addition to the .sln)
• wwwroot
Root for static content (html, css, js, images, etc…)
• Program.cs
ASP.NET hosting libraries. This is where it all starts
• project.json
References, compiler settings, tooling (replaces web.config and
packages.config)
• Startup.cs
DI and pipeline configuration
(replaces global.asax and configuration code)

13. PROJECT.JSON, STARTUP.CS
AND PROGRAM.CS
Demo

14. ASP.NET Core Middlewares
• Improved HTTP performance
– New lean and fast HTTP request pipeline
– You choose what to use in your application
– By registering middlewares
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerfactory)
{
app.UseExceptionHandler("/Home/Error");
app.UseStaticFiles();
app.UseIdentity();
app.UseMvc(routes => ...)
}

15. Where’s the AppSettings?
• Not relying on web.config anymore
• New configuration system based on key/value pairs:
– JSON files
– INI files
– XML files
– Environment variables
• Configuration can come from multiple resources
– Last resource wins

16. Loading Settings
var builder = new ConfigurationBuilder()
.SetBasePath(env.ContentRootPath)
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
.AddXmlFile("appsettings.xml", optional:true)
.AddJsonFile($"appsettings.{env.EnvironmentName}.json",true);
if (env.IsDevelopment())
{
builder.AddUserSecrets();
}
builder.AddEnvironmentVariables();
IConfigurationRoot Configuration = builder.Build();
...
string connString = Configuration["Data:Default:ConnectionString"];

17. Dependency Injection
• ASP.NET Core is DI-friendly
• Basic DI container available throughout the stack
• BYOC is also supported (already implemented for Autofac, Dryloc,
StructureMap, etc.)
• Out-of-the-box container supports:
– Singleton / Instance – single instance
– Transient – new instance each time
– Scoped – new instance per request (HTTP context)
• https://github.com/aspnet/DependencyInjection

18. DI with Controllers
public class ProductsController : Controller
{
private readonly IProductsRepository _repository;
public ProductsController(IProductsRepository repository)
{
this._repository = repository;
}
public IActionResult Index()
{
var products = _repository.GetAllProducts();
return View(products);
}
}
services.AddTransient<IProductsRepository, DefaultProductsRepository>();

19. Logging
• ASP.NET Core has built-in support for logging
• Uses the built-in DI to get a logger instance
• Standard logger outputs: category, log level, event Id, and message
• Built-in loggers for:
– Console (hosting from cmd/terminal)
– TraceSource (good old System.Diagnostics)
– Debug (Visual Studio output window)
• Custom loggers are also available (log4net, serilog, elmah, etc.)
• https://github.com/aspnet/Logging

20. Logging with Controllers
public class TodoController : Controller
{
private readonly ITodoRepository _todoRepository;
private readonly ILogger<TodoController> _logger;
private const int LIST_ITEMS = 1001;
public TodoController(ITodoRepository todoRepo, ILogger<TodoController> logger)
{
_todoRepository = todoRepo;
_logger = logger;
}
[HttpGet]
public IEnumerable<TodoItem> GetAll()
{
_logger.LogInformation(LIST_ITEMS, "Listing all items");
EnsureItems();
return _todoRepository.GetAll();
}
}

21. The dotnet CLI
• Cross-platform command line toolchain
• Written in .NET Core
• External commands
• https://github.com/dotnet/cli
dotnet new
dotnet restore
dotnet build --output /stuff
dotnet /stuff/new.dll
dotnet publish
dotnet ef
dotnet razor-tooling
Dotnet aspnet-codegenerator

22. Hosting ASP.NET Core
• ASP.NET Core 1.0 is a stand-alone application
– Uses Kestrel HTTP server (based on libuv, as with node.js)
• Self-hosting with .NET Core
– Compiled into a .dll file, hosted by the dotnet CLI
• Self-hosting with .NET 4.6
– Compiles into an .exe file
– Kestrel or the WebListener server (Windows HTTP.sys)
• IIS-hosted (.NET Core / .NET 4.6)
– IIS uses the ASP.NET Core Module to start the self-hosted app
– ASP.NET Core template generates the required web.config
– Starts either dotnet webapp1.dll or webapp.exe
• https://docs.asp.net/en/latest/hosting/aspnet-core-module.html

23. CROSS-PLATFORM
ASP.NET CORE
Demo

24. ASP.NET CORE MVC

25. ASP.NET <= 4.6 Frameworks

26. ASP.NET Core with MVC

27. ASP.NET Core MVC
• No more duplication - one set of concepts
• Used for creating both UI and API
• Based on the new ASP.NET Core pipeline
• Supports .NET Core
• Built DI first
• Runs on IIS or self-host
• New features in controllers and views

28. Getting Started with MVC
• Project.json
• Startup.cs
"dependencies": {
"Microsoft.AspNet.Server.Kestrel": "1.0.0",
// Add this:
"Microsoft.AspNet.Mvc": "1.0.0"
}
// Register MVC default services for DI
services.AddMvc();
app.UseMvc(routes => {
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});

29. Web API Configuration
• Route configuration -> attribute-based routing
• Message handlers -> middleware pipeline
• Filters and Formatters -> startup.cs
services.AddMvc()
.AddXmlDataContractSerializerFormatters()
.AddMvcOptions(options =>
{
options.Filters.Add(new ValidatorFilterAttribute());
})
.AddJsonOptions(jsonOptions =>
{
jsonOptions.SerializerSettings.Formatting = Formatting.Indented;
});

30. Controllers – Two in One
• UI – same as with MVC 5
• API – similar, but different
public class HomeController : Controller
{
public IActionResult Index()
{
return View();
}
}
[Route("api/[controller]")]
public class ProductsController : Controller
{
[HttpGet("{id:int}")]
public Product GetProduct(int id)
{
return new Product() { ID = id };
}
}

31. Actions – IActionResult
[HttpGet("{id:int}", Name = "GetByIdRoute")]
public IActionResult GetById (int id)
{
var item = _items.FirstOrDefault(x => x.Id == id);
if (item == null) { return NotFound(); }
return new ObjectResult(item);
}
[HttpPost]
public IActionResult CreateTodoItem([FromBody] TodoItem item)
{
_items.Add(item);
return CreatedAtRoute(
"GetByIdRoute", new { id = item.Id }, item);
}

32. Showing Some UI for Your API
• Swagger - a JSON-based service description framework
• Create a Swagger endpoint using Swashbuckle.SwaggerGen
– Browse to /swagger/v1/swagger.json
• Host a built-in UI for testing APIs with Swashbuckle.SwaggerUi
– Browse to /swagger/ui
"dependencies": {
"Swashbuckle.SwaggerGen": "6.0.0-beta901",
"Swashbuckle.SwaggerUi": "6.0.0-beta901"
}
services.AddSwaggerGen();
app.UseSwagger();
app.UseSwaggerUi();

33. Enough with controllers,
What about views?
Oh, right!

34. Injecting Services to Views
• Preferable than using static classes/methods
• Use interfaces instead of concrete types
• Register in IoC using different lifecycles
public class CatalogService : ICatalogService
{
public async Task<int> GetTotalProducts() {...} // From ICatalogService
}
@inject MyApp.Services.ICatalogService Catalog
<html>
<body>
<h3>Number of products in the catalog</h3>
@await Catalog.GetTotalProducts()
</body>
</html>
services.AddTransient<ICatalogService, CatalogService>();

35. Flushing Content with Razor
• In ASP.NET <= 5, browser had to wait until Razor
rendered the entire page
• Razor now supports flushing, causing HTML to get
chunked (streamed)
– @await FlushAsync()
• Not supported when rendering layout sections

36. Last, but not Least, Tag Helpers
• Tag helpers are an alternative to HTML helpers
• Tag helpers look like regular HTML elements
• Instead of doing this:
• Do this:
• It’s the return of Web Controls, NOOOOOO!!!
@Html.ActionLink("Click me", "AnotherAction")
<a asp-action="AnotherAction">Click me</a>

37. Tag Helpers are not Evil
• Tag Helpers generate markup within their enclosing tag
• Less Razor/HTML mess in the .cshtml file
• Data-attributes style approach
• Use C# to better construct the markup
– Add/remove parts from the inner content
– Generate complex HTML (recursive, nested, …)
– Cache the output

38. Existing Tag Helpers
• HTML elements
– <a>, <form>, <input>, <label>, <link>, <script>, <select>, <textarea>
• Logical
– <cache>
• Placeholders
– ValidationSummary (<div>), ValidationMessage (<span>)
• You can create your own Tag Helpers
• Check out the source for reference
https://github.com/aspnet/Mvc/tree/dev/src/Microsoft.AspNetCore.Mvc.TagHelpers

39. Key Improvements in ASP.NET Core
• Totally modular - Everything is a package
• Lightweight - you use minimum set of modules
• Faster startup, lower memory footprint
• Can be deployed side-by-side with .NET Core
• Cross platform - can be hosted anywhere
• Better developer experience – DI and one MVC
• Everything is open-sourced

40. Key Improvements in ASP.NET Core

41. Get Started with ASP.NET Core
• Install Visual Studio 2015 / Visual Studio Code
• Walkthroughs and samples at http://www.asp.net/core
• Documentation at http://docs.asp.net/en/latest
• Get the code from http://github.com/aspnet
• Read blogs at http://blogs.msdn.com/b/webdev
• @IdoFlatow // idof@sela.co.il // http://www.idoflatow.net/downloads