Skip to content
TheChatArchiveThe Chat Archive
Claudeclaude-sonnet-4-20250514-thinking-32k· AnthropicHugging Face LMArena Human Preference 140K

я пишу приложение на minimal API и мене надо при вызове определять язык…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Amazon Novaamazon.nova-pro-v1:0’s answer.
  1. User

    я пишу приложение на minimal API и мене надо при вызове определять язык пользовательского интерфейса, который указан в его URL, чтобы потом в фильтре приложения установить такой же CultureInfo.

    Как это сделать?

  2. Claude Assistant

    Для определения языка из URL и установки CultureInfo в minimal API можно использовать несколько подходов. Вот наиболее распространенные варианты:

    1. Использование параметра маршрута

    var builder = WebApplication.CreateBuilder(args);
    
    // Добавляем поддержку локализации
    builder.Services.Configure<RequestLocalizationOptions>(options =>
    {
        var supportedCultures = new[] { "en", "ru", "de" };
        options.SetDefaultCulture(supportedCultures[0])
               .AddSupportedCultures(supportedCultures)
               .AddSupportedUICultures(supportedCultures);
    });
    
    var app = builder.Build();
    
    // Middleware для извлечения языка из URL
    app.Use(async (context, next) =>
    {
        var path = context.Request.Path.Value;
        if (path != null && path.StartsWith("/"))
        {
            var segments = path.Split('/', StringSplitOptions.RemoveEmptyEntries);
            if (segments.Length > 0 && IsValidCulture(segments[0]))
            {
                var culture = segments[0];
                Thread.CurrentThread.CurrentCulture = new CultureInfo(culture);
                Thread.CurrentThread.CurrentUICulture = new CultureInfo(culture);
                
                // Удаляем язык из пути для дальнейшей обработки
                context.Request.Path = "/" + string.Join("/", segments.Skip(1));
            }
        }
        
        await next();
    });
    
    app.MapGet("/{lang}/api/users", (string lang) => 
    {
        var currentCulture = Thread.CurrentThread.CurrentUICulture.Name;
        return Results.Ok(new { Message = "Hello", Culture = currentCulture, RequestedLang = lang });
    });
    
    bool IsValidCulture(string culture)
    {
        var supportedCultures = new[] { "en", "ru", "de" };
        return supportedCultures.Contains(culture);
    }
    

    2. Использование query параметра

    var builder = WebApplication.CreateBuilder(args);
    var app = builder.Build();
    
    app.Use(async (context, next) =>
    {
        var langParam = context.Request.Query["lang"].FirstOrDefault();
        
        if (!string.IsNullOrEmpty(langParam) && IsValidCulture(langParam))
        {
            var culture = new CultureInfo(langParam);
            Thread.CurrentThread.CurrentCulture = culture;
            Thread.CurrentThread.CurrentUICulture = culture;
        }
        
        await next();
    });
    
    app.MapGet("/api/users", () => 
    {
        var currentCulture = Thread.CurrentThread.CurrentUICulture.Name;
        return Results.Ok(new { Message = "Hello", Culture = currentCulture });
    });
    // Вызов: /api/users?lang=ru
    

    3. Создание кастомного фильтра

    public class CultureActionFilter : IActionFilter
    {
        public void OnActionExecuting(ActionExecutingContext context)
        {
            var httpContext = context.HttpContext;
            
            // Попытка извлечь язык из маршрута
            if (httpContext.Request.RouteValues.TryGetValue("lang", out var langValue))
            {
                var language = langValue?.ToString();
                if (!string.IsNullOrEmpty(language) && IsValidCulture(language))
                {
                    SetCulture(language);
                }
            }
            // Альтернативно из query параметра
            else
            {
                var langParam = httpContext.Request.Query["lang"].FirstOrDefault();
                if (!string.IsNullOrEmpty(langParam) && IsValidCulture(langParam))
                {
                    SetCulture(langParam);
                }
            }
        }
    
        public void OnActionExecuted(ActionExecutedContext context) { }
    
        private void SetCulture(string culture)
        {
            var cultureInfo = new CultureInfo(culture);
            Thread.CurrentThread.CurrentCulture = cultureInfo;
            Thread.CurrentThread.CurrentUICulture = cultureInfo;
        }
    
        private bool IsValidCulture(string culture)
        {
            var supportedCultures = new[] { "en", "ru", "de" };
            return supportedCultures.Contains(culture);
        }
    }
    
    // Регистрация фильтра
    builder.Services.AddScoped<CultureActionFilter>();
    
    // Применение к конкретному endpoint
    app.MapGet("/{lang}/api/users", (string lang) => 
    {
        return Results.Ok(new { Culture = Thread.CurrentThread.CurrentUICulture.Name });
    }).AddEndpointFilter<CultureActionFilter>();
    

    4. Использование встроенного RequestLocalizationMiddleware

    var builder = WebApplication.CreateBuilder(args);
    
    builder.Services.Configure<RequestLocalizationOptions>(options =>
    {
        var supportedCultures = new[] { "en", "ru", "de" };
        options.SetDefaultCulture(supportedCultures[0])
               .AddSupportedCultures(supportedCultures)
               .AddSupportedUICultures(supportedCultures);
        
        // Настройка провайдеров для определения культуры
        options.RequestCultureProviders.Insert(0, new RouteDataRequestCultureProvider());
    });
    
    var app = builder.Build();
    
    app.UseRequestLocalization();
    
    app.MapGet("/{culture}/api/users", (string culture) => 
    {
        var currentCulture = Thread.CurrentThread.CurrentUICulture.Name;
        return Results.Ok(new { Culture = currentCulture });
    });
    

    Рекомендую использовать первый подход с middleware, так как он простой в реализации и дает полный контроль над извлечением языка из URL. Не забудьте добавить валидацию поддерживаемых языков, чтобы избежать ошибок при неправильных значениях.

  3. User

    ты неправильно понял, lang в строке и параметрах обращения к API отсутствует, он указан только при загрузке фронта в браузер mysite.com/ru-ru/index.html

  4. Claude Assistant

    Понял! Язык определяется только при загрузке фронта (например, /ru-ru/index.html), а затем фронт делает API вызовы без указания языка. В этом случае нужно передавать информацию о языке от фронта к API другими способами.

    1. Через HTTP заголовки (рекомендуемый подход)

    На фронте (JavaScript):

    // Извлекаем язык из URL при загрузке страницы
    const language = window.location.pathname.split('/')[1]; // "ru-ru"
    
    // Сохраняем в localStorage для последующих запросов
    localStorage.setItem('userLanguage', language);
    
    // Настраиваем все API запросы с заголовком
    fetch('/api/users', {
        headers: {
            'Accept-Language': language,
            // или кастомный заголовок
            'X-User-Language': language
        }
    })
    

    В minimal API:

    var builder = WebApplication.CreateBuilder(args);
    var app = builder.Build();
    
    app.Use(async (context, next) =>
    {
        // Проверяем кастомный заголовок
        var language = context.Request.Headers["X-User-Language"].FirstOrDefault();
        
        // Если нет кастомного, проверяем Accept-Language
        if (string.IsNullOrEmpty(language))
        {
            language = context.Request.Headers["Accept-Language"].FirstOrDefault();
        }
        
        if (!string.IsNullOrEmpty(language) && IsValidCulture(language))
        {
            var culture = new CultureInfo(language);
            Thread.CurrentThread.CurrentCulture = culture;
            Thread.CurrentThread.CurrentUICulture = culture;
        }
        
        await next();
    });
    
    app.MapGet("/api/users", () => 
    {
        var currentCulture = Thread.CurrentThread.CurrentUICulture.Name;
        return Results.Ok(new { Culture = currentCulture });
    });
    
    bool IsValidCulture(string culture)
    {
        try
        {
            CultureInfo.GetCultureInfo(culture);
            return true;
        }
        catch
        {
            return false;
        }
    }
    

    2. Через Cookie

    На фронте:

    // При загрузке страницы
    const language = window.location.pathname.split('/')[1];
    document.cookie = `userLanguage=${language}; path=/; max-age=31536000`; // год
    

    В API:

    app.Use(async (context, next) =>
    {
        if (context.Request.Cookies.TryGetValue("userLanguage", out var language))
        {
            if (IsValidCulture(language))
            {
                var culture = new CultureInfo(language);
                Thread.CurrentThread.CurrentCulture = culture;
                Thread.CurrentThread.CurrentUICulture = culture;
            }
        }
        
        await next();
    });
    

    3. Настройка Axios/Fetch для автоматической отправки заголовков

    Axios:

    // При инициализации приложения
    const language = window.location.pathname.split('/')[1];
    
    axios.defaults.headers.common['X-User-Language'] = language;
    
    // Или создать instance
    const apiClient = axios.create({
        headers: {
            'X-User-Language': language
        }
    });
    

    Fetch wrapper:

    const language = localStorage.getItem('userLanguage') || 
                     window.location.pathname.split('/')[1];
    
    const apiRequest = (url, options = {}) => {
        return fetch(url, {
            ...options,
            headers: {
                'X-User-Language': language,
                ...options.headers
            }
        });
    };
    
    // Использование
    apiRequest('/api/users').then(response => response.json());
    

    4. Комплексное решение с fallback

    var builder = WebApplication.CreateBuilder(args);
    
    // Настройка поддерживаемых культур
    var supportedCultures = new[] { "en-US", "ru-RU", "de-DE" };
    builder.Services.Configure<RequestLocalizationOptions>(options =>
    {
        options.SetDefaultCulture(supportedCultures[0])
               .AddSupportedCultures(supportedCultures)
               .AddSupportedUICultures(supportedCultures);
    });
    
    var app = builder.Build();
    
    app.Use(async (context, next) =>
    {
        string language = null;
        
        // Приоритет источников языка:
        // 1. Кастомный заголовок
        language = context.Request.Headers["X-User-Language"].FirstOrDefault();
        
        // 2. Cookie
        if (string.IsNullOrEmpty(language))
        {
            context.Request.Cookies.TryGetValue("userLanguage", out language);
        }
        
        // 3. Accept-Language заголовок
        if (string.IsNullOrEmpty(language))
        {
            language = context.Request.Headers["Accept-Language"].FirstOrDefault()?.Split(',')[0];
        }
        
        // Нормализация и валидация
        if (!string.IsNullOrEmpty(language))
        {
            language = NormalizeCulture(language);
            if (supportedCultures.Contains(language))
            {
                var culture = new CultureInfo(language);
                Thread.CurrentThread.CurrentCulture = culture;
                Thread.CurrentThread.CurrentUICulture = culture;
            }
        }
        
        await next();
    });
    
    string NormalizeCulture(string culture)
    {
        // Приводим к стандартному формату
        culture = culture.Trim().Replace('_', '-');
        
        // Маппинг для разных форматов
        return culture.ToLower() switch
        {
            "ru" or "ru-ru" => "ru-RU",
            "en" or "en-us" => "en-US", 
            "de" or "de-de" => "de-DE",
            _ => culture
        };
    }
    

    Рекомендую использовать первый подход с HTTP заголовками, так как он наиболее стандартный и надежный. Cookie тоже хороший вариант, особенно если нужно сохранять язык между сессиями.

  5. User

    Получается, что при каждом запросе пользователей из разных стран будет устанавливаться свой Culture? Как сильно это может повлиять на произвоительность?

  6. Claude Assistant

    Отличный вопрос! Да, установка Thread.CurrentThread.CurrentCulture при каждом запросе может негативно повлиять на производительность и создать проблемы в многопользовательском окружении.

    Проблемы с Thread.CurrentThread.CurrentCulture:

    1. Состояние гонки - один поток может обслуживать разных пользователей
    2. Загрязнение состояния - культура от одного пользователя может "просочиться" к другому
    3. Накладные расходы - установка культуры при каждом запросе

    Правильные подходы:

    1. Использование HttpContext.Items (рекомендуемый)

    app.Use(async (context, next) =>
    {
        var language = context.Request.Headers["X-User-Language"].FirstOrDefault();
        
        if (!string.IsNullOrEmpty(language) && IsValidCulture(language))
        {
            var culture = new CultureInfo(language);
            // Сохраняем в контексте запроса
            context.Items["RequestCulture"] = culture;
        }
        
        await next();
    });
    
    // Расширение для удобного доступа
    public static class HttpContextExtensions 
    {
        public static CultureInfo GetRequestCulture(this HttpContext context)
        {
            return context.Items["RequestCulture"] as CultureInfo ?? CultureInfo.CurrentCulture;
        }
    }
    
    // Использование в endpoint
    app.MapGet("/api/users", (HttpContext context) => 
    {
        var culture = context.GetRequestCulture();
        var localizedMessage = GetLocalizedMessage(culture);
        return Results.Ok(new { Message = localizedMessage, Culture = culture.Name });
    });
    

    2. Использование встроенного RequestLocalizationMiddleware

    var builder = WebApplication.CreateBuilder(args);
    
    builder.Services.Configure<RequestLocalizationOptions>(options =>
    {
        var supportedCultures = new[] { "en-US", "ru-RU", "de-DE" };
        options.SetDefaultCulture(supportedCultures[0])
               .AddSupportedCultures(supportedCultures)
               .AddSupportedUICultures(supportedCultures);
        
        // Кастомный провайдер для извлечения из заголовка
        options.RequestCultureProviders.Insert(0, new CustomHeaderRequestCultureProvider());
    });
    
    var app = builder.Build();
    
    app.UseRequestLocalization();
    
    // Кастомный провайдер
    public class CustomHeaderRequestCultureProvider : RequestCultureProvider
    {
        public override Task<ProviderCultureResult?> DetermineProviderCultureResult(HttpContext httpContext)
        {
            var language = httpContext.Request.Headers["X-User-Language"].FirstOrDefault();
            
            if (!string.IsNullOrEmpty(language))
            {
                return Task.FromResult<ProviderCultureResult?>(new ProviderCultureResult(language));
            }
            
            return Task.FromResult<ProviderCultureResult?>(null);
        }
    }
    
    // Использование
    app.MapGet("/api/users", (HttpContext context) => 
    {
        var culture = context.Features.Get<IRequestCultureFeature>()?.RequestCulture.Culture;
        return Results.Ok(new { Culture = culture?.Name });
    });
    

    3. Dependency Injection с Scoped сервисом

    public interface ICultureService
    {
        CultureInfo GetCurrentCulture();
    }
    
    public class CultureService : ICultureService
    {
        private readonly HttpContext _httpContext;
        
        public CultureService(IHttpContextAccessor httpContextAccessor)
        {
            _httpContext = httpContextAccessor.HttpContext;
        }
        
        public CultureInfo GetCurrentCulture()
        {
            if (_httpContext?.Items.TryGetValue("RequestCulture", out var culture) == true)
            {
                return culture as CultureInfo ?? CultureInfo.CurrentCulture;
            }
            
            return CultureInfo.CurrentCulture;
        }
    }
    
    // Регистрация
    builder.Services.AddHttpContextAccessor();
    builder.Services.AddScoped<ICultureService, CultureService>();
    
    // Использование
    app.MapGet("/api/users", (ICultureService cultureService) => 
    {
        var culture = cultureService.GetCurrentCulture();
        return Results.Ok(new { Culture = culture.Name });
    });
    

    4. Локализация сообщений без установки Thread Culture

    public class LocalizationService
    {
        private readonly Dictionary<string, Dictionary<string, string>> _translations = new()
        {
            ["en-US"] = new() { ["Hello"] = "Hello", ["Welcome"] = "Welcome" },
            ["ru-RU"] = new() { ["Hello"] = "Привет", ["Welcome"] = "Добро пожаловать" }
        };
        
        public string GetString(string key, CultureInfo culture)
        {
            if (_translations.TryGetValue(culture.Name, out var translations) &&
                translations.TryGetValue(key, out var translation))
            {
                return translation;
            }
            
            return key; // fallback
        }
    }
    
    app.MapGet("/api/users", (HttpContext context, LocalizationService localization) => 
    {
        var culture = context.GetRequestCulture();
        var message = localization.GetString("Welcome", culture);
        return Results.Ok(new { Message = message });
    });
    

    Влияние на производительность:

    • HttpContext.Items - минимальные накладные расходы
    • RequestLocalizationMiddleware - оптимизирован Microsoft, кэширует результаты
    • Thread.CurrentCulture - может быть проблематично при высокой нагрузке

    Рекомендация: Используйте HttpContext.Items или встроенный RequestLocalizationMiddleware. Они безопасны для многопользовательского окружения и имеют минимальное влияние на производительность.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.