C#中动态修改静态变量实现网站运行时切换语言（非会话/Cookie方案）

Alright, let's fix this up. The core problem with your current setup is that CurrentLanguage is a readonly static field—once your application starts, that value is locked in, so you can't switch languages while the app is running. Since you want to avoid sessions or expiring cookies, we'll use stateless, request-based language resolution—the most user-friendly (and SEO-friendly) approach is embedding the language code directly in the URL. Here's how to implement it:

Step 1: Refactor the LanguageFactory #

First, we'll replace the static hardcoded CurrentLanguage with a method that pulls the language code from the current request. This way, every request gets the appropriate language based on the URL (or a fallback if none is specified).

public class LanguageCodes { 
    public const string DenmarkCode = "DK"; 
    public const string SwedenCode = "SE"; 
} 

public class LanguageFactory { 
    // Replace the static Current property with a request-aware method
    public static AbstractLanguage GetCurrent(HttpContext context)
    {
        string languageCode = ResolveLanguageCodeFromRequest(context);
        
        switch (languageCode) { 
            case LanguageCodes.DenmarkCode: 
                return new LanguageDK(); 
            case LanguageCodes.SwedenCode: 
                return new LanguageSE(); 
            default:
                // Fallback to default language if invalid code is provided
                return new LanguageDK();
        } 
    }

    private static string ResolveLanguageCodeFromRequest(HttpContext context)
    {
        // 1. First, try to get the language code from the URL path
        // Assumes URLs follow format: /{lang}/controller/action
        var pathSegments = context.Request.Path.Value.Split('/')
            .Where(segment => !string.IsNullOrWhiteSpace(segment))
            .ToList();

        if (pathSegments.Any() && IsValidLanguageCode(pathSegments[0]))
        {
            return pathSegments[0].ToUpperInvariant();
        }

        // 2. Fallback: Use the browser's Accept-Language header
        var acceptLanguageHeader = context.Request.Headers.AcceptLanguage.FirstOrDefault();
        if (!string.IsNullOrWhiteSpace(acceptLanguageHeader))
        {
            var primaryLanguage = acceptLanguageHeader.Split(',')[0].Split('-')[0].ToUpperInvariant();
            if (primaryLanguage == "DA") return LanguageCodes.DenmarkCode;
            if (primaryLanguage == "SV") return LanguageCodes.SwedenCode;
        }

        // 3. Final fallback: Default to Danish
        return LanguageCodes.DenmarkCode;
    }

    private static bool IsValidLanguageCode(string code)
    {
        return code.Equals(LanguageCodes.DenmarkCode, StringComparison.OrdinalIgnoreCase) ||
               code.Equals(LanguageCodes.SwedenCode, StringComparison.OrdinalIgnoreCase);
    }
}

Step 2: Configure Localized Routes #

Next, update your routing to support the language code in the URL. This ensures that requests like /dk/home or /se/products are properly routed, and the language code is available for resolution.

If you're using ASP.NET Core, add these routes in your Program.cs (or Startup.cs for older versions):

// Localized route (matches URLs with language code)
app.MapControllerRoute(
    name: "localized",
    pattern: "{lang:regex(^dk$|^se$)}/{controller=Home}/{action=Index}/{id?}");

// Default route (redirects to default language if no code is present)
app.MapControllerRoute(
    name: "default",
    pattern: "{controller=Home}/{action=Index}/{id?}",
    defaults: new { lang = LanguageCodes.DenmarkCode });

The regex constraint ensures only valid language codes (dk or se) are accepted in the URL.

Step 3: Use the Language in Controllers/Views #

Now, you can fetch the current language in your controllers by passing the HttpContext:

public class HomeController : Controller
{
    public IActionResult Index()
    {
        var currentLanguage = LanguageFactory.GetCurrent(HttpContext);
        ViewBag.WelcomeMessage = currentLanguage.GetWelcomeMessage(); // Example method on your AbstractLanguage
        return View();
    }
}

In your views, add language switch links that point to the correct localized URLs:

<!-- Language Switcher -->
<div class="language-switcher">
    <a href="@Url.Action("Index", "Home", new { lang = "dk" })">Dansk</a>
    <a href="@Url.Action("Index", "Home", new { lang = "se" })">Svenska</a>
</div>

Alternative Stateless Options #

If URLs aren't your preference, here are two other stateless approaches:

• Subdomains: Use dk.yourdomain.com and se.yourdomain.com. Modify ResolveLanguageCodeFromRequest to parse the subdomain from context.Request.Host.Host.
• Custom Request Header: For API scenarios, have clients send an X-Language-Code header. Read it in ResolveLanguageCodeFromRequest with context.Request.Headers["X-Language-Code"].FirstOrDefault().

Why This Works #

This approach is completely stateless—no sessions or cookies required. The language is determined per-request from the URL (or fallback sources), so switching languages is as simple as navigating to the correct URL. It's also SEO-friendly, as search engines can index each language version separately.

内容的提问来源于stack exchange，提问作者Nick Developer