Dall'archivio script > ASP.NET Core

Portare un progetto da ASP.NET Core 2.2 a 3.0

di Marco De SanctisMarco De Sanctis, in ASP.NET Core,

Come sappiamo, Microsoft ha recentemente rilasciato la versione 3.0 di ASP.NET Core. Nelle prossime settimane ci occuperemo in maniera dettagliata delle nuove funzionalità presenti in questa versione. Tuttavia, come dobbiamo comportarci quando abbiamo un progetto esistente che vogliamo migrare su 3.0?

Il passaggio, come vedremo, non è tra i più complicati.

Aggiornamento della reference version del progetto


Il primo step è quello di aggiornare la versione di ASP.NET Core referenziata dal nostro progetto, e il modo più semplice è editando direttamente il file .csproj:

<Project Sdk="Microsoft.NET.Sdk.Web">

  <PropertyGroup>
    <TargetFramework>netcoreapp3.0</TargetFramework>
    <AspNetCoreHostingModel>InProcess</AspNetCoreHostingModel>
  </PropertyGroup>

  <ItemGroup>
  </ItemGroup>

</Project>

Come possiamo notare, è sufficiente impostare il TargetFramework a netcoreapp3.0 e, se il Project SDK è impostato su Microsoft.NET.Sdk.Web, non abbiamo neanche necessità di referenziare il package Microsoft.AspNet.Core come avveniva in passato.

Il file Program.cs


La configurazione di Kestrel e in generale del bootstrap dell'applicazione ora usa la nuova interfaccia IHostBuilder, pertanto dobbiamo modificare la classe Program come segue:

public static IHostBuilder CreateHostBuilder(string[] args) =>
    Host.CreateDefaultBuilder(args)
        .ConfigureWebHostDefaults(webBuilder =>
        {
            webBuilder.UseStartup<Startup>();
        });

La classe Startup


La classe Startup è quella che richiede un po' più di lavoro. Il metodo Configure accetta ora un parametro di tipo IWebHostEnvironment, per il quale sono definiti extension method simili a quelli del vecchio IHostingEnvironment.

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
  // altro codice qui ..
  app.UseHttpsRedirection();
  app.UseStaticFiles();
  app.UseCookiePolicy();

  app.UseAuthentication();
  // da aggiungere se usiamo l'attributo Authorize
  app.UseAuthorization();

  // Middleware per il routing
  app.UseRouting();

  //in luogo di app.UseMvc() va configurato l'endpoint
  app.UseEndpoints(config => 
  {
    // se usiamo anche Razor Pages
    // config.MapRazorPages();
    config.MapControllerRoute("default", 
        "{controller=Home}/{action=Index}/{id?}");
  });
}

All'interno dello stesso metodo, dobbiamo effettuare anche le altre modifiche dello snippet in alto, tra cui aggiungere i middleware di Authorization e Routing e usare il nuovo metodo UseEndpoints per configurare le route dell'applicazione di controller e (eventualmente) Razor Pages.

Supporto a EntityFramework Core 3.0 e Identity


Se il nostro progetto originario utilizzava EntityFramework Core, dobbiamo ora aggiungere manualmente la reference, perché essa non è più inclusa all'interno del pacchetto Microsoft.AspNet.Core.

Ancora una volta, il modo più comodo per aggiungere i pacchetti necessari, è agire direttamente sul file di progetto, specificandole come PackageReference.

<ItemGroup>
  <!-- EntityFramework Core -->
  <PackageReference Include="Microsoft.EntityFrameworkCore" Version="3.0.0" />
  <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="3.0.0" />
  <PackageReference Include="Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore"
     Version="3.0.0" />

  <!-- AspNetCore Identity per Entity Framework Core -->
  <PackageReference Include="Microsoft.AspNetCore.Identity.EntityFrameworkCore" Version="3.0.0" />
  <PackageReference Include="Microsoft.AspNetCore.Identity.UI" Version="3.0.0" />
</ItemGroup>

Nell'esempio in alto, abbiamo aggiunto anche il package Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore, che ci permette di sfruttare il metodo UseDatabaseErrorPage nella classe di startup per configurare una pagina di errore per lo sviluppo, specifica per problemi con EntityFramework:

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
  if (env.IsDevelopment())
  {
    app.UseDeveloperExceptionPage();
    app.UseDatabaseErrorPage();
  }

  // .. altro codice qui..
}

Supporto a Newtonsoft Json.NET


Una delle principali novità di ASP.NET Core 3.0 è la rimozione della dipendenza da Newtonsoft Json.NET, in favore del nuovo package System.Text.Json. Se la nostra applicazione usa questa libreria, oltre all'opzione di migrare al nuovo serializer, abbiamo comunque la possibilità di continuare a sfruttare Json.NET.

Questo può essere vantaggioso se vogliamo limitare gli impatti nel codice: pensiamo per esempio a un'applicazione che fa un uso estensivo di JsonConvert o che ha diverse classi di dominio la cui serializzazione è personalizzata tramite gli attributi JsonConverter o JsonProperty.

In questo caso, oltre a ovviamente referenziare il package Newtonsoft.Json, dobbiamo includere anche Microsoft.AspNetCore.Mvc.NewtonsoftJson. Questa libreria ci permetterà di indicare nel metodo ConfigureServices quale serializer vogliamo utilizzare:

public void ConfigureServices(IServiceCollection services)
{
  // .. altro codice qui ..

  services.AddMvc()
    .AddNewtonsoftJson();
}

Conclusioni


Con questi semplici passaggi, dovremmo essere in grado a questo punto di eseguire il progetto con il runtime di ASP.NET Core 3.0. Per ulteriori dipendenze e per la soluzione di eventuali problemi, esiste una pagina appositamente dedicata alla migrazione nella documentazione ufficiale di ASP.NET Core:
https://docs.microsoft.com/en-us/aspnet/core/migration/22-to-30

Commenti

Visualizza/aggiungi commenti

| Condividi su: Twitter, Facebook, LinkedIn
Aggiorna

Per inserire un commento, devi avere un account.

Fai il login e torna a questa pagina, oppure registrati alla nostra community.

Approfondimenti

I più letti di oggi