Migrera ASP.NET Framework-session till ASP.NET Core

Sessionstillstånd är en viktig komponent i många webbprogram och lagrar användarspecifika data över HTTP-begäranden. När du migrerar från ASP.NET Framework till ASP.NET Core innebär sessionstillstånd unika utmaningar eftersom de två ramverken hanterar sessioner på ett helt annat sätt.

Varför sessionsmigrering är komplex

ASP.NET Framework och ASP.NET Core har i grunden olika metoder för sessionshantering:

• ASP.NET Framework tillhandahåller automatisk objektserialisering och inbyggd sessionslåsning
• ASP.NET Core kräver manuell serialisering och erbjuder inga garantier för sessionslåsning

Dessa skillnader innebär att du inte bara kan flytta sessionskoden från Framework till Core utan ändringar.

Översikt över migreringsstrategier

Du har tre huvudsakliga metoder för att hantera sessionstillstånd under migreringen:

1. Fullständig omskrivning – Skriv om all sessionskod för att använda ASP.NET Cores interna sessionsimplementering
2. Inkrementell med separata sessioner – Migrera komponenter bit för bit, där varje app behåller sitt eget sessionstillstånd
3. Inkrementell med delade sessioner – Migrera komponenter samtidigt som sessionsdata delas mellan Framework och Core-applikationer

För de flesta program ger migrering till ASP.NET Core-session bästa prestanda och underhållsbarhet. Större applikationer eller program med komplexa sessionskrav kan dock dra nytta av en inkrementell metod genom System.Web-adaptrarna.

Välj migreringsmetod

Du har tre huvudsakliga alternativ för att migrera sessionstillstånd från ASP.NET Framework till ASP.NET Core. Ditt val beror på din tidslinje för migrering, om du behöver köra båda programmen samtidigt och hur mycket kod du är villig att skriva om.

Snabb beslutsguide

Besvara dessa frågor för att välja din metod:

1. Gör du en fullständig omskrivning eller inkrementell migrering?

   • Slutför omskrivningen → inbyggd ASP.NET Core-session
   • Inkrementell migrering → Fortsätt till fråga 2

2. Behöver både dina ASP.NET Framework- och ASP.NET Core-appar komma åt samma sessionsdata?

   • Ja, delad session krävs → fjärrappsession
   • Nej, separata sessioner är bra → Insluten ASP.NET Core-session

Förstå skillnaderna

Innan du går in på implementeringsinformation är det viktigt att förstå hur ASP.NET Framework och ASP.NET Core hanterar sessionstillstånd på olika sätt:

• Objektserialisering
  • ASP.NET Framework serialiserar och deserialiserar objekt automatiskt (om du inte använder minnesintern lagring)
  • ASP.NET Core kräver manuell serialisering/deserialisering och lagrar data som byte[]
• Sessionslåsning
  • ASP.NET Framework låser sessionsanvändningen i en session och hanterar efterföljande begäranden seriellt
  • ASP.NET Core ger inga garantier för sessionslåsning

Jämförelse av migreringstillvägagångssätt

System.Web-adaptererna aktiverar angreppssätten "Wrapped" och "Remote app" genom att överbrygga skillnaderna mellan implementeringar av ASP.NET Framework-sessioner och Core-sessioner via två viktiga gränssnitt.

• Microsoft.AspNetCore.SystemWebAdapters.ISessionManager: Accepterar en HttpContext och sessionsmetadata, returnerar ett ISessionState objekt
• Microsoft.AspNetCore.SystemWebAdapters.ISessionState: Beskriver status för sessionsobjekt och säkerhetskopierar HttpSessionState typen

Inbyggt ASP.NET Core-sessionstillstånd

Välj den här metoden när du utför en fullständig migrering och kan skriva om sessionsrelaterad kod för att använda ASP.NET Cores interna sessionsimplementering.

ASP.NET Core tillhandahåller en enkel implementering av sessionstillstånd med höga prestanda som lagrar data som byte[] och kräver explicit serialisering. Den här metoden ger bästa prestanda men kräver fler kodändringar under migreringen.

Mer information om hur du konfigurerar och använder det finns i [ASP.NET sessionsdokumentation]((xref:fundamentals/app-state.md).

Fördelar och nackdelar

Överväganden vid migrering

När du migrerar till inbyggd ASP.NET Core-session:

Kodändringar krävs:

• Ersätt Session["key"] med HttpContext.Session.GetString("key")
• Ersätt Session["key"] = value med HttpContext.Session.SetString("key", value)
• Lägga till explicit serialisering/deserialisering för komplexa objekt
• Hantera null-värden explicit (ingen automatisk typkonvertering)

Datamigrering:

• Ändringar i sessionsdatastrukturen kräver noggrann planering
• Överväg att köra båda systemen parallellt under migreringen
• Implementera verktyg för import/export av sessionsdata om det behövs

Teststrategi:

• Enhetstestsessionsserialisering/deserialiseringslogik
• Beteende för integreringstestsessioner mellan begäranden
• Läsa in mönster för samtidig sessionsåtkomst för belastningstest

När du ska välja den här metoden:

• Du har råd att skriva om sessionsrelaterad kod
• Prestanda är högsta prioritet
• Du delar inte sessionsdata med äldre program
• Du vill eliminera System.Web-beroenden helt

System.Web Adapter Session

Serialiseringskonfiguration

Objektet HttpSessionState kräver serialisering för fjärrappsessionstillstånd.

I ASP.NET Framework användes BinaryFormatter för att automatiskt serialisera innehållet i sessionsvärdet. För att serialisera dessa för användning med System.Web-adaptrar måste serialiseringen uttryckligen konfigureras med implementeringar ISessionKeySerializer.

Det finns en enkel JSON-serialiserare som gör att varje sessionsnyckel kan registreras till en känd typ med hjälp av JsonSessionSerializerOptions:

• RegisterKey<T>(string) – Registrerar en sessionsnyckel för en känd typ. Den här registreringen krävs för korrekt serialisering/deserialisering. Saknade registreringar orsakar fel och förhindrar sessionsåtkomst.

builder.Services.AddSystemWebAdapters()
    .AddJsonSessionSerializer(options =>
    {
        // Serialization/deserialization requires each session key to be registered to a type
        options.RegisterKey<int>("test-value");
    });

Om det behövs mer anpassning kan du ISessionKeySerializer implementera:

builder.Services.AddSystemWebAdapters()
    .AddSessionSerializer();

builder.Services.AddSingleton<ISessionKeySerializer, CustomSessionKeySerializer>();

sealed class CustomSessionKeySerializer : ISessionKeySerializer
{
    public bool TryDeserialize(string key, byte[] bytes, out object? obj)
    {
        // Custom deserialization logic
    }

    public bool TrySerialize(string key, object? value, out byte[] bytes)
    {
        // Custom serialization logic
    }
}

Aktivera session

Sessionsstöd kräver explicit aktivering. Konfigurera den per väg eller globalt med hjälp av ASP.NET Core-metadata:

• Kommentera kontroller

[Session]
public class SomeController : Controller
{
}

• Aktivera globalt för alla slutpunkter

app.MapDefaultControllerRoute()
    .RequireSystemWebAdapterSession();

Inkapslad ASP.NET Core-sessionstillstånd

Välj den här metoden när dina migrerade komponenter inte behöver dela sessionsdata med ditt äldre program.

Tilläggsmetoden Microsoft.Extensions.DependencyInjection.WrappedSessionExtensions.AddWrappedAspNetCoreSession lägger till en förpackad ASP.NET Core-session för att använda adaptrar. Den använder samma lagringsplats som ISession och ger starkt typad åtkomst.

Konfiguration för ASP.NET Core:

builder.Services.AddSystemWebAdapters()
    .AddJsonSessionSerializer(options =>
    {
        // Serialization/deserialization requires each session key to be registered to a type
        options.RegisterKey<int>("test-value");
        options.RegisterKey<SessionDemoModel>("SampleSessionItem");
    })
    .AddWrappedAspNetCoreSession();

Framework-programmet kräver inga ändringar.

Mer information finns i exempelappen för omslutet sessionstillstånd

Fjärrappsessionstillstånd

Välj den här metoden när du behöver dela sessionstillstånd mellan dina ASP.NET Framework- och ASP.NET Core-program under inkrementell migrering.

Fjärrappsession möjliggör kommunikation mellan program för att hämta och ange sessionstillstånd genom att exponera en slutpunkt i ASP.NET Framework-appen.

Förutsättningar

Slutför installationsanvisningarna för fjärrappen för att ansluta dina ASP.NET Core- och ASP.NET Framework-program.

Programkonfiguration

builder.Services.AddSystemWebAdapters()
    .AddJsonSessionSerializer(options =>
    {
        // Serialization/deserialization requires each session key to be registered to a type
        options.RegisterKey<int>("test-value");
        options.RegisterKey<SessionDemoModel>("SampleSessionItem");
    })
    .AddRemoteAppClient(options =>
    {
        // Provide the URL for the remote app that has enabled session querying
        options.RemoteAppUrl = new(builder.Configuration["ReverseProxy:Clusters:fallbackCluster:Destinations:fallbackApp:Address"]);

        // Provide a strong API key that will be used to authenticate the request on the remote app for querying the session
        options.ApiKey = builder.Configuration["RemoteAppApiKey"];
    })
    .AddSessionClient();

public class Global : HttpApplication
{
        protected void Application_Start()
        {
            SystemWebAdapterConfiguration.AddSystemWebAdapters(this)
                .AddJsonSessionSerializer(options =>
                {
                    // Serialization/deserialization requires each session key to be registered to a type
                    options.RegisterKey<int>("test-value");
                    options.RegisterKey<SessionDemoModel>("SampleSessionItem");
                })
                // Provide a strong API key that will be used to authenticate the request on the remote app for querying the session
                // ApiKey is a string representing a GUID
                .AddRemoteAppServer(options => options.ApiKey = ConfigurationManager.AppSettings["RemoteAppApiKey"])
                .AddSessionServer();
        }
}

...

var coreApp = builder.AddProject<Projects.CoreApplication>("core")
    .WithHttpHealthCheck()
    .WaitFor(frameworkApp)
    .WithIncrementalMigrationFallback(frameworkApp, options => options.RemoteSession = RemoteSession.Enabled);

...

Kommunikationsprotokoll

Skrivskyddade sessioner

Readonly-sessioner hämtar sessionstillstånd utan att låsas. Processen använder en enskild GET begäran som returnerar sessionstillstånd och stängs omedelbart.

Skrivbara sessioner

Skrivbara sessioner kräver ytterligare steg:

• Börja med samma GET begäran som för skrivskyddad session
• Behåll den inledande GET begäran öppen tills sessionen har slutförts
• Använd ytterligare en PUT begäran om att uppdatera tillståndet
• Stäng den första begäran först när uppdateringen har slutförts