Megosztás a következőn keresztül:

A ASP.NET Core 3.0 újdonságai

Ez a cikk a ASP.NET Core 3.0 legfontosabb változásait emeli ki a vonatkozó dokumentációra mutató hivatkozásokkal.

Blazor

Blazor az ASP.NET Core új keretrendszere az interaktív ügyféloldali webes felhasználói felület .NET-tel való létrehozásához:

  • Gazdag interaktív felhasználói felületeket hozhat létre a C# használatával.
  • Ossza meg a .NET-ben írt kiszolgálóoldali és ügyféloldali alkalmazáslogikát.
  • A felhasználói felületet HTML-ként és CSS-ként jeleníti meg a széles körű böngészőtámogatás érdekében, beleértve a mobilböngészőket is.

Blazor keretrendszer által támogatott forgatókönyvek:

  • Újrafelhasználható felhasználói felületi összetevők (Razor összetevők)
  • Ügyféloldali útválasztás
  • Összetevők elrendezései
  • Függőséginjektálás támogatása
  • Űrlapok és ellenőrzés
  • Összetevők ellátása Razor osztálykódtárakban Razor
  • JavaScript interop

További információ: ASP.NET Core Blazor.

Blazor Server

Blazor leválasztja az összetevők renderelési logikáját a felhasználói felületi frissítések alkalmazásáról. Blazor Server támogatja Razor összetevők üzemeltetését a kiszolgálón egy ASP.NET Core-alkalmazásban. A felhasználói felület frissítései SignalR kapcsolaton keresztül kezelhetők. Blazor Server ASP.NET Core 3.0 támogatja.

Blazor WebAssembly (előzetes verzió)

Blazor az alkalmazások közvetlenül a böngészőben is futtathatók WebAssembly-alapú .NET-futtatókörnyezet használatával. Blazor WebAssembly előzetes verzióban érhető el, és nem támogatott a ASP.NET Core 3.0-ban. Blazor WebAssembly A ASP.NET Core egy későbbi kiadásában támogatott lesz.

Razor összetevők

Blazor az alkalmazások összetevőkből épülnek fel. Az összetevők a felhasználói felület (UI) önálló adattömbjei, például egy lap, párbeszédpanel vagy űrlap. Az összetevők normál .NET-osztályok, amelyek felhasználói felületi renderelési logikát és ügyféloldali eseménykezelőket határoznak meg. JavaScript nélkül is létrehozhat gazdag interaktív webalkalmazásokat.

A Blazor komponenseket általában a Razor szintaxissal hozzák létre, amely a HTML és a C# természetes keveréke. Razor összetevők hasonlóak a Razor Pages és MVC nézetekhez, mivel mindkettő használja Razor. A kérés-válasz modellen alapuló oldalaktól és nézetektől eltérően az összetevők kifejezetten a felhasználói felület összetételének kezelésére szolgálnak.

gRPC

gRPC:

  • Egy népszerű, nagy teljesítményű RPC-keretrendszer (távoli eljáráshívás).

  • Véleményvezérelt, szerződés-első megközelítést kínál az API-fejlesztéshez.

  • Modern technológiákat használ, például:

    • HTTP/2 a szállításhoz.
    • Protokollpufferek a felület leírási nyelveként.
    • Bináris szerializálási formátum.

  • Olyan funkciókat biztosít, mint például:

    • Hitelesítés
    • Kétirányú streamelés és folyamatvezérlés.
    • Lemondás és időtúllépések.

GRPC-funkciók a ASP.NET Core 3.0-ban a következőket tartalmazzák:

  • Grpc.AspNetCore: A gRPC-szolgáltatások üzemeltetésére szolgáló ASP.NET Core-keretrendszer. A gRPC a ASP.NET Core-on olyan szabványos ASP.NET Core-funkciókkal integrálható, mint a naplózás, a függőséginjektálás (DI), a hitelesítés és az engedélyezés.
  • Grpc.Net.Client: A .NET Core-hoz készült gRPC-ügyfél, amely a jól ismert HttpClient.
  • Grpc.Net.ClientFactory: gRPC-ügyfélintegráció a HttpClientFactory.

További információ: A .NET-en található gRPC áttekintése.

SignalR

A migrálási SignalR utasítások frissítési kódját lásd. SignalR mostantól A JSON-üzenetek szerializálására/deszerializálására használja System.Text.Json .

JavaScript és .NET ügyfelekhez SignalR esetén támogatást adtak hozzá az automatikus újracsatlakozáshoz. Alapértelmezés szerint az ügyfél megpróbál azonnal újracsatlakozni, és szükség esetén 2, 10 és 30 másodperc után újra próbálkozik. Ha az ügyfél sikeresen újracsatlakozik, új kapcsolatazonosítót kap. Az automatikus újracsatlakozás választható.activációhoz kötött.

const connection = new signalR.HubConnectionBuilder()
    .withUrl("/chathub")
    .withAutomaticReconnect()
    .build();

Az újracsatlakozási időközök az ezredmásodpercen alapuló időtartamok tömbjének átadásával adhatók meg:

.withAutomaticReconnect([0, 3000, 5000, 10000, 15000, 30000])
//.withAutomaticReconnect([0, 2000, 10000, 30000]) The default intervals.

Az újracsatlakozási időközök teljes vezérlése érdekében egyéni implementációk is átadhatók.

Ha az újracsatlakozás az utolsó újracsatlakozási időköz után meghiúsul:

  • Az ügyfél úgy véli, hogy a kapcsolat offline állapotban van.
  • Az ügyfél nem próbál újracsatlakozni.

Az újracsatlakozási kísérletek során frissítse az alkalmazás felhasználói felületét, hogy értesítse a felhasználót az újracsatlakozás kísérletéről.

Ha felhasználói felületi visszajelzést szeretne adni a kapcsolat megszakadásakor, az SignalR ügyfél API ki lett bővítve a következő eseménykezelőkre:

  • onreconnecting: Lehetővé teszi a fejlesztők számára, hogy letilthassák a felhasználói felületet, vagy értesíthessék a felhasználókat arról, hogy az alkalmazás offline állapotban van.
  • onreconnected: Lehetővé teszi a fejlesztők számára a felhasználói felület frissítését a kapcsolat újbóli létrehozása után.

A következő kód a onreconnecting használatával frissíti a felhasználói felületet a csatlakozási próbálkozás során.

connection.onreconnecting((error) => {
    const status = `Connection lost due to error "${error}". Reconnecting.`;
    document.getElementById("messageInput").disabled = true;
    document.getElementById("sendButton").disabled = true;
    document.getElementById("connectionStatus").innerText = status;
});

A következő kód kapcsolat esetén a felhasználói felületet frissíti onreconnected használatával.

connection.onreconnected((connectionId) => {
    const status = `Connection reestablished. Connected.`;
    document.getElementById("messageInput").disabled = false;
    document.getElementById("sendButton").disabled = false;
    document.getElementById("connectionStatus").innerText = status;
});

SignalR A 3.0-s vagy újabb verziók egyéni erőforrást biztosítanak az engedélyezési kezelőknek, ha egy hub-metódus engedélyezést igényel. Az erőforrás a HubInvocationContextpéldánya. A HubInvocationContext következőkre vonatkozik:

  • HubCallerContext
  • A meghívandó központ metódusának neve.
  • A hub metódus argumentumai.

Tekintse meg az alábbi példát egy csevegőszoba-alkalmazásra, amely több szervezeti bejelentkezést tesz lehetővé az Azure Active Directoryn keresztül. Bárki bejelentkezhet a csevegésbe, aki Microsoft-fiókkal rendelkezik, de csak a tulajdonos szervezet tagjai tilthatják be a felhasználókat, vagy megtekinthetik a felhasználók csevegési előzményeit. Az alkalmazás bizonyos funkciókat bizonyos felhasználóktól korlátozhatja.

public class DomainRestrictedRequirement :
    AuthorizationHandler<DomainRestrictedRequirement, HubInvocationContext>,
    IAuthorizationRequirement
{
    protected override Task HandleRequirementAsync(AuthorizationHandlerContext context,
        DomainRestrictedRequirement requirement,
        HubInvocationContext resource)
    {
        if (context.User?.Identity?.Name == null)
        {
            return Task.CompletedTask;
        }

        if (IsUserAllowedToDoThis(resource.HubMethodName, context.User.Identity.Name))
        {
            context.Succeed(requirement);
        }

        return Task.CompletedTask;
    }

    private bool IsUserAllowedToDoThis(string hubMethodName, string currentUsername)
    {
        if (hubMethodName.Equals("banUser", StringComparison.OrdinalIgnoreCase))
        {
            return currentUsername.Equals("bob42@jabbr.net", StringComparison.OrdinalIgnoreCase);
        }

        return currentUsername.EndsWith("@jabbr.net", StringComparison.OrdinalIgnoreCase));
    }
}

Az előző kódban a DomainRestrictedRequirement egyedi IAuthorizationRequirementként szolgál. Mivel az HubInvocationContext erőforrásparaméter átadása folyamatban van, a belső logika a következőt teheti:

  • Vizsgálja meg a Hub hívásának környezetét.
  • Döntsön, hogy engedélyezi-e a felhasználónak az egyes Hub-metódusok végrehajtását.

Az egyes Hub-metódusok megjelölhetők annak a szabályzatnak a nevével, amit a kód futtatáskor ellenőriz. Amikor az ügyfelek megpróbálják meghívni az egyes Hub-metódusokat, a DomainRestrictedRequirement kezelő futtatja és szabályozza a metódusokhoz való hozzáférést. A DomainRestrictedRequirement által szabályozott hozzáférés alapján:

  • A metódust minden bejelentkezett felhasználó meghívhatja SendMessage .
  • Csak azok a felhasználók tekinthetik meg a felhasználók történetét, akik e-mail-címmel @jabbr.net jelentkeztek be.
  • Csak bob42@jabbr.net a csevegőszobából tilthat ki felhasználókat.
[Authorize]
public class ChatHub : Hub
{
    public void SendMessage(string message)
    {
    }

    [Authorize("DomainRestricted")]
    public void BanUser(string username)
    {
    }

    [Authorize("DomainRestricted")]
    public void ViewUserHistory(string username)
    {
    }
}

A szabályzat létrehozása magában foglalhatja a DomainRestricted következőket:

  • Az Startup.cs-ban adja hozzá az új szabályzatot.
  • Adja meg az egyéni DomainRestrictedRequirement követelményt paraméterként.
  • DomainRestricted regisztrálása az engedélyezési köztes szoftverrel.
services
    .AddAuthorization(options =>
    {
        options.AddPolicy("DomainRestricted", policy =>
        {
            policy.Requirements.Add(new DomainRestrictedRequirement());
        });
    });

SignalR a hubok végpont-útválasztást használnak. SignalR a hub-kapcsolat korábban kifejezetten megtörtént:

app.UseSignalR(routes =>
{
    routes.MapHub<ChatHub>("hubs/chat");
});

Az előző verzióban a fejlesztőknek különböző pontokon kellett összekapcsolni a vezérlőket, Razor oldalakat és központokat. Az explicit kapcsolat majdnem azonos útválasztási szegmensek sorozatát eredményezi:

app.UseSignalR(routes =>
{
    routes.MapHub<ChatHub>("hubs/chat");
});

app.UseRouting(routes =>
{
    routes.MapRazorPages();
});

SignalR A 3.0-s központok végpont-útválasztással irányíthatók. A végponti útválasztással általában az összes útválasztás konfigurálható a következőben UseRouting:

app.UseRouting(routes =>
{
    routes.MapRazorPages();
    routes.MapHub<ChatHub>("hubs/chat");
});

ASP.NET Core 3.0 SignalR jött létre új funkciókkal.

Ügyfél-kiszolgáló közötti streamelés. Az ügyfél-kiszolgáló közötti streamelés esetén a kiszolgálóoldali metódusok képesek példányokat átvenni, akár IAsyncEnumerable<T>, akár ChannelReader<T>. A következő C#-mintában a UploadStream hub metódusa sztringek adatfolyamát kapja meg az ügyféltől:

public async Task UploadStream(IAsyncEnumerable<string> stream)
{
    await foreach (var item in stream)
    {
        // process content
    }
}

A .NET-ügyfélalkalmazások a fenti Hub metódus argumentumaként megadhatnak egy IAsyncEnumerable<T> vagy egy ChannelReader<T> példányt stream.

Miután a for hurok befejeződött, és a helyi függvény kilép, a rendszer elküldi a stream befejezését:

async IAsyncEnumerable<string> clientStreamData()
{
    for (var i = 0; i < 5; i++)
    {
        var data = await FetchSomeData();
        yield return data;
    }
}

await connection.SendAsync("UploadStream", clientStreamData());

A JavaScript-ügyfélalkalmazások a fent említett Hub metódus SignalR argumentumához a Subject-t (vagy stream) használják.

let subject = new signalR.Subject();
await connection.send("StartStream", "MyAsciiArtStream", subject);

A JavaScript-kód a subject.next metódust felhasználhatja a sztringek kezelésére, amelyek rögzítettek és készen állnak a kiszolgálónak való elküldésre.

subject.next("example");
subject.complete();

Az előző két kódrészlethez hasonló kód használatával valós idejű streamelési élmények hozhatók létre.

Új JSON-szerializálás

ASP.NET Core 3.0 alapértelmezés szerint JSON-szerializálást használ System.Text.Json :

  • JSON-t olvas és ír aszinkron módon.
  • UTF-8 szövegre van optimalizálva.
  • Általában nagyobb a teljesítmény, mint Newtonsoft.Json.

Ha hozzá szeretné adni a Json.NET-et az ASP.NET Core 3.0-hoz, olvassa el a Támogatás hozzáadása a Newtonsoft.Json-alapú JSON formátumhoz.

Új Razor irányelvek

Az alábbi lista új Razor irányelveket tartalmaz:

  • @attribute: Az @attribute irányelv a létrehozott oldal vagy nézet osztályára alkalmazza a megadott attribútumot. Például: @attribute [Authorize].
  • @implements: Az @implements irányelv megvalósítja a létrehozott osztály felületét. Például: @implements IDisposable.

Az IdentityServer4 támogatja a webes API-k és SPA-k hitelesítését és engedélyezését

ASP.NET Core 3.0 egyoldalas alkalmazásokban (SPA-kban) nyújt hitelesítést a webes API-hitelesítés támogatásával. ASP.NET Core Identity felhasználók hitelesítésére és tárolására az IdentityServer4-nel kombinálva megvalósítja az OpenID Connectet.

Az IdentityServer4 egy OpenID Connect- és OAuth 2.0-keretrendszer ASP.NET Core 3.0-hoz. A következő biztonsági funkciókat teszi lehetővé:

  • Hitelesítés szolgáltatásként (AaaS)
  • Egyszeri bejelentkezés/kijelentkezés (SSO) több alkalmazástípuson keresztül
  • Hozzáférés-vezérlés API-khoz
  • Szövetségi átjáró

További információkért tekintse meg az IdentityServer4 dokumentációját vagy azSLA-k hitelesítését és engedélyezését.

Tanúsítvány és Kerberos-hitelesítés

A tanúsítványhitelesítéshez a következőre van szükség:

  • A kiszolgáló konfigurálása tanúsítványok elfogadására.
  • A hitelesítési köztes szoftver hozzáadása a Startup.Configure.
  • A tanúsítványhitelesítési szolgáltatás hozzáadása a következőben: Startup.ConfigureServices.
public void ConfigureServices(IServiceCollection services)
{
    services.AddAuthentication(
        CertificateAuthenticationDefaults.AuthenticationScheme)
            .AddCertificate();
    // Other service configuration removed.
}

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
    app.UseAuthentication();
    // Other app configuration removed.
}

A tanúsítványhitelesítési lehetőségek közé tartoznak a következők:

  • Önaláírt tanúsítványok elfogadása.
  • Ellenőrizze a tanúsítvány visszavonását.
  • Ellenőrizze, hogy a felkínált tanúsítvány rendelkezik-e a megfelelő használati zászlókkal.

A rendszer létrehoz egy alapértelmezett felhasználónevet a tanúsítvány tulajdonságaiból. A felhasználói jogosultság olyan eseményt tartalmaz, amely lehetővé teszi a jogosultság kiegészítését vagy cseréjét. További információ: Tanúsítványhitelesítés konfigurálása ASP.NET Core.

A Windows-hitelesítés linuxos és macOS rendszerre is ki lett terjesztve. A korábbi verziókban a Windows-hitelesítés csak IIS-ra és HTTP.sysvolt korlátozva. Az ASP.NET Core 3.0-ban Kestrel képes a Negotiate, Kerberos és NTLM használatára Windows, Linux és macOS rendszereken a Windows tartományhoz csatlakoztatott gazdagépekhez. Kestrel Ezeknek a hitelesítési sémáknak a támogatását a Microsoft.AspNetCore.Authentication.Negotiate NuGet csomag biztosítja. A többi hitelesítési szolgáltatáshoz hasonlóan konfigurálja a hitelesítési alkalmazást széles körben, majd konfigurálja a szolgáltatást:

public void ConfigureServices(IServiceCollection services)
{
    services.AddAuthentication(NegotiateDefaults.AuthenticationScheme)
        .AddNegotiate();
    // Other service configuration removed.
}

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
    app.UseAuthentication();
    // Other app configuration removed.
}

Gazdagép követelmények:

  • A Windows-gazdagépeknek hozzá kell adni a szolgáltatásnévneveket (SPN-eket) az alkalmazást futtató felhasználói fiókhoz.
  • Linux- és macOS-gépeket kell csatlakoztatni a tartományhoz.
    • A webes folyamathoz szolgáltatásnév (SPN) létrehozása szükséges.
    • A keytab-fájlokat a gazdaszámítógépen kell létrehozni és konfigurálni.

További információ: Windows-hitelesítés konfigurálása a ASP.NET Core-ban.

Sablonmódosítások

A webes felhasználói felület sablonjai (Razor Pages, MVC vezérlővel és nézetekkel) az alábbiakat távolítják el:

Az Angular-sablon az Angular 8 használatára frissült.

Az Razor osztálykönyvtár (RCL) sablon alapértelmezésként a Razor összetevők fejlesztésére szolgál. A Visual Studio új sablonbeállítása sablontámogatást biztosít a lapokhoz és nézetekhez. Ha RCL-t hoz létre a sablonból egy parancshéjban, adja meg a --support-pages-and-views (dotnet new razorclasslib --support-pages-and-views) lehetőséget.

Általános kiszolgáló

A ASP.NET Core 3.0-sablonok a .NET Generic Gazdagépet használják a ASP.NET Core-ban. Korábbi verziók a WebHostBuilder-t használták. A .NET Core Generic Host (HostBuilder) használata jobb integrációt biztosít a ASP.NET Core-alkalmazásokhoz más, nem webspecifikus kiszolgálói forgatókönyvekkel. További információért lásd: HostBuilder felváltja a WebHostBuildert.

Hoszt konfigurációja

Az ASP.NET Core 3.0 kiadása előtt a ASPNETCORE_ előtaggal rendelkező környezeti változók betöltődtek a webgazda konfigurációjába. A 3.0 verzióban a AddEnvironmentVariables szolgál a DOTNET_ előtaggal ellátott környezeti változók betöltésére host konfigurációhoz CreateDefaultBuilder.

A Startup konstruktor injektálásának változásai

Az Általános gazdagép csak a konstruktorinjektáláshoz a következő típusokat Startup támogatja:

Az összes szolgáltatás közvetlenül is injektálható a Startup.Configure metódus argumentumaként. További információért lásd: Generic Host restricts Startup constructor injection (aspnet/Announcements #353).

Kestrel

  • Kestrel konfigurációja frissítve lett az általános gazdagépre való migráláshoz. A 3.0 verzióban a Kestrel konfigurálva van a web hosztra, amelyet a ConfigureWebHostDefaults biztosít.
  • A csatlakozási adapterek el lettek távolítva a Kestrel-ből, és helyettesítve lettek a Connection Middleware-rel, amely hasonló a HTTP Middleware-hez az ASP.NET Core folyamatban, de az alacsonyabb szintű kapcsolatok kezelésére.
  • A Kestrel szállítási réteg nyilvános felületként lett elérhetővé téve a következőben Connections.Abstractions: .
  • A fejlécek és az utófejlécek közötti kétértelműséget úgy oldottuk meg, hogy a záró fejléceket egy új gyűjteménybe helyeztük.
  • A szinkron I/O API-k, mint például HttpRequest.Body.Read, az alkalmazások összeomlásához vezető száléhezés gyakori okai. A 3.0-ban AllowSynchronousIO alapértelmezés szerint le van tiltva.

További információ: Migrálás ASP.NET Core 2.2-ről 3.0-ra.

Alapértelmezés szerint engedélyezve van a HTTP/2

A HTTP/2 alapértelmezés szerint engedélyezve van a Kestrel HTTPS-végpontok esetében. Az IIS vagy a HTTP.sys HTTP/2 támogatása engedélyezve van, ha az operációs rendszer támogatja.

EventCounters kérésre

A Hosting EventSource Microsoft.AspNetCore.Hostinga következő új EventCounter típusokat bocsátja ki a bejövő kérelmekhez kapcsolódóan:

  • requests-per-second
  • total-requests
  • current-requests
  • failed-requests

Végpont útválasztása

A végpont-útválasztás, amely lehetővé teszi, hogy a keretrendszerek (például az MVC) jól működjenek a köztes szoftverekkel, továbbfejlesztett:

  • A köztes szoftver és a végpontok sorrendje konfigurálható a kérelemfeldolgozási folyamatban.Startup.Configure
  • A végpontok és a köztes szoftverek jól össze vannak összhangban más ASP.NET core-alapú technológiákkal, például az állapot-ellenőrzéssel.
  • A végpontok a köztes szoftverben és az MVC-ben is implementálhatnak olyan szabályzatokat, mint a CORS vagy az engedélyezés.
  • A szűrők és attribútumok a vezérlők metódusaihoz helyezhetők.

További információkért lásd: Útvonalkezelés az ASP.NET Core-ban.

Állapotellenőrzések

Az állapotellenőrzések végpont-útválasztást használnak az általános tárhelyszolgáltatóval. In Startup.Configure, hívja meg MapHealthChecks a végpontkészítőt a végpont URL-címével vagy relatív elérési útjával:

app.UseEndpoints(endpoints =>
{
    endpoints.MapHealthChecks("/health");
});

Az állapot-ellenőrzési végpontok a következőket tehetik:

  • Adjon meg egy vagy több engedélyezett gazdagépet/portot.
  • Engedélyezésre van szükség.
  • CORS-t igényel.

További információkért lásd a következő cikkeket:

Csővezetékek a HttpContextben

Mostantól beolvasható a kérelem törzse, és megírható a válasz törzse az System.IO.Pipelines API használatával. A HttpRequest.BodyReader tulajdonság egy olyan tulajdonságot PipeReader biztosít, amely a kérelem törzsének olvasására használható. A HttpResponse.BodyWriter tulajdonság egy olyan tulajdonságot PipeWriter biztosít, amely a válasz törzsének megírására használható. HttpRequest.BodyReader HttpRequest.Body adatfolyamának analógja. HttpResponse.BodyWriter HttpResponse.Body adatfolyamának analógja.

Továbbfejlesztett hibajelentés az IIS-ben

A ASP.NET Core-alkalmazások IIS-ben való üzemeltetésével kapcsolatos indítási hibák mostantól gazdagabb diagnosztikai adatokat hoznak létre. Ezeket a hibákat a rendszer a Windows eseménynaplójába jelenti, amennyiben lehetséges, veremkövetési információkkal. Emellett a rendszer minden figyelmeztetést, hibát és kezeletlen kivételt naplóz a Windows eseménynaplójába.

Feldolgozói szolgáltatás és feldolgozó SDK

A .NET Core 3.0 bemutatja az új Worker Service alkalmazássablont. Ez a sablon kiindulópontot biztosít a hosszú ideig futó szolgáltatások írásához a .NET Core-ban.

További információkért lásd:

Továbbított fejlécek Köztes szoftver fejlesztései

Az ASP.NET Core korábbi verzióiban, az Azure Linuxon vagy fordított proxy mögött, amely nem IIS, történő üzembe helyezéskor a UseHsts és UseHttpsRedirection hívása problémát okozott. A korábbi verziók javítása a Linux és nem IIS fordított proxyk sémájának továbbítása című témakörben található.

Ez a forgatókönyv ASP.NET Core 3.0-ban van javítva. A gazdagép engedélyezi a továbbított fejlécek köztes szoftvert, ha a ASPNETCORE_FORWARDEDHEADERS_ENABLED környezeti változó értéke true. ASPNETCORE_FORWARDEDHEADERS_ENABLED beállítás a true tárolórendszerképeinkben van beállítva.

Teljesítménybeli fejlesztések

ASP.NET Core 3.0 számos olyan fejlesztést tartalmaz, amelyek csökkentik a memóriahasználatot és javítják az átviteli sebességet:

  • A memóriahasználat csökkentése a beépített függőséginjektálási tároló hatóköralapú szolgáltatásokhoz való használatakor.
  • A kiosztások csökkentése a keretrendszerben, beleértve a köztes szoftveres forgatókönyveket és az útválasztást.
  • A WebSocket-kapcsolatok memóriahasználatának csökkentése.
  • A HTTPS-kapcsolatok memóriacsökkentési és átviteli sebességének javítása.
  • Új optimalizált és teljesen aszinkron JSON szerializáló.
  • A memóriahasználat és az átviteli sebesség csökkentése az űrlap-elemzésben.

ASP.NET Core 3.0 csak .NET Core 3.0-n fut

Az ASP.NET Core 3.0-tól kezdve a .NET Framework már nem támogatott célkeretrendszer. A .NET-keretrendszert célzó projektek a .NET Core 2.1 LTS-kiadással továbbra is teljes mértékben támogatott módon folytathatók. A legtöbb ASP.NET Core 2.1.x-csomag korlátlan ideig támogatott lesz a .NET Core 2.1 hároméves LTS-időszakán túl.

A migrálással kapcsolatos információkért tekintse meg a kód portját a .NET-keretrendszerből a .NET Core-ba.

A ASP.NET Core megosztott keretrendszerének használata

A Microsoft.AspNetCore.App metapackage-ben található ASP.NET Core 3.0 megosztott keretrendszerhez már nincs szükség explicit <PackageReference /> elemre a projektfájlban. A megosztott keretrendszerre a rendszer automatikusan hivatkozik, amikor az Microsoft.NET.Sdk.Web SDK-t használja a projektfájlban:

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

Az ASP.NET Core megosztott keretrendszerből eltávolított assemblyk

A ASP.NET Core 3.0 megosztott keretrendszerből eltávolított legfontosabb szerelvények a következők:

A megosztott keretrendszerből eltávolított szerelvények teljes listájáért tekintse meg a Microsoft.AspNetCore.App 3.0-s verziójából eltávolított szerelvényeket. A változás indokáról további információt a Microsoft.AspNetCore.App 3.0-s és a ASP.NET Core 3.0-s újdonságainak első áttekintésében talál.

Kritikus változások

A .NET kompatibilitástörő módosításainak cikkeit használva megtalálhatja azokat a kompatibilitástörő módosításokat, amelyek az alkalmazások újabb .NET-verzióra való frissítésekor alkalmazhatók.

  • Last updated on