Upgrade z architektury ASP.NET na ASP.NET Core

Proč upgradovat na nejnovější .NET

ASP.NET Core je moderní webová architektura pro .NET. I když ASP.NET Core má mnoho podobností s ASP.NET v rozhraní .NET Framework, jedná se o novou architekturu, která se kompletně přepíše. ASP.NET aplikace aktualizované na ASP.NET Core můžou těžit z lepšího výkonu a přístupu k nejnovějším funkcím a možnostem vývoje webu.

přístupy k aktualizaci ASP.NET Frameworku

Většina jiných než triviálních aplikací ASP.NET Framework by měla zvážit použití přístupu přírůstkového upgradu . Další informace najdete v tématu Přírůstkové ASP.NET upgradu ASP.NET Core.

Informace o ASP.NET aplikacích MVC a webových rozhraní API najdete v tématu Informace o upgradu z ASP.NET MVC a webového rozhraní API na ASP.NET Core MVC. Informace o aplikacích webových formulářů ASP.NET Framework najdete v tématu Informace o upgradu z webových formulářů ASP.NET na ASP.NET Core.

Spolehlivé vzory webových aplikací

Pokyny k vytvoření moderní, spolehlivé, výkonné, testovatelné, nákladově efektivní a škálovatelné aplikace ASP.NET Core, ať už od začátku nebo refaktoring existující aplikace, najdete v článku o modelu Reliable Web App Pattern for.NET YouTube.

Rozdíly dekódování identifikátoru URI mezi ASP.NET na ASP.NET Core

ASP.NET Core má následující rozdíly dekódování identifikátorů URI s architekturou ASP.NET:

Při dekódování %2F na ASP.NET Core:

• Celá cesta se dostane unescaped s výjimkou %2F toho, že převod na / by změnil strukturu cesty. Nedá se dekódovat, dokud se cesta rozdělí do segmentů.

K vygenerování hodnoty HttpRequest.Urlpoužijte new Uri(this.AspNetCoreHttpRequest.GetEncodedUrl()); , abyste se vyhnuli Uri nesprávné interpretaci hodnot.

Migrace tajných kódů uživatelů z architektury ASP.NET na ASP.NET Core

Podívejte se na tento problém na GitHubu.

Tento článek slouží jako referenční příručka pro migraci aplikací ASP.NET na ASP.NET Core.

Visual Studio obsahuje nástroje, které vám pomůžou migrovat ASP.NET aplikace na ASP.NET Core. Další informace najdete v tématu Migrace z ASP.NET na ASP.NET Core v sadě Visual Studio.

Pomocník při upgradu na .NET je nástroj příkazového řádku, který může pomoct s migrací ASP.NET na ASP.NET Core. Další informace viz Přehled Pomocníka při upgradu na .NET a Upgrade aplikace ASP.NET MVC na .NET 6 pomocí Pomocníka při upgradu na .NET.

Komplexního průvodce přenesením najdete v elektronické knize Přenesení stávajících aplikací ASP.NET na .NET Core.

Požadavky

.NET Core SDK 2.2 nebo novější

Cílové architektury

Projekty ASP.NET Core nabízí vývojářům možnost flexibilně se zaměřit na .NET Core, .NET Framework nebo na obojí. Informace o tom, jak určit, která cílová architektura je nejvhodnější, viz Volba mezi .NET Core a .NET Framework pro serverové aplikace.

Při cílení na .NET Framework musí projekty odkazovat na jednotlivé balíčky NuGet.

Cílení na .NET Core umožňuje eliminovat početné explicitní odkazy na balíčky díky metabalíčku ASP.NET Core. Nainstalujte metabalíček Microsoft.AspNetCore.App do svého projektu:

<ItemGroup>
   <PackageReference Include="Microsoft.AspNetCore.App" />
</ItemGroup>

Při použití metabalíčku nejsou s aplikací nasazeny žádné balíčky, na které se odkazuje v metabalíčku. Tyto prostředky jsou zahrnuty v úložišti .NET Core Runtime Store a jsou předkompilovány kvůli zlepšení výkonu. Další podrobnosti viz Metabalíček Microsoft.AspNetCore.App pro ASP.NET Core.

Rozdíly struktury projektu

Formát souboru .csproj byl v ASP.NET Core zjednodušen. Mezi významné změny patří:

• Explicitní zahrnutí souborů není nutné k tomu, aby byly považovány za součást projektu. To snižuje riziko konfliktů při slučování XML při práci ve velkých týmech.

• Neexistují žádné odkazy na jiné projekty založené na GUID, což zlepšuje čitelnost souborů.

• Soubor lze upravovat, aniž by bylo nutné ho uvolnit ze sady Visual Studio:

  ]

Nahrazení souboru Global.asax

ASP.NET Core zavádí nový mechanismus spouštění aplikace. Vstupním bodem aplikací ASP.NET je soubor Global.asax. Úlohy, jako je konfigurace tras a registrace filtrů a oblastí, se zpracovávají v souboru Global.asax.

public class MvcApplication : System.Web.HttpApplication
{
    protected void Application_Start()
    {
        AreaRegistration.RegisterAllAreas();
        FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
        RouteConfig.RegisterRoutes(RouteTable.Routes);
        BundleConfig.RegisterBundles(BundleTable.Bundles);
    }
}

Tento přístup spojuje aplikaci a server, na kterém je nasazena, způsobem, který zasahuje do implementace. V rámci snahy o oddálení se zavedl OWIN, který poskytuje čistší způsob, jak používat více architektur společně. OWIN poskytuje kanál pro přidávání pouze potřebných modulů. Hostitelské prostředí využívá funkci Startup ke konfiguraci služeb a kanálu žádostí aplikace. Startup registruje sadu middlewaru s aplikací. U každé žádosti volá aplikace každou z komponent middlewaru s hlavním ukazatelem propojeného seznamu na existující sadu obslužných rutin. Každá komponenta middlewaru může do kanálu zpracování žádostí přidat jednu nebo více obslužných rutin. Toho se dosáhne vrácením odkazu na obslužnou rutinu, která je novým hlavním ukazatelem v seznamu. Každá obslužná rutina zodpovídá za zapamatování a vyvolání další obslužné rutiny v seznamu. V ASP.NET Core je vstupním bodem do aplikace příkaz Startup a už tu není závislost na souboru Global.asax. Při používání OWIN s .NET Framework použijte jako kanál něco, co se bude podobat následujícímu kódu:

using Owin;
using System.Web.Http;

namespace WebApi
{
    // Note: By default all requests go through this OWIN pipeline. Alternatively you can turn this off by adding an appSetting owin:AutomaticAppStartup with value “false”. 
    // With this turned off you can still have OWIN apps listening on specific routes by adding routes in global.asax file using MapOwinPath or MapOwinRoute extensions on RouteTable.Routes
    public class Startup
    {
        // Invoked once at startup to configure your application.
        public void Configuration(IAppBuilder builder)
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("Default", "{controller}/{customerID}", new { controller = "Customer", customerID = RouteParameter.Optional });

            config.Formatters.XmlFormatter.UseXmlSerializer = true;
            config.Formatters.Remove(config.Formatters.JsonFormatter);
            // config.Formatters.JsonFormatter.UseDataContractJsonSerializer = true;

            builder.UseWebApi(config);
        }
    }
}

Tím se nakonfigurují výchozí trasy a jako výchozí nastavení se použije XmlSerialization před souborem JSON. Podle potřeby přidejte do tohoto kanálu další middleware (načítání služeb, nastavení konfigurace, statické soubory atd.).

ASP.NET Core používá podobný přístup, ale nespoléhá se při zpracování položky na OWIN. Místo toho se to provádí metodou Program.cs Main (podobně jako konzolové aplikace) a Startup je načtena tam.

using Microsoft.AspNetCore;
using Microsoft.AspNetCore.Hosting;

namespace WebApplication2
{
    public class Program
    {
        public static void Main(string[] args)
        {
            CreateWebHostBuilder(args).Build().Run();
        }

        public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
            WebHost.CreateDefaultBuilder(args)
                .UseStartup<Startup>();
    }
}

Startup musí obsahovat metodu Configure. V Configure přidejte do kanálu potřebný middleware. V následujícím příkladu (z výchozí šablony webu) konfigurují rozšiřující metody kanál s podporou pro:

• Stránky chyb
• HTTP Strict Transport Security
• Přesměrování HTTP na HTTPS
• ASP.NET Core MVC

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }
    else
    {
        app.UseHsts();
    }

    app.UseHttpsRedirection();
    app.UseMvc();
}

Hostitel a aplikace byly odděleny, což umožňuje flexibilní přechod na jinou platformu v budoucnu.

Konfigurace úložiště

ASP.NET podporuje ukládání nastavení. Tato nastavení se používají například k podpoře prostředí, do kterého byly aplikace nasazeny. Běžný postup je ukládat všechny vlastní páry klíč-hodnota do oddílu <appSettings> v souboru Web.config:

<appSettings>
  <add key="UserName" value="User" />
  <add key="Password" value="Password" />
</appSettings>

Aplikace čtou tato nastavení pomocí kolekce ConfigurationManager.AppSettings v oboru názvů System.Configuration:

string userName = System.Web.Configuration.ConfigurationManager.AppSettings["UserName"];
string password = System.Web.Configuration.ConfigurationManager.AppSettings["Password"];

ASP.NET Core může ukládat konfigurační data aplikace do libovolného souboru a načítat je jako součást spouštění middlewaru. Výchozí soubor použitý v šablonách projektů je appsettings.json:

{
  "Logging": {
    "IncludeScopes": false,
    "LogLevel": {
      "Default": "Debug",
      "System": "Information",
      "Microsoft": "Information"
    }
  },
  "AppConfiguration": {
    "UserName": "UserName",
    "Password": "Password"
  }
}

Načtení tohoto souboru do instance IConfiguration v rámci aplikace se provádí v Startup.cs:

public Startup(IConfiguration configuration)
{
    Configuration = configuration;
}

public IConfiguration Configuration { get; }

Aplikace čte z Configuration, aby získala nastavení:

string userName = Configuration.GetSection("AppConfiguration")["UserName"];
string password = Configuration.GetSection("AppConfiguration")["Password"];

Existují rozšíření tohoto přístupu, aby byl proces robustnější, jako je například použití vkládání závislostí k načtení služby s těmito hodnotami. Metoda vkládání závislostí poskytuje sadu konfiguračních objektů se silnými typy.

// Assume AppConfiguration is a class representing a strongly-typed version of AppConfiguration section
services.Configure<AppConfiguration>(Configuration.GetSection("AppConfiguration"));

Nativní vkládání závislostí

Důležitým cílem při sestavování rozsáhlých škálovatelných aplikací je volné propojení komponent a služeb. Oblíbenou technikou pro dosažení tohoto cíle je technika vkládání závislostí, která je nativní komponentou ASP.NET Core.

V aplikacích ASP.NET se vývojáři při implementaci vkládání závislostí spoléhají na knihovny třetí strany. Jednou z takových knihoven je Unity, kterou poskytuje Microsoft Patterns &Practices.

Příkladem nastavení vkládání závislosti pomocí Unity je implementace IDependencyResolver, která zabalí UnityContainer:

using Microsoft.Practices.Unity;
using System;
using System.Collections.Generic;
using System.Web.Http.Dependencies;

public class UnityResolver : IDependencyResolver
{
    protected IUnityContainer container;

    public UnityResolver(IUnityContainer container)
    {
        if (container == null)
        {
            throw new ArgumentNullException("container");
        }
        this.container = container;
    }

    public object GetService(Type serviceType)
    {
        try
        {
            return container.Resolve(serviceType);
        }
        catch (ResolutionFailedException)
        {
            return null;
        }
    }

    public IEnumerable<object> GetServices(Type serviceType)
    {
        try
        {
            return container.ResolveAll(serviceType);
        }
        catch (ResolutionFailedException)
        {
            return new List<object>();
        }
    }

    public IDependencyScope BeginScope()
    {
        var child = container.CreateChildContainer();
        return new UnityResolver(child);
    }

    public void Dispose()
    {
        Dispose(true);
    }

    protected virtual void Dispose(bool disposing)
    {
        container.Dispose();
    }
}

Vytvořte si instanci UnityContainer, službu zaregistrujte a nastavte překladač závislostí HttpConfiguration na novou instanciUnityResolver vašeho kontejneru:

public static void Register(HttpConfiguration config)
{
    var container = new UnityContainer();
    container.RegisterType<IProductRepository, ProductRepository>(new HierarchicalLifetimeManager());
    config.DependencyResolver = new UnityResolver(container);

    // Other Web API configuration not shown.
}

Vložte IProductRepository tam, kde je to potřeba:

public class ProductsController : ApiController
{
    private IProductRepository _repository;

    public ProductsController(IProductRepository repository)  
    {
        _repository = repository;
    }

    // Other controller methods not shown.
}

Protože vkládání závislostí je součástí ASP.NET Core, můžete přidat svou službu v metodě ConfigureServices v souboru Startup.cs:

public void ConfigureServices(IServiceCollection services)
{
    // Add application services.
    services.AddTransient<IProductRepository, ProductRepository>();
}

Úložiště může být vloženo kdekoli, stejně jako to platí u Unity.

Poskytování statických souborů

Důležitou součástí vývoje webů je schopnost poskytovat statické prostředky na straně klienta. Nejběžnějšími příklady statických souborů jsou HTML, CSS, JavaScript a obrázky. Tyto soubory musí být uloženy v publikovaném umístění aplikace (nebo CDN) a odkazovány, aby je bylo možné načítat pomocí žádostí. Tento proces se v ASP.NET Core změnil.

V ASP.NET jsou statické soubory uloženy v různých adresářích a odkazovány v zobrazeních.

V ASP.NET Core se statické soubory ukládají do „kořene webu“ (<kořen obsahu>/wwwroot), pokud to není nakonfigurováno jinak. Soubory se načítají do kanálu žádostí voláním rozšiřující metody UseStaticFiles z Startup.Configure:

Například prostředek obrázku ve složce wwwroot/images je dostupný pro prohlížeč v umístění, jako je například http://<app>/images/<imageFileName>.

Soubory cookie s více hodnotami

Soubory cookie s více hodnotami se v ASP.NET Core nepodporují. Vytvářejte jeden soubor cookie na hodnotu.

Ověřovací soubory cookie nejsou komprimovány v ASP.NET Core.

Z bezpečnostních důvodů nejsou soubory cookie ověřování komprimované v ASP.NET Core. Při používání ověřovacích souborů cookie by vývojáři měli minimalizovat počet informací o deklaraci identity, které jsou zahrnuté jenom tak, aby to bylo nezbytné pro jejich potřeby.

Částečná migrace aplikace

Jedním z přístupů k částečné migraci aplikace je vytvoření dílčí aplikace služby IIS a přesunutí pouze určitých tras z ASP.NET 4.x do ASP.NET Core při zachování struktury URL aplikace. Vezměme si například strukturu URL aplikace ze souboru applicationHost.config:

<sites>
    <site name="Default Web Site" id="1" serverAutoStart="true">
        <application path="/">
            <virtualDirectory path="/" physicalPath="D:\sites\MainSite\" />
        </application>
        <application path="/api" applicationPool="DefaultAppPool">
            <virtualDirectory path="/" physicalPath="D:\sites\netcoreapi" />
        </application>
        <bindings>
            <binding protocol="http" bindingInformation="*:80:" />
            <binding protocol="https" bindingInformation="*:443:" sslFlags="0" />
        </bindings>
    </site>
	...
</sites>

Adresářová struktura:

.
├── MainSite
│   ├── ...
│   └── Web.config
└── NetCoreApi
    ├── ...
    └── web.config

[BIND] a formátovače vstupů

Předchozí verze ASP.NET používaly atribut [Bind] k ochraně před útoky typu overpost. Formátovače vstupů fungují v ASP.NET Core jinak. Atribut [Bind] už není navržený tak, aby při použití se vstupními formátovacími moduly pro parsování JSON nebo XML zabránil přesunutí. Tyto atributy ovlivňují vazbu modelu, pokud jsou zdrojem dat data formuláře publikovaná s typem obsahu x-www-form-urlencoded.

Pro aplikace, které publikují informace JSON na kontrolery a používají vstupní formát JSON k analýze dat, doporučujeme nahradit [Bind] atribut modelem zobrazení, který odpovídá vlastnostem definovaným atributem [Bind] .

Další materiály

• Přenos knihoven do .NET Core