Globalization & Localization

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

  <PropertyGroup>
    <OutputType>WinExe</OutputType>
    <TargetFramework>net10.0-windows</TargetFramework>
    <Nullable>enable</Nullable>
    <UseWPF>true</UseWPF>
    <RootNamespace>Bookshelf.Desktop</RootNamespace>
    <!-- The language of Strings.resx; becomes the NeutralResourcesLanguage attribute. -->
    <NeutralLanguage>en</NeutralLanguage>
  </PropertyGroup>

  <ItemGroup>
    <!-- Generates a public strongly typed class named Strings. -->
    <EmbeddedResource Update="Properties\Strings.resx">
      <Generator>PublicResXFileCodeGenerator</Generator>
      <LastGenOutput>Strings.Designer.cs</LastGenOutput>
    </EmbeddedResource>
  </ItemGroup>

</Project>

using System.Resources;

// Equivalent to <NeutralLanguage>en</NeutralLanguage> in the project file.
[assembly: NeutralResourcesLanguage("en", UltimateResourceFallbackLocation.MainAssembly)]

namespace Bookshelf.Desktop;

using System.Globalization;
using Bookshelf.Core;
using Bookshelf.Desktop.Properties;
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;

public partial class BooksViewModel : ObservableObject
{
    private readonly IBookRepository repository;
    private readonly IDialogService dialogs;

    public BooksViewModel(IBookRepository repository, IDialogService dialogs)
    {
        this.repository = repository;
        this.dialogs = dialogs;
    }

    public ObservableCollection<BookViewModel> Books { get; } = new();

    [ObservableProperty]
    [NotifyCanExecuteChangedFor(nameof(RemoveCommand))]
    public partial BookViewModel? SelectedBook { get; set; }

    // Whole sentences, never concatenated fragments. Singular and plural are separate resources.
    public string BookCountText => Books.Count == 1
        ? Strings.BookCountOne
        : string.Format(CultureInfo.CurrentCulture, Strings.BookCountOther, Books.Count);

    [RelayCommand(CanExecute = nameof(CanRemove))]
    private async Task RemoveAsync()
    {
        if (SelectedBook is null)
        {
            return;
        }

        var message = string.Format(CultureInfo.CurrentCulture, Strings.ConfirmRemove, SelectedBook.Title);
        if (await dialogs.ConfirmAsync("Bookshelf Desktop", message))
        {
            Books.Remove(SelectedBook);
            OnPropertyChanged(nameof(BookCountText));
        }
    }

    private bool CanRemove() => SelectedBook is not null;
}

using System.Globalization;
using Bookshelf.Desktop.Properties;

var es = CultureInfo.GetCultureInfo("es");

// Uses the satellite assembly for "es" regardless of the current thread culture.
string title = Strings.ResourceManager.GetString("BooksTitle", es) ?? "";

<Window x:Class="Bookshelf.Desktop.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:p="clr-namespace:Bookshelf.Desktop.Properties"
        Title="{x:Static p:Strings.AppTitle}"
        SizeToContent="WidthAndHeight"
        MinWidth="480">
    <Grid Margin="12">
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="Auto" SharedSizeGroup="Buttons" />
            <ColumnDefinition Width="*" />
            <ColumnDefinition Width="Auto" SharedSizeGroup="Buttons" />
        </Grid.ColumnDefinitions>
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto" />
            <RowDefinition Height="*" />
        </Grid.RowDefinitions>

        <Button Grid.Column="0" Content="{x:Static p:Strings.AddBook}" Padding="12,4" />
        <TextBlock Grid.Column="1" Text="{x:Static p:Strings.BooksTitle}"
                   FontSize="18" Margin="12,0" TextWrapping="Wrap" VerticalAlignment="Center" />
        <Button Grid.Column="2" Content="{x:Static p:Strings.RemoveBook}" Padding="12,4" />
    </Grid>
</Window>

namespace Bookshelf.Desktop;

using System.ComponentModel;
using System.Globalization;
using Bookshelf.Desktop.Properties;

public sealed class LocalizationSource : INotifyPropertyChanged
{
    public static LocalizationSource Instance { get; } = new();

    private LocalizationSource()
    {
    }

    public event PropertyChangedEventHandler? PropertyChanged;

    // XAML: {Binding [BooksTitle], Source={x:Static local:LocalizationSource.Instance}}
    public string this[string key] =>
        Strings.ResourceManager.GetString(key, CultureInfo.CurrentUICulture) ?? $"!{key}!";

    public void Refresh() => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(string.Empty));
}

<TextBlock xmlns:local="clr-namespace:Bookshelf.Desktop"
           Text="{Binding [BooksTitle], Source={x:Static local:LocalizationSource.Instance}, Mode=OneWay}" />

<Button Content="{Binding [AddBook], Source={x:Static local:LocalizationSource.Instance}, Mode=OneWay}" />

namespace Bookshelf.Desktop;

using System.Globalization;
using System.Windows;
using System.Windows.Markup;

public partial class App : Application
{
    protected override void OnStartup(StartupEventArgs e)
    {
        // Saved user preference, or null to follow Windows.
        var saved = Environment.GetEnvironmentVariable("BOOKSHELF_LANGUAGE");
        var culture = string.IsNullOrWhiteSpace(saved)
            ? CultureInfo.CurrentUICulture
            : CultureInfo.GetCultureInfo(saved);

        Apply(culture);

        // Make the WPF element tree use the same culture for bindings and StringFormat.
        // OverrideMetadata may be called only once per type, so do it here and nowhere else.
        FrameworkElement.LanguageProperty.OverrideMetadata(
            typeof(FrameworkElement),
            new FrameworkPropertyMetadata(XmlLanguage.GetLanguage(culture.IetfLanguageTag)));

        base.OnStartup(e);
    }

    internal static void Apply(CultureInfo culture)
    {
        CultureInfo.DefaultThreadCurrentCulture = culture;
        CultureInfo.DefaultThreadCurrentUICulture = culture;
        Thread.CurrentThread.CurrentCulture = culture;
        Thread.CurrentThread.CurrentUICulture = culture;
    }
}

namespace Bookshelf.Desktop;

using System.Globalization;
using System.Windows;
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;

public sealed record LanguageOption(string Name, string Tag);

public partial class LanguageViewModel : ObservableObject
{
    public IReadOnlyList<LanguageOption> Languages { get; } =
    [
        new("English", "en"),
        new("Español", "es"),
    ];

    [ObservableProperty]
    public partial LanguageOption Selected { get; set; }

    public LanguageViewModel()
    {
        var current = CultureInfo.CurrentUICulture.TwoLetterISOLanguageName;
        Selected = Languages.FirstOrDefault(l => l.Tag == current) ?? Languages[0];
    }

    partial void OnSelectedChanged(LanguageOption value)
    {
        var culture = CultureInfo.GetCultureInfo(value.Tag);
        App.Apply(culture);
        LocalizationSource.Instance.Refresh();

        // Flow direction follows the writing system of the chosen culture.
        var flow = culture.TextInfo.IsRightToLeft ? FlowDirection.RightToLeft : FlowDirection.LeftToRight;
        foreach (Window window in Application.Current.Windows)
        {
            window.FlowDirection = flow;
        }
    }
}

<StackPanel Orientation="Horizontal" xmlns:local="clr-namespace:Bookshelf.Desktop">
    <TextBlock Text="{Binding [LanguageLabel], Source={x:Static local:LocalizationSource.Instance}, Mode=OneWay}"
               VerticalAlignment="Center" Margin="0,0,8,0" />
    <ComboBox ItemsSource="{Binding Languages}"
              SelectedItem="{Binding Selected}"
              DisplayMemberPath="Name"
              MinWidth="120" />
</StackPanel>

using System.Globalization;

decimal price = 1234.5m;
var lastOpened = new DateTime(2026, 10, 23, 18, 30, 0);

// Display: follows the user's culture.
string shownPrice = price.ToString("C2", CultureInfo.CurrentCulture);
string shownDate = lastOpened.ToString("d", CultureInfo.CurrentCulture);

// Storage and interchange: invariant culture, explicit round-trip format.
string storedPrice = price.ToString(CultureInfo.InvariantCulture);
string storedDate = lastOpened.ToString("O", CultureInfo.InvariantCulture);

<StackPanel xmlns:sys="clr-namespace:System;assembly=System.Runtime">
    <!-- Follows FrameworkElement.Language (en-US by default, es after the override in App.OnStartup). -->
    <TextBlock Text="{Binding Price, StringFormat={}{0:C2}}" />

    <!-- Fixed to a culture, regardless of Language. -->
    <TextBlock Text="{Binding Price, StringFormat={}{0:C2}, ConverterCulture=es-ES}" />

    <TextBlock Text="{Binding LastOpened, StringFormat={}{0:d}}" />
</StackPanel>

namespace Bookshelf.Desktop.ViewModels;

using CommunityToolkit.Mvvm.ComponentModel;

// A reduced stand-in for the scenario's BookDetailsViewModel, with only the members this example formats.
public partial class BookDetailsViewModel : ObservableObject
{
    [ObservableProperty]
    public partial string Title { get; set; } = "";

    [ObservableProperty]
    public partial decimal Price { get; set; }

    [ObservableProperty]
    public partial DateTime LastOpened { get; set; }
}

<Grid xmlns:local="clr-namespace:Bookshelf.Desktop" Margin="12">
    <Grid.ColumnDefinitions>
        <ColumnDefinition Width="Auto" SharedSizeGroup="Labels" />
        <ColumnDefinition Width="*" />
    </Grid.ColumnDefinitions>
    <Grid.RowDefinitions>
        <RowDefinition Height="Auto" />
        <RowDefinition Height="Auto" />
    </Grid.RowDefinitions>

    <TextBlock Grid.Row="0" Grid.Column="0" Margin="0,0,12,4"
               Text="{Binding [PriceLabel], Source={x:Static local:LocalizationSource.Instance}, Mode=OneWay}" />
    <TextBlock Grid.Row="0" Grid.Column="1" Text="{Binding Price, StringFormat={}{0:C2}}" />

    <TextBlock Grid.Row="1" Grid.Column="0" Margin="0,0,12,0"
               Text="{Binding [LastOpenedLabel], Source={x:Static local:LocalizationSource.Instance}, Mode=OneWay}" />
    <TextBlock Grid.Row="1" Grid.Column="1" Text="{Binding LastOpened, StringFormat={}{0:d}}" />
</Grid>

Bookshelf.WinUI/
  Strings/
    en-US/Resources.resw
    es-ES/Resources.resw
  Package.appxmanifest

<Page xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
      xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
      x:Class="Bookshelf.WinUI.BooksPage">
    <StackPanel Spacing="8" Padding="12">
        <TextBlock x:Uid="BooksHeader" />
        <AutoSuggestBox x:Uid="SearchBox" />
        <Button x:Uid="AddBookButton" />
    </StackPanel>
</Page>

namespace Bookshelf.WinUI;

using Microsoft.Windows.ApplicationModel.Resources;

public sealed class WinUiStrings
{
    private readonly ResourceLoader loader = new();

    public string ConfirmRemove => loader.GetString("ConfirmRemove");

    // A dotted identifier such as Fare.Well is addressed with a slash: Fare/Well.
    public string Get(string key) => loader.GetString(key.Replace('.', '/'));
}

using Microsoft.Windows.ApplicationModel.Resources;

var manager = new ResourceManager();
var context = manager.CreateResourceContext();
context.QualifierValues["Language"] = "es-ES";

var map = manager.MainResourceMap.GetSubtree("Resources");
string text = map.GetValue("ConfirmRemove", context).ValueAsString;