{"id":13015,"date":"2018-04-12T10:24:30","date_gmt":"2018-04-12T17:24:30","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/webdev\/?p=13015"},"modified":"2023-12-18T08:55:08","modified_gmt":"2023-12-18T16:55:08","slug":"asp-net-core-2-1-0-preview2-now-available","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/dotnet\/asp-net-core-2-1-0-preview2-now-available\/","title":{"rendered":"ASP.NET Core 2.1.0-preview2 now available"},"content":{"rendered":"

Today we’re very happy to announce that the second preview of the next minor release of ASP.NET Core and .NET Core is now available for you to try out. This second preview includes many refinements based on feedback we received from the first preview<\/a> we released back in February.<\/p>\n

You can read about .NET Core 2.1.0-preview2 over on their blog<\/a>.<\/p>\n

You can also read about Entity Framework Core 2.1.0-preview2 on their blog<\/a>.<\/p>\n

How do I get it?<\/h2>\n

You can download the new .NET Core SDK for 2.1.0-preview2 (which includes ASP.NET Core 2.1.0-preview2) from https:\/\/www.microsoft.com\/net\/download\/dotnet-core\/sdk-2.1.300-preview2<\/a><\/p>\n

Visual Studio 2017 version requirements<\/h3>\n

Customers using Visual Studio 2017 should also install (in addition to the SDK above) and use the Preview channel<\/a> (15.7 Preview 3 at the time of writing) when working with .NET Core and ASP.NET Core 2.1 projects. .NET Core 2.1 projects require Visual Studio 2017 15.7 or greater.<\/p>\n

Impact to machines<\/h3>\n

Please note that given this is a preview release there are likely to be known issues and as-yet-to-be-discovered bugs. While .NET Core SDK and runtime installs are side-by-side on your machine, your default SDK will become the latest version, which in this case will be the preview. If you run into issues working on existing projects using earlier versions of .NET Core after installing the preview SDK, you can force specific projects to use an earlier installed version of the SDK using a global.json file as documented here<\/a>. Please log an issue<\/a> if you run into such cases as SDK releases are intended to be backwards compatible.<\/p>\n

Already published applications running on earlier versions of .NET Core and ASP.NET Core shouldn’t be impacted by installing the preview. That said, we don’t recommend installing previews on machines running critical workloads.<\/p>\n

Announcements and release notes<\/h2>\n

You can see all the announcements published pertaining to this release at https:\/\/github.com\/aspnet\/Announcements\/issues?q=is%3Aopen+is%3Aissue+milestone%3A2.1.0-preview2<\/a><\/p>\n

Release notes, including known issues, are available at https:\/\/github.com\/aspnet\/Home\/releases\/tag\/2.1.0-preview2<\/a><\/p>\n

Giving feedback<\/h2>\n

The main purpose of providing previews like this is to solicit feedback from customers such that we can refine and improve the changes in time for the final release. We intend to ship a release candidate in about a month (with “go-live” license and support) before the final RTW release.<\/p>\n

Please provide feedback by logging issues in the appropriate repository at https:\/\/github.com\/aspnet<\/a> or https:\/\/github.com\/dotnet<\/a>. The posts on specific topics above will provide direct links to the most appropriate place to log issues for the features detailed.<\/p>\n

New features<\/h2>\n

You can see a summary of the new features planned in 2.1 in the roadmap post<\/a> we published previously.<\/p>\n

Following are details of additions and changes in preview2 itself.<\/p>\n

<\/a>Improvements to Razor UI libraries<\/h3>\n

New in ASP.NET Core 2.1 is support for building Razor UI in class libraries<\/a>. In Preview 2 we’ve made various improvements to simplify authoring Razor UI in class libraries through the introduction of the new Razor SDK.<\/p>\n

To create a Razor UI class library, start with a .NET Standard class library and then update the SDK in the .csproj file to be Microsoft.NET.SDK.Razor<\/code>. The Razor SDK adds the necessary build targets and properties so that Razor files can be included in the build.<\/p>\n

To create your own Razor UI class library:<\/p>\n

    \n
  1. Create a .NET Standard class library\n
    dotnet new classlib -o ClassLibrary1\r\n<\/code><\/pre>\n<\/li>\n
  2. Add a reference from the class library to Microsoft.AspNetCore.Mvc<\/code>\n
    dotnet add ClassLibrary1 package Microsoft.AspNetCore.Mvc -v 2.1.0-preview2-final\r\n<\/code><\/pre>\n<\/li>\n
  3. Open ClassLibrary1.csproj<\/code> and change the SDK to be Microsoft.NET.SDK.Razor<\/code>\n
    \n
    <Project<\/span> Sdk<\/span>=\"<\/span>Microsoft.NET.Sdk.Razor\"<\/span><\/span>>\r\n\r\n  <PropertyGroup<\/span>>\r\n    <TargetFramework<\/span>>netstandard2.0<\/TargetFramework<\/span>>\r\n  <\/PropertyGroup<\/span>>\r\n\r\n  <ItemGroup<\/span>>\r\n    <PackageReference<\/span> Include<\/span>=\"<\/span>Microsoft.AspNetCore.Mvc\"<\/span><\/span> Version<\/span>=\"<\/span>2.1.0-preview2-final\"<\/span><\/span> \/>\r\n  <\/ItemGroup<\/span>>\r\n\r\n<\/Project<\/span>><\/pre>\n<\/div>\n<\/li>\n
  4. Add a Razor page and a view imports file to the class library\n
    dotnet new page -n Test -na ClassLibrary1.Pages -o ClassLibrary1\/Pages\r\ndotnet new viewimports -na ClassLibrary1.Pages -o ClassLibrary1\/Pages\r\n<\/code><\/pre>\n<\/li>\n
  5. Update the Razor page to add some markup\n
    \n
    @page\r\n\r\n<h1<\/span>>Hello from a Razor UI class library!<\/h1<\/span>><\/pre>\n<\/div>\n<\/li>\n
  6. Build the class library to ensure there are no build errors\n
    dotnet build ClassLibrary1\r\n<\/code><\/pre>\n
    In the build output you should see both ClassLibrary1.dll<\/code> and ClassLibrary1.Views.dll<\/code>, where the latter contains the compiled Razor content.<\/li>\n<\/ol>\n
    Now let’s use our Razor UI library from an ASP.NET Core web app.<\/p>\n
      \n
    1. Create a ASP.NET Core Web Application\n
      dotnet new razor -o WebApplication1\r\n<\/code><\/pre>\n<\/li>\n
    2. Create a solution file and add both projects to the solution\n
      dotnet new sln\r\ndotnet sln add WebApplication1\r\ndotnet sln add ClassLibrary1\r\n<\/code><\/pre>\n<\/li>\n
    3. Add a reference from the web application to the class library\n
      dotnet add WebApplication1 reference ClassLibrary1\r\n<\/code><\/pre>\n<\/li>\n
    4. Build and run the web app\n
      cd WebApplication1\r\ndotnet run\r\n<\/code><\/pre>\n<\/li>\n
    5. Browse to \/test<\/code> to see your page from your Razor UI class library\"Razor<\/a><\/li>\n<\/ol>\n
      Looks great! Now we can package up our Razor UI class library and share it with others.<\/p>\n
        \n
      1. Create a package for the Razor UI class library\n
        cd ..\r\ndotnet pack ClassLibrary1\r\n<\/code><\/pre>\n<\/li>\n
      2. Create a new web app and add a package reference to our Razor UI class library package\n
        dotnet new razor -o WebApplication2\r\ndotnet add WebApplication2 package ClassLibrary1 --source <current path>\/ClassLibrary1\/bin\/Debug\r\n<\/code><\/pre>\n<\/li>\n
      3. Run the new app with the package reference\n
        cd WebApplication2\r\ndotnet run\r\n<\/code><\/pre>\n<\/li>\n
      4. Browse to \/test<\/code> for the new app to see that your package is getting used.\"Razor<\/a><\/li>\n<\/ol>\n
        Publish your package to NuGet to share your handiwork with everyone.<\/p>\n
        <\/a>Razor compilation on build<\/h3>\n
        Razor compilation is now part of every build. This means that Razor compilation issues are caught at design time instead of when the app is first run. Compiling the Razor views and pages also significantly speeds up startup time. And even though your view and pages are built up front, you can still modify your Razor files at runtime and see them updated without having to restart the app.<\/p>\n
        <\/a>Scaffold identity into an existing project<\/h3>\n
        The latest preview of Visual Studio 2017 (15.7 Preview 3) supports scaffolding identity into an existing application and overriding specific pages from the default identity UI<\/a>.<\/p>\n
        To scaffold identity into an existing application:<\/p>\n
          \n
        1. Right-click on the project in the solution explorer and select Add -> New Scaffolded Item...<\/code><\/li>\n
        2. Select the Identity scaffolder and click Add.\"Add<\/a><\/li>\n
        3. The Add Identity dialog appears. Leave the layout unspecified. Check the checkbox in the override file list for “LoginPartial”. Also click the “+” button to create a new data context class and a custom identity user class. Click Add to run the identity scaffolder.\"Add<\/a>The scaffolder will add an Identity area to your application that configures identity and also will update the layout to include the login partial.<\/li>\n
        4. Update the Configure<\/code> method in Startup.cs<\/code> to add the database error page when in development and also the authentication middleware before invoking MVC.\n
          \n
          public<\/span> void<\/span> Configure<\/span>(IApplicationBuilder<\/span> app<\/span>, IHostingEnvironment<\/span> env<\/span>)\r\n{\r\n    if<\/span> (env.IsDevelopment())\r\n    {\r\n        app.UseDeveloperExceptionPage();\r\n        app.UseDatabaseErrorPage();\r\n    }\r\n    else<\/span>\r\n    {\r\n        app.UseExceptionHandler(\"<\/span>\/Error\"<\/span><\/span>);\r\n        app.UseHsts();\r\n    }\r\n\r\n    app.UseHttpsRedirection();\r\n    app.UseStaticFiles();\r\n    app.UseCookiePolicy();\r\n\r\n    app.UseAuthentication();\r\n\r\n    app.UseMvc();\r\n}<\/pre>\n<\/div>\n<\/li>\n
        5. The generated _ViewStart.cshtml<\/code> in this preview release contains an unfortunate typo in the specified layout path. Fixup the layout path to be \/Pages\/Shared\/_Layout.cshtml<\/code>. This will be fixed in the next release.<\/li>\n
        6. Select Tools -> NuGet Package Manager -> Package Manager Console<\/code> and run the following commands to add an EF migration and create the database.\n
          Add-Migration Initial\r\nUpdate-Database\r\n<\/code><\/pre>\n<\/li>\n
        7. Build and run the application. You should now be able to register and login users.\"Web<\/a><\/li>\n<\/ol>\n
          <\/a>Customize default Identity UI<\/h3>\n
          The identity scaffolder can also scaffold individual pages to override the default identity UI. For example, you can use a custom user type and update the identity UI to add additional user properties.<\/p>\n
            \n
          1. In the solution explorer right-click on the project you added Identity to in the previous section and select Add -> New Scaffolded Item...<\/code><\/li>\n
          2. Select the Identity scaffolder and click Add.\"Add<\/a><\/li>\n
          3. The Add Identity dialog appears. Again leave the layout unspecified. Check the checkbox for the AccountManageIndex<\/code> file. For the data context select the data context we created in the previous section. Click Add to run the identity scaffolder.\"Override<\/a><\/li>\n
          4. Fixup the layout path in _ViewStart.cshtml<\/code> as we did previously.<\/li>\n
          5. Open the generated \/Areas\/Identity\/Pages\/Account\/Manage\/Index.cshtml.cs<\/code> file and replace references IdentityUser<\/code> with your custom user type (ScaffoldIdentityWebAppUser<\/code>). This manual edit is necessary in this preview, but will be handled by the identity scaffolder in a future update.<\/li>\n
          6. Update ScaffoldIdentityWebAppUser<\/code> to add an Age<\/code> property.\n
            \n
                public<\/span> class<\/span> ScaffoldIdentityWebAppUser<\/span> : IdentityUser<\/span>\r\n    {\r\n        public <\/span>int<\/span> Age<\/span> { get<\/span>; set<\/span>; }\r\n    }<\/pre>\n<\/div>\n<\/li>\n
          7. Update the InputModel<\/code> in \/Areas\/Identity\/Pages\/Account\/Manage\/Index.cshtml.cs<\/code> to add a new Age<\/code> property.\n
            \n
            public<\/span> class<\/span> InputModel<\/span>\r\n{\r\n    [Required]\r\n    [EmailAddress]\r\n    public <\/span>string<\/span> Email<\/span> { get<\/span>; set<\/span>; }\r\n\r\n    [Phone]\r\n    [Display(Name = \"<\/span>Phone number\"<\/span><\/span>)]\r\n    public <\/span>string<\/span> PhoneNumber<\/span> { get<\/span>; set<\/span>; }\r\n    \r\n    [Range(0<\/span>, 120<\/span>)]\r\n    public <\/span>int<\/span> Age<\/span> { get<\/span>; set<\/span>; }\r\n}<\/pre>\n<\/div>\n<\/li>\n
          8. Update \/Areas\/Identity\/Pages\/Account\/Manage\/Index.cshtml<\/code> to add a field for setting the Age property. You can the field below the existing phone number field.\n
            \n
            <div<\/span> class<\/span>=\"<\/span>form-group\"<\/span><\/span>>\r\n    <label<\/span> asp-for<\/span>=\"<\/span>Input.Age\"<\/span><\/span>><\/label<\/span>>\r\n    <input<\/span> asp-for<\/span>=\"<\/span>Input.Age\"<\/span><\/span> class<\/span>=\"<\/span>form-control\"<\/span><\/span> \/>\r\n    <span<\/span> asp-validation-for<\/span>=\"<\/span>Input.Age\"<\/span><\/span> class<\/span>=\"<\/span>text-danger\"<\/span><\/span>><\/span<\/span>>\r\n<\/div<\/span>><\/pre>\n<\/div>\n<\/li>\n
          9. Update the OnPostAsync<\/code> method in \/Areas\/Identity\/Pages\/Account\/Manage\/Index.cshtml.cs<\/code> to save the user’s age to the database:\n
            \n
            if<\/span> (Input.Age<\/span> >= 0 && Input.Age < 120)\r\n{\r\n    user.Age = Input.Age;\r\n    await<\/span> _userManager.UpdateAsync(user);\r\n}<\/pre>\n<\/div>\n<\/li>\n
          10. Update the OnGetAsync<\/code> method in to initialize the InputModel<\/code> with the user’s age from the database:\n
            \n
            Input<\/span> = new InputModel\r\n{\r\n    Email = user.Email,\r\n    PhoneNumber = user.PhoneNumber,\r\n    Age = user.Age\r\n};<\/pre>\n<\/div>\n<\/li>\n
          11. Select Tools -> NuGet Package Manager -> Package Manager Console<\/code> and run the following commands to add an EF migration and update the database.\n
            Add-Migration UserAge\r\nUpdate-Database\r\n<\/code><\/pre>\n<\/li>\n
          12. Build and run the app. Register a user and then set the user’s age on the manage page:\"Web<\/a><\/li>\n<\/ol>\n
            <\/a>Improvements to [ApiController] parameter binding<\/h3>\n
            Applying [ApiController]<\/code> to your controller sets up convenient conventions for how parameters get bound to request data. In Preview 2 we’ve made a number of improvements to how these conventions work based on feedback:<\/p>\n