### Get Uid from Control

Source: https://context7.com/andrewkeepcoding/winui3localizer/llms.txt

Retrieve the Uid that has been assigned to a DependencyObject. This can be used for debugging or to perform actions based on the control's identifier.

```csharp
// Getting the current Uid from a control
private void OnControlPointerEntered(object sender, PointerRoutedEventArgs e)
{
    if (sender is DependencyObject dependencyObject)
    {
        string uid = Uids.GetUid(dependencyObject);
        Console.WriteLine($"Hovered control Uid: {uid}");
    }
}
```

--------------------------------

### Configure Project File for Resource Deployment

Source: https://context7.com/andrewkeepcoding/winui3localizer/llms.txt

Update the .csproj file to include the WinUI3Localizer package and ensure .resw files are copied to the output directory.

```xml
<!-- MyApp.csproj -->
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>WinExe</OutputType>
    <TargetFramework>net7.0-windows10.0.19041.0</TargetFramework>
    <TargetPlatformMinVersion>10.0.17763.0</TargetPlatformMinVersion>
    <UseWinUI>true</UseWinUI>
  </PropertyGroup>

  <!-- NuGet package reference -->
  <ItemGroup>
    <PackageReference Include="WinUI3Localizer" Version="2.3.0" />
  </ItemGroup>

  <!-- Copy all .resw files in the Strings folder to output directory -->
  <ItemGroup>
    <Content Include="Strings\**\*.resw">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </Content>
  </ItemGroup>
</Project>
```

--------------------------------

### Initialize Localizer for Non-Packaged Apps

Source: https://github.com/andrewkeepcoding/winui3localizer/blob/main/README.md

Configure the Localizer in App.xaml.cs for non-packaged applications by pointing to the local file system path.

```csharp
private async Task InitializeLocalizer()
{
    // Initialize a "Strings" folder in the executables folder.
    StringsFolderPath StringsFolderPath = Path.Combine(AppContext.BaseDirectory, "Strings");
    StorageFolder stringsFolder = await StorageFolder.GetFolderFromPathAsync(StringsFolderPath);

    ILocalizer localizer = await new LocalizerBuilder()
        .AddStringResourcesFolderForLanguageDictionaries(StringsFolderPath)
        .SetOptions(options =>
        {
            options.DefaultLanguage = "en-US";
        })
        .Build();
}
```

--------------------------------

### Configure Project File for Resource Copying

Source: https://github.com/andrewkeepcoding/winui3localizer/blob/main/README.md

Add this ItemGroup to your .csproj file to ensure all .resw files in the Strings folder are copied to the output directory.

```xml
<!-- Copy all "Resources.resw" files in the "Strings" folder to the output folder. -->
<ItemGroup>
  <Content Include="Strings\**\*.resw">
    <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
  </Content>
</ItemGroup>
```

--------------------------------

### Define Resource Files in .resw Format

Source: https://context7.com/andrewkeepcoding/winui3localizer/llms.txt

Organize string resources in .resw files by language. Map Uid.Property names to localized values for automatic UI updates.

```xml
<!-- Strings/en-US/Resources.resw -->
<?xml version="1.0" encoding="utf-8"?>
<root>
  <data name="WelcomeText.Text" xml:space="preserve">
    <value>Welcome to Our App</value>
  </data>
  <data name="SubmitButton.Content" xml:space="preserve">
    <value>Submit</value>
  </data>
  <data name="EmailTextBox.PlaceholderText" xml:space="preserve">
    <value>Enter your email</value>
  </data>
  <data name="EmailTextBox.Header" xml:space="preserve">
    <value>Email Address</value>
  </data>
  <data name="RememberMeCheckBox.Content" xml:space="preserve">
    <value>Remember me</value>
  </data>
  <data name="DarkModeToggle.Header" xml:space="preserve">
    <value>Dark Mode</value>
  </data>
  <data name="DarkModeToggle.OnContent" xml:space="preserve">
    <value>On</value>
  </data>
  <data name="DarkModeToggle.OffContent" xml:space="preserve">
    <value>Off</value>
  </data>
  <!-- Simple key for code-behind usage -->
  <data name="Red" xml:space="preserve">
    <value>Red</value>
  </data>
  <data name="Green" xml:space="preserve">
    <value>Green</value>
  </data>
  <data name="Blue" xml:space="preserve">
    <value>Blue</value>
  </data>
</root>

<!-- Strings/es-ES/Resources.resw -->
<?xml version="1.0" encoding="utf-8"?>
<root>
  <data name="WelcomeText.Text" xml:space="preserve">
    <value>Bienvenido a Nuestra App</value>
  </data>
  <data name="SubmitButton.Content" xml:space="preserve">
    <value>Enviar</value>
  </data>
  <data name="EmailTextBox.PlaceholderText" xml:space="preserve">
    <value>Ingrese su correo</value>
  </data>
  <data name="Red" xml:space="preserve">
    <value>Rojo</value>
  </data>
  <data name="Green" xml:space="preserve">
    <value>Verde</value>
  </data>
  <data name="Blue" xml:space="preserve">
    <value>Azul</value>
  </data>
</root>

<!-- Strings/ja/Resources.resw -->
<?xml version="1.0" encoding="utf-8"?>
<root>
  <data name="WelcomeText.Text" xml:space="preserve">
    <value>アプリへようこそ</value>
  </data>
  <data name="SubmitButton.Content" xml:space="preserve">
    <value>送信</value>
  </data>
  <data name="Red" xml:space="preserve">
    <value>赤</value>
  </data>
  <data name="Green" xml:space="preserve">
    <value>緑</value>
  </data>
  <data name="Blue" xml:space="preserve">
    <value>青</value>
  </data>
</root>
```

--------------------------------

### Initialize Localizer with LocalizerBuilder

Source: https://context7.com/andrewkeepcoding/winui3localizer/llms.txt

Configures and builds the ILocalizer singleton using various initialization patterns for packaged, non-packaged, and advanced logging scenarios.

```csharp
using WinUI3Localizer;
using Microsoft.Extensions.Logging;
using Windows.Storage;

// Non-packaged app initialization
private async Task InitializeLocalizerForNonPackagedApp()
{
    string stringsFolderPath = Path.Combine(AppContext.BaseDirectory, "Strings");

    ILocalizer localizer = await new LocalizerBuilder()
        .AddStringResourcesFolderForLanguageDictionaries(stringsFolderPath)
        .SetOptions(options =>
        {
            options.DefaultLanguage = "en-US";
            options.DisableDefaultLocalizationActions = false;
        })
        .Build();
}

// Packaged app initialization with resource file setup
private async Task InitializeLocalizerForPackagedApp()
{
    StorageFolder localFolder = ApplicationData.Current.LocalFolder;
    StorageFolder stringsFolder = await localFolder.CreateFolderAsync(
        "Strings",
        CreationCollisionOption.OpenIfExists);

    // Ensure resource files exist for each language
    await CreateStringResourceFileIfNotExists(stringsFolder, "en-US", "Resources.resw");
    await CreateStringResourceFileIfNotExists(stringsFolder, "es-ES", "Resources.resw");
    await CreateStringResourceFileIfNotExists(stringsFolder, "ja", "Resources.resw");

    ILocalizer localizer = await new LocalizerBuilder()
        .AddStringResourcesFolderForLanguageDictionaries(stringsFolder.Path)
        .SetDefaultStringResourcesFileName("Resources.resw")
        .SetOptions(options =>
        {
            options.DefaultLanguage = "en-US";
        })
        .Build();
}

// Advanced initialization with logging and custom actions
private async Task InitializeLocalizerWithLogging(ILoggerFactory loggerFactory)
{
    string stringsFolderPath = Path.Combine(AppContext.BaseDirectory, "Strings");

    ILocalizer localizer = await new LocalizerBuilder()
        .AddStringResourcesFolderForLanguageDictionaries(stringsFolderPath)
        .SetLogger(loggerFactory.CreateLogger<Localizer>())
        .AddLocalizationAction(new LocalizationActions.ActionItem(
            typeof(CustomControl),
            args =>
            {
                if (args.DependencyObject is CustomControl target)
                {
                    target.LocalizedText = args.Value;
                }
            }))
        .SetOptions(options =>
        {
            options.DefaultLanguage = "ja";
        })
        .Build();
}
```

--------------------------------

### Create Localized Menu Dynamically

Source: https://context7.com/andrewkeepcoding/winui3localizer/llms.txt

Dynamically build a menu with items that are localized using Uids. This is useful for creating context menus or flyout menus where items are generated at runtime.

```csharp
// Creating a fully localized menu dynamically
private void BuildDynamicMenu()
{
    string[] menuItemUids = { "MenuItem_Home", "MenuItem_Profile", "MenuItem_Settings" };

    foreach (string uid in menuItemUids)
    {
        MenuFlyoutItem item = new MenuFlyoutItem();
        Uids.SetUid(item, uid);
        DynamicMenuFlyout.Items.Add(item);
    }
}
```

--------------------------------

### Initialize Localizer for Packaged Apps

Source: https://github.com/andrewkeepcoding/winui3localizer/blob/main/README.md

Configure the Localizer in App.xaml.cs for packaged applications, ensuring resource files exist in the LocalFolder.

```csharp
private async Task InitializeLocalizer()
{

    // Initialize a "Strings" folder in the "LocalFolder" for the packaged app.
    StorageFolder localFolder = ApplicationData.Current.LocalFolder;
    StorageFolder stringsFolder = await localFolder.CreateFolderAsync(
      "Strings",
       CreationCollisionOption.OpenIfExists);

    // Create string resources file from app resources if doesn't exists.
    string resourceFileName = "Resources.resw";
    await CreateStringResourceFileIfNotExists(stringsFolder, "en-US", resourceFileName);
    await CreateStringResourceFileIfNotExists(stringsFolder, "es-ES", resourceFileName);
    await CreateStringResourceFileIfNotExists(stringsFolder, "ja", resourceFileName);

    ILocalizer localizer = await new LocalizerBuilder()
        .AddStringResourcesFolderForLanguageDictionaries(stringsFolder.Path)
        .SetOptions(options =>
        {
            options.DefaultLanguage = "en-US";
        })
        .Build();
}

private static async Task CreateStringResourceFileIfNotExists(StorageFolder stringsFolder, string language, string resourceFileName)
{
    StorageFolder languageFolder = await stringsFolder.CreateFolderAsync(
        language,
        CreationCollisionOption.OpenIfExists);

    if (await languageFolder.TryGetItemAsync(resourceFileName) is null)
    {
        string resourceFilePath = Path.Combine(stringsFolder.Name, language, resourceFileName);
        StorageFile resourceFile = await LoadStringResourcesFileFromAppResource(resourceFilePath);
        _ = await resourceFile.CopyAsync(languageFolder);
    }
}

private static async Task<StorageFile> LoadStringResourcesFileFromAppResource(string filePath)
{
    Uri resourcesFileUri = new($"ms-appx:///{filePath}");
    return await StorageFile.GetFileFromApplicationUriAsync(resourcesFileUri);
}
```

--------------------------------

### Build Language Selector from Dictionaries

Source: https://context7.com/andrewkeepcoding/winui3localizer/llms.txt

Generate a list of available languages for a language selector UI. Each item includes the language code, a localized display name, and the count of items in that language's dictionary.

```csharp
using WinUI3Localizer;

// Build a language selector with all available dictionaries
private List<LanguageItem> BuildLanguageSelector()
{
    ILocalizer localizer = Localizer.Get();

    return localizer.GetLanguageDictionaries()
        .Select(dict => new LanguageItem
        {
            Code = dict.Language,
            DisplayName = localizer.GetLocalizedString($"Language_{dict.Language}"),
            ItemCount = dict.GetItemsCount()
        })
        .ToList();
}
```

--------------------------------

### Switch Application Language at Runtime with SetLanguage()

Source: https://context7.com/andrewkeepcoding/winui3localizer/llms.txt

Use SetLanguage() to change the application's active language dynamically. All registered UI elements update automatically without requiring a restart. Ensure the language is available before attempting to switch.

```csharp
using WinUI3Localizer;

// In a language selection ComboBox handler
private async void LanguagesComboBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
    if (e.AddedItems.FirstOrDefault() is LanguageItem selectedLanguage)
    {
        // Switch language - all UI elements update automatically
        await Localizer.Get().SetLanguage(selectedLanguage.Language);

        // Optionally refresh data-bound collections
        UpdateLanguageDictionaryDisplay();
    }
}
```

```csharp
using WinUI3Localizer;

// Example with error handling
private async Task SwitchToLanguageAsync(string languageCode)
{
    try
    {
        ILocalizer localizer = Localizer.Get();

        // Verify language is available before switching
        if (localizer.GetAvailableLanguages().Contains(languageCode))
        {
            await localizer.SetLanguage(languageCode);
            Console.WriteLine($
```

```csharp
    }
    catch (FailedToSetLanguageException ex)
    {
        Console.WriteLine($"Failed to set language: {ex.Message}");
    }
}
```

--------------------------------

### Localizing XAML Controls

Source: https://github.com/andrewkeepcoding/winui3localizer/blob/main/README.md

Assign a Uid to XAML elements to map them to resource files. Use the /<resources-file-name>/ prefix to reference non-default resource files.

```xml
<Page
    x:Class="WinUI3Localizer.SampleApp.TestPage"
    ...
    xmlns:l="using:WinUI3Localizer">
    <StackPanel>
        <Button l:Uids.Uid="TestPage_Button">
            <Button.Flyout>
                <Flyout>
                    <TextBlock l:Uids.Uid="/Messages/ButtonFlyoutMessage" />
                </Flyout>
            </Button.Flyout>
        </Button>
    </StackPanel>
</Page>
```

--------------------------------

### Implement Custom Localization Actions

Source: https://context7.com/andrewkeepcoding/winui3localizer/llms.txt

Define specialized localization behavior for specific control types during the LocalizerBuilder initialization process.

```csharp
using WinUI3Localizer;
using Microsoft.UI.Xaml;
using Microsoft.UI.Xaml.Documents;

// Adding custom localization actions during builder setup
private async Task InitializeWithCustomActions()
{
    string stringsFolderPath = Path.Combine(AppContext.BaseDirectory, "Strings");

    ILocalizer localizer = await new LocalizerBuilder()
        .AddStringResourcesFolderForLanguageDictionaries(stringsFolderPath)
        .SetOptions(options =>
        {
            options.DefaultLanguage = "en-US";
            // Keep default actions and add custom ones
            options.DisableDefaultLocalizationActions = false;
        })
        // Custom action for a Hyperlink control
        .AddLocalizationAction(new LocalizationActions.ActionItem(
            typeof(Hyperlink),
            args =>
            {
                if (args.DependencyObject is Hyperlink hyperlink)
                {
                    hyperlink.Inlines.Clear();
                    hyperlink.Inlines.Add(new Run { Text = args.Value });
                }
            }))
        // Custom action for a custom control
        .AddLocalizationAction(new LocalizationActions.ActionItem(
            typeof(MyCustomBadge),
            args =>
            {
                if (args.DependencyObject is MyCustomBadge badge)
                {
                    badge.BadgeText = args.Value;
                    badge.UpdateLayout();
                }
            }))
        // Custom action for InfoBar
        .AddLocalizationAction(new LocalizationActions.ActionItem(
            typeof(InfoBar),
            args =>
            {
                if (args.DependencyObject is InfoBar infoBar)
                {
                    infoBar.Message = args.Value;
                }
            }))
        .Build();
}
```

--------------------------------

### Access Localizer Singleton

Source: https://context7.com/andrewkeepcoding/winui3localizer/llms.txt

Retrieves the configured ILocalizer instance to query current language settings and available language resources.

```csharp
using WinUI3Localizer;

// Access the localizer from anywhere in your application
ILocalizer localizer = Localizer.Get();

// Check current language
string currentLanguage = localizer.GetCurrentLanguage();
Console.WriteLine($"Current language: {currentLanguage}"); // Output: Current language: en-US

// Get all available languages
IEnumerable<string> languages = localizer.GetAvailableLanguages();
foreach (string lang in languages)
{
    Console.WriteLine($"Available: {lang}");
}
// Output:
// Available: en-US
// Available: es-ES
// Available: ja
```

--------------------------------

### Search Uid Across All Languages

Source: https://context7.com/andrewkeepcoding/winui3localizer/llms.txt

Retrieve translations for a specific Uid across all available language dictionaries. This returns a dictionary mapping language codes to their respective translations for the given Uid.

```csharp
// Search for a specific Uid across all languages
private Dictionary<string, string> GetAllTranslationsForUid(string uid)
{
    return Localizer.Get()
        .GetLanguageDictionaries()
        .ToDictionary(
            dict => dict.Language,
            dict => dict.TryGetItems(uid, out var items)
                ? items.FirstOrDefault()?.Value ?? "N/A"
                : "N/A"
        );
}
```

--------------------------------

### Access Current Language Dictionary

Source: https://context7.com/andrewkeepcoding/winui3localizer/llms.txt

Retrieve and iterate through the current language dictionary to display all available strings or for debugging purposes. This method provides access to the language code, total items, and individual string items.

```csharp
using WinUI3Localizer;

// Display all strings from current language dictionary
private void DisplayCurrentDictionary()
{
    LanguageDictionary currentDict = Localizer.Get().GetCurrentLanguageDictionary();

    Console.WriteLine($"Current Language: {currentDict.Language}");
    Console.WriteLine($"Total Items: {currentDict.GetItemsCount()}");

    foreach (LanguageDictionary.Item item in currentDict.GetItems())
    {
        Console.WriteLine($"  {item.StringResourceItemName} = {item.Value}");
    }
}
```

--------------------------------

### Retrieve Localized Strings in Code with GetLocalizedString()

Source: https://context7.com/andrewkeepcoding/winui3localizer/llms.txt

Use GetLocalizedString() to fetch localized string values by their Uid. This is crucial for localizing text in code-behind files or ViewModels. Extension methods offer a more concise syntax for direct string retrieval.

```csharp
using WinUI3Localizer;

// Basic usage in code-behind
private void ShowLocalizedMessage()
{
    ILocalizer localizer = Localizer.Get();

    string title = localizer.GetLocalizedString("DialogTitle");
    string message = localizer.GetLocalizedString("WelcomeMessage");
    string okButton = localizer.GetLocalizedString("OkButton");

    // Use in a ContentDialog
    ContentDialog dialog = new()
    {
        Title = title,
        Content = message,
        PrimaryButtonText = okButton
    };
}
```

```csharp
using WinUI3Localizer;

// Localizing a collection of items
private List<string> GetLocalizedColors()
{
    List<string> colorKeys = new() { "Red", "Green", "Blue", "Yellow" };

    ILocalizer localizer = Localizer.Get();
    return colorKeys
        .Select(key => localizer.GetLocalizedString(key))
        .ToList();
}
```

```csharp
// Using the extension method for cleaner syntax
private void DisplayLocalizedStatus()
{
    // Extension method directly on string
    string status = "StatusOnline".GetLocalizedString();
    string error = "/ErrorMessages/ConnectionFailed".GetLocalizedString();

    Console.WriteLine($"Status: {status}");
    Console.WriteLine($"Error: {error}");
}
```

```csharp
using WinUI3Localizer;

// Getting strings from multiple resource files
private void GetStringsFromMultipleResources()
{
    ILocalizer localizer = Localizer.Get();

    // From default Resources.resw
    string buttonText = localizer.GetLocalizedString("SubmitButton");

    // From ErrorMessages.resw (prefix with /FileName/)
    string errorMsg = localizer.GetLocalizedString("/ErrorMessages/ValidationFailed");

    // From Messages.resw
    string notification = localizer.GetLocalizedString("/Messages/SuccessNotification");
}
```

--------------------------------

### Retrieving Localized Strings in Code

Source: https://github.com/andrewkeepcoding/winui3localizer/blob/main/README.md

Use the GetLocalizedString() method from the ILocalizer instance to translate strings in code-behind or ViewModels using the Uid as the resource name.

```csharp
List<string> colors = new()
{
    "Red",
    "Green",
    "Blue",
};

ILocalizer localizer = Localizer.Get();
List<string> localizedColors = colors
    .Select(x => localizer.GetLocalizedString(x))
    .ToList();
```

--------------------------------

### Localize XAML Controls with Uids.Uid

Source: https://context7.com/andrewkeepcoding/winui3localizer/llms.txt

Use the l:Uids.Uid attached property to bind XAML controls to localized strings. Ensure the WinUI3Localizer namespace is correctly referenced in the Page definition.

```xml
<!-- Add namespace reference -->
<Page
    x:Class="MyApp.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:l="using:WinUI3Localizer">

    <StackPanel Spacing="10" Padding="20">
        <!-- TextBlock - localizes Text property -->
        <TextBlock l:Uids.Uid="WelcomeText" Style="{StaticResource TitleTextBlockStyle}" />

        <!-- Button - localizes Content property -->
        <Button l:Uids.Uid="SubmitButton" Click="OnSubmitClick" />

        <!-- TextBox - localizes PlaceholderText and Header -->
        <TextBox l:Uids.Uid="EmailTextBox" />

        <!-- CheckBox - localizes Content property -->
        <CheckBox l:Uids.Uid="RememberMeCheckBox" />

        <!-- ToggleSwitch - localizes Header, OnContent, OffContent -->
        <ToggleSwitch l:Uids.Uid="DarkModeToggle" />

        <!-- ComboBox with localized items using data binding -->
        <ComboBox ItemsSource="{x:Bind ColorOptions}">
            <ComboBox.ItemTemplate>
                <DataTemplate x:DataType="x:String">
                    <TextBlock l:Uids.Uid="{x:Bind}" />
                </DataTemplate>
            </ComboBox.ItemTemplate>
        </ComboBox>

        <!-- NavigationViewItem -->
        <NavigationView>
            <NavigationView.MenuItems>
                <NavigationViewItem l:Uids.Uid="NavHome" Icon="Home" Tag="Home" />
                <NavigationViewItem l:Uids.Uid="NavSettings" Icon="Setting" Tag="Settings" />
            </NavigationView.MenuItems>
        </NavigationView>

        <!-- RichTextBlock with Run elements -->
        <RichTextBlock>
            <Paragraph>
                <Run l:Uids.Uid="IntroText" />
                <Bold l:Uids.Uid="ImportantNote" />
                <Hyperlink l:Uids.Uid="LearnMoreLink" NavigateUri="https://example.com" />
            </Paragraph>
        </RichTextBlock>

        <!-- Targeting specific properties with dot notation -->
        <Button l:Uids.Uid="HelpButton.Content" ToolTipService.ToolTip="{x:Bind}" />
    </StackPanel>
</Page>
```

--------------------------------

### Assign Uid to NavigationView Settings Item

Source: https://context7.com/andrewkeepcoding/winui3localizer/llms.txt

Assign a Uid to a NavigationView's SettingsItem when it's not directly accessible via XAML. This allows the settings item's content to be localized.

```csharp
// Setting Uid on NavigationView settings item (not accessible in XAML)
private void NavigationViewControl_Loaded(object sender, RoutedEventArgs e)
{
    if (NavigationViewControl.SettingsItem is NavigationViewItem settingsItem)
    {
        Uids.SetUid(settingsItem, "MainWindow_NavigationView_Settings");
    }
}
```

--------------------------------

### Subscribe to LanguageChanged Event

Source: https://context7.com/andrewkeepcoding/winui3localizer/llms.txt

Subscribe to the LanguageChanged event to perform custom updates when the application's language changes. This includes updating data-bound collections, window titles, and notifying ViewModels.

```csharp
using WinUI3Localizer;

public sealed partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();

        // Subscribe to language change events
        Localizer.Get().LanguageChanged += OnLanguageChanged;
    }

    private void OnLanguageChanged(object? sender, LanguageChangedEventArgs e)
    {
        Console.WriteLine($"Language changed from '{e.PreviousLanguage}' to '{e.CurrentLanguage}'");

        // Update data-bound collections that need manual refresh
        RefreshLocalizedCollections();

        // Update window title
        this.Title = Localizer.Get().GetLocalizedString("AppTitle");

        // Notify ViewModels
        ViewModel.OnLanguageChanged(e.CurrentLanguage);
    }

    private void RefreshLocalizedCollections()
    {
        // Re-localize any collections that don't auto-update
        ILocalizer localizer = Localizer.Get();

        LocalizedMenuItems = MenuItemKeys
            .Select(key => new MenuItem
            {
                Key = key,
                DisplayText = localizer.GetLocalizedString(key)
            })
            .ToList();
    }
}
```

--------------------------------

### Assign Uid to Dynamic Controls

Source: https://context7.com/andrewkeepcoding/winui3localizer/llms.txt

Programmatically assign a Unique Identifier (Uid) to controls that are created dynamically or when XAML binding is not feasible. This ensures that these controls can be localized.

```csharp
using WinUI3Localizer;
using Microsoft.UI.Xaml.Controls;

// Setting Uid on dynamically created controls
private void CreateDynamicButton()
{
    Button dynamicButton = new Button();
    Uids.SetUid(dynamicButton, "DynamicButton");

    // The button's Content will be automatically localized
    MainStackPanel.Children.Add(dynamicButton);
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.