WPFLocalizeExtension

https://github.com/xamlmarkupextensions/wpflocalizeextension
Admin
WPFLocalizeExtension is a XAML markup extension library that provides the easiest way to localize...
Tokens:13,406
Snippets:190
Trust Score:6.5
Update:5 months ago
Show doc for...
Tokens:
Raw
### Set Culture Command Example

Source: https://github.com/xamlmarkupextensions/wpflocalizeextension/blob/master/docs/Features.md

Culture can be swapped at runtime using Commands. This example demonstrates setting the culture via a command binding.

```xaml
<Button Content="Set German"
        Command="{x:Static lex:SetCultureCommand.Command}"
        CommandParameter="de" />
```

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

### Formatting Example with LocText Extension

Source: https://github.com/xamlmarkupextensions/wpflocalizeextension/blob/master/docs/Features.md

Example of using the LocText extension for formatting strings, including placeholders. This functionality is not bindable at the moment.

```xaml
<TextBlock Text="{lex:LocText FormatKey: 'this is the {0} value'}" />
```

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

### Install WPFLocalizeExtension using .NET CLI

Source: https://github.com/xamlmarkupextensions/wpflocalizeextension/blob/master/README.md

Use this command to add the WPFLocalizationExtension NuGet package to your project.

```bash
dotnet add package WPFLocalizationExtension
```

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

### Prefix and Suffix Example with LocText Extension

Source: https://github.com/xamlmarkupextensions/wpflocalizeextension/blob/master/docs/Features.md

Demonstrates adding prefix and suffix values to localized text using the LocText extension.

```xaml
<TextBlock Text="{lex:LocText PrefixSuffixKey, Prefix='[', Suffix=']'}" />
```

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

### Binding Syntax Example

Source: https://github.com/xamlmarkupextensions/wpflocalizeextension/blob/master/docs/Features.md

Supports binding-like write style for localization. Define a default assembly and/or resource file to shorten the key. Automatic key lookup uses the Name and Property Name of the target if no key is specified.

```xaml
<TextBlock Text="{lex:LocText ResAssembly:ResFile:ResKey}" />
<TextBlock Text="{lex:LocText ResAssembly::ResKey}" />
<TextBlock Text="{lex:LocText ResKey}" />
```

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

### Implement Custom JSON Localization Provider

Source: https://context7.com/xamlmarkupextensions/wpflocalizeextension/llms.txt

Create a custom localization provider by implementing ILocalizationProvider. This example shows a basic JSON provider structure with resource loading and culture handling.

```csharp
using WPFLocalizeExtension.Providers;
using System.Collections.ObjectModel;
using System.Globalization;
using System.Windows;

public class JsonLocalizationProvider : ILocalizationProvider
{
    private Dictionary<string, Dictionary<string, string>> _resources;

    public ObservableCollection<CultureInfo> AvailableCultures { get; }
        = new ObservableCollection<CultureInfo>();

    public event ProviderChangedEventHandler ProviderChanged;
    public event ProviderErrorEventHandler ProviderError;
    public event ValueChangedEventHandler ValueChanged;

    public JsonLocalizationProvider()
    {
        LoadResources();
    }

    public object GetLocalizedObject(string key, DependencyObject target, CultureInfo culture)
    {
        var cultureName = culture?.Name ?? "en-US";

        if (_resources.TryGetValue(cultureName, out var cultureResources))
        {
            if (cultureResources.TryGetValue(key, out var value))
                return value;
        }

        // Fallback to invariant
        if (_resources.TryGetValue("", out var fallbackResources))
        {
            if (fallbackResources.TryGetValue(key, out var value))
                return value;
        }

        return null;
    }

    public FullyQualifiedResourceKeyBase GetFullyQualifiedResourceKey(string key, DependencyObject target)
    {
        return new FQAssemblyDictionaryKey(key);
    }

    protected void OnProviderChanged(DependencyObject target)
    {
        ProviderChanged?.Invoke(this, new ProviderChangedEventArgs(target));
    }

    private void LoadResources() { /* Load from JSON files */ }
}

// Register custom provider in XAML
// <Window lex:LocalizeDictionary.DefaultProvider="{StaticResource MyJsonProvider}">

```

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

### Configure Resx Search Cultures

Source: https://github.com/xamlmarkupextensions/wpflocalizeextension/blob/master/docs/FAQ.md

Reduce startup time for culture searches with the Resx provider by explicitly setting the list of cultures to search for. This example sets cultures for German, English, Hebrew, and Arabic.

```csharp
(LocalizeDictionary.Instance.DefaultProvider as ResxLocalizationProvider).SearchCultures =
                new List<System.Globalization.CultureInfo>()
                {
                    System.Globalization.CultureInfo.GetCultureInfo("de-de"),
                    System.Globalization.CultureInfo.GetCultureInfo("en"),
                    System.Globalization.CultureInfo.GetCultureInfo("he"),
                    System.Globalization.CultureInfo.GetCultureInfo("ar")
                };
```

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

### Upper and Lower Text Example

Source: https://github.com/xamlmarkupextensions/wpflocalizeextension/blob/master/docs/Features.md

Shows how to convert localized text to upper or lower case using the LocText extension.

```xaml
<TextBlock Text="{lex:LocText UpperKey, ToUpper=True}" />
<TextBlock Text="{lex:LocText LowerKey, ToLower=True}" />
```

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

### C# Enum Definition

Source: https://github.com/xamlmarkupextensions/wpflocalizeextension/blob/master/docs/Localize.md

Example C# enum definition used in conjunction with localization examples.

```csharp
public enum TestEnum
{
    Test1,
    Test2
}

...

public TestEnum Foo {get; set;}

...

Foo = TestEnum.Test1;
```

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

### Automatic Key Resolution in XAML

Source: https://github.com/xamlmarkupextensions/wpflocalizeextension/blob/master/docs/Localize.md

When no key is explicitly provided, the `{lex:Loc}` extension attempts to automatically resolve the resource key based on the property name and the element's name. This example shows how `{lex:Loc}` can be used for Content, ToolTip, and FontSize properties.

```xaml
<Button x:Name="MyButton" Content="{lex:Loc}" ToolTip="{lex:Loc}" FontSize="{lex:Loc}"/>
```

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

### Initialize Localization Engine in XAML

Source: https://github.com/xamlmarkupextensions/wpflocalizeextension/wiki/Preparing-the-XAML-code

Set up the xmlns reference and configure the design-time culture, default assembly, and dictionary for the resx provider. This allows for design-time localization previews in the WPF designer.

```xaml
<Window xmlns:lex="http://wpflocalizeextension.codeplex.com"
        lex:LocalizeDictionary.DesignCulture="en"
        lex:ResxLocalizationProvider.DefaultAssembly="AssemblyTestResourceLib"
        lex:ResxLocalizationProvider.DefaultDictionary="Strings">
<!-- Some controls -->
</Window>
```

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

### Configure XAML Namespace and Defaults

Source: https://context7.com/xamlmarkupextensions/wpflocalizeextension/llms.txt

Set up the XAML namespace and default assembly/dictionary for resource lookup in your WPF window or control.

```xml
<Window xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:lex="http://wpflocalizeextension.codeplex.com"
        lex:LocalizeDictionary.DesignCulture="en"
        lex:ResxLocalizationProvider.DefaultAssembly="MyApp"
        lex:ResxLocalizationProvider.DefaultDictionary="Resources">
    <Grid>
        <!-- Localized controls go here -->
    </Grid>
</Window>
```

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

### Basic Key Localization with {lex:Loc}

Source: https://context7.com/xamlmarkupextensions/wpflocalizeextension/llms.txt

Use the {lex:Loc} markup extension to specify resource keys explicitly or in a fully qualified format.

```xml
<!-- Explicit key specification -->
<Button Content="{lex:Loc Key=ButtonSave}" />
<Button Content="{lex:Loc ButtonSave}" />
```

```xml
<!-- Fully qualified key with assembly:dictionary:key format -->
<Button Content="{lex:Loc MyAssembly:MyResources:ButtonSave}" />
```

```xml
<!-- Using converter and converter parameter -->
<TextBlock Text="{lex:Loc WelcomeMessage,
                  Converter={StaticResource MyConverter},
                  ConverterParameter=Uppercase}" />
```

```xml
<!-- Force a specific culture regardless of app culture -->
<Label Content="{lex:Loc Greeting, ForceCulture=de-DE}" />
```

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

### Optimize Culture Search in WPF Application

Source: https://context7.com/xamlmarkupextensions/wpflocalizeextension/llms.txt

Optimize application startup time by limiting the culture search to only supported cultures. This is achieved by setting the 'SearchCultures' property of the 'ResxLocalizationProviderBase'.

```csharp
using WPFLocalizeExtension.Providers;
using System.Globalization;
using System.Collections.Generic;

public partial class App : Application
{
    protected override void OnStartup(StartupEventArgs e)
    {
        base.OnStartup(e);

        // Limit culture search to only supported cultures
        var provider = LocalizeDictionary.Instance.DefaultProvider as ResxLocalizationProviderBase;
        if (provider != null)
        {
            provider.SearchCultures = new List<CultureInfo>
            {
                CultureInfo.GetCultureInfo("en-US"),
                CultureInfo.GetCultureInfo("de-DE"),
                CultureInfo.GetCultureInfo("fr-FR"),
                CultureInfo.GetCultureInfo("es-ES"),
                CultureInfo.GetCultureInfo("ja-JP")
            };
        }

        // Optionally disable caching for development
        // LocalizeDictionary.Instance.DisableCache = true;
    }
}
```

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

### Configure .resx Resource Files

Source: https://context7.com/xamlmarkupextensions/wpflocalizeextension/llms.txt

Set up .resx resource files with proper naming conventions for culture-specific resources. Ensure the 'Access Modifier' is set to 'Public' in the resource file designer or use 'PublicResXFileCodeGenerator' as the Custom Tool.

```xml
<!-- Project structure:
     MyApp/
     ├── Properties/
     │   └── Resources.resx              (default/invariant)
     │   └── Resources.de.resx           (German)
     │   └── Resources.de-AT.resx        (Austrian German)
     │   └── Resources.fr.resx           (French)
     └── Strings/
         └── Messages.resx
         └── Messages.de.resx
-->

<!-- .csproj configuration for grouped resources -->
<ItemGroup>
    <EmbeddedResource Include="Properties\Resources.resx">
        <Generator>ResXFileCodeGenerator</Generator>
        <LastGenOutput>Resources.Designer.cs</LastGenOutput>
    </EmbeddedResource>
    <EmbeddedResource Include="Properties\Resources.de.resx">
        <DependentUpon>Resources.resx</DependentUpon>
    </EmbeddedResource>
    <EmbeddedResource Include="Properties\Resources.fr.resx">
        <DependentUpon>Resources.resx</DependentUpon>
    </EmbeddedResource>
</ItemGroup>

<!-- IMPORTANT: Set Access Modifier to "Public" in resource file designer
     or use PublicResXFileCodeGenerator as the Custom Tool -->
```

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

### Binding Path as Constructor for {lex:Loc}

Source: https://github.com/xamlmarkupextensions/wpflocalizeextension/blob/master/docs/Localize.md

For MVVM scenarios or when binding to dynamic keys, use the `{lex:Loc}` extension with a binding path provided as a constructor argument. This allows full flexibility with Binding features like Converters and StringFormat.

```xaml
{lex:Loc {Binding Path=Foo}}
```

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

### Specify Assembly and Dictionary in LocExtension

Source: https://github.com/xamlmarkupextensions/wpflocalizeextension/wiki/Multiple-assemblies-and-dictionaries

Use the LocExtension with a qualified name to specify the assembly, resource dictionary, and key for localization. This is an alternative to setting default properties.

```xaml
<Button Content="{lex:Loc MyAssembly:MyResource:Test}" />
```

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

### Configure Localization for Multiple Assemblies

Source: https://context7.com/xamlmarkupextensions/wpflocalizeextension/llms.txt

Set default assembly and dictionary for localization using attached properties. This allows resources to be loaded from different locations.

```xml
<Window xmlns:lex="http://wpflocalizeextension.codeplex.com"
        lex:ResxLocalizationProvider.DefaultAssembly="MainApp"
        lex:ResxLocalizationProvider.DefaultDictionary="Strings">

    <StackPanel>
        <!-- Uses default assembly and dictionary -->
        <TextBlock Text="{lex:Loc AppTitle}" />

        <!-- Override for a section using different resources -->
        <GroupBox lex:ResxLocalizationProvider.DefaultAssembly="SharedLibrary"
                  lex:ResxLocalizationProvider.DefaultDictionary="CommonStrings">
            <StackPanel>
                <!-- Uses SharedLibrary:CommonStrings -->
                <TextBlock Text="{lex:Loc OkButton}" />
                <TextBlock Text="{lex:Loc CancelButton}" />
            </StackPanel>
        </GroupBox>

        <!-- Explicit fully qualified key -->
        <Button Content="{lex:Loc ThirdPartyLib:Dialogs:ConfirmMessage}" />
    </StackPanel>
</Window>
```

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

### Direct Key Entry with LocExtension

Source: https://github.com/xamlmarkupextensions/wpflocalizeextension/wiki/Keys

Use this method to directly specify the localization key after the LocExtension name. This is a straightforward way to link UI elements to their translated strings.

```xaml
<Button Content="{lex:Loc Test}" />
```

```xaml
<Button Content="{lex:Loc Key=Test}" />
```

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

### LocalizeDictionary - Culture Management in C#

Source: https://context7.com/xamlmarkupextensions/wpflocalizeextension/llms.txt

Manage application culture and access localization programmatically using the LocalizeDictionary singleton. Import System.Globalization and WPFLocalizeExtension.Engine.

```csharp
using WPFLocalizeExtension.Engine;
using System.Globalization;

// Get the singleton instance
var dict = LocalizeDictionary.Instance;

// Change the application culture
LocalizeDictionary.Instance.Culture = new CultureInfo("de-DE");

// Get current culture
CultureInfo current = LocalizeDictionary.CurrentCulture;

// Get specific culture for formatting (IFormatProvider)
CultureInfo specific = LocalizeDictionary.Instance.SpecificCulture;
decimal price = 123.45m;
string formatted = price.ToString("C", specific); // Formats with current culture

// Get list of available cultures from resources
ObservableCollection<CultureInfo> cultures = LocalizeDictionary.Instance.MergedAvailableCultures;

// Bind culture list to ComboBox
// <ComboBox ItemsSource="{Binding Source={x:Static lex:LocalizeDictionary.Instance},
//                                 Path=MergedAvailableCultures}"/>
```

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

### Combine Case Conversion with Binding

Source: https://context7.com/xamlmarkupextensions/wpflocalizeextension/llms.txt

Demonstrates combining a localization binding with a case converter within a TextBlock's Style Setter. Ensure the Key is correctly bound.

```xml
<TextBlock Text="{Binding HeaderKey,
                  Converter={lex:TranslateConverter}}">
    <TextBlock.Style>
        <Style TargetType="TextBlock">
            <Setter Property="Text">
                <Setter.Value>
                    <lex:BLoc Key="{Binding HeaderKey}"
                              Converter="{lex:ToUpperConverter}"/>
                </Setter.Value>
            </Setter>
        </Style>
    </TextBlock.Style>
</TextBlock>
```

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

### Dynamic Key Resolution with {lex:Loc} and Binding

Source: https://context7.com/xamlmarkupextensions/wpflocalizeextension/llms.txt

Use binding syntax within {lex:Loc} to dynamically resolve resource keys from your view model or data context.

```xml
<!-- Bind the key from a property -->
<TextBlock Text="{lex:Loc {Binding Path=StatusKey}}" />
```

```xml
<!-- Bind with string format for enum-style keys -->
<TextBlock Text="{lex:Loc {Binding Path=CurrentStatus, StringFormat=Status_{0}}}" />
```

```csharp
<!-- Example ViewModel -->
<!--
public class MyViewModel : INotifyPropertyChanged
{
    public string StatusKey { get; set; } = "Status_Active";
    public string CurrentStatus { get; set; } = "Active";
}
-->
```

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

### Handle Missing Localization Keys

Source: https://context7.com/xamlmarkupextensions/wpflocalizeextension/llms.txt

Subscribe to the MissingKeyEvent to log or provide fallback values for missing resource keys. Configure output behavior for missing keys.

```csharp
using WPFLocalizeExtension.Engine;

public partial class App : Application
{
    protected override void OnStartup(StartupEventArgs e)
    {
        base.OnStartup(e);

        // Subscribe to missing key events
        LocalizeDictionary.Instance.MissingKeyEvent += OnMissingKey;

        // Configure missing key output
        LocalizeDictionary.Instance.OutputMissingKeys = true;
    }

    private void OnMissingKey(object sender, MissingKeyEventArgs e)
    {
        // Log the missing key
        Debug.WriteLine($"Missing localization key: {e.Key}");

        // Optionally provide a custom fallback
        e.MissingKeyResult = $"[{e.Key}]";

        // Or trigger a reload
        // e.Reload = true;
    }
}

// Alternative: Subscribe to provider errors
LocalizeDictionary.Instance.DefaultProvider.ProviderError += (sender, args) =>
{
    Debug.WriteLine($"Provider error: {args.Message}");
};

```

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

### Basic {lex:Loc} Markup Extension Usage

Source: https://github.com/xamlmarkupextensions/wpflocalizeextension/blob/master/docs/Localize.md

Use this markup extension to localize strings in XAML. It supports parameters for specifying the resource key, forcing a culture, and applying converters.

```xaml
{lex:Loc Key=, ForceCulture=, Converter=, ConverterParameter=,}
```

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

### Configure RESX Files in CSPROJ

Source: https://github.com/xamlmarkupextensions/wpflocalizeextension/blob/master/docs/Resource-files.md

Modify your project file to correctly link culture-specific RESX files using the DependentUpon syntax. This ensures proper resource management during the build process.

```xml
<EmbeddedResource Include="Strings.de.resx">
      <SubType>Designer</SubType>
      <DependentUpon>Strings.resx</DependentUpon>
    </EmbeddedResource>
    <EmbeddedResource Include="Strings.resx">
      <Generator>ResXFileCodeGenerator</Generator>
      <LastGenOutput>Strings.Designer.cs</LastGenOutput>
    </EmbeddedResource>
```

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

### Automatic Key Retrieval with LocExtension

Source: https://github.com/xamlmarkupextensions/wpflocalizeextension/wiki/Keys

When no key is provided, the LocExtension attempts to automatically resolve a resource key based on the control's Name or x:Name property. It first looks for a key in the format '_ControlName_PropertyName_' and then '_ControlName_'. This is useful for reducing boilerplate when naming conventions align with resource keys.

```xaml
<Button Name="MyButton" Content="{lex:Loc}" />
```

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

### Configure Embedded Resources in CSPROJ

Source: https://github.com/xamlmarkupextensions/wpflocalizeextension/wiki/Resource-files

Modify your .csproj file to correctly link culture-specific resource files to the main resource file using the DependencyUpon syntax. This ensures proper handling of localized resources.

```xml
<EmbeddedResource Include="Strings.de.resx">
  <SubType>Designer</SubType>
  <DependentUpon>Strings.resx</DependentUpon>
</EmbeddedResource>
<EmbeddedResource Include="Strings.resx">
  <Generator>ResXFileCodeGenerator</Generator>
  <LastGenOutput>Strings.Designer.cs</LastGenOutput>
</EmbeddedResource>
```

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

### WPF MultiBinding with StringFormatConverter

Source: https://github.com/xamlmarkupextensions/wpflocalizeextension/blob/master/docs/GapText.md

Use this snippet to format localized strings with multiple parameters. The first parameter is the StringFormat, and subsequent bindings provide the values.

```XML
<element.Text>
    <MultiBinding Converter={lex:StringFormatConverter}>
        <lex:BLoc Path="assembly:resource:key" />
         <Binding Foo />
         <Binding Bar />
         <Binding ... />
    </MultiBinding>
</element.Text>
```

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

### Binding-Based Localization with {lex:BLoc}

Source: https://context7.com/xamlmarkupextensions/wpflocalizeextension/llms.txt

Utilize the {lex:BLoc} extension, which derives from Binding, for localization in scenarios like MultiBindings or triggers where {lex:Loc} is not suitable.

```xml
<!-- BLoc for simple localization -->
<TextBlock Text="{lex:BLoc Key=WelcomeMessage}" />
```

```xml
<!-- Using BLoc in DataTriggers -->
<Style TargetType="TextBlock">
    <Style.Triggers>
        <DataTrigger Binding="{Binding IsActive}" Value="True">
            <Setter Property="Text">
                <Setter.Value>
                    <lex:BLoc Key="ActiveStatus"/>
                </Setter.Value>
            </Setter>
        </DataTrigger>
    </Style.Triggers>
</Style>
```

```xml
<!-- BLoc in MultiBinding scenarios -->
<TextBlock>
    <TextBlock.Text>
        <MultiBinding Converter="{StaticResource MyMultiConverter}">
            <lex:BLoc Key="LabelPrefix"/>
            <Binding Path="UserName"/>
        </MultiBinding>
    </TextBlock.Text>
</TextBlock>
```

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

### Using TranslateConverter in XAML

Source: https://github.com/xamlmarkupextensions/wpflocalizeextension/blob/master/docs/ValueConverters.md

Demonstrates the direct usage of TranslateConverter as a Markup Extension in XAML for localization.

```xaml
<Element Converter="{lex:TranslateConverter}" />
```

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

### Enum Localization with PrependTypeConverter

Source: https://github.com/xamlmarkupextensions/wpflocalizeextension/blob/master/docs/Localize.md

Automate enum localization by using the `PrependTypeConverter` with the `{lex:Loc}` extension. This converter automatically prepends the enum's type name to the key, simplifying the process and improving refactoring support.

```xaml
{lex:Loc {Binding Path=Foo, Converter={lex:PrependTypeConverter}}}
```

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

### Code-Behind Localization with GetLocalizedValue

Source: https://context7.com/xamlmarkupextensions/wpflocalizeextension/llms.txt

Retrieve localized strings and images programmatically using the static GetLocalizedValue methods from LocExtension. Ensure necessary using directives are included.

```csharp
using WPFLocalizeExtension.Extensions;
using WPFLocalizeExtension.Engine;
using System.Globalization;

// Simple string lookup with current culture
string welcomeText = LocExtension.GetLocalizedValue<string>("WelcomeMessage");

// Lookup with specific culture
string germanText = LocExtension.GetLocalizedValue<string>(
    "WelcomeMessage",
    new CultureInfo("de-DE"));

// Lookup with target DependencyObject context
string contextText = LocExtension.GetLocalizedValue<string>(
    "WelcomeMessage",
    myButton);

// Full lookup with all parameters
string fullText = LocExtension.GetLocalizedValue<string>(
    "WelcomeMessage",
    new CultureInfo("en-US"),
    myButton,
    converter: null,
    converterParameter: null);

// Using fully qualified key (Assembly:Dictionary:Key)
string qualifiedText = LocExtension.GetLocalizedValue<string>(
    "MyApp:Resources:WelcomeMessage");

// Get localized image
var image = LocExtension.GetLocalizedValue<BitmapSource>("LogoImage");
```

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

### Specific Culture for Formatting

Source: https://github.com/xamlmarkupextensions/wpflocalizeextension/blob/master/docs/Features.md

Offers a 'SpecificCulture' property to be used as an IFormatProvider for custom formatting, such as number or date formatting.

```csharp
var number = 123.20;
var formattedNumber = number.ToString(LocalizeDictionary.SpecificCulture);
// formattedNumber will be "123.20" or "123,20" depending on the culture
```

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

### ILocalizationProvider Interface Definition

Source: https://github.com/xamlmarkupextensions/wpflocalizeextension/wiki/Localization-providers

Defines the contract for localization providers. Implement this interface to create custom providers for localized values, culture management, and event handling.

```csharp
public interface ILocalizationProvider
{
    /// <summary>
    /// Get the localized object.
    /// </summary>
    /// <param name="key">The key to the value.</param>
    /// <param name="target">The target <see cref="DependencyObject"/>.</param>
    /// <param name="culture">The culture to use.</param>
    /// <returns>The value corresponding to the key and culture.</returns>
    object GetLocalizedObject(string key, DependencyObject target, CultureInfo culture);

    /// <summary>
    /// An observable list of available cultures.
    /// </summary>
    ObservableCollection<CultureInfo> AvailableCultures { get; }

    /// <summary>
    /// An event when the provider changed.
    /// </summary>
    event ProviderChangedEventHandler ProviderChanged;

    /// <summary>
    /// An event when an error occurred.
    /// </summary>
    event ProviderErrorEventHandler ProviderError;
}
```

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

### Automatic Key Lookup with {lex:Loc}

Source: https://context7.com/xamlmarkupextensions/wpflocalizeextension/llms.txt

Leverage automatic key lookup by omitting the key; the extension uses the control's Name and property name.

```xml
<!-- Automatic key lookup: looks for "MyButton_Content" then "MyButton" -->
<Button x:Name="MyButton" Content="{lex:Loc}" />
```

```xml
<!-- Multiple properties with automatic keys -->
<Button x:Name="SaveButton"
        Content="{lex:Loc}"
        ToolTip="{lex:Loc}" />
<!-- Looks for: SaveButton_Content, SaveButton_ToolTip -->
```

```xml
<!-- Resource file (Resources.resx) should contain:
     Key: SaveButton_Content    Value: Save
     Key: SaveButton_ToolTip    Value: Click to save changes
-->
```

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

### Basic FELoc Usage in XAML

Source: https://context7.com/xamlmarkupextensions/wpflocalizeextension/llms.txt

Use FELoc to localize content in XAML. Ensure the 'lex' namespace is properly defined.

```xml
<ContentControl>
    <ContentControl.Content>
        <lex:FELoc Key="DynamicContent"/>
    </ContentControl.Content>
</ContentControl>
```

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

### Enum Localization with StringFormat

Source: https://github.com/xamlmarkupextensions/wpflocalizeextension/blob/master/docs/Localize.md

Localize enum values by using `StringFormat` with the `{lex:Loc}` extension. This approach requires manually specifying the enum type name and the desired key format, offering flexibility but potentially impacting refactoring.

```xaml
{lex:Loc {Binding Path=Foo, StringFormat=TestEnum_{0}}}
```

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

### Bind Localized Text to Button Content

Source: https://github.com/xamlmarkupextensions/wpflocalizeextension/wiki/Our-first-localized-text

Use the lex:Loc markup extension to bind a resource key to the Content property of a button. Ensure the key exists in your resource files for the desired cultures.

```xaml
<Button Content="{lex:Loc Test}" />
```

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

### SetCultureCommand for XAML Culture Switching

Source: https://context7.com/xamlmarkupextensions/wpflocalizeextension/llms.txt

Switch application culture directly from XAML using the SetCultureCommand. This command is available via the LocalizeDictionary instance.

```xml
<!-- Culture switching buttons -->
<StackPanel Orientation="Horizontal">
    <Button Content="English"
            Command="{Binding Source={x:Static lex:LocalizeDictionary.Instance},
                              Path=SetCultureCommand}"
            CommandParameter="en-US"/>
    <Button Content="Deutsch"
            Command="{Binding Source={x:Static lex:LocalizeDictionary.Instance},
                              Path=SetCultureCommand}"
            CommandParameter="de-DE"/>
    <Button Content="Français"
            Command="{Binding Source={x:Static lex:LocalizeDictionary.Instance},
                              Path=SetCultureCommand}"
            CommandParameter="fr-FR"/>
</StackPanel>

<!-- Culture ComboBox with automatic switching -->
<ComboBox ItemsSource="{Binding Source={x:Static lex:LocalizeDictionary.Instance},
                                Path=MergedAvailableCultures}"
          SelectedItem="{Binding Source={x:Static lex:LocalizeDictionary.Instance},
                                 Path=Culture}"
          DisplayMemberPath="DisplayName"/>
```

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

### Localize Enum Values with LocProxy

Source: https://github.com/xamlmarkupextensions/wpflocalizeextension/wiki/LocProxy-&-EnumComboBox

Use LocProxy to localize enum values by binding the Source property to the enum value and Result to the TextBlock. Set PrependType to True to include the enum type name in the localization key.

```xaml
<lex:LocProxy Source="{Binding}" x:Name="Proxy" PrependType="True" />
<TextBlock Text="{Binding Result, ElementName=Proxy}" Margin="2" FontWeight="Normal" />
```

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

### StringFormatConverter for Gap Text and Pluralization

Source: https://context7.com/xamlmarkupextensions/wpflocalizeextension/llms.txt

StringFormatConverter enables complex string formatting with multiple values and supports SmartFormat for advanced pluralization. It's used with MultiBinding to combine resource strings and dynamic data.

```xml
<!-- Gap text with multiple parameters -->
<TextBlock>
    <TextBlock.Text>
        <MultiBinding Converter="{lex:StringFormatConverter}">
            <lex:BLoc Key="WelcomeFormat"/>
            <Binding Path="UserName"/>
            <Binding Path="ItemCount"/>
        </MultiBinding>
    </TextBlock.Text>
</TextBlock>

<!-- Resource file:
     Key: WelcomeFormat
     Value: "Welcome {0}! You have {1} items."

     If SmartFormat is installed:
     Value: "Welcome {0}! You have {1:item|items}."
-->

<!-- Pluralization with SmartFormat (requires SmartFormat NuGet) -->
<TextBlock>
    <TextBlock.Text>
        <MultiBinding Converter="{lex:StringFormatConverter}">
            <lex:BLoc Key="CartItemsFormat"/>
            <Binding Path="CartItemCount"/>
        </MultiBinding>
    </TextBlock.Text>
</TextBlock>

<!-- SmartFormat resource:
     Key: CartItemsFormat
     Value: "You have {0} {0:item|items} in your cart."
-->
```

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

### LocalizeDictionary.GetLocalizedObject Direct Access

Source: https://context7.com/xamlmarkupextensions/wpflocalizeextension/llms.txt

Use LocalizeDictionary directly for lower-level access to localized resources, allowing specification of assembly, dictionary, and key. It also provides methods to check for the existence of resource keys, with or without a specific culture.

```csharp
using WPFLocalizeExtension.Engine;
using System.Globalization;

// Get localized object with assembly, dictionary, and key
object value = LocalizeDictionary.Instance.GetLocalizedObject(
    "MyApp",           // Assembly name
    "Resources",       // Dictionary (resource file name without extension)
    "WelcomeMessage",  // Resource key
    new CultureInfo("en-US"));

// Get with key and target context
object contextValue = LocalizeDictionary.Instance.GetLocalizedObject(
    "WelcomeMessage",
    myTargetElement,
    LocalizeDictionary.Instance.SpecificCulture);

// Check if a resource key exists
bool exists = LocalizeDictionary.Instance.ResourceKeyExists(
    "MyApp",
    "Resources",
    "WelcomeMessage");

// Check with specific culture
bool existsInGerman = LocalizeDictionary.Instance.ResourceKeyExists(
    "MyApp",
    "Resources",
    "WelcomeMessage",
    new CultureInfo("de-DE"));
```

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

### Change Localization Provider at Runtime

Source: https://github.com/xamlmarkupextensions/wpflocalizeextension/blob/master/docs/Features.md

Use the Provider property in LocalizeDictionary to change the localization provider for a specific sub-tree. The DefaultProvider property sets the provider for the entire application.

```csharp
LocalizeDictionary.Provider = new CsvLocalizationProvider("MyCustomProvider.csv");
LocalizeDictionary.DefaultProvider = new ResxLocalizationProvider();
```

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

### FELoc with Custom Converter in XAML

Source: https://context7.com/xamlmarkupextensions/wpflocalizeextension/llms.txt

Apply a custom converter to a FELoc localization in XAML. The converter must be defined and available in your resources.

```xml
<ContentControl>
    <ContentControl.Content>
        <lex:FELoc Key="ImageKey"
                   Converter="{StaticResource ImageConverter}"/>
    </ContentControl.Content>
</ContentControl>
```

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

### Register for MissingKeyEvent

Source: https://github.com/xamlmarkupextensions/wpflocalizeextension/blob/master/docs/FAQ.md

Register to the MissingKeyEvent to be notified when translation keys are not found. This event is triggered when using LocExtension or BLoc.

```csharp
LocalizeDictionary.Instance.MissingKeyEvent += Instance_MissingKeyEvent;
```

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

### TranslateConverter for Runtime Key Translation

Source: https://context7.com/xamlmarkupextensions/wpflocalizeextension/llms.txt

The TranslateConverter allows resource keys to be used as bound values, translating them at runtime. This is useful for dynamic content, such as in a DataGrid column where the bound property contains the resource key.

```xml
<!-- Use TranslateConverter to translate dynamic keys -->
<TextBlock Text="{Binding StatusKey,
                  Converter={lex:TranslateConverter}}" />

<!-- In a DataGrid column -->
<DataGridTextColumn Header="Status"
                    Binding="{Binding StatusCode,
                              Converter={lex:TranslateConverter}}"/>

<!-- Example: StatusCode property contains "Active", "Inactive", "Pending" 
     Resource file should have:
     Key: Active     Value: Currently Active
     Key: Inactive   Value: Not Active
     Key: Pending    Value: Awaiting Approval
-->
```

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

### Handle ProviderError Event

Source: https://github.com/xamlmarkupextensions/wpflocalizeextension/blob/master/docs/FAQ.md

Subscribe to the ProviderError event on the default provider to handle errors during localized object retrieval, particularly for code-behind translations.

```csharp
LocalizeDictionary.Instance.DefaultProvider.ProviderError  += ...
```

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

### XAML Markup Extension Syntax

Source: https://github.com/xamlmarkupextensions/wpflocalizeextension/wiki/MarkupExtension-basics

General syntax for applying markup extensions to a property of an element in XAML. Replace ExtensionName with the actual extension class name (without the 'Extension' suffix).

```xaml
<Element Property="{ExtensionName ...}" />
```

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

### PrependTypeConverter for Enum Localization

Source: https://context7.com/xamlmarkupextensions/wpflocalizeextension/llms.txt

PrependTypeConverter automatically prepends the type name to enum values for resource key lookup, simplifying enum localization. It supports custom separators and can be combined with LocExtension for translation.

```xml
<!-- Enum binding with automatic type prefix -->
<TextBlock Text="{Binding MyEnumProperty,
                  Converter={lex:PrependTypeConverter}}" />

<!-- Custom separator (default is underscore) -->
<TextBlock Text="{Binding MyEnumProperty,
                  Converter={lex:PrependTypeConverter},
                  ConverterParameter=.}" />

<!-- Combined with LocExtension for enum translation -->
<TextBlock Text="{lex:Loc {Binding Path=Status,
                          Converter={lex:PrependTypeConverter}}}" />

<!-- Example enum and resources:
     public enum OrderStatus { Pending, Processing, Shipped, Delivered }

     Resource keys (with default _ separator):
     OrderStatus_Pending    -> "Order Pending"
     OrderStatus_Processing -> "Processing Order"
     OrderStatus_Shipped    -> "Order Shipped"
     OrderStatus_Delivered  -> "Delivered"
-->
```

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

### Convert Localized Text to Lowercase

Source: https://context7.com/xamlmarkupextensions/wpflocalizeextension/llms.txt

Use ToLowerConverter to transform localized text to lowercase. This converter is applied similarly to ToUpperConverter.

```xml
<!-- Convert to lowercase -->
<TextBlock Text="{lex:Loc Subtitle,
                  Converter={lex:ToLowerConverter}}" />
```

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

### ResolveLocalizedValue Instance Method

Source: https://context7.com/xamlmarkupextensions/wpflocalizeextension/llms.txt

Use the ResolveLocalizedValue instance method for more control over localization with an out parameter pattern. It supports resolving values with the current culture, a specific culture, or a target object context. Programmatic binding can also be set up.

```csharp
using WPFLocalizeExtension.Extensions;
using System.Globalization;

// Create a LocExtension instance
var locExt = new LocExtension("MyResourceKey");

// Resolve value with current culture
if (locExt.ResolveLocalizedValue<string>(out string result))
{
    Console.WriteLine($"Resolved: {result}");
}

// Resolve with specific culture
if (locExt.ResolveLocalizedValue<string>(out string germanResult, new CultureInfo("de-DE")))
{
    Console.WriteLine($"German: {germanResult}");
}

// Resolve with target object context
if (locExt.ResolveLocalizedValue<string>(out string contextResult, myButton))
{
    myLabel.Content = contextResult;
}

// Set up programmatic binding
var ext = new LocExtension("DynamicKey");
bool success = ext.SetBinding(myTextBlock, TextBlock.TextProperty);
```

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

### Resolve Localized Value in Code Behind

Source: https://github.com/xamlmarkupextensions/wpflocalizeextension/blob/master/docs/Features.md

Provides functionality in code-behind to check and retrieve resource values. This is useful for dynamically generating controls or advanced scenarios.

```csharp
var localizedValue = LocalizeDictionary.ResolveLocalizedValue("MyKey");
// Use localizedValue for dynamic controls or other purposes
```

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

### Convert Localized Text to Uppercase

Source: https://context7.com/xamlmarkupextensions/wpflocalizeextension/llms.txt

Use ToUpperConverter to transform localized text to uppercase. Apply it directly within XAML bindings.

```xml
<TextBlock Text="{lex:Loc Title,
                  Converter={lex:ToUpperConverter}}" />
```

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

### Design Value Property

Source: https://github.com/xamlmarkupextensions/wpflocalizeextension/blob/master/docs/Features.md

Offers a DesignValue property to specify custom values during design mode, useful for MS Expression Blend and Visual Studio.

```xaml
<TextBlock Text="{lex:LocText MyKey, DesignValue='Design Time Text'}" />
```
Tokens:
Raw