Then maybe this enhanced .NET MAUI version of the Zebra Scanner SDK for Xamarin/MAUI is for you!

Background

A couple of years ago, when upgrading a Xamarin application to .NET MAUI, the Zebra Scanner Xamarin Wrapper (Android and iOS) was not yet migrated to .NET MAUI, so this library was created. Zebra have since then released the .NET MAUI Wrapper for Scanner SDK (iOS and Android) package. That package is not distributed as a common NuGet package and is not updated in the same pace as the native Android/iOS libraries, therefore this library is still maintained as a convenient complement.

Library

The library is available both as a NuGet package and a MIT licensed repository at GitHub.

Name	Nuget	GitHub	Support
ZebraScannerSDK.Maui

What’s included?

Compared to the original solution we have some enhanced and added features:

• One easy to use NuGet package.
• Easy setup with service collection extension.

• New IScannerSDK interface registered for constructor injection with DI.

• New sample app.

Setup

Use the AddZebraScannerSDK service collection extension method for library configuration.

var builder = MauiApp.CreateBuilder();
builder
    .UseMauiApp<App>()
    .ConfigureFonts(fonts =>
    {
        fonts.AddFont("OpenSans-Regular.ttf", "OpenSansRegular");
        fonts.AddFont("OpenSans-Semibold.ttf", "OpenSansSemibold");
    })

    //Add Services
    builder.Services.AddZebraScannerSDK();

For further documentation, see the Official Zebra Resources or the Sample application.

Sample

Look at the Sample project for a example of how to use this library in an .NET MAUI application.

Official Zebra Resources

• .NET MAUI Wrapper for Scanner SDK (iOS and Android)
• Scanner SDK for Android
• Scanner SDK for iOS
• Scanner Xamarin Wrapper (Android and iOS) (Deprecated and no longer maintained)

var cornerRadius = Application.Current?.Resources["DefaultCornerRadius"] as CornerRadius;

…or with TryGetValue…

if (Application.Current?.Resources.TryGetValue("DefaultCornerRadius", out var resource) ?? false)
{
  var cornerRadius = resource as CornerRadius;
}

BUT when we need to access a Resource that is defined with OnPlatform, OnIdiom and/or references a DynamicResource in a Merged Dictionary, it gets trickier! Especially if this is nested in multiple layers!

Let’s look at an extreme example!

First we have the main Application Resource Dictionary with the DefaultCornerRadiusresource. Based OnPlatform the value references a specific DynamicResource.

<Application.Resources>
    <ResourceDictionary>
        <OnPlatform x:Key="DefaultCornerRadius" x:TypeArguments="CornerRadius">
            <On Platform="Android" Value="{DynamicResource SmallCornerRadius}"/>
            <On Platform="iOS"  Value="{DynamicResource MediumCornerRadius}/>
        </OnPlatform>
    </ResourceDictionary>
</Application.Resources>

At runtime, the DefaultStyle Resource Dictionary is added, based on screen resolution, as a Merged Dictionary with the values for CornerRadius.

Resources.MergedDictionaries.Add(new DefaultStyle());

In DefaultStyle dictionary, both SmallCornerRadius and MediumCornerRadius is defined based on Idiom!

<ResourceDictionary
    x:Class="RetailOperationApp.Resources.Styles.DefaultStyle"
    xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
    xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml">

    <OnIdiom
        x:Key="SmallCornerRadius"
        x:TypeArguments="CornerRadius"
        Default="10"
        Desktop="11"
        Phone="12"
        TV="13"
        Tablet="14"
        Watch="15" />

    <OnIdiom
        x:Key="MediumCornerRadius"
        x:TypeArguments="CornerRadius"
        Default="20"
        Desktop="21"
        Phone="22"
        TV="23"
        Tablet="24"
        Watch="25" />
        
</ResourceDictionary>

In this case and as far as I know, to resolve the correct CornerRadius for DefaultCornerRadius requires first resolving the correct OnPlatform, then finding the DynamicResource and finally resolve the correct OnIdom…which makes it tricky to have a easy way of resolving ANY resource!

BUT, what if we could resolve ANY resource like this:

var cornerRadius = ResourcesUtility.FindResource<CornerRadius>("DefaultCornerRadius");

…or…

var cornerRadius = Application.Current?.Resources.FindResource<CornerRadius>("DefaultCornerRadius");

To solve this, I have made the following static class that enables just that!

public static class ResourcesUtility
{
    private static T? GetResource<T>(ResourceDictionary resources, object? resource)
    {
        //Check resource type
        switch (resource)
        {
            case OnPlatform<T> value:
                //Get return type platform specific resource
                return GetResource<T>(resources, value.Platforms?.FirstOrDefault(p => p.Platform.Contains($"{DeviceInfo.Platform}"))?.Value);

            case OnIdiomExtension value:
                {
                    //Get idiom specific resource
                    var idiomValue = value.Default;
                    if (DeviceInfo.Idiom == DeviceIdiom.Desktop) idiomValue = value.Desktop;
                    if (DeviceInfo.Idiom == DeviceIdiom.Phone) idiomValue = value.Phone;
                    if (DeviceInfo.Idiom == DeviceIdiom.Tablet) idiomValue = value.Tablet;
                    if (DeviceInfo.Idiom == DeviceIdiom.TV) idiomValue = value.TV;
                    if (DeviceInfo.Idiom == DeviceIdiom.Watch) idiomValue = value.Watch;
                    return GetResource<T>(resources, idiomValue);
                }

            case OnIdiom<T> value:
                {
                    //Get return type idiom specific resource
                    var idiomValue = value.Default;
                    if (DeviceInfo.Idiom == DeviceIdiom.Desktop) idiomValue = value.Desktop;
                    if (DeviceInfo.Idiom == DeviceIdiom.Phone) idiomValue = value.Phone;
                    if (DeviceInfo.Idiom == DeviceIdiom.Tablet) idiomValue = value.Tablet;
                    if (DeviceInfo.Idiom == DeviceIdiom.TV) idiomValue = value.TV;
                    if (DeviceInfo.Idiom == DeviceIdiom.Watch) idiomValue = value.Watch;
                    return idiomValue;
                }

            case DynamicResource value:
                //Get dynamic resource
                return resources.FindResource<T>(value.Key);

            case string value:
                {
                    //Attempt to cast to resource type or return default
                    try
                    {
                        var converter = TypeDescriptor.GetConverter(typeof(T));
                        if (converter?.CanConvertFrom(typeof(string)) ?? false)
                        {
                            // Cast ConvertFromString(string text) : object to (T)
                            return (T?)converter.ConvertFromString(value);
                        }
                        return default;
                    }
                    catch
                    {
                        return default;
                    }
                }

            case T value:
                //Return found resource value
                return value;

            default:
                //Return default resource value
                return default;
        }
    }

    public static T? FindResource<T>(this ResourceDictionary resources, string resourceKey)
    {
        //Verify parameter
        if (string.IsNullOrWhiteSpace(resourceKey))
            return default;

        //Attempt to find resource
        if (resources.TryGetValue(resourceKey, out var resource))
            //Get resource
            return GetResource<T>(resources, resource);
        else
            //If nothing found, return default
            return default;
    }

    public static T? FindResource<T>(string resourceKey)
    {
        //Verify Current Application
        if (Application.Current is not null)
            //Attempt to find resource
            return Application.Current.Resources.FindResource<T>(resourceKey);
        else
            //If nothing found, return default
            return default;
    }
}

So with this we have a easy way to “Get ANY Resource Dictionary Value in Code Behind”. Enjoy!

Big shoutout to the original authors, Charlin Agramonte, Brandon Minnick, Maksym Koshovyi and the entire Xamarin Community Toolkit Team!

Library

The library is available both as a NuGet package and a MIT licensed repository at GitHub.

Name	Nuget	GitHub
LocalizationResourceManager.Maui

Compared to the original solution we have some enhanced and added features:

• Easy setup with builder pattern extension
• Supports multiple Resource managers
• Supports file based Resource managers
• Supports storing and restoring of the latest set culture
• New ILocalizationResourceManager interface registered for constructor injection with DI
• Stores current Default / System culture
• Supports Resource names with dots.
• Option to set a placeholder text to be displayed if text is not found.
• TranslateBindingExtension for custom binding with format and plural support in XAML by Stephen Quan.
• Uses the WeakEventManager (.NET MAUI)

For localized texts used in XAML and/or code behind, we still have:

• TranslateExtension (XAML Markup Extension)
• LocalizedString (Track Culture Change in code behind)

Preparations

To use this library, there are some preperations you need to do in your .NET MAUI project/application:

• Set the Assembly neutral language to your default language.
  (In project properties screen or directly in the project file!)
  

<NeutralLanguage>en</NeutralLanguage>

• Create/Add a Resources File (resx) with the Resources Files Template for your default language. e.g. AppResources.resx
• Create/Add a Resources File (resx) for each additional language you want to support. e.g. AppResources-fr.rex for French
  (Use same name as default file and add language code. List of all Language codes)

Easy setup

As many .NET MAUI libraries, I use the builder pattern for easy configuration. To setup the library, you use the UseLocalizationResourceManager extension method with the ILocalizationSettings settings methods for custom configuration.

var builder = MauiApp.CreateBuilder();
builder
    .UseMauiApp<App>()
    .ConfigureFonts(fonts =>
    {
        fonts.AddFont("OpenSans-Regular.ttf", "OpenSansRegular");
        fonts.AddFont("OpenSans-Semibold.ttf", "OpenSansSemibold");
    })
    .UseLocalizationResourceManager(settings =>
    {
        settings.AddResource(AppResources.ResourceManager);
        settings.RestoreLatestCulture(true);
    });

Settings contains 6 methods for configuration:

• AddResource
• AddFileResource
• InitialCulture
• RestoreLatestCulture
• SupportNameWithDots
• SuppressTextNotFoundException

AddResource

Used to add one or more Resource Managers. e.g. AppResources.ResourceManager, SpecialResources.ResourceManager etc.

Note: All resource libraries will be searched in the order they were added, until resource is found!

AddFileResource

Use to add file based Resource Managers. Enables the option to Create/Read/Write at runtime with ResourceWriter and ResourceReader.

InitialCulture

Set the initial/startup culture used for application. e.g. new CultureInfo(“fr”)

Default: Current System Culture

RestoreLatestCulture

Flag indicating if latest set culture should be restored on application startup.

Default: false
Note: This setting, if set to true, will override the InitalCulture setting!

SupportNameWithDots

Activate support for Resource Names with Dots when used with TranslateExtension. e.g. Text=”{localization:Translate Hello.World}”
Dots in names will be temporarily replaced by the substitution text to correctly be handled in the extension binding.

Option to set custom dot substitution. Default: “_”

SuppressTextNotFoundException

Ability to Suppress/Deactivate throwing the text not found exception with the option to set a placeholder text to be displayed if text is not found.

• UsePlaceholder flag to indicating if a placeholder text should be displayed if text is not found. (Optional, Default: false, string.Empy will be returned)
• Placeholder text to be displayed if text is not found, when UsePlaceHolder is activated. (Optional, Default: Resource name)

(“{0}” in the placeholder text, will be replaced with the resource name.)

Use in XAML

When used for localized texts in XAML pages, use the TranslateExtension:

• Add namespace reference to library.
• Use Translate extension with name of resource.

<ContentPage
    x:Class="LocalizationResourceManager.Maui.Sample.MainPage"
    xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
    xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
    xmlns:localization="clr-namespace:LocalizationResourceManager.Maui;assembly=LocalizationResourceManager.Maui">

<Label
    FontSize="18"
    HorizontalOptions="Center"
    SemanticProperties.Description="{localization:Translate WelcomeToMAUI}"
    SemanticProperties.HeadingLevel="Level2"
    Text="{localization:Translate WelcomeToMAUI}" />

Custom binding in XAML

Use the TranslateBindingExtension for custom binding with format and plural support.

Plural support in XAML

<Button
    x:Name="CounterBtn"
    Clicked="OnCounterClicked"
    HorizontalOptions="Center"
    SemanticProperties.Hint="{localization:Translate CounterBtnHint}"
    Text="{localization:TranslateBinding Count, TranslateFormat=ClickedManyTimes, TranslateOne=ClickedOneTime, TranslateZero=ClickMe}" />

The way it works is:

TranslateFormat : (optional) similar to StringFormat, but the format comes from a string resource, e.g. “Clicked {0} times”
TranslateOne : (optional) similar to StringFormat, but used for when the binding value is one (1), e.g. “Clicked {0} time”
TranslateZero : (optional) similar to StringFormat, but used for when the binding value is zero (0), e.g. “Click Me”

Date/Time in XAML

public DateTime CurrentDateTime { get; set; } = DateTime.Now;

<!-- DateIs string resource: "Date is: {0}" -->
<Label Text="{localization:TranslateBinding CurrentDateTime, TranslateFormat=DateIs}/"/>

<! -- TimeIs string resource: "Time is: {0:HH}:{0:mm}:{0:ss}" -->
<Label Text="{localization:TranslateBinding CurrentDateTime, TranslateFormat=TimeIs}/" />

Currency in XAML

public decimal Price { get; set; } = 123.45;

<!-- TotalPrice string resource: "Total Price is: {0:C}" -->
<Label Text="{localization:TranslateBinding Price, TranslateFormat=TotalPrice}" />

Translate collections in XAML

TranslateValue : (optional) Apply localization changes to a view model, e.g.

public IList<string> Fruits { get; set; } = new List<string> { "LBL_APPLES", "LBL_ORANGES" };

<CollectionView ItemsSource="{Binding Fruits}">
    <CollectionView.ItemTemplate>
        <DataTemplate>
            <Label Text="{localization:TranslateBinding . , TranslateValue=True}"/>
        <DataTemplate>
    </CollectionView.ItemTemplate>
</CollectionView>

Translate true/false states in XAML

TranslateTrue : (optional) string resource used for when the binding value is true, e.g. “Yes”, “On”, “Activated”
TranslateFalse : (optional) string resource used for when the binding value is false, e.g. “No”, “Off”, “Deactivated”

public bool OrderSent { get; set; } = false;

<!-- Yes/No string resources: "Yes" / "No" -->
<Label Text="{localization:TranslateBinding OrderSent, TranslateTrue=Yes, TranslateFalse=No}" />

Use in Code

When used to handle localized texts in code behind or ViewModel, use the LocalizedString class:

• Add LocalizedString to code behind or ViewModel to track culture changes
• If needed, make binding to LocalizedString in XAML

public LocalizedString HelloWorld { get; } = new(() => $"{AppResources.Hello}, {AppResources.World}!");

…or to support multiple Resource managers…

public LocalizedString HelloWorld { get; }

public MainPage(ILocalizationResourceManager resourceManager)
{
    HelloWorld = new(() => $"{resourceManager["Hello"]}, {resourceManager["World"]}!");

<Label
    FontSize="32"
    HorizontalOptions="Center"
    SemanticProperties.HeadingLevel="Level1"
    Text="{Binding HelloWorld.Localized}" />

Set and Get Culture

To handle and access the Current or Default Culture, we inject the ILocalizationResourceManager interface into our code behind or ViewModel to access the LocalizationResourceManager instance:

• Add the ILocalizationResourceManager interface to your constructor and store locally for later access.
• Use CurrentCulture property to Get or Set CurrentCulture. (All text accessed by TranslateExtension or LocalizedString will be updated immediately!)
• Use DefaultCulture property to Get Default/System culture.
• Use GetValue method or Indexer operator [] to manually retrieve localized text based on Current culture.
• Use ReleaseAllResources method to Release/Close all resources for all registered resources. (Use before manually accessing registered file based resources!)

public partial class MainPage : ContentPage
{
    private readonly ILocalizationResourceManager resourceManager;

    public MainPage(ILocalizationResourceManager resourceManager)
    {
        InitializeComponent();
        this.resourceManager = resourceManager;

public string? CurrentCulture => resourceManager?.CurrentCulture.NativeName;

…or…

public LocalizedString CurrentCulture { get; }

public MainPage(ILocalizationResourceManager resourceManager)
{
    CurrentCulture = new(() => resourceManager.CurrentCulture.NativeName);

One line to change Current Culture and Refresh ALL localized texts!

resourceManager.CurrentCulture = new CultureInfo("en");

Sample

Look at the Sample project for a example of how to use this library in an .NET MAUI application.

Like in this example for a base view model class:

/// <summary>
/// Base ViewModel.
/// </summary>
public partial class BaseViewModel : ObservableObject
{
    [ObservableProperty]
    private string title;
    
    [ObservableProperty]
    [NotifyPropertyChangedFor(nameof(CanExecute))]
    private bool isBusy;

    public bool CanExecute => !IsBusy;
}

No WeakEventManager! The one thing that I miss from the Xamarin Community Toolkit is the WeakEventManager for safe handling of events! In .NET MAUI we have that WeakEventManager built in!

So I decided to extend the ObservableObject class in the MVVM Toolkit to add this! By inherting this class into a class called BaseObservableObject and implementing INotifyPropertyChanged and INotifyPropertyChanging events, I could override the EventHandler and intercept the events to use the WeakEventManager.

/// <summary>
/// Extended ObservableObject that uses WeakEventManager to avoid memory leaks!
/// </summary>
public class BaseObservableObject : ObservableObject, INotifyPropertyChanged, INotifyPropertyChanging
{
    private readonly WeakEventManager weakEventManager = new WeakEventManager();

    event PropertyChangedEventHandler? INotifyPropertyChanged.PropertyChanged
    {
        add => weakEventManager.AddEventHandler(value);
        remove => weakEventManager.RemoveEventHandler(value);
    }

    event System.ComponentModel.PropertyChangingEventHandler? INotifyPropertyChanging.PropertyChanging
    {
        add => weakEventManager.AddEventHandler(value);
        remove => weakEventManager.RemoveEventHandler(value);
    }

    public new event PropertyChangedEventHandler? PropertyChanged
    {
        add => weakEventManager.AddEventHandler(value);
        remove => weakEventManager.RemoveEventHandler(value);
    }

    public new event System.ComponentModel.PropertyChangingEventHandler? PropertyChanging
    {
        add => weakEventManager.AddEventHandler(value);
        remove => weakEventManager.RemoveEventHandler(value);
    }

    protected override void OnPropertyChanged(PropertyChangedEventArgs e)
    {
        weakEventManager.HandleEvent(this, e, nameof(INotifyPropertyChanged.PropertyChanged));
    }

    protected override void OnPropertyChanging(System.ComponentModel.PropertyChangingEventArgs e)
    {
        weakEventManager.HandleEvent(this, e, nameof(INotifyPropertyChanging.PropertyChanging));
    }
}

So now by inherting the BaseObservableObject in our classes, we now have event handling with WeakEventManager in our code using the MVVM Toolkit!

public partial class BaseViewModel : BaseObservableObject