How to use CompiledBindingExtension in MarkupExtension

[Coloryr]

I was use ReflectionBindingExtension before

public class LangExtension : MarkupExtension
{
    public string Key { get; set; }

    public LangExtension(string key)
    {
        Key = key;
    }

    public override object ProvideValue(IServiceProvider serviceProvider)
    {
        var binding = new ReflectionBindingExtension($"[{Key}]")
        {
            Mode = BindingMode.OneWay,
            Source = LangSel.Instance,
        };

        return binding.ProvideValue(serviceProvider);
    }
}

and it can replace the ReflectionBindingExtension to CompiledBindingExtension?

[Coloryr]

public class LangSel : INotifyPropertyChanged
{
    public readonly static LangSel Instance = new();

    public string this[string key]
    {
        get
        {
            return Lang.Get(key);
        }
    }

    public event PropertyChangedEventHandler? PropertyChanged;

    public void Reload()
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(Indexer.IndexerName));
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(Indexer.IndexerArrayName));
    }
}

[maxkatz6]

It should be way simpler (and trimming safer) in your case to create an IObservable from your object/events and then use observable.ToBinding() method.

CompiledBindingExtension doesn't make much sense outside of XAML markup.

[Coloryr]

IObservable whit MarkupExtension?
how to do that?
Use the LangExtension in xaml

<Label Content="{setting:Lang Window.Device.Info1}" />

[3400442579]

 public sealed class LocalizeExtension : MarkupExtension
 {
     
     public LocalizeExtension(string key)
     {
         Key = key;
     }

     public string Key { get; set; }


     public string? Context { get; set; }

  
     public override object ProvideValue(IServiceProvider serviceProvider)
     {
         var keyToUse = Key;
         if (!string.IsNullOrWhiteSpace(Context))
         {
             keyToUse = $"{Context}/{Key}";
         }
         return Localizer.Instance[keyToUse];

         //var binding = new ReflectionBindingExtension($"[{keyToUse}]")
         //{
         //    Mode = BindingMode.OneWay,
         //    Source = Localizer.Instance
         //};
         //return binding.ProvideValue(serviceProvider);
     }
 }

[Coloryr]

 public sealed class LocalizeExtension : MarkupExtension
 {
     
     public LocalizeExtension(string key)
     {
         Key = key;
     }

     public string Key { get; set; }


     public string? Context { get; set; }

  
     public override object ProvideValue(IServiceProvider serviceProvider)
     {
         var keyToUse = Key;
         if (!string.IsNullOrWhiteSpace(Context))
         {
             keyToUse = $"{Context}/{Key}";
         }
         return Localizer.Instance[keyToUse];

         //var binding = new ReflectionBindingExtension($"[{keyToUse}]")
         //{
         //    Mode = BindingMode.OneWay,
         //    Source = Localizer.Instance
         //};
         //return binding.ProvideValue(serviceProvider);
     }
 }

nope, now i use

public class LocalizeExtension(string key) : MarkupExtension, IObservable<string>
{
    public override object ProvideValue(IServiceProvider serviceProvider)
    {
        return this.ToBinding();
    }

    public IDisposable Subscribe(IObserver<string> observer)
    {
        return LangSel.Add(key, observer);
    }
}

public static class LangSel
{
    private static readonly Dictionary<string, List<WeakReference<IObserver<string>>>> s_langList = [];

    public static IDisposable Add(string key, IObserver<string> observer)
    {
        if (s_langList.TryGetValue(key, out var list))
        {
            list.Add(new(observer));
        }
        else
        {
            list = [new(observer)];
            s_langList.Add(key, list);
        }
        var value = App.Lang(key);
        observer.OnNext(value);
        return new Unsubscribe(list, observer);
    }

    private class Unsubscribe(List<WeakReference<IObserver<string>>> observers, IObserver<string> observer) : IDisposable
    {
        public void Dispose()
        {
            foreach (var item in observers.ToArray())
            {
                if (!item.TryGetTarget(out var target)
                    || target == observer)
                {
                    observers.Remove(item);
                }
            }
        }
    }

    public static void Reload()
    {
        foreach (var item in s_langList)
        {
            var value = App.Lang(item.Key);
            foreach (var item1 in item.Value)
            {
                if (item1.TryGetTarget(out var target))
                { 
                    target.OnNext(value);
                }
            }
        }
    }
}

[Coloryr]

https://github.com/Coloryr/ColorMC/blob/master/src/ColorMC.Gui/Utils/LaunchSetting/Extensions.cs
https://github.com/Coloryr/ColorMC/blob/master/src/ColorMC.Gui/Utils/LaunchSetting/LangSel.cs
https://github.com/Coloryr/ColorMC/blob/master/src/ColorMC.Gui/UI/Controls/Add/AddControl.axaml

[Kermel]

Thank you

[BuriKizilkaya]

Is it possible to user your extension also with CompiledBindings?

[HellGate94]

i tried it any many other things with no success. the binding just never updates other than the first time

[tobyfirth]

This works for me. It will cause all bindings to be updated at once so if you are frequently changing a subset of the values it isn't going to be the best solution but for language changing an updating all texts together this will work.

I also don't know how stable the CompiledBinding apis are intended to be but it hasn't broken in 11.x yet.

public class TextsExtension : MarkupExtension
{
    public TextsExtension(string key)
    {
        _key = key;
    }

    public readonly string _key;

    public override object ProvideValue(IServiceProvider serviceProvider)
    {
        var path = new CompiledBindingPathBuilder()
			.Property(
			    new ClrPropertyInfo("Item",
			        o => Texts.Instance[_key],
			        null,
			        typeof(string)),
			    PropertyInfoAccessorFactory.CreateInpcPropertyAccessor)
			.Build();

        return new CompiledBindingExtension(path)
	{
	    Mode = Avalonia.Data.BindingMode.OneWay,
	    Source = Texts.Instance,
	};
    }
}

public class Texts : INotifyPropertyChanged
{
    public static Texts Instance { get; set; } = new Texts();

    private Dictionary<string, string> _texts = [];

    public string this[string key]
    {
	get
	{
		return _texts[key];
	}
    }

    public event PropertyChangedEventHandler? PropertyChanged;

    public void ChangeTexts(Dictionary<string, string> texts)
    {
        _texts = texts;
        Dispatcher.UIThread.Post(() => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Item")));
    }
}