Wrap FluentAvalonia controls within same named classes allowing us to declare the xmlns namespace in our assembly

Framework/Avalonia/Avalonia.csproj

@@ -0,0 +1,21 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net7.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <AssemblyName>Toolkit.Foundation.Avalonia</AssemblyName>
+    <RootNamespace>Toolkit.Foundation.Avalonia</RootNamespace>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Avalonia" Version="11.0.0-preview4" />
+    <PackageReference Include="FluentAvaloniaUI" Version="2.0.0-preview4" />
+    <PackageReference Include="Mediator.Abstractions" Version="2.1.0-preview.5" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Foundation\Foundation.csproj" />
+  </ItemGroup>
+
+</Project>

Framework/Avalonia/Extensions/EventArgsExtensions.cs

@@ -0,0 +1,24 @@
+using Avalonia.Data.Converters;
+using System.Globalization;
+
+namespace Toolkit.Foundation.Avalonia
+{
+    public static class EventArgsExtensions
+    {
+        public static dynamic? GetEventArguments(this EventArgs args, string? path, IValueConverter? converter, object? converterParameter)
+        {
+            return !string.IsNullOrWhiteSpace(path) ? GetEventArgsPropertyPathValue(args, path) : converter is not null ? converter.Convert(args, typeof(object), converterParameter, CultureInfo.CurrentCulture) : (dynamic)args;
+        }
+
+        private static object GetEventArgsPropertyPathValue(object args, string path)
+        {
+            object? value = args;
+            if (path is { })
+            {
+                value = PropertyPathHelper.GetValue(args, path);
+            }
+
+            return value;
+        }
+    }
+}

Framework/Avalonia/Extensions/IHostBuilderExtensions.cs

@@ -0,0 +1,35 @@
+using Mediator;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+using Microsoft.Extensions.Hosting;
+
+namespace Toolkit.Foundation.Avalonia
+{
+    public static class IHostBuilderExtensions
+    {
+        public static IHostBuilder ConfigureTemplates(this IHostBuilder hostBuilder, Action<ITemplateBuilder> builderDelegate)
+        {
+            hostBuilder.ConfigureServices((hostBuilderContext, serviceCollection) =>
+            {
+                TemplateBuilder? builder = new();
+                builderDelegate?.Invoke(builder);
+
+                serviceCollection.TryAddSingleton(builder.Descriptors);
+                serviceCollection.TryAddSingleton<ITemplateDescriptorProvider, TemplateDescriptorProvider>();
+                serviceCollection.TryAddSingleton<ITemplateFactory, TemplateFactory>();
+                serviceCollection.TryAddSingleton<INamedTemplateFactory, NamedTemplateFactory>();
+                serviceCollection.TryAddSingleton<ITypedDataTemplateFactory, TypedDataTemplateFactory>();
+                serviceCollection.TryAddSingleton<INamedDataTemplateFactory, NamedDataTemplateFactory>();
+                serviceCollection.TryAddSingleton<ITemplateSelector, TemplateSelector>();
+
+                foreach (ITemplateDescriptor? descriptor in builder.Descriptors)
+                {
+                    serviceCollection.Add(new ServiceDescriptor(descriptor.TemplateType, descriptor.TemplateType, descriptor.Lifetime));
+                    serviceCollection.Add(new ServiceDescriptor(descriptor.ContentType, descriptor.ContentType, descriptor.Lifetime));
+                }
+            });
+
+            return hostBuilder;
+        }
+    }
+}

Framework/Avalonia/Extensions/IServiceCollectionExtensions.cs

@@ -0,0 +1,21 @@
+using Avalonia.Controls;
+using FluentAvalonia.UI.Controls;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+
+namespace Toolkit.Foundation.Avalonia
+{ 
+    public static class IServiceCollectionExtensions
+    {
+        public static IServiceCollection AddNavigation(this IServiceCollection serviceCollection)
+        {
+            serviceCollection.TryAddSingleton<INavigationRouteDescriptorCollection, NavigationRouteDescriptorCollection>();
+
+            serviceCollection.TryAddTransient<Navigation<Frame>, FrameNavigation>();
+            serviceCollection.TryAddTransient<Navigation<ContentDialog>, ContentDialogNavigation>();
+            serviceCollection.TryAddTransient<Navigation<ContentControl>, ContentControlNavigation>();
+
+            return serviceCollection;
+        }
+    }
+}

Framework/Avalonia/Extensions/MarkupExtensions.cs

@@ -0,0 +1,17 @@
+using Avalonia.Data;
+
+namespace Toolkit.Foundation.Avalonia
+{
+    public static class MarkupExtensions
+    {
+        public static Binding? ToBinding(this object value)
+        {
+            if (value is Binding)
+            {
+                return value as Binding;
+            }
+
+            return new Binding { Mode = BindingMode.OneWay, Source = value };
+        }
+    }
+}

Framework/Avalonia/Extensions/PropertyPathHelper..cs

@@ -0,0 +1,28 @@
+using Avalonia;
+using Avalonia.Data;
+
+namespace Toolkit.Foundation.Avalonia
+{
+    public static class PropertyPathHelper
+    {
+        private static readonly Dummy dummy = new();
+
+        public static object GetValue(object args, string path)
+        {
+            Binding binding = new(path)
+            {
+                Mode = BindingMode.OneTime,
+                Source = args
+            };
+
+            dummy.Bind(Dummy.ValueProperty, binding);
+            return dummy.GetValue(Dummy.ValueProperty);
+        }
+
+        private class Dummy : AvaloniaObject
+        {
+            public static readonly StyledProperty<object> ValueProperty =
+                AvaloniaProperty.Register<Dummy, object>("Value");
+        }
+    }
+}

Framework/Avalonia/Markups/CompositeExtension.cs

@@ -0,0 +1,321 @@
+using Avalonia.Markup.Xaml;
+
+namespace Toolkit.Foundation.Avalonia
+{
+    public class CompositeExtension : TriggerExtension
+    {
+        [ConstructorArgument(nameof(Triggers))]
+        public TriggerCollection Triggers { get; } = new TriggerCollection();
+
+        public CompositeExtension(object args0)
+        {
+            Triggers.Add(args0);
+        }
+
+        public CompositeExtension(object args0,
+            object args1)
+        {
+            Triggers.Add(args0);
+            Triggers.Add(args1);
+        }
+
+        public CompositeExtension(object args0,
+            object args1,
+            object args2)
+        {
+            Triggers.Add(args0);
+            Triggers.Add(args1);
+            Triggers.Add(args2);
+        }
+
+        public CompositeExtension(object args0,
+            object args1,
+            object args2,
+            object args3)
+        {
+            Triggers.Add(args0);
+            Triggers.Add(args1);
+            Triggers.Add(args2);
+            Triggers.Add(args3);
+        }
+
+        public CompositeExtension(object args0,
+            object args1,
+            object args2,
+            object args3,
+            object args4)
+        {
+            Triggers.Add(args0);
+            Triggers.Add(args1);
+            Triggers.Add(args2);
+            Triggers.Add(args3);
+            Triggers.Add(args4);
+        }
+
+        public CompositeExtension(object args0,
+            object args1,
+            object args2,
+            object args3,
+            object args4,
+            object args5)
+        {
+            Triggers.Add(args0);
+            Triggers.Add(args1);
+            Triggers.Add(args2);
+            Triggers.Add(args3);
+            Triggers.Add(args4);
+            Triggers.Add(args5);
+        }
+
+        public CompositeExtension(object args0,
+            object args1,
+            object args2,
+            object args3,
+            object args4,
+            object args5,
+            object args6)
+        {
+            Triggers.Add(args0);
+            Triggers.Add(args1);
+            Triggers.Add(args2);
+            Triggers.Add(args3);
+            Triggers.Add(args4);
+            Triggers.Add(args5);
+            Triggers.Add(args6);
+        }
+
+        public CompositeExtension(object args0,
+            object args1,
+            object args2,
+            object args3,
+            object args4,
+            object args5,
+            object args6,
+            object args7)
+        {
+            Triggers.Add(args0);
+            Triggers.Add(args1);
+            Triggers.Add(args2);
+            Triggers.Add(args3);
+            Triggers.Add(args4);
+            Triggers.Add(args5);
+            Triggers.Add(args6);
+            Triggers.Add(args7);
+        }
+
+        public CompositeExtension(object args0,
+            object args1,
+            object args2,
+            object args3,
+            object args4,
+            object args5,
+            object args6,
+            object args7,
+            object args8)
+        {
+            Triggers.Add(args0);
+            Triggers.Add(args1);
+            Triggers.Add(args2);
+            Triggers.Add(args3);
+            Triggers.Add(args4);
+            Triggers.Add(args5);
+            Triggers.Add(args6);
+            Triggers.Add(args7);
+            Triggers.Add(args8);
+        }
+
+        public CompositeExtension(object args0,
+            object args1,
+            object args2,
+            object args3,
+            object args4,
+            object args5,
+            object args6,
+            object args7,
+            object args8,
+            object args9)
+        {
+            Triggers.Add(args0);
+            Triggers.Add(args1);
+            Triggers.Add(args2);
+            Triggers.Add(args3);
+            Triggers.Add(args4);
+            Triggers.Add(args5);
+            Triggers.Add(args6);
+            Triggers.Add(args7);
+            Triggers.Add(args8);
+            Triggers.Add(args9);
+        }
+
+        public CompositeExtension(object args0, object args1, object args2, object args3, object args4,
+            object args5, object args6, object args7, object args8, object args9, object args10)
+        {
+            Triggers.Add(args0);
+            Triggers.Add(args1);
+            Triggers.Add(args2);
+            Triggers.Add(args3);
+            Triggers.Add(args4);
+            Triggers.Add(args5);
+            Triggers.Add(args6);
+            Triggers.Add(args7);
+            Triggers.Add(args8);
+            Triggers.Add(args9);
+            Triggers.Add(args10);
+        }
+
+        public CompositeExtension(object args0, object args1, object args2, object args3, object args4,
+            object args5, object args6, object args7, object args8, object args9, object args10, object args11)
+        {
+            Triggers.Add(args0);
+            Triggers.Add(args1);
+            Triggers.Add(args2);
+            Triggers.Add(args3);
+            Triggers.Add(args4);
+            Triggers.Add(args5);
+            Triggers.Add(args6);
+            Triggers.Add(args7);
+            Triggers.Add(args8);
+            Triggers.Add(args9);
+            Triggers.Add(args10);
+            Triggers.Add(args11);
+        }
+
+        public CompositeExtension(object args0,
+            object args1,
+            object args2,
+            object args3,
+            object args4,
+            object args5,
+            object args6,
+            object args7,
+            object args8,
+            object args9,
+            object args10,
+            object args11,
+            object args12)
+        {
+            Triggers.Add(args0);
+            Triggers.Add(args1);
+            Triggers.Add(args2);
+            Triggers.Add(args3);
+            Triggers.Add(args4);
+            Triggers.Add(args5);
+            Triggers.Add(args6);
+            Triggers.Add(args7);
+            Triggers.Add(args8);
+            Triggers.Add(args9);
+            Triggers.Add(args10);
+            Triggers.Add(args11);
+            Triggers.Add(args12);
+        }
+
+        public CompositeExtension(object args0,
+            object args1,
+            object args2,
+            object args3,
+            object args4,
+            object args5,
+            object args6,
+            object args7,
+            object args8,
+            object args9,
+            object args10,
+            object args11,
+            object args12,
+            object args13)
+        {
+            Triggers.Add(args0);
+            Triggers.Add(args1);
+            Triggers.Add(args2);
+            Triggers.Add(args3);
+            Triggers.Add(args4);
+            Triggers.Add(args5);
+            Triggers.Add(args6);
+            Triggers.Add(args7);
+            Triggers.Add(args8);
+            Triggers.Add(args9);
+            Triggers.Add(args10);
+            Triggers.Add(args11);
+            Triggers.Add(args12);
+            Triggers.Add(args13);
+        }
+
+        public CompositeExtension(object args0,
+            object args1,
+            object args2,
+            object args3,
+            object args4,
+            object args5,
+            object args6,
+            object args7,
+            object args8,
+            object args9,
+            object args10,
+            object args11,
+            object args12,
+            object args13,
+            object args14)
+        {
+            Triggers.Add(args0);
+            Triggers.Add(args1);
+            Triggers.Add(args2);
+            Triggers.Add(args3);
+            Triggers.Add(args4);
+            Triggers.Add(args5);
+            Triggers.Add(args6);
+            Triggers.Add(args7);
+            Triggers.Add(args8);
+            Triggers.Add(args9);
+            Triggers.Add(args10);
+            Triggers.Add(args11);
+            Triggers.Add(args12);
+            Triggers.Add(args13);
+            Triggers.Add(args14);
+        }
+
+        public CompositeExtension(object args0,
+            object args1,
+            object args2,
+            object args3,
+            object args4,
+            object args5,
+            object args6,
+            object args7,
+            object args8,
+            object args9,
+            object args10,
+            object args11,
+            object args12,
+            object args13,
+            object args14,
+            object args15)
+        {
+            Triggers.Add(args0);
+            Triggers.Add(args1);
+            Triggers.Add(args2);
+            Triggers.Add(args3);
+            Triggers.Add(args4);
+            Triggers.Add(args5);
+            Triggers.Add(args6);
+            Triggers.Add(args7);
+            Triggers.Add(args8);
+            Triggers.Add(args9);
+            Triggers.Add(args10);
+            Triggers.Add(args11);
+            Triggers.Add(args12);
+            Triggers.Add(args13);
+            Triggers.Add(args14);
+            Triggers.Add(args15);
+        }
+
+        protected override void OnInvoked(object sender, EventArgs args)
+        {
+            foreach (Delegate? trigger in Triggers)
+            {
+                trigger.Method.Invoke(trigger.Target, new object[] { sender, args });
+            }
+
+            base.OnInvoked(sender, args);
+        }
+    }
+}

Framework/Avalonia/Markups/EventParameterExtension.cs

@@ -0,0 +1,65 @@
+using Avalonia.Data.Converters;
+using Avalonia.Markup.Xaml;
+
+namespace Toolkit.Foundation.Avalonia
+{
+    public class EventParameterExtension : MarkupExtension, IEventParameter
+    {
+        private readonly IValueConverter? converter;
+
+        private readonly object? converterParameter;
+
+        private readonly string? key;
+        private readonly string? path;
+
+        public EventParameterExtension()
+        {
+
+        }
+
+        public EventParameterExtension(string key, string path)
+        {
+            this.key = key;
+            this.path = path;
+        }
+
+        public EventParameterExtension(string path)
+        {
+            this.path = path;
+        }
+
+        public EventParameterExtension(IValueConverter? converter = null, object? converterParameter = null)
+        {
+            this.converter = converter;
+            this.converterParameter = converterParameter;
+        }
+
+        public List<object> GetValues(EventArgs args)
+        {
+            List<object>? parameters = new();
+
+            dynamic? arguments = args.GetEventArguments(path, converter, converterParameter);
+            if (arguments is not null)
+            {
+                if (arguments is ICollection<object> collection)
+                {
+                    foreach (object? argument in collection)
+                    {
+                        parameters.Add(key is not null ? new KeyValuePair<string, object>(key, (dynamic)argument) : argument);
+                    }
+                }
+                else
+                {
+                    parameters.Add(key is not null ? new KeyValuePair<string, object>(key, arguments) : arguments);
+                }
+            }
+
+            return parameters;
+        }
+
+        public override object ProvideValue(IServiceProvider serviceProvider)
+        {
+            return this;
+        }
+    }
+}

Framework/Avalonia/Markups/InvokeExtension.cs

@@ -0,0 +1,424 @@
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Data;
+using Avalonia.Markup.Xaml;
+using System.Diagnostics.CodeAnalysis;
+using System.Reflection;
+
+namespace Toolkit.Foundation.Avalonia
+{
+    public class InvokeExtension : TriggerExtension
+    {
+        private static readonly AvaloniaProperty TargetProperty =
+            AvaloniaProperty.RegisterAttached<InvokeExtension, Control, object>("Target");
+
+        private readonly object path;
+        private readonly List<object?> parameters = new();
+
+        public InvokeExtension(object path)
+        {
+            this.path = path;
+        }
+
+        public InvokeExtension(object path,
+            object args1)
+        {
+            this.path = path;
+
+            parameters.Add(args1 is not MarkupExtension ? args1.ToBinding() : args1);
+        }
+
+        public InvokeExtension(object path,
+            object args1,
+            object args2)
+        {
+            this.path = path;
+
+            parameters.Add(args1 is MarkupExtension ? args1 : args1.ToBinding());
+            parameters.Add(args2 is MarkupExtension ? args2 : args2.ToBinding());
+        }
+
+        public InvokeExtension(object path,
+            object args1,
+            object args2,
+            object args3)
+        {
+            this.path = path;
+
+            parameters.Add(args1 is MarkupExtension ? args1 : args1.ToBinding());
+            parameters.Add(args2 is MarkupExtension ? args2 : args2.ToBinding());
+            parameters.Add(args3 is MarkupExtension ? args3 : args3.ToBinding());
+        }
+
+        public InvokeExtension(object path,
+            object args1,
+            object args2,
+            object args3,
+            object args4)
+        {
+            this.path = path;
+
+            parameters.Add(args1 is MarkupExtension ? args1 : args1.ToBinding());
+            parameters.Add(args2 is MarkupExtension ? args2 : args2.ToBinding());
+            parameters.Add(args3 is MarkupExtension ? args3 : args3.ToBinding());
+            parameters.Add(args4 is MarkupExtension ? args4 : args4.ToBinding());
+        }
+
+        public InvokeExtension(object path,
+            object args1,
+            object args2,
+            object args3,
+            object args4,
+            object args5)
+        {
+            this.path = path;
+
+            parameters.Add(args1 is MarkupExtension ? args1 : args1.ToBinding());
+            parameters.Add(args2 is MarkupExtension ? args2 : args2.ToBinding());
+            parameters.Add(args3 is MarkupExtension ? args3 : args3.ToBinding());
+            parameters.Add(args4 is MarkupExtension ? args4 : args4.ToBinding());
+            parameters.Add(args5 is MarkupExtension ? args5 : args5.ToBinding());
+        }
+
+        public InvokeExtension(object path,
+            object args1,
+            object args2,
+            object args3,
+            object args4,
+            object args5,
+            object args6)
+        {
+            this.path = path;
+
+            parameters.Add(args1 is MarkupExtension ? args1 : args1.ToBinding());
+            parameters.Add(args2 is MarkupExtension ? args2 : args2.ToBinding());
+            parameters.Add(args3 is MarkupExtension ? args3 : args3.ToBinding());
+            parameters.Add(args4 is MarkupExtension ? args4 : args4.ToBinding());
+            parameters.Add(args5 is MarkupExtension ? args5 : args5.ToBinding());
+            parameters.Add(args6 is MarkupExtension ? args6 : args6.ToBinding());
+        }
+
+        public InvokeExtension(object path,
+            object args1,
+            object args2,
+            object args3,
+            object args4,
+            object args5,
+            object args6,
+            object args7)
+        {
+            this.path = path;
+
+            parameters.Add(args1 is MarkupExtension ? args1 : args1.ToBinding());
+            parameters.Add(args2 is MarkupExtension ? args2 : args2.ToBinding());
+            parameters.Add(args3 is MarkupExtension ? args3 : args3.ToBinding());
+            parameters.Add(args4 is MarkupExtension ? args4 : args4.ToBinding());
+            parameters.Add(args5 is MarkupExtension ? args5 : args5.ToBinding());
+            parameters.Add(args6 is MarkupExtension ? args6 : args6.ToBinding());
+            parameters.Add(args7 is MarkupExtension ? args7 : args7.ToBinding());
+        }
+
+        public InvokeExtension(object path,
+            object args1,
+            object args2,
+            object args3,
+            object args4,
+            object args5,
+            object args6,
+            object args7,
+            object args8)
+        {
+            this.path = path;
+
+            parameters.Add(args1 is MarkupExtension ? args1 : args1.ToBinding());
+            parameters.Add(args2 is MarkupExtension ? args2 : args2.ToBinding());
+            parameters.Add(args3 is MarkupExtension ? args3 : args3.ToBinding());
+            parameters.Add(args4 is MarkupExtension ? args4 : args4.ToBinding());
+            parameters.Add(args5 is MarkupExtension ? args5 : args5.ToBinding());
+            parameters.Add(args6 is MarkupExtension ? args6 : args6.ToBinding());
+            parameters.Add(args7 is MarkupExtension ? args7 : args7.ToBinding());
+            parameters.Add(args8 is MarkupExtension ? args8 : args8.ToBinding());
+        }
+
+        public InvokeExtension(object path,
+            object args1,
+            object args2,
+            object args3,
+            object args4,
+            object args5,
+            object args6,
+            object args7,
+            object args8,
+            object args9)
+        {
+            this.path = path;
+
+            parameters.Add(args1 is MarkupExtension ? args1 : args1.ToBinding());
+            parameters.Add(args2 is MarkupExtension ? args2 : args2.ToBinding());
+            parameters.Add(args3 is MarkupExtension ? args3 : args3.ToBinding());
+            parameters.Add(args4 is MarkupExtension ? args4 : args4.ToBinding());
+            parameters.Add(args5 is MarkupExtension ? args5 : args5.ToBinding());
+            parameters.Add(args6 is MarkupExtension ? args6 : args6.ToBinding());
+            parameters.Add(args7 is MarkupExtension ? args7 : args7.ToBinding());
+            parameters.Add(args8 is MarkupExtension ? args8 : args8.ToBinding());
+            parameters.Add(args9 is MarkupExtension ? args9 : args9.ToBinding());
+        }
+
+        public InvokeExtension(object path,
+            object args1,
+            object args2,
+            object args3,
+            object args4,
+            object args5,
+            object args6,
+            object args7,
+            object args8,
+            object args9,
+            object args10)
+        {
+            this.path = path;
+
+            parameters.Add(args1 is MarkupExtension ? args1 : args1.ToBinding());
+            parameters.Add(args2 is MarkupExtension ? args2 : args2.ToBinding());
+            parameters.Add(args3 is MarkupExtension ? args3 : args3.ToBinding());
+            parameters.Add(args4 is MarkupExtension ? args4 : args4.ToBinding());
+            parameters.Add(args5 is MarkupExtension ? args5 : args5.ToBinding());
+            parameters.Add(args6 is MarkupExtension ? args6 : args6.ToBinding());
+            parameters.Add(args7 is MarkupExtension ? args7 : args7.ToBinding());
+            parameters.Add(args8 is MarkupExtension ? args8 : args8.ToBinding());
+            parameters.Add(args9 is MarkupExtension ? args9 : args9.ToBinding());
+            parameters.Add(args10 is MarkupExtension ? args10 : args10.ToBinding());
+        }
+
+        public InvokeExtension(object path,
+            object args1,
+            object args2,
+            object args3,
+            object args4,
+            object args5,
+            object args6,
+            object args7,
+            object args8,
+            object args9,
+            object args10,
+            object args11)
+        {
+            this.path = path;
+
+            parameters.Add(args1 is MarkupExtension ? args1 : args1.ToBinding());
+            parameters.Add(args2 is MarkupExtension ? args2 : args2.ToBinding());
+            parameters.Add(args3 is MarkupExtension ? args3 : args3.ToBinding());
+            parameters.Add(args4 is MarkupExtension ? args4 : args4.ToBinding());
+            parameters.Add(args5 is MarkupExtension ? args5 : args5.ToBinding());
+            parameters.Add(args6 is MarkupExtension ? args6 : args6.ToBinding());
+            parameters.Add(args7 is MarkupExtension ? args7 : args7.ToBinding());
+            parameters.Add(args8 is MarkupExtension ? args8 : args8.ToBinding());
+            parameters.Add(args9 is MarkupExtension ? args9 : args9.ToBinding());
+            parameters.Add(args10 is MarkupExtension ? args10 : args10.ToBinding());
+            parameters.Add(args11 is MarkupExtension ? args11 : args11.ToBinding());
+        }
+
+        public InvokeExtension(object path,
+            object args1,
+            object args2,
+            object args3,
+            object args4,
+            object args5,
+            object args6,
+            object args7,
+            object args8,
+            object args9,
+            object args10,
+            object args11,
+            object args12)
+        {
+            this.path = path;
+
+            parameters.Add(args1 is MarkupExtension ? args1 : args1.ToBinding());
+            parameters.Add(args2 is MarkupExtension ? args2 : args2.ToBinding());
+            parameters.Add(args3 is MarkupExtension ? args3 : args3.ToBinding());
+            parameters.Add(args4 is MarkupExtension ? args4 : args4.ToBinding());
+            parameters.Add(args5 is MarkupExtension ? args5 : args5.ToBinding());
+            parameters.Add(args6 is MarkupExtension ? args6 : args6.ToBinding());
+            parameters.Add(args7 is MarkupExtension ? args7 : args7.ToBinding());
+            parameters.Add(args8 is MarkupExtension ? args8 : args8.ToBinding());
+            parameters.Add(args9 is MarkupExtension ? args9 : args9.ToBinding());
+            parameters.Add(args10 is MarkupExtension ? args10 : args10.ToBinding());
+            parameters.Add(args11 is MarkupExtension ? args11 : args11.ToBinding());
+            parameters.Add(args12 is MarkupExtension ? args12 : args12.ToBinding());
+        }
+
+        public InvokeExtension(object path,
+            object args1,
+            object args2,
+            object args3,
+            object args4,
+            object args5,
+            object args6,
+            object args7,
+            object args8,
+            object args9,
+            object args10,
+            object args11,
+            object args12,
+            object args13)
+        {
+            this.path = path;
+
+            parameters.Add(args1 is MarkupExtension ? args1 : args1.ToBinding());
+            parameters.Add(args2 is MarkupExtension ? args2 : args2.ToBinding());
+            parameters.Add(args3 is MarkupExtension ? args3 : args3.ToBinding());
+            parameters.Add(args4 is MarkupExtension ? args4 : args4.ToBinding());
+            parameters.Add(args5 is MarkupExtension ? args5 : args5.ToBinding());
+            parameters.Add(args6 is MarkupExtension ? args6 : args6.ToBinding());
+            parameters.Add(args7 is MarkupExtension ? args7 : args7.ToBinding());
+            parameters.Add(args8 is MarkupExtension ? args8 : args8.ToBinding());
+            parameters.Add(args9 is MarkupExtension ? args9 : args9.ToBinding());
+            parameters.Add(args10 is MarkupExtension ? args10 : args10.ToBinding());
+            parameters.Add(args11 is MarkupExtension ? args11 : args11.ToBinding());
+            parameters.Add(args12 is MarkupExtension ? args12 : args12.ToBinding());
+            parameters.Add(args13 is MarkupExtension ? args13 : args13.ToBinding());
+        }
+
+        public InvokeExtension(object path,
+            object args1,
+            object args2,
+            object args3,
+            object args4,
+            object args5,
+            object args6,
+            object args7,
+            object args8,
+            object args9,
+            object args10,
+            object args11,
+            object args12,
+            object args13,
+            object args14)
+        {
+            this.path = path;
+
+            parameters.Add(args1 is MarkupExtension ? args1 : args1.ToBinding());
+            parameters.Add(args2 is MarkupExtension ? args2 : args2.ToBinding());
+            parameters.Add(args3 is MarkupExtension ? args3 : args3.ToBinding());
+            parameters.Add(args4 is MarkupExtension ? args4 : args4.ToBinding());
+            parameters.Add(args5 is MarkupExtension ? args5 : args5.ToBinding());
+            parameters.Add(args6 is MarkupExtension ? args6 : args6.ToBinding());
+            parameters.Add(args7 is MarkupExtension ? args7 : args7.ToBinding());
+            parameters.Add(args8 is MarkupExtension ? args8 : args8.ToBinding());
+            parameters.Add(args9 is MarkupExtension ? args9 : args9.ToBinding());
+            parameters.Add(args10 is MarkupExtension ? args10 : args10.ToBinding());
+            parameters.Add(args11 is MarkupExtension ? args11 : args11.ToBinding());
+            parameters.Add(args12 is MarkupExtension ? args12 : args12.ToBinding());
+            parameters.Add(args13 is MarkupExtension ? args13 : args13.ToBinding());
+            parameters.Add(args14 is MarkupExtension ? args14 : args14.ToBinding());
+        }
+
+        public InvokeExtension(object path,
+            object args1,
+            object args2,
+            object args3,
+            object args4,
+            object args5,
+            object args6,
+            object args7,
+            object args8,
+            object args9,
+            object args10,
+            object args11,
+            object args12,
+            object args13,
+            object args14,
+            object args15)
+        {
+            this.path = path;
+
+            parameters.Add(args1 is MarkupExtension ? args1 : args1.ToBinding());
+            parameters.Add(args2 is MarkupExtension ? args2 : args2.ToBinding());
+            parameters.Add(args3 is MarkupExtension ? args3 : args3.ToBinding());
+            parameters.Add(args4 is MarkupExtension ? args4 : args4.ToBinding());
+            parameters.Add(args5 is MarkupExtension ? args5 : args5.ToBinding());
+            parameters.Add(args6 is MarkupExtension ? args6 : args6.ToBinding());
+            parameters.Add(args7 is MarkupExtension ? args7 : args7.ToBinding());
+            parameters.Add(args8 is MarkupExtension ? args8 : args8.ToBinding());
+            parameters.Add(args9 is MarkupExtension ? args9 : args9.ToBinding());
+            parameters.Add(args10 is MarkupExtension ? args10 : args10.ToBinding());
+            parameters.Add(args11 is MarkupExtension ? args11 : args11.ToBinding());
+            parameters.Add(args12 is MarkupExtension ? args12 : args12.ToBinding());
+            parameters.Add(args13 is MarkupExtension ? args13 : args13.ToBinding());
+            parameters.Add(args14 is MarkupExtension ? args14 : args14.ToBinding());
+            parameters.Add(args15 is MarkupExtension ? args15 : args15.ToBinding());
+        }
+
+        protected override void OnInvoked(object sender, EventArgs args)
+        {
+            if (sender is AvaloniaObject avaloniaObject)
+            {
+                CreaterHandler(avaloniaObject, args);
+            }
+        }
+
+        private void CreaterHandler(AvaloniaObject sender, EventArgs args)
+        {
+            if (TryGetInvoke(sender, out (object? Target, MethodInfo? MethodInfo) invoker))
+            {
+                if (invoker.Target is object target)
+                {
+                    if (invoker.MethodInfo is MethodInfo methodInfo)
+                    {
+                        ParameterInfo[] parameterInfo = methodInfo.GetParameters();
+                        List<object> parameters = new();
+
+                        foreach (object? parameter in this.parameters)
+                        {
+                            switch (parameter)
+                            {
+                                //case IParameter keyedParameter:
+                                //    BindingOperations.SetBinding(sender, ParameterProperty, parameter.ToBinding());
+                                //    parameters.Add(new KeyValuePair<string, object>(keyedParameter.Key, (dynamic)sender.GetValue(ParameterProperty)));
+                                //    break;
+                                //case IEventParameter eventParameter:
+                                //    parameters.AddRange(eventParameter.GetParameters(args));
+                                //    break;
+                                //default:
+                                //    BindingOperations.SetBinding(sender, ParameterProperty, parameter.ToBinding());
+                                //    parameters.Add((dynamic)sender.GetValue(ParameterProperty));
+                                //    break;
+                            }
+                        }
+
+                        methodInfo.Invoke(target, parameters.Any() ? parameters.ToArray() : parameterInfo.Length > 0 ? new object?[] { null } : Array.Empty<object>());
+                    }
+                }
+            }
+        }
+
+        private bool TryGetInvoke(AvaloniaObject sender, [AllowNull] out (object?, MethodInfo?) invoker)
+        {
+            if (path is Binding binding)
+            {
+                sender.Bind(TargetProperty, binding);
+                if (sender.GetValue(TargetProperty) is Action action)
+                {
+                    invoker = new(action.Target, action.Method);
+                    return true;
+                }
+            }
+
+            if (path is string name)
+            {
+                if (sender.GetValue(StyledElement.DataContextProperty) is object dataContext)
+                {
+                    if (dataContext.GetType().GetMethod(name, BindingFlags.Public | BindingFlags.Instance) is MethodInfo methodInfo)
+                    {
+                        invoker = new(dataContext, methodInfo);
+                        return true;
+                    }
+                }
+            }
+
+            invoker = default;
+            return false;
+        }
+    }
+}

Framework/Avalonia/Markups/NavigateExtension.cs

@@ -0,0 +1,485 @@
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Data;
+using Avalonia.Markup.Xaml;
+using Mediator;
+
+namespace Toolkit.Foundation.Avalonia
+{
+    public class NavigateExtension : TriggerExtension
+    {
+        private static readonly AttachedProperty<IMediator> MediatorProperty =
+            AvaloniaProperty.RegisterAttached<NavigateExtension, Control, IMediator>("Mediator");
+
+        private static readonly AttachedProperty<object> ParameterProperty =
+            AvaloniaProperty.RegisterAttached<NavigateExtension, Control, object>("Parameter");
+
+        private static readonly AvaloniaProperty RouteProperty =
+            AvaloniaProperty.RegisterAttached<NavigateExtension, Control, object>("Route");
+
+        private static readonly AvaloniaProperty ToProperty =
+            AvaloniaProperty.RegisterAttached<NavigateExtension, Control, object>("To");
+
+        private readonly Binding? mediatorBinding;
+        private readonly List<object?> parameters = new();
+        private readonly Binding? toBinding;
+        private object? route;
+        private Binding? routeBinding;
+
+        public NavigateExtension(object mediator,
+            object to)
+        {
+            mediatorBinding = mediator.ToBinding();
+            this.toBinding = to is Binding toBinding ? toBinding : to.ToBinding();
+        }
+
+        public NavigateExtension(object mediator,
+            object to,
+            object args1)
+        {
+            mediatorBinding = mediator.ToBinding();
+            this.toBinding = to is Binding toBinding ? toBinding : to.ToBinding();
+
+            parameters.Add(args1 is MarkupExtension ? args1 : args1.ToBinding());
+        }
+
+        public NavigateExtension(object mediator,
+            object to,
+            object args1,
+            object args2)
+        {
+            mediatorBinding = mediator.ToBinding();
+            this.toBinding = to is Binding toBinding ? toBinding : to.ToBinding();
+
+            parameters.Add(args1 is MarkupExtension ? args1 : args1.ToBinding());
+            parameters.Add(args2 is MarkupExtension ? args2 : args2.ToBinding());
+        }
+
+        public NavigateExtension(object mediator,
+            object to,
+            object args1,
+            object args2,
+            object args3)
+        {
+            mediatorBinding = mediator.ToBinding();
+            this.toBinding = to is Binding toBinding ? toBinding : to.ToBinding();
+
+            parameters.Add(args1 is MarkupExtension ? args1 : args1.ToBinding());
+            parameters.Add(args2 is MarkupExtension ? args2 : args2.ToBinding());
+            parameters.Add(args3 is MarkupExtension ? args3 : args3.ToBinding());
+        }
+
+        public NavigateExtension(object mediator,
+            object to,
+            object args1,
+            object args2,
+            object args3,
+            object args4)
+        {
+            mediatorBinding = mediator.ToBinding();
+            this.toBinding = to is Binding toBinding ? toBinding : to.ToBinding();
+
+            parameters.Add(args1 is MarkupExtension ? args1 : args1.ToBinding());
+            parameters.Add(args2 is MarkupExtension ? args2 : args2.ToBinding());
+            parameters.Add(args3 is MarkupExtension ? args3 : args3.ToBinding());
+            parameters.Add(args4 is MarkupExtension ? args4 : args4.ToBinding());
+        }
+
+        public NavigateExtension(object mediator,
+            object to,
+            object args1,
+            object args2,
+            object args3,
+            object args4,
+            object args5)
+        {
+            mediatorBinding = mediator.ToBinding();
+            this.toBinding = to is Binding toBinding ? toBinding : to.ToBinding();
+
+            parameters.Add(args1 is MarkupExtension ? args1 : args1.ToBinding());
+            parameters.Add(args2 is MarkupExtension ? args2 : args2.ToBinding());
+            parameters.Add(args3 is MarkupExtension ? args3 : args3.ToBinding());
+            parameters.Add(args4 is MarkupExtension ? args4 : args4.ToBinding());
+            parameters.Add(args5 is MarkupExtension ? args5 : args5.ToBinding());
+        }
+
+        public NavigateExtension(object mediator,
+            object to,
+            object args1,
+            object args2,
+            object args3,
+            object args4,
+            object args5,
+            object args6)
+        {
+            mediatorBinding = mediator.ToBinding();
+            this.toBinding = to is Binding toBinding ? toBinding : to.ToBinding();
+
+            parameters.Add(args1 is MarkupExtension ? args1 : args1.ToBinding());
+            parameters.Add(args2 is MarkupExtension ? args2 : args2.ToBinding());
+            parameters.Add(args3 is MarkupExtension ? args3 : args3.ToBinding());
+            parameters.Add(args4 is MarkupExtension ? args4 : args4.ToBinding());
+            parameters.Add(args5 is MarkupExtension ? args5 : args5.ToBinding());
+            parameters.Add(args6 is MarkupExtension ? args6 : args6.ToBinding());
+        }
+
+        public NavigateExtension(object mediator,
+            object to,
+            object args1,
+            object args2,
+            object args3,
+            object args4,
+            object args5,
+            object args6,
+            object args7)
+        {
+            mediatorBinding = mediator.ToBinding();
+            this.toBinding = to is Binding toBinding ? toBinding : to.ToBinding();
+
+            parameters.Add(args1 is MarkupExtension ? args1 : args1.ToBinding());
+            parameters.Add(args2 is MarkupExtension ? args2 : args2.ToBinding());
+            parameters.Add(args3 is MarkupExtension ? args3 : args3.ToBinding());
+            parameters.Add(args4 is MarkupExtension ? args4 : args4.ToBinding());
+            parameters.Add(args5 is MarkupExtension ? args5 : args5.ToBinding());
+            parameters.Add(args6 is MarkupExtension ? args6 : args6.ToBinding());
+            parameters.Add(args7 is MarkupExtension ? args7 : args7.ToBinding());
+        }
+
+        public NavigateExtension(object mediator,
+            object to,
+            object args1,
+            object args2,
+            object args3,
+            object args4,
+            object args5,
+            object args6,
+            object args7,
+            object args8)
+        {
+            mediatorBinding = mediator.ToBinding();
+            this.toBinding = to is Binding toBinding ? toBinding : to.ToBinding();
+
+            parameters.Add(args1 is MarkupExtension ? args1 : args1.ToBinding());
+            parameters.Add(args2 is MarkupExtension ? args2 : args2.ToBinding());
+            parameters.Add(args3 is MarkupExtension ? args3 : args3.ToBinding());
+            parameters.Add(args4 is MarkupExtension ? args4 : args4.ToBinding());
+            parameters.Add(args5 is MarkupExtension ? args5 : args5.ToBinding());
+            parameters.Add(args6 is MarkupExtension ? args6 : args6.ToBinding());
+            parameters.Add(args7 is MarkupExtension ? args7 : args7.ToBinding());
+            parameters.Add(args8 is MarkupExtension ? args8 : args8.ToBinding());
+        }
+
+        public NavigateExtension(object mediator,
+            object to,
+            object args1,
+            object args2,
+            object args3,
+            object args4,
+            object args5,
+            object args6,
+            object args7,
+            object args8,
+            object args9)
+        {
+            mediatorBinding = mediator.ToBinding();
+            this.toBinding = to is Binding toBinding ? toBinding : to.ToBinding();
+
+            parameters.Add(args1 is MarkupExtension ? args1 : args1.ToBinding());
+            parameters.Add(args2 is MarkupExtension ? args2 : args2.ToBinding());
+            parameters.Add(args3 is MarkupExtension ? args3 : args3.ToBinding());
+            parameters.Add(args4 is MarkupExtension ? args4 : args4.ToBinding());
+            parameters.Add(args5 is MarkupExtension ? args5 : args5.ToBinding());
+            parameters.Add(args6 is MarkupExtension ? args6 : args6.ToBinding());
+            parameters.Add(args7 is MarkupExtension ? args7 : args7.ToBinding());
+            parameters.Add(args8 is MarkupExtension ? args8 : args8.ToBinding());
+            parameters.Add(args9 is MarkupExtension ? args9 : args9.ToBinding());
+        }
+
+        public NavigateExtension(object mediator,
+            object to,
+            object args1,
+            object args2,
+            object args3,
+            object args4,
+            object args5,
+            object args6,
+            object args7,
+            object args8,
+            object args9,
+            object args10)
+        {
+            mediatorBinding = mediator.ToBinding();
+            this.toBinding = to is Binding toBinding ? toBinding : to.ToBinding();
+
+            parameters.Add(args1 is MarkupExtension ? args1 : args1.ToBinding());
+            parameters.Add(args2 is MarkupExtension ? args2 : args2.ToBinding());
+            parameters.Add(args3 is MarkupExtension ? args3 : args3.ToBinding());
+            parameters.Add(args4 is MarkupExtension ? args4 : args4.ToBinding());
+            parameters.Add(args5 is MarkupExtension ? args5 : args5.ToBinding());
+            parameters.Add(args6 is MarkupExtension ? args6 : args6.ToBinding());
+            parameters.Add(args7 is MarkupExtension ? args7 : args7.ToBinding());
+            parameters.Add(args8 is MarkupExtension ? args8 : args8.ToBinding());
+            parameters.Add(args9 is MarkupExtension ? args9 : args9.ToBinding());
+            parameters.Add(args10 is MarkupExtension ? args10 : args10.ToBinding());
+        }
+
+        public NavigateExtension(object mediator,
+            object to,
+            object args1,
+            object args2,
+            object args3,
+            object args4,
+            object args5,
+            object args6,
+            object args7,
+            object args8,
+            object args9,
+            object args10,
+            object args11)
+        {
+            mediatorBinding = mediator.ToBinding();
+            this.toBinding = to is Binding toBinding ? toBinding : to.ToBinding();
+
+            parameters.Add(args1 is MarkupExtension ? args1 : args1.ToBinding());
+            parameters.Add(args2 is MarkupExtension ? args2 : args2.ToBinding());
+            parameters.Add(args3 is MarkupExtension ? args3 : args3.ToBinding());
+            parameters.Add(args4 is MarkupExtension ? args4 : args4.ToBinding());
+            parameters.Add(args5 is MarkupExtension ? args5 : args5.ToBinding());
+            parameters.Add(args6 is MarkupExtension ? args6 : args6.ToBinding());
+            parameters.Add(args7 is MarkupExtension ? args7 : args7.ToBinding());
+            parameters.Add(args8 is MarkupExtension ? args8 : args8.ToBinding());
+            parameters.Add(args9 is MarkupExtension ? args9 : args9.ToBinding());
+            parameters.Add(args10 is MarkupExtension ? args10 : args10.ToBinding());
+            parameters.Add(args11 is MarkupExtension ? args11 : args11.ToBinding());
+        }
+
+        public NavigateExtension(object mediator,
+            object to,
+            object args1,
+            object args2,
+            object args3,
+            object args4,
+            object args5,
+            object args6,
+            object args7,
+            object args8,
+            object args9,
+            object args10,
+            object args11,
+            object args12)
+        {
+            mediatorBinding = mediator.ToBinding();
+            this.toBinding = to is Binding toBinding ? toBinding : to.ToBinding();
+
+            parameters.Add(args1 is MarkupExtension ? args1 : args1.ToBinding());
+            parameters.Add(args2 is MarkupExtension ? args2 : args2.ToBinding());
+            parameters.Add(args3 is MarkupExtension ? args3 : args3.ToBinding());
+            parameters.Add(args4 is MarkupExtension ? args4 : args4.ToBinding());
+            parameters.Add(args5 is MarkupExtension ? args5 : args5.ToBinding());
+            parameters.Add(args6 is MarkupExtension ? args6 : args6.ToBinding());
+            parameters.Add(args7 is MarkupExtension ? args7 : args7.ToBinding());
+            parameters.Add(args8 is MarkupExtension ? args8 : args8.ToBinding());
+            parameters.Add(args9 is MarkupExtension ? args9 : args9.ToBinding());
+            parameters.Add(args10 is MarkupExtension ? args10 : args10.ToBinding());
+            parameters.Add(args11 is MarkupExtension ? args11 : args11.ToBinding());
+            parameters.Add(args12 is MarkupExtension ? args12 : args12.ToBinding());
+        }
+
+        public NavigateExtension(object mediator,
+            object to,
+            object args1,
+            object args2,
+            object args3,
+            object args4,
+            object args5,
+            object args6,
+            object args7,
+            object args8,
+            object args9,
+            object args10,
+            object args11,
+            object args12,
+            object args13)
+        {
+            mediatorBinding = mediator.ToBinding();
+            this.toBinding = to is Binding toBinding ? toBinding : to.ToBinding();
+
+            parameters.Add(args1 is MarkupExtension ? args1 : args1.ToBinding());
+            parameters.Add(args2 is MarkupExtension ? args2 : args2.ToBinding());
+            parameters.Add(args3 is MarkupExtension ? args3 : args3.ToBinding());
+            parameters.Add(args4 is MarkupExtension ? args4 : args4.ToBinding());
+            parameters.Add(args5 is MarkupExtension ? args5 : args5.ToBinding());
+            parameters.Add(args6 is MarkupExtension ? args6 : args6.ToBinding());
+            parameters.Add(args7 is MarkupExtension ? args7 : args7.ToBinding());
+            parameters.Add(args8 is MarkupExtension ? args8 : args8.ToBinding());
+            parameters.Add(args9 is MarkupExtension ? args9 : args9.ToBinding());
+            parameters.Add(args10 is MarkupExtension ? args10 : args10.ToBinding());
+            parameters.Add(args11 is MarkupExtension ? args11 : args11.ToBinding());
+            parameters.Add(args12 is MarkupExtension ? args12 : args12.ToBinding());
+            parameters.Add(args13 is MarkupExtension ? args13 : args13.ToBinding());
+        }
+
+        public NavigateExtension(object mediator,
+            object to,
+            object args1,
+            object args2,
+            object args3,
+            object args4,
+            object args5,
+            object args6,
+            object args7,
+            object args8,
+            object args9,
+            object args10,
+            object args11,
+            object args12,
+            object args13,
+            object args14)
+        {
+            mediatorBinding = mediator.ToBinding();
+            this.toBinding = to is Binding toBinding ? toBinding : to.ToBinding();
+
+            parameters.Add(args1 is MarkupExtension ? args1 : args1.ToBinding());
+            parameters.Add(args2 is MarkupExtension ? args2 : args2.ToBinding());
+            parameters.Add(args3 is MarkupExtension ? args3 : args3.ToBinding());
+            parameters.Add(args4 is MarkupExtension ? args4 : args4.ToBinding());
+            parameters.Add(args5 is MarkupExtension ? args5 : args5.ToBinding());
+            parameters.Add(args6 is MarkupExtension ? args6 : args6.ToBinding());
+            parameters.Add(args7 is MarkupExtension ? args7 : args7.ToBinding());
+            parameters.Add(args8 is MarkupExtension ? args8 : args8.ToBinding());
+            parameters.Add(args9 is MarkupExtension ? args9 : args9.ToBinding());
+            parameters.Add(args10 is MarkupExtension ? args10 : args10.ToBinding());
+            parameters.Add(args11 is MarkupExtension ? args11 : args11.ToBinding());
+            parameters.Add(args12 is MarkupExtension ? args12 : args12.ToBinding());
+            parameters.Add(args13 is MarkupExtension ? args13 : args13.ToBinding());
+            parameters.Add(args14 is MarkupExtension ? args14 : args14.ToBinding());
+        }
+
+        public NavigateExtension(object mediator,
+            object to,
+            object args1,
+            object args2,
+            object args3,
+            object args4,
+            object args5,
+            object args6,
+            object args7,
+            object args8,
+            object args9,
+            object args10,
+            object args11,
+            object args12,
+            object args13,
+            object args14,
+            object args15)
+        {
+            mediatorBinding = mediator.ToBinding();
+            this.toBinding = to is Binding toBinding ? toBinding : to.ToBinding();
+
+            parameters.Add(args1 is MarkupExtension ? args1 : args1.ToBinding());
+            parameters.Add(args2 is MarkupExtension ? args2 : args2.ToBinding());
+            parameters.Add(args3 is MarkupExtension ? args3 : args3.ToBinding());
+            parameters.Add(args4 is MarkupExtension ? args4 : args4.ToBinding());
+            parameters.Add(args5 is MarkupExtension ? args5 : args5.ToBinding());
+            parameters.Add(args6 is MarkupExtension ? args6 : args6.ToBinding());
+            parameters.Add(args7 is MarkupExtension ? args7 : args7.ToBinding());
+            parameters.Add(args8 is MarkupExtension ? args8 : args8.ToBinding());
+            parameters.Add(args9 is MarkupExtension ? args9 : args9.ToBinding());
+            parameters.Add(args10 is MarkupExtension ? args10 : args10.ToBinding());
+            parameters.Add(args11 is MarkupExtension ? args11 : args11.ToBinding());
+            parameters.Add(args12 is MarkupExtension ? args12 : args12.ToBinding());
+            parameters.Add(args13 is MarkupExtension ? args13 : args13.ToBinding());
+            parameters.Add(args14 is MarkupExtension ? args14 : args14.ToBinding());
+            parameters.Add(args15 is MarkupExtension ? args15 : args15.ToBinding());
+        }
+
+        public object? Route
+        {
+            get
+            {
+                return route;
+            }
+            set
+            {
+                route = value;
+                if (route is not null)
+                {
+                    routeBinding = route.ToBinding();
+                }
+            }
+
+        }
+
+        protected override void OnInvoked(object sender, EventArgs args)
+        {
+            if (TargetObject is not null)
+            {
+                if (mediatorBinding is not null)
+                {
+                    TargetObject.Bind(MediatorProperty, mediatorBinding);
+                    if (TargetObject.GetValue(MediatorProperty) is IMediator mediator)
+                    {
+                        if (toBinding is not null)
+                        {
+                            TargetObject.Bind(ToProperty, toBinding);
+                            if (TargetObject.GetValue(ToProperty) is { } to)
+                            {
+                                List<object>? parameters = new();
+                                foreach (object? parameter in this.parameters)
+                                {
+                                    if (parameter is not null)
+                                    {
+                                        switch (parameter)
+                                        {
+                                            case IParameter keyedParameter:
+                                                if (keyedParameter.GetValue(TargetObject) is KeyValuePair<string, object> keyValuePair)
+                                                {
+                                                    parameters.Add(keyValuePair);
+                                                }
+                                                break;
+                                            case IEventParameter eventParameter:
+                                                parameters.AddRange(eventParameter.GetValues(args));
+                                                break;
+                                            default:
+                                                if (parameter.ToBinding() is Binding defaultDinding)
+                                                {
+                                                    TargetObject.Bind(ParameterProperty, defaultDinding);
+                                                    parameters.Add((dynamic)TargetObject.GetValue(ParameterProperty));
+                                                }
+                                                break;
+                                        }
+                                    }
+                                }
+
+                                object? route = null;
+                                if (routeBinding is not null)
+                                {
+                                    TargetObject.Bind(RouteProperty, routeBinding);
+                                    route = TargetObject.GetValue(RouteProperty);
+                                }
+
+                                if (to is string name)
+                                {
+                                    if (toBinding?.StringFormat is string format)
+                                    {
+                                        name = string.Format(format, name);
+                                    }
+
+                                    mediator.Send(new Navigate(name, parameters.ToArray()) { Route = route });
+                                }
+
+                                if (to is Type type)
+                                {
+                                    mediator.Send(new Navigate(type, parameters.ToArray()) { Route = route });
+                                }
+                            }
+                        }
+
+                    }
+
+                    base.OnInvoked(sender, args);
+                }
+            }
+        }
+    }
+}

Framework/Avalonia/Markups/NavigationRouteExtension.cs

@@ -0,0 +1,95 @@
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Controls.Primitives;
+using Avalonia.Data;
+using Avalonia.Interactivity;
+using Avalonia.Markup.Xaml;
+using Mediator;
+
+namespace Toolkit.Foundation.Avalonia
+{
+    public class NavigationRouteExtension : MarkupExtension
+    {
+        private static readonly AttachedProperty<IMediator> MediatorProperty =
+            AvaloniaProperty.RegisterAttached<NavigationRouteExtension, Control, IMediator>("Mediator");
+
+        private readonly string name;
+        private readonly Binding? mediatorBinding;
+
+        public NavigationRouteExtension(object mediator, string name)
+        {
+            mediatorBinding = mediator is Binding toBinding ? toBinding : mediator.ToBinding();
+            this.name = name;
+        }
+
+        private bool TryGetBinding(AvaloniaObject sender, out object? binding)
+        {
+            binding = sender.GetValue(StyledElement.DataContextProperty);
+            return binding is not null;
+        }
+
+        public override object? ProvideValue(IServiceProvider serviceProvider)
+        {
+            if (serviceProvider.GetService(typeof(IProvideValueTarget)) is IProvideValueTarget target)
+            {
+                if (target.TargetObject is TemplatedControl control)
+                {
+                    if (!TryGetBinding(control, out object? binding))
+                    {
+                        void HandleDataContextChanged(object? sender, EventArgs args)
+                        {
+                            if (TryGetBinding(control, out binding))
+                            {
+                                control.Loaded -= HandleLoaded;
+                                if (mediatorBinding is not null)
+                                {
+                                    control.Bind(MediatorProperty, mediatorBinding);
+                                    if (control.GetValue(MediatorProperty) is IMediator mediator)
+                                    {
+                                        mediator.Send(new NavigationRoute(name, control));
+                                        control.ClearValue(MediatorProperty);
+                                    }
+                                }
+                            }
+                        }
+
+                        control.DataContextChanged += HandleDataContextChanged;
+
+                        void HandleLoaded(object? sender, RoutedEventArgs args)
+                        {
+                            control.Loaded -= HandleLoaded;
+                            if (TryGetBinding(control, out binding))
+                            {
+                                if (mediatorBinding is not null)
+                                {
+                                    control.Bind(MediatorProperty, mediatorBinding);
+                                    if (control.GetValue(MediatorProperty) is IMediator mediator)
+                                    {
+                                        mediator.Send(new NavigationRoute(name, control));
+                                        control.ClearValue(MediatorProperty);
+                                    }
+                                }
+                            }
+                        }
+
+                        control.Loaded += HandleLoaded;
+                    }
+                    else
+                    {
+                        if (mediatorBinding is not null)
+                        {
+                            control.Bind(MediatorProperty, mediatorBinding);
+                            if (control.GetValue(MediatorProperty) is IMediator mediator)
+                            {
+                                mediator.Send(new NavigationRoute(name, control));
+                                control.ClearValue(MediatorProperty);
+                            }
+                        }
+                    }
+                }
+            }
+
+            return null;
+        }
+    }
+}

Framework/Avalonia/Markups/ParameterBindingExtension.cs

@@ -0,0 +1,42 @@
+using Avalonia.Controls;
+using Avalonia;
+using Avalonia.Data;
+using Avalonia.Markup.Xaml;
+
+namespace Toolkit.Foundation.Avalonia
+{
+    public class ParameterBindingExtension : MarkupExtension, IParameter
+    {
+        private static readonly AttachedProperty<object> ValueProperty =
+            AvaloniaProperty.RegisterAttached<ParameterBindingExtension, Control, object>("Value");
+
+        private readonly Binding? valueBinding;
+
+        public ParameterBindingExtension(string key, object value)
+        {
+            Key = key;
+            valueBinding = value.ToBinding();
+        }
+
+        public string? Key { get; }
+
+        public KeyValuePair<string, object>? GetValue(object target)
+        {
+            if (target is AvaloniaObject avaloniaObject)
+            {
+                if (valueBinding is not null)
+                {
+                    avaloniaObject.Bind(ValueProperty, valueBinding);
+                    return new KeyValuePair<string, object>(Key, (dynamic)avaloniaObject.GetValue(ValueProperty));
+                }
+            }
+
+            return default;
+        }
+
+        public override object ProvideValue(IServiceProvider serviceProvider)
+        {
+            return this;
+        }
+    }
+}

Framework/Avalonia/Markups/TriggerCollection.cs

@@ -0,0 +1,15 @@
+using System.Collections.ObjectModel;
+
+namespace Toolkit.Foundation.Avalonia
+{
+    public class TriggerCollection : Collection<Delegate>
+    {
+        public void Add(object item)
+        {
+            if (item is Delegate trigger)
+            {
+                base.Add(trigger);
+            }
+        }
+    }
+}

Framework/Avalonia/Markups/TriggerExtension.cs

@@ -0,0 +1,76 @@
+using Avalonia;
+using Avalonia.Markup.Xaml;
+using System;
+using System.Reflection;
+
+namespace Toolkit.Foundation.Avalonia
+{
+    public class TriggerExtension : MarkupExtension
+    {
+        public AvaloniaObject? TargetObject { get; protected set; }
+
+        protected object? TargetInvoke { get; private set; }
+
+        public void Invoke(object sender, EventArgs args)
+        {
+            OnInvoked(sender, args);
+        }
+
+        public override object? ProvideValue(IServiceProvider serviceProvider)
+        {
+            if (serviceProvider.GetService(typeof(IProvideValueTarget)) is IProvideValueTarget target)
+            {
+                if (target.TargetObject is AvaloniaObject avaloniaObject)
+                {
+                    TargetObject = avaloniaObject;
+                }
+                else if (serviceProvider.GetService(typeof(IRootObjectProvider)) is IRootObjectProvider root)
+                {
+                    TargetObject = (AvaloniaObject)root.RootObject;
+                }
+
+                if (TargetObject is not null)
+                {
+                    string? targetName = target.TargetProperty as string;
+
+                    TargetInvoke = target.TargetProperty;
+                    OnAttached(serviceProvider);
+
+                    EventInfo? eventInfo = target.TargetProperty as EventInfo ?? (targetName is not null ? TargetObject.GetType().GetEvent(targetName) : null);
+                    MethodInfo? methodInfo = eventInfo is not null ? null : target.TargetProperty as MethodInfo ?? (targetName is not null ? TargetObject.GetType().GetMethod(targetName) : null);
+
+                    MethodInfo invokeMethod = GetType().GetMethod("Invoke", BindingFlags.Instance | BindingFlags.Public)!;
+                    if (invokeMethod is null)
+                    {
+                        return this;
+                    }
+
+                    if (eventInfo is not null)
+                    {
+                        return Delegate.CreateDelegate(eventInfo.EventHandlerType!, this, invokeMethod);
+                    }
+
+                    if (methodInfo is not null)
+                    {
+                        if (methodInfo.GetParameters() is ParameterInfo[] methodParameters && methodParameters is { Length: 2 })
+                        {
+                            return Delegate.CreateDelegate(methodParameters[1].ParameterType, this, invokeMethod);
+                        }
+                    }
+                }
+            }
+
+            return null;
+        }
+
+        protected virtual void OnAttached(IServiceProvider serviceProvider)
+        {
+
+        }
+
+        protected virtual void OnInvoked(object sender, EventArgs args)
+        {
+
+        }
+    }
+}

Framework/Avalonia/Navigation/ContentControlNavigation.cs

@@ -0,0 +1,14 @@
+using Avalonia.Controls;
+
+namespace Toolkit.Foundation.Avalonia
+{
+    public record ContentControlNavigation : Navigation<ContentControl>
+    {
+        public ContentControlNavigation(ContentControl route,
+            object? content,
+            object? template,
+            IDictionary<string, object>? parameters) : base(route, content, template, parameters)
+        {
+        }
+    }
+}

Framework/Avalonia/Navigation/ContentControlNavigationHandler.cs

@@ -0,0 +1,19 @@
+using Avalonia.Controls.Primitives;
+using Mediator;
+
+namespace Toolkit.Foundation.Avalonia
+{
+    public class ContentControlNavigationHandler : IRequestHandler<ContentControlNavigation, bool>
+    {
+        public async ValueTask<bool> Handle(ContentControlNavigation request, CancellationToken cancellationToken)
+        {
+            if (request.Template is TemplatedControl control)
+            {
+                control.DataContext = request.Content;
+                request.Route.Content = control;
+            }
+
+            return await Task.FromResult(true);
+        }
+    }
+}

Framework/Avalonia/Navigation/ContentDialogNavigation.cs

@@ -0,0 +1,15 @@
+using FluentAvalonia.UI.Controls;
+
+namespace Toolkit.Foundation.Avalonia
+{
+    public record ContentDialogNavigation : Navigation<ContentDialog>
+    {
+        public ContentDialogNavigation(ContentDialog route,
+            object? content, 
+            object? template, 
+            IDictionary<string, object>? parameters) : base(route, content, template, parameters)
+        {
+
+        }
+    }
+}

Framework/Avalonia/Navigation/ContentDialogNavigationHandler.cs

@@ -0,0 +1,44 @@
+using FluentAvalonia.UI.Controls;
+using Mediator;
+
+namespace Toolkit.Foundation.Avalonia
+{
+    public class ContentDialogNavigationHandler : IRequestHandler<ContentDialogNavigation, bool>
+    {
+        public async ValueTask<bool> Handle(ContentDialogNavigation request, CancellationToken cancellationToken)
+        {
+            if (request.Template is ContentDialog contentDialog)
+            {
+                async void HandleButtonClick(ContentDialog sender, ContentDialogButtonClickEventArgs args)
+                {
+                    ContentDialogButtonClickDeferral defferal = args.GetDeferral();
+                    if (sender.DataContext is INavigationConfirmation confirmation)
+                    {
+                        if (!await confirmation.CanConfirm())
+                        {
+                            args.Cancel = true;
+                        }
+                    }
+
+                    if (!args.Cancel)
+                    {
+                        contentDialog.SecondaryButtonClick -= HandleButtonClick;
+                        contentDialog.PrimaryButtonClick -= HandleButtonClick;
+                        contentDialog.CloseButtonClick -= HandleButtonClick;
+                    }
+
+                    defferal.Complete();
+                }
+
+                contentDialog.SecondaryButtonClick += HandleButtonClick;
+                contentDialog.PrimaryButtonClick += HandleButtonClick;
+                contentDialog.CloseButtonClick += HandleButtonClick;
+
+                contentDialog.DataContext = request.Content;
+                await contentDialog.ShowAsync();
+            }
+
+            return await Task.FromResult(true);
+        }
+    }
+}

Framework/Avalonia/Navigation/FrameNavigation.cs

@@ -0,0 +1,15 @@
+using FluentAvalonia.UI.Controls;
+
+namespace Toolkit.Foundation.Avalonia
+{
+    public record FrameNavigation : Navigation<Frame>
+    {
+        public FrameNavigation(Frame route, 
+            object? content, 
+            object? template,
+            IDictionary<string, object>? 
+            parameters) : base(route, content, template, parameters)
+        {
+        }
+    }
+}

Framework/Avalonia/Navigation/FrameNavigationHandler.cs

@@ -0,0 +1,33 @@
+using Avalonia.Controls.Primitives;
+using FluentAvalonia.UI.Navigation;
+using Mediator;
+
+namespace Toolkit.Foundation.Avalonia
+{
+    public class FrameNavigationHandler : IRequestHandler<FrameNavigation, bool>
+    {
+        public async ValueTask<bool> Handle(FrameNavigation request, CancellationToken cancellationToken)
+        {
+            request.Route.NavigationPageFactory = new NavigationPageFactory();
+
+            TaskCompletionSource<bool> completionSource = new();
+            if (request.Template is TemplatedControl content)
+            {
+                void HandleNavigated(object sender, NavigationEventArgs args)
+                {
+                    request.Route.Navigated -= HandleNavigated;
+                    if (request.Route.Content is TemplatedControl control)
+                    {
+                        control.DataContext = request.Content;
+                        completionSource.SetResult(true);
+                    }
+                }
+
+                request.Route.Navigated += HandleNavigated;
+                request.Route.NavigateFromObject(content);
+            }
+
+            return await completionSource.Task;
+        }
+    }
+}

Framework/Avalonia/Navigation/NavigateBackHandler.cs

@@ -0,0 +1,38 @@
+using Avalonia.Controls;
+using Avalonia.Controls.Primitives;
+using FluentAvalonia.UI.Controls;
+using Mediator;
+
+namespace Toolkit.Foundation.Avalonia
+{
+    public class NavigateBackHandler : IRequestHandler<NavigateBack>
+    {
+        private readonly INavigationRouteDescriptorCollection descriptors;
+
+        public NavigateBackHandler(INavigationRouteDescriptorCollection descriptors)
+        {
+            this.descriptors = descriptors;
+        }
+
+        public ValueTask<Unit> Handle(NavigateBack request, CancellationToken cancellationToken)
+        {
+            if (descriptors.FirstOrDefault(x => request.Route is string { } name && name == x.Name) is NavigationRouteDescriptor descriptor)
+            {
+                if (descriptor.Route is ContentControl { Content: TemplatedControl content })
+                {
+                    if (content.DataContext is IDisposable disposable)
+                    {
+                        disposable.Dispose();
+                    }
+                }
+
+                if (descriptor.Route is Frame frame)
+                {
+                    frame.GoBack();
+                }
+            }
+
+            return default;
+        }
+    }
+}

Framework/Avalonia/Navigation/NavigateHandler.cs

@@ -0,0 +1,116 @@
+using Avalonia.Controls;
+using FluentAvalonia.UI.Controls;
+using Mediator;
+
+namespace Toolkit.Foundation.Avalonia
+{
+    public class NavigateHandler : IRequestHandler<Navigate>
+    {
+        private readonly INavigationRouteDescriptorCollection descriptors;
+        private readonly IMediator mediator;
+        private readonly INamedDataTemplateFactory namedDataTemplateFactory;
+        private readonly INamedTemplateFactory namedTemplateFactory;
+        private readonly ITemplateFactory templateFactory;
+        private readonly ITypedDataTemplateFactory typedDataTemplateFactory;
+
+        public NavigateHandler(IMediator mediator,
+            ITemplateFactory templateFactory,
+            INamedTemplateFactory namedTemplateFactory,
+            INamedDataTemplateFactory namedDataTemplateFactory,
+            ITypedDataTemplateFactory typedDataTemplateFactory,
+            INavigationRouteDescriptorCollection descriptors)
+        {
+            this.mediator = mediator;
+            this.templateFactory = templateFactory;
+            this.namedTemplateFactory = namedTemplateFactory;
+            this.namedDataTemplateFactory = namedDataTemplateFactory;
+            this.typedDataTemplateFactory = typedDataTemplateFactory;
+            this.descriptors = descriptors;
+        }
+
+        public async ValueTask<Unit> Handle(Navigate request, CancellationToken cancellationToken)
+        {
+            object? content = null;
+            object? template = null;
+
+            Dictionary<string, object> keyedParameters = new();
+            List<object> parameters = new();
+
+            foreach (object? parameter in request.Parameters)
+            {
+                if (parameter is not null)
+                {
+                    if (parameter is KeyValuePair<string, object> keyed)
+                    {
+                        keyedParameters.Add(keyed.Key, keyed.Value);
+                    }
+                    else
+                    {
+                        parameters.Add(parameter);
+                    }
+                }
+            }
+
+            if (request.Name is { Length: > 0 } name)
+            {
+                content = namedDataTemplateFactory.Create(name, parameters.ToArray());
+                template = namedTemplateFactory.Create(name);
+            }
+
+            if (request.Type is Type type)
+            {
+                content = typedDataTemplateFactory.Create(type, parameters.ToArray());
+                template = templateFactory.Create(content);
+            }
+
+            if (template is not null)
+            {
+                object? target = null;
+                if (descriptors.FirstOrDefault(x => request.Route is string { } name && name == x.Name) is NavigationRouteDescriptor descriptor)
+                {
+                    target = descriptor.Route;
+                }
+                else
+                {
+                    target = template;
+                }
+
+                bool hasNavigated = false;
+                if (target is Frame frame)
+                {
+                    hasNavigated = await mediator.Send(new FrameNavigation(frame, content, template, keyedParameters));
+                }
+
+                if (target is ContentDialog dialog)
+                {
+                    hasNavigated = await mediator.Send(new ContentDialogNavigation(dialog, content, template, keyedParameters));
+                }
+
+                if (target is ContentControl contentControl)
+                {
+                    hasNavigated = await mediator.Send(new ContentControlNavigation(contentControl, content, template, keyedParameters));
+                }
+
+                if (hasNavigated)
+                {
+                    if (content is INavigated navigated)
+                    {
+                        await navigated.Navigated();
+                    }
+                }
+            }
+            else
+            {
+                if (descriptors.FirstOrDefault(x => request.Route is string { } name && name == x.Name) is NavigationRouteDescriptor descriptor)
+                {
+                    if (descriptor.Route is ContentControl contentControl)
+                    {
+                        contentControl.Content = null;
+                    }
+                }
+            }
+
+            return default;
+        }
+    }
+}

Framework/Avalonia/Navigation/Navigation.cs

@@ -0,0 +1,27 @@
+using Avalonia.Controls.Primitives;
+using Mediator;
+
+namespace Toolkit.Foundation.Avalonia
+{
+    public record Navigation<TRoute> : IRequest<bool> where TRoute : TemplatedControl
+    {
+        public TRoute Route { get; }
+
+        public Navigation(TRoute route, 
+            object? content, 
+            object? template, 
+            IDictionary<string, object>? parameters)
+        {
+            Route = route;
+            Content = content;
+            Template = template;
+            Parameters = parameters;
+        }
+
+        public object? Content { get; }
+
+        public object? Template { get; }
+
+        public IDictionary<string, object>? Parameters { get; }
+    }
+}

Framework/Avalonia/Navigation/NavigationPageFactory.cs

@@ -0,0 +1,18 @@
+using FluentAvalonia.UI.Controls;
+using Avalonia.Controls;
+
+namespace Toolkit.Foundation.Avalonia
+{
+    internal class NavigationPageFactory : INavigationPageFactory
+    {
+        public IControl? GetPage(Type srcType)
+        {
+            return default;
+        }
+
+        public IControl GetPageFromObject(object target)
+        {
+            return (IControl)target;
+        }
+    }
+}

Framework/Avalonia/Navigation/NavigationRouteHandler.cs

@@ -0,0 +1,39 @@
+using Avalonia.Controls.Primitives;
+using Avalonia.Interactivity;
+using Mediator;
+
+namespace Toolkit.Foundation.Avalonia
+{
+    public class NavigationRouteHandler : IRequestHandler<NavigationRoute>
+    {
+        private readonly INavigationRouteDescriptorCollection descriptors;
+
+        public NavigationRouteHandler(INavigationRouteDescriptorCollection descriptors)
+        {
+            this.descriptors = descriptors;
+        }
+
+        public ValueTask<Unit> Handle(NavigationRoute request, CancellationToken cancellationToken)
+        {
+            if (request.Route is TemplatedControl control)
+            {
+                void HandleUnloaded(object? sender, RoutedEventArgs args)
+                {
+                    if (descriptors.FirstOrDefault(x => x.Route == sender) is INavigationRouteDescriptor descriptor)
+                    {
+                        descriptors.Remove(descriptor);
+                    }
+                }
+                control.Unloaded += HandleUnloaded;
+            }
+
+            if (descriptors.FirstOrDefault(x => x.Name == request.Name) is INavigationRouteDescriptor descriptor)
+            {
+                descriptors.Remove(descriptor);
+            }
+
+            descriptors.Add(new NavigationRouteDescriptor(request.Name, request.Route));
+            return default;
+        }
+    }
+}

Framework/Avalonia/Properties/Assembly.cs

@@ -0,0 +1,3 @@
+using Avalonia.Metadata;
+
+[assembly: XmlnsDefinition("https://github.com/avaloniaui", "Toolkit.Foundation.Avalonia")]

Framework/Avalonia/Templates/TemplateSelector.cs

@@ -0,0 +1,37 @@
+using Avalonia.Controls.Templates;
+using Avalonia.Controls;
+
+namespace Toolkit.Foundation.Avalonia
+{
+    public class TemplateSelector : IDataTemplate, ITemplateSelector
+    {
+        private readonly Dictionary<object, IControl> dataTracking = new();
+
+        private readonly ITemplateFactory templateFactory;
+
+        public TemplateSelector(ITemplateFactory templateFactory)
+        {
+            this.templateFactory = templateFactory;
+        }
+
+        public IControl? Build(object? item)
+        {
+            if (item is not null)
+            {
+                if (dataTracking.TryGetValue(item, out IControl? control))
+                {
+                    return control;
+                }
+
+                return (IControl?)templateFactory.Create(item);
+            }
+
+            return null;
+        }
+
+        public bool Match(object? data)
+        {
+            return true;
+        }
+    }
+}

Framework/Foundation/Configurations/ConfigurationChanged.cs

@@ -0,0 +1,3 @@
+namespace Toolkit.Foundation;
+
+public record ConfigurationChanged<TConfiguration>(TConfiguration Configuration) where TConfiguration : class;

Framework/Foundation/Configurations/ConfigurationInitializer.cs

@@ -0,0 +1,22 @@
+using Mediator;
+
+namespace Toolkit.Foundation;
+
+public class ConfigurationInitializer<TConfiguration> : IInitializable where TConfiguration : class, new()
+{
+    private readonly TConfiguration configuration;
+    private readonly IMediator mediator;
+
+    public ConfigurationInitializer(TConfiguration configuration,
+        IMediator mediator)
+    {
+        this.configuration = configuration;
+        this.mediator = mediator;
+    }
+
+    public async Task InitializeAsync()
+    {
+        await mediator.Send(configuration);
+        await Task.CompletedTask;
+    }
+}

Framework/Foundation/Configurations/ConfigurationWriter.cs

@@ -0,0 +1,29 @@
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+
+namespace Toolkit.Foundation;
+
+public class ConfigurationWriter<TConfiguration> : IConfigurationWriter<TConfiguration> where TConfiguration : class, new()
+{
+    private readonly IConfiguration rootConfiguration;
+
+    public ConfigurationWriter(IConfiguration rootConfiguration)
+    {
+        this.rootConfiguration = rootConfiguration;
+    }
+
+    public void Write(string section, TConfiguration configuration)
+    {
+        if (rootConfiguration is IConfigurationRoot root)
+        {
+            foreach (IConfigurationProvider? provider in root.Providers)
+            {
+                if (provider is IWritableConfigurationProvider writableConfigurationProvider)
+                {
+                    writableConfigurationProvider.Write(section, configuration);
+                }
+            }
+        }
+    }
+}

Framework/Foundation/Configurations/IConfigurationWriter.cs

@@ -0,0 +1,6 @@
+namespace Toolkit.Foundation;
+
+public interface IConfigurationWriter<TConfiguration> where TConfiguration : class
+{
+    void Write(string section, TConfiguration args);
+}

Framework/Foundation/Configurations/IWritableConfigurationProvider.cs

@@ -0,0 +1,6 @@
+namespace Toolkit.Foundation;
+
+public interface IWritableConfigurationProvider
+{
+    void Write<TValue>(string section, TValue value) where TValue : class, new();
+}

Framework/Foundation/Configurations/IWritableJsonConfigurationBuilder.cs

@@ -0,0 +1,12 @@
+namespace Toolkit.Foundation;
+
+public interface IWritableJsonConfigurationBuilder
+{
+    Stream? DefaultFileStream { get; }
+
+    IWritableJsonConfigurationBuilder AddDefaultConfiguration<TConfiguration>(string Key) where TConfiguration : class;
+
+    IWritableJsonConfigurationBuilder AddDefaultFileStream(Stream stream);
+
+    void Build(string path);
+}

Framework/Foundation/Configurations/IWritableJsonConfigurationDescriptor.cs

@@ -0,0 +1,8 @@
+namespace Toolkit.Foundation;
+
+public interface IWritableJsonConfigurationDescriptor
+{
+    Type ConfigurationType { get; }
+
+    string Key { get; }
+}

Framework/Foundation/Configurations/WritableJsonConfigurationBuilder.cs

@@ -0,0 +1,108 @@
+using Json.Patch;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using JsonSerializer = System.Text.Json.JsonSerializer;
+
+namespace Toolkit.Foundation;
+
+public class WritableJsonConfigurationBuilder : IWritableJsonConfigurationBuilder
+{
+    private readonly List<IWritableJsonConfigurationDescriptor> descriptors = new();
+
+    public Stream? DefaultFileStream { get; private set; }
+
+    public IReadOnlyCollection<IWritableJsonConfigurationDescriptor> Descriptors => new ReadOnlyCollection<IWritableJsonConfigurationDescriptor>(descriptors);
+
+    public IWritableJsonConfigurationBuilder AddDefaultConfiguration<TConfiguration>(string Key) where TConfiguration : class
+    {
+        descriptors.Add(new WritableJsonConfigurationDescriptor(typeof(TConfiguration), Key));
+        return this;
+    }
+
+    public IWritableJsonConfigurationBuilder AddDefaultFileStream(Stream stream)
+    {
+        DefaultFileStream = stream;
+        return this;
+    }
+
+    public void Build(string path)
+    {
+        JObject? sourceDocument = new();
+        if (TryLoadSource(out string? defaultContent))
+        {
+            sourceDocument = JObject.Parse(defaultContent!);
+        }
+
+        JObject? targetDocument = new();
+        if (TryLoadTarget(path, out string? targetContent))
+        {
+            targetDocument = JObject.Parse(targetContent!);
+        }
+
+        foreach (IWritableJsonConfigurationDescriptor? descriptor in descriptors)
+        {
+            if (sourceDocument.SelectToken($"$.{descriptor.Key}") is JToken sourceSection)
+            {
+                if (targetDocument.SelectToken($"$.{descriptor.Key}") is JToken targetSection)
+                {
+                    object? source = JsonSerializer.Deserialize(JsonConvert.SerializeObject(sourceSection), descriptor.ConfigurationType);
+                    object? target = JsonSerializer.Deserialize(JsonConvert.SerializeObject(targetSection), descriptor.ConfigurationType);
+
+                    JsonPatch? patch = source.CreatePatch(target);
+
+                    object? sourcePatched = patch.Apply(source);
+                    targetSection.Replace(JToken.Parse(JsonSerializer.Serialize(sourcePatched, new JsonSerializerOptions { DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull })));
+                }
+                else
+                {
+                    object? source = JsonSerializer.Deserialize(JsonConvert.SerializeObject(sourceSection), descriptor.ConfigurationType);
+                    targetDocument.Add(descriptor.Key, JToken.Parse(JsonSerializer.Serialize(source, new JsonSerializerOptions { DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull })));
+                }
+            }
+            else
+            {
+                object? configuration = Activator.CreateInstance(descriptor.ConfigurationType);
+                targetDocument.Add(descriptor.Key, JToken.Parse(JsonSerializer.Serialize(configuration, new JsonSerializerOptions { DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull })));
+            }
+        }
+
+        using FileStream? fileStream = new(path, FileMode.Create, FileAccess.Write);
+        using StreamWriter streamWriter = new(fileStream);
+        using JsonTextWriter writer = new(streamWriter) { Formatting = Formatting.Indented };
+        targetDocument.WriteTo(writer);
+    }
+
+    private bool TryLoadTarget(string path, [MaybeNull] out string? content)
+    {
+        if (File.Exists(path))
+        {
+            using FileStream? fileStream = new(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+            using StreamReader? streamReader = new(fileStream);
+            content = streamReader.ReadToEnd();
+            return true;
+        }
+
+        content = null;
+        return false;
+    }
+
+    private bool TryLoadSource([MaybeNull] out string? content)
+    {
+        if (DefaultFileStream is Stream fileStream)
+        {
+            using StreamReader? streamReader = new(fileStream);
+            content = streamReader.ReadToEnd();
+            return true;
+        }
+
+        content = null;
+        return false;
+    }
+}

Framework/Foundation/Configurations/WritableJsonConfigurationDescriptor.cs

@@ -0,0 +1,3 @@
+namespace Toolkit.Foundation;
+
+public record WritableJsonConfigurationDescriptor(Type ConfigurationType, string Key) : IWritableJsonConfigurationDescriptor;

Framework/Foundation/Configurations/WritableJsonConfigurationExtensions.cs

@@ -0,0 +1,74 @@
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.FileProviders;
+
+namespace Toolkit.Foundation;
+
+public static class WritableJsonConfigurationExtensions
+{
+    public static IConfigurationBuilder AddWritableJsonFile(this IConfigurationBuilder builder,
+        string path)
+    {
+        return builder.AddWritableJsonFile(null, path, false, false, null);
+    }
+
+    public static IConfigurationBuilder AddWritableJsonFile(this IConfigurationBuilder builder,
+        string path,
+        Action<IWritableJsonConfigurationBuilder>? factoryDelegate)
+    {
+        return builder.AddWritableJsonFile(null, path, false, false, factoryDelegate);
+    }
+
+    public static IConfigurationBuilder AddWritableJsonFile(this IConfigurationBuilder builder,
+        string path,
+        bool optional)
+    {
+        return builder.AddWritableJsonFile(null, path, optional, false, null);
+    }
+
+    public static IConfigurationBuilder AddWritableJsonFile(this IConfigurationBuilder builder,
+        string path,
+        bool optional,
+        Action<IWritableJsonConfigurationBuilder>? factoryDelegate)
+    {
+        return builder.AddWritableJsonFile(null, path, optional, false, factoryDelegate);
+    }
+
+    public static IConfigurationBuilder AddWritableJsonFile(this IConfigurationBuilder builder,
+        string path,
+        bool optional,
+        bool reloadOnChange)
+    {
+        return builder.AddWritableJsonFile(null, path, optional, reloadOnChange, null);
+    }
+
+    public static IConfigurationBuilder AddWritableJsonFile(this IConfigurationBuilder builder,
+        string path,
+        bool optional,
+        bool reloadOnChange,
+        Action<IWritableJsonConfigurationBuilder>? factoryDelegate)
+    {
+        return builder.AddWritableJsonFile(null, path, optional, reloadOnChange, factoryDelegate);
+    }
+
+    public static IConfigurationBuilder AddWritableJsonFile(this IConfigurationBuilder builder,
+        IFileProvider? provider,
+        string path,
+        bool optional,
+        bool reloadOnChange, Action<IWritableJsonConfigurationBuilder>? writableJsonConfigurationDelegate)
+    {
+        IWritableJsonConfigurationBuilder writableJsonConfigurationBuilder = new WritableJsonConfigurationBuilder();
+        writableJsonConfigurationDelegate?.Invoke(writableJsonConfigurationBuilder);
+
+        return builder.AddWritableJsonFile(configuration =>
+        {
+            configuration.FileProvider = provider;
+            configuration.Path = path;
+            configuration.Optional = optional;
+            configuration.ReloadOnChange = reloadOnChange;
+            configuration.Factory = writableJsonConfigurationBuilder;
+            configuration.ResolveFileProvider();
+        });
+    }
+
+    public static IConfigurationBuilder AddWritableJsonFile(this IConfigurationBuilder builder, Action<WritableJsonConfigurationSource> configureSource) => builder.Add(configureSource);
+}

Framework/Foundation/Configurations/WritableJsonConfigurationFile.cs

@@ -0,0 +1,148 @@
+using Microsoft.Extensions.Configuration;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using System.Text.Json;
+
+namespace Toolkit.Foundation;
+
+internal class WritableJsonConfigurationFile
+{
+    private readonly Dictionary<string, (JsonValueKind?, string?)> data = new(StringComparer.OrdinalIgnoreCase);
+    private readonly Stack<string> paths = new();
+    private JObject tokenCache = new();
+    private bool isParsing;
+
+    public IDictionary<string, string?> Parse(Stream input)
+    {
+        return ParseStream(input);
+    }
+
+    public void Write(string key, string value, Stream output)
+    {
+        if (isParsing)
+        {
+            return;
+        }
+
+        if (key[^1] == ':')
+        {
+            key = key[0..^1];
+        }
+
+        string? tokenPath = $"$.{key.Replace(":", ".")}";
+        key = key.Replace("[", "").Replace("]", "");
+
+        if (tokenCache.SelectToken(tokenPath) is JToken token && data.ContainsKey(key))
+        {
+            (JsonValueKind? kind, string _) = data[key];
+            object? newValue = ConvertValue(kind, value);
+
+            data[key] = new(kind, value);
+            token.Replace(JToken.FromObject(newValue));
+        }
+
+        using StreamWriter streamWriter = new(output);
+        using JsonTextWriter writer = new(streamWriter) { Formatting = Formatting.Indented };
+        tokenCache.WriteTo(writer);
+
+        output.SetLength(output.Position);
+    }
+
+    private static object ConvertValue(JsonValueKind? kind, string value)
+    {
+        return kind is JsonValueKind.True or JsonValueKind.False ? bool.Parse(value) : value;
+    }
+
+    private void EnterContext(string context)
+    {
+        paths.Push(paths.Count > 0 ? paths.Peek() + ConfigurationPath.KeyDelimiter + context : context);
+    }
+
+    private void ExitContext()
+    {
+        paths.Pop();
+    }
+
+    private IDictionary<string, string?> ParseStream(Stream input)
+    {
+        data.Clear();
+
+        JsonDocumentOptions jsonDocumentOptions = new()
+        {
+            CommentHandling = JsonCommentHandling.Skip,
+            AllowTrailingCommas = true,
+        };
+
+        isParsing = true;
+        using (StreamReader? reader = new(input))
+        {
+            string? content = reader.ReadToEnd();
+            tokenCache = JObject.Parse(content);
+
+            using JsonDocument? doc = JsonDocument.Parse(content, jsonDocumentOptions);
+            VisitElement(doc.RootElement);
+        }
+        isParsing = false;
+
+        return data.ToDictionary(k => k.Key, v => v.Value.Item2?.ToString() ?? null);
+    }
+
+    private void VisitElement(JsonElement element)
+    {
+        bool isEmpty = true;
+
+        foreach (JsonProperty property in element.EnumerateObject())
+        {
+            isEmpty = false;
+
+            EnterContext(property.Name);
+            VisitValue(property.Value);
+            ExitContext();
+        }
+
+        if (isEmpty && paths.Count > 0)
+        {
+            data[paths.Peek()] = (JsonValueKind.Null, null);
+        }
+    }
+
+    private void VisitValue(JsonElement value)
+    {
+        switch (value.ValueKind)
+        {
+            case JsonValueKind.Object:
+                VisitElement(value);
+                break;
+
+            case JsonValueKind.Array:
+                int index = 0;
+                foreach (JsonElement arrayElement in value.EnumerateArray())
+                {
+                    EnterContext(index.ToString());
+                    VisitValue(arrayElement);
+                    ExitContext();
+                    index++;
+                }
+                break;
+
+            case JsonValueKind.Number:
+            case JsonValueKind.String:
+            case JsonValueKind.True:
+            case JsonValueKind.False:
+            case JsonValueKind.Null:
+                string key = paths.Peek();
+                if (data.ContainsKey(key))
+                {
+                    throw new FormatException();
+                }
+                data[key] = new(value.ValueKind, value.ToString());
+                break;
+
+            case JsonValueKind.Undefined:
+                break;
+
+            default:
+                throw new FormatException();
+        }
+    }
+}

Framework/Foundation/Configurations/WritableJsonConfigurationProvider.cs

@@ -0,0 +1,46 @@
+using Microsoft.Extensions.Configuration.Json;
+using Microsoft.Extensions.FileProviders;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace Toolkit.Foundation;
+
+public class WritableJsonConfigurationProvider : JsonConfigurationProvider, IWritableConfigurationProvider
+{
+    public WritableJsonConfigurationProvider(JsonConfigurationSource source) : base(source)
+    {
+
+    }
+
+    public void Write<TValue>(string section, TValue value) where TValue : class, new()
+    {
+        IFileInfo? file = Source.FileProvider?.GetFileInfo(Source.Path ?? string.Empty);
+        static Stream OpenRead(IFileInfo fileInfo)
+        {
+            return fileInfo.PhysicalPath is not null
+                ? new FileStream(fileInfo.PhysicalPath, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.ReadWrite)
+                : fileInfo.CreateReadStream();
+        }
+
+        if (file is null)
+        {
+            throw new FileNotFoundException();
+        }
+
+        using Stream stream = OpenRead(file);
+        using StreamReader? reader = new(stream);
+
+        string? content = reader.ReadToEnd();
+        JObject? document = JObject.Parse(content);
+
+        if (document.SelectToken($"$.{section}") is JToken sectionToken)
+        {
+            sectionToken.Replace(JToken.Parse(JsonConvert.SerializeObject(value)));
+            stream.SetLength(0);
+
+            using StreamWriter streamWriter = new(stream);
+            using JsonTextWriter writer = new(streamWriter) { Formatting = Formatting.Indented };
+            document.WriteTo(writer);
+        }
+    }
+}

Framework/Foundation/Configurations/WritableJsonConfigurationSource.cs

@@ -0,0 +1,27 @@
+using Microsoft.Extensions.Configuration.Json;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.FileProviders;
+
+namespace Toolkit.Foundation;
+
+public class WritableJsonConfigurationSource : JsonConfigurationSource
+{
+    public IWritableJsonConfigurationBuilder? Factory { get; set; }
+
+    public override IConfigurationProvider Build(IConfigurationBuilder builder)
+    {
+        EnsureDefaultsWithSteam(builder);
+        return new WritableJsonConfigurationProvider(this);
+    }
+
+    private void EnsureDefaultsWithSteam(IConfigurationBuilder builder)
+    {
+        EnsureDefaults(builder);
+
+        if (FileProvider is PhysicalFileProvider physicalFileProvider)
+        {
+            string? outputFile = System.IO.Path.Combine(physicalFileProvider.Root, Path);
+            Factory?.Build(outputFile);
+        }
+    }
+}

Framework/Foundation/Configurations/Write.cs

@@ -0,0 +1,5 @@
+using Mediator;
+
+namespace Toolkit.Foundation;
+
+public abstract record Write<TConfiguration>(string Section, Action<TConfiguration> UpdateDelegate) : IRequest  where TConfiguration : class;

Framework/Foundation/Configurations/WriteHandler.cs

@@ -0,0 +1,29 @@
+using Mediator;
+
+namespace Toolkit.Foundation;
+
+public class WriteHandler<TConfiguration> : IRequestHandler<Write<TConfiguration>> where TConfiguration : class
+{
+    private readonly IMediator mediator;
+    private readonly TConfiguration configuration;
+    private readonly IConfigurationWriter<TConfiguration> writer;
+
+    public WriteHandler(TConfiguration configuration,
+        IConfigurationWriter<TConfiguration> writer,
+        IMediator mediator)
+    {
+        this.mediator = mediator;
+        this.configuration = configuration;
+        this.writer = writer;
+    }
+
+    public async ValueTask<Unit> Handle(Write<TConfiguration> request, CancellationToken cancellationToken)
+    {
+        request.UpdateDelegate.Invoke(configuration);
+        writer.Write(request.Section, configuration);
+
+        await mediator.Send(new ConfigurationChanged<TConfiguration>(configuration), cancellationToken);
+
+        return default;
+    }
+}

Framework/Foundation/Extensions/IHostBuilderExtensions.cs

@@ -0,0 +1,16 @@
+using Microsoft.Extensions.Hosting;
+
+namespace Toolkit.Foundation;
+
+public static class IHostBuilderExtensions
+{
+    public static IHostBuilder UseContentRoot(this IHostBuilder hostBuilder, string contentRoot, bool createDirectory)
+    {
+        if (!Directory.Exists(contentRoot) && createDirectory)
+        {
+            Directory.CreateDirectory(contentRoot);
+        }
+
+        return hostBuilder.UseContentRoot(contentRoot);
+    }
+}

Framework/Foundation/Extensions/IServiceCollectionExtensions.cs

@@ -0,0 +1,30 @@
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+
+namespace Toolkit.Foundation;
+
+public static class IServiceCollectionExtensions
+{
+    public static IServiceCollection AddHandler<TRequestHandler>(this IServiceCollection serviceCollection)
+    {
+        serviceCollection.TryAdd(new ServiceDescriptor(typeof(TRequestHandler), typeof(TRequestHandler), ServiceLifetime.Transient));
+        return serviceCollection;
+    }
+
+
+    public static IServiceCollection AddFoundation(this IServiceCollection serviceCollection)
+    {
+        serviceCollection.AddSingleton<IServiceFactory>(provider => new ServiceFactory(provider.GetService, (instanceType, parameters) => ActivatorUtilities.CreateInstance(provider, instanceType, parameters!)))
+            .AddSingleton<IInitialization, Initialization>(provider => new Initialization(() =>
+            {
+                return serviceCollection.Where(x => x.ServiceType.GetInterfaces()
+                    .Contains(typeof(IInitializable)) || x.ServiceType == typeof(IInitializable))
+                    .GroupBy(x => x.ServiceType)
+                    .Select(x => x.First())
+                    .SelectMany(x => provider.GetServices(x.ServiceType)
+                    .Select(x => (IInitializable?)x)).ToList();
+            }));
+
+        return serviceCollection;
+    }
+}

Framework/Foundation/Extensions/IServiceFactoryExtensions.cs

@@ -0,0 +1,15 @@
+namespace Toolkit.Foundation;
+
+public static class IServiceFactoryExtensions
+{
+    public static T? Create<T>(this IServiceFactory serviceFactory, params object?[] parameters)
+    {
+        return serviceFactory.Create<T>(typeof(T), parameters);
+    }
+
+    public static object? Create(this IServiceFactory serviceFactory, Type type)
+    {
+        ServiceFactoryDescriptor? descriptor = new(serviceFactory);
+        return descriptor.Create(type);
+    }
+}

Framework/Foundation/Foundation.csproj

@@ -0,0 +1,21 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net7.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <AssemblyName>Toolkit.Foundation</AssemblyName>
+    <RootNamespace>Toolkit.Foundation</RootNamespace>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="JsonPatch.Net" Version="2.0.4" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="7.0.0" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="7.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Hosting" Version="7.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Options" Version="7.0.0" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.2" />
+    <PackageReference Include="Mediator.Abstractions" Version="2.1.0-preview.5" />
+  </ItemGroup>
+
+</Project>

Framework/Foundation/Lifecycles/AppService.cs

@@ -0,0 +1,25 @@
+using Mediator;
+using Microsoft.Extensions.Hosting;
+
+namespace Toolkit.Foundation;
+
+public class AppService : IHostedService
+{
+    private readonly IMediator mediator;
+
+    public AppService(IMediator mediator)
+    {
+        this.mediator = mediator;
+    }
+
+    public async Task StartAsync(CancellationToken cancellationToken)
+    {
+        await mediator.Send(new Initialize());
+        await mediator.Send(new Initialized());
+    }
+
+    public Task StopAsync(CancellationToken cancellationToken)
+    {
+        return Task.CompletedTask;
+    }
+}

Framework/Foundation/Lifecycles/ICache.cs

@@ -0,0 +1,6 @@
+namespace Toolkit.Foundation;
+
+public interface ICache
+{
+
+}

Framework/Foundation/Lifecycles/IInitializable.cs

@@ -0,0 +1,6 @@
+namespace Toolkit.Foundation;
+
+public interface IInitializable
+{
+    Task InitializeAsync();
+}

Framework/Foundation/Lifecycles/IInitialization.cs

@@ -0,0 +1,6 @@
+namespace Toolkit.Foundation;
+
+public interface IInitialization
+{
+    Task InitializeAsync();
+}

Framework/Foundation/Lifecycles/Initialization.cs

@@ -0,0 +1,26 @@
+using System.Diagnostics;
+
+namespace Toolkit.Foundation;
+
+public class Initialization : IInitialization
+{
+    private readonly Func<IEnumerable<IInitializable?>> factory;
+
+    public Initialization(Func<IEnumerable<IInitializable?>> factory)
+    {
+        this.factory = factory;
+    }
+
+    public async Task InitializeAsync()
+    {
+        foreach (IInitializable? initializer in factory())
+        {
+            if (initializer is not null)
+            {
+                Trace.WriteLine(initializer.GetType());
+                await initializer.InitializeAsync();
+                Trace.WriteLine("Done");
+            }
+        }
+    }
+}

Framework/Foundation/Lifecycles/Initialize.cs

@@ -0,0 +1,5 @@
+using Mediator;
+
+namespace Toolkit.Foundation;
+
+public record Initialize : IRequest;

Framework/Foundation/Lifecycles/InitializeHandler.cs

@@ -0,0 +1,19 @@
+using Mediator;
+
+namespace Toolkit.Foundation;
+
+public class InitializeHandler : IRequestHandler<Initialize>
+{
+    private readonly IInitialization initialization;
+
+    public InitializeHandler(IInitialization initialization)
+    {
+        this.initialization = initialization;
+    }
+
+    public async ValueTask<Unit> Handle(Initialize request, CancellationToken cancellationToken)
+    {
+        await initialization.InitializeAsync();
+        return default;
+    }
+}

Framework/Foundation/Lifecycles/Initialized.cs

@@ -0,0 +1,5 @@
+using Mediator;
+
+namespace Toolkit.Foundation;
+
+public record class Initialized : IRequest;

Framework/Foundation/Navigation/IEventParameter.cs

@@ -0,0 +1,10 @@
+using System;
+using System.Collections.Generic;
+
+namespace Toolkit.Foundation
+{
+    public interface IEventParameter
+    {
+        List<object> GetValues(EventArgs args);
+    }
+}

Framework/Foundation/Navigation/INavigationConfirmation.cs

@@ -0,0 +1,13 @@
+
+namespace Toolkit.Foundation
+{
+    public interface INavigationConfirmation
+    {
+        ValueTask<bool> CanConfirm();
+    }
+
+    public interface INavigated
+    {
+        ValueTask Navigated();
+    }
+}

Framework/Foundation/Navigation/INavigationRouteDescriptor.cs

@@ -0,0 +1,9 @@
+namespace Toolkit.Foundation
+{
+    public interface INavigationRouteDescriptor
+    {
+        object Route { get; }
+
+        string? Name { get; }
+    }
+}

Framework/Foundation/Navigation/INavigationRouteDescriptorCollection.cs

@@ -0,0 +1,8 @@
+using System.Collections.Generic;
+
+namespace Toolkit.Foundation
+{
+    public interface INavigationRouteDescriptorCollection : IList<INavigationRouteDescriptor>
+    {
+    }
+}

Framework/Foundation/Navigation/IParameter.cs

@@ -0,0 +1,9 @@
+namespace Toolkit.Foundation
+{
+    public interface IParameter
+    {
+        string? Key { get; }
+
+        KeyValuePair<string, object>? GetValue(object target);
+    }
+}

Framework/Foundation/Navigation/Navigate.cs

@@ -0,0 +1,29 @@
+using Mediator;
+
+namespace Toolkit.Foundation
+{
+    public record Navigate : IRequest
+    {
+        public Navigate(string name, params object?[] parameters)
+        {
+            Name = name;
+            Parameters = parameters;
+        }
+
+        public Navigate(Type type, params object?[] parameters)
+        {
+            Type = type;
+            Parameters = parameters;
+        }
+
+        public Type? Type { get; }
+
+        public object? Route { get; init; }
+
+        public string? Name { get; }
+
+        public string? FriendlyName { get; init; }
+
+        public object?[] Parameters { get; }
+    }
+}

Framework/Foundation/Navigation/NavigateBack.cs

@@ -0,0 +1,7 @@
+using Mediator;
+
+namespace Toolkit.Foundation
+{
+    public record NavigateBack(object Route) : IRequest;
+
+}

Framework/Foundation/Navigation/NavigationRoute.cs

@@ -0,0 +1,6 @@
+using Mediator;
+
+namespace Toolkit.Foundation
+{
+    public record NavigationRoute(string Name, object Route) : IRequest;
+}

Framework/Foundation/Navigation/NavigationRouteDescriptor.cs

@@ -0,0 +1,15 @@
+namespace Toolkit.Foundation
+{
+    public record NavigationRouteDescriptor : INavigationRouteDescriptor
+    {
+        public NavigationRouteDescriptor(string name, object route)
+        {
+            Name = name;
+            Route = route;
+        }
+
+        public string Name { get; }
+
+        public object Route { get; }
+    }
+}

Framework/Foundation/Navigation/NavigationRouteDescriptorCollection.cs

@@ -0,0 +1,9 @@
+namespace Toolkit.Foundation
+{
+    public class NavigationRouteDescriptorCollection : List<INavigationRouteDescriptor>, INavigationRouteDescriptorCollection
+    {
+        public NavigationRouteDescriptorCollection(IEnumerable<INavigationRouteDescriptor> collection) : base(collection)
+        {
+        }
+    }
+}

Framework/Foundation/Services/IServiceCreator.cs

@@ -0,0 +1,7 @@
+namespace Toolkit.Foundation
+{
+    public interface IServiceCreator<T>
+    {
+        object Create(Func<Type, object[], object> creator, params object[] parameters);
+    }
+}

Framework/Foundation/Services/IServiceFactory.cs

@@ -0,0 +1,9 @@
+namespace Toolkit.Foundation
+{
+    public interface IServiceFactory
+    {
+        object? Create(Type type, params object?[] parameters);
+
+        T? Create<T>(Type type, params object?[] parameters);
+    }
+}

Framework/Foundation/Services/ServiceCreator.cs

@@ -0,0 +1,10 @@
+namespace Toolkit.Foundation
+{
+    public class ServiceCreator<I, T> : IServiceCreator<I>
+    {
+        public virtual object Create(Func<Type, object[], object> creator, params object[] parameters)
+        {
+            return creator(typeof(T), parameters);
+        }
+    }
+}

Framework/Foundation/Services/ServiceFactory.cs

@@ -0,0 +1,26 @@
+namespace Toolkit.Foundation
+{
+    public class ServiceFactory : IServiceFactory
+    {
+        private readonly Func<Type, object?> factory;
+        private readonly Func<Type, object?[], object> creator;
+
+        public ServiceFactory(Func<Type, object?> factory, Func<Type, object?[], object> creator)
+        {
+            this.factory = factory;
+            this.creator = creator;
+        }
+
+        public object? Create(Type type, params object?[] parameters)
+        {
+            dynamic? lookup = factory(typeof(IServiceCreator<>).MakeGenericType(type));
+            return lookup is not null ? lookup.Create(creator, parameters) : creator(type, parameters);
+        }
+
+        public T? Create<T>(Type type, params object?[] parameters)
+        {
+            dynamic? lookup = factory(typeof(IServiceCreator<>).MakeGenericType(type));
+            return lookup is not null ? (T)lookup.Create(creator, parameters) : (T)creator(type, parameters);
+        }
+    }
+}

Framework/Foundation/Services/ServiceFactoryDescriptor.cs

@@ -0,0 +1,25 @@
+using System.Reflection;
+
+namespace Toolkit.Foundation
+{
+    internal class ServiceFactoryDescriptor
+    {
+        private readonly IServiceFactory serviceFactory;
+
+        public ServiceFactoryDescriptor(IServiceFactory serviceFactory)
+        {
+            this.serviceFactory = serviceFactory;
+        }
+
+        public object? Create(Type type)
+        {
+            MethodInfo? methodInfo = typeof(ServiceFactoryDescriptor).GetMethod(nameof(Create), BindingFlags.NonPublic | BindingFlags.Instance);
+            return methodInfo?.MakeGenericMethod(type).Invoke(this, new object[] { type });
+        }
+
+        private T Create<T>(Type type)
+        {
+            return serviceFactory.Create<T>(type);
+        }
+    }
+}

Framework/Foundation/Templates/INamedDataTemplateFactory.cs

@@ -0,0 +1,7 @@
+namespace Toolkit.Foundation
+{
+    public interface INamedDataTemplateFactory
+    {
+        object? Create(string name, params object[] parameters);
+    }
+}

Framework/Foundation/Templates/INamedTemplateFactory.cs

@@ -0,0 +1,7 @@
+namespace Toolkit.Foundation
+{
+    public interface INamedTemplateFactory
+    {
+        object? Create(string name);
+    }
+}

Framework/Foundation/Templates/ITemplateBuilder.cs

@@ -0,0 +1,13 @@
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Toolkit.Foundation
+{
+    public interface ITemplateBuilder
+    {
+        IReadOnlyCollection<ITemplateDescriptor> Descriptors { get; }
+
+        ITemplateBuilder Add<TViewModel, TView>(string name, ServiceLifetime lifetime = ServiceLifetime.Transient);
+
+        ITemplateBuilder Add<TViewModel, TView>(ServiceLifetime lifetime = ServiceLifetime.Transient);
+    }
+}

Framework/Foundation/Templates/ITemplateDescriptor.cs

@@ -0,0 +1,15 @@
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Toolkit.Foundation
+{
+    public interface ITemplateDescriptor
+    {
+        Type ContentType { get; }
+
+        ServiceLifetime Lifetime { get; }
+
+        string? Name { get; }
+
+        Type TemplateType { get; }
+    }
+}

Framework/Foundation/Templates/ITemplateDescriptorProvider.cs

@@ -0,0 +1,12 @@
+namespace Toolkit.Foundation
+{
+
+    public interface ITemplateDescriptorProvider
+    {
+        ITemplateDescriptor? Get(string name);
+
+        ITemplateDescriptor? Get(Type type);
+
+        ITemplateDescriptor? Get<T>();
+    }
+}

Framework/Foundation/Templates/ITemplateFactory.cs

@@ -0,0 +1,9 @@
+using System.Diagnostics.CodeAnalysis;
+
+namespace Toolkit.Foundation
+{
+    public interface ITemplateFactory
+    {
+        object? Create([MaybeNull] object? data);
+    }
+}

Framework/Foundation/Templates/ITemplateSelector.cs

@@ -0,0 +1,6 @@
+namespace Toolkit.Foundation
+{
+    public interface ITemplateSelector
+    {
+    }
+}

Framework/Foundation/Templates/ITypedDataTemplateFactory.cs

@@ -0,0 +1,7 @@
+namespace Toolkit.Foundation
+{
+    public interface ITypedDataTemplateFactory
+    {
+        object? Create(Type type, params object[] parameters);
+    }
+}

Framework/Foundation/Templates/NamedDataTemplateFactory.cs

@@ -0,0 +1,36 @@
+namespace Toolkit.Foundation
+{
+    public class NamedDataTemplateFactory : INamedDataTemplateFactory
+    {
+        private readonly Dictionary<string, object> cache = new();
+
+        private readonly IReadOnlyCollection<ITemplateDescriptor> descriptors;
+        private readonly IServiceFactory serviceFactory;
+
+        public NamedDataTemplateFactory(IReadOnlyCollection<ITemplateDescriptor> descriptors,
+            IServiceFactory serviceFactory)
+        {
+            this.descriptors = descriptors;
+            this.serviceFactory = serviceFactory;
+        }
+
+        public virtual object? Create(string name, params object[] parameters)
+        {
+            if (cache.TryGetValue(name, out object? data))
+            {
+                return data;
+            }
+
+            if (descriptors.FirstOrDefault(x => x.Name == name) is ITemplateDescriptor descriptor)
+            {
+                data = parameters is { Length: > 0 } ? serviceFactory.Create<object>(descriptor.ContentType, parameters) : serviceFactory.Create(descriptor.ContentType);
+                if (data is ICache cache)
+                {
+                    this.cache[name] = cache;
+                }
+            }
+
+            return data;
+        }
+    }
+}

Framework/Foundation/Templates/NamedTemplateFactory.cs

@@ -0,0 +1,41 @@
+namespace Toolkit.Foundation
+{
+    public class NamedTemplateFactory : INamedTemplateFactory
+    {
+        private readonly Dictionary<string, object> cache = new();
+
+        private readonly ITemplateDescriptorProvider provider;
+        private readonly IServiceFactory serviceFactory;
+
+        public NamedTemplateFactory(ITemplateDescriptorProvider provider,
+            IServiceFactory serviceFactory)
+        {
+            this.provider = provider;
+            this.serviceFactory = serviceFactory;
+        }
+
+        public virtual object? Create(string name)
+        {
+            if (cache.TryGetValue(name, out object? view))
+            {
+                return view;
+            }
+
+            if (provider.Get(name) is ITemplateDescriptor descriptor)
+            {
+                view = serviceFactory.Create(descriptor.TemplateType);
+                if (view is ICache cache)
+                {
+                    this.cache[name] = cache;
+                }
+
+                if (descriptor.GetType().GenericTypeArguments is { Length: 2 })
+                {
+                    (descriptor as dynamic).ViewInvoker?.Invoke(view);
+                }
+            }
+
+            return view;
+        }
+    }
+}

Framework/Foundation/Templates/TemplateBuilder.cs

@@ -0,0 +1,24 @@
+using Microsoft.Extensions.DependencyInjection;
+using System.Collections.ObjectModel;
+
+namespace Toolkit.Foundation
+{
+    public class TemplateBuilder : ITemplateBuilder
+    {
+        private readonly List<ITemplateDescriptor> descriptors = new();
+
+        public IReadOnlyCollection<ITemplateDescriptor> Descriptors => new ReadOnlyCollection<ITemplateDescriptor>(descriptors);
+
+        public ITemplateBuilder Add<TViewModel, TView>(string name, ServiceLifetime lifetime = ServiceLifetime.Transient)
+        {
+            descriptors.Add(new TemplateDescriptor(typeof(TViewModel), typeof(TView), name, lifetime));
+            return this;
+        }
+
+        public ITemplateBuilder Add<TViewModel, TView>(ServiceLifetime lifetime = ServiceLifetime.Transient)
+        {
+            descriptors.Add(new TemplateDescriptor(typeof(TViewModel), typeof(TView), null, lifetime));
+            return this;
+        }
+    }
+}

Framework/Foundation/Templates/TemplateDescriptor.cs

@@ -0,0 +1,26 @@
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Toolkit.Foundation
+{
+    public class TemplateDescriptor : ITemplateDescriptor
+    {
+        public TemplateDescriptor(Type dataType,
+            Type templateType,
+            string? name = null,
+            ServiceLifetime lifetime = ServiceLifetime.Transient)
+        {
+            TemplateType = templateType;
+            ContentType = dataType;
+            Name = name;
+            Lifetime = lifetime;
+        }
+
+        public ServiceLifetime Lifetime { get; }
+
+        public Type TemplateType { get; }
+
+        public Type ContentType { get; }
+
+        public string? Name { get; }
+    }
+}

Framework/Foundation/Templates/TemplateDescriptorProvider.cs

@@ -0,0 +1,42 @@
+namespace Toolkit.Foundation
+{
+    public class TemplateDescriptorProvider : ITemplateDescriptorProvider
+    {
+        private readonly IReadOnlyCollection<ITemplateDescriptor> descriptors;
+
+        public TemplateDescriptorProvider(IReadOnlyCollection<ITemplateDescriptor> descriptors)
+        {
+            this.descriptors = descriptors;
+        }
+
+        public ITemplateDescriptor? Get(string name)
+        {
+            if (descriptors.FirstOrDefault(x => x.Name == name) is ITemplateDescriptor descriptor)
+            {
+                return descriptor;
+            }
+
+            return null;
+        }
+
+        public ITemplateDescriptor? Get(Type type)
+        {
+            if (descriptors.FirstOrDefault(x => x.ContentType == type) is ITemplateDescriptor descriptor)
+            {
+                return descriptor;
+            }
+
+            return null;
+        }
+
+        public ITemplateDescriptor? Get<T>()
+        {
+            if (descriptors.FirstOrDefault(x => x.ContentType == typeof(T)) is ITemplateDescriptor descriptor)
+            {
+                return descriptor;
+            }
+
+            return null;
+        }
+    }
+}

Framework/Foundation/Templates/TemplateFactory.cs

@@ -0,0 +1,43 @@
+using System.Diagnostics.CodeAnalysis;
+
+namespace Toolkit.Foundation
+{
+    public class TemplateFactory : ITemplateFactory
+    {
+        private readonly Dictionary<object, object> cache = new();
+
+        private readonly ITemplateDescriptorProvider provider;
+        private readonly IServiceFactory serviceFactory;
+
+        public TemplateFactory(ITemplateDescriptorProvider provider,
+            IServiceFactory serviceFactory)
+        {
+            this.provider = provider;
+            this.serviceFactory = serviceFactory;
+        }
+
+        public virtual object? Create([MaybeNull] object? data)
+        {
+            if (data is null)
+            {
+                return null;
+            }
+
+            if (cache.TryGetValue(data, out object? template))
+            {
+                return template;
+            }
+
+            if (provider.Get(data.GetType()) is ITemplateDescriptor descriptor)
+            {
+                template = serviceFactory.Create(descriptor.TemplateType);
+                if (template is ICache cache)
+                {
+                    this.cache[data] = cache;
+                }
+            }
+
+            return template;
+        }
+    }
+}

Framework/Foundation/Templates/TypedDataTemplateFactory.cs

@@ -0,0 +1,36 @@
+namespace Toolkit.Foundation
+{
+    public class TypedDataTemplateFactory : ITypedDataTemplateFactory
+    {
+        private readonly Dictionary<Type, object> cache = new();
+
+        private readonly IReadOnlyCollection<ITemplateDescriptor> descriptors;
+        private readonly IServiceFactory serviceFactory;
+
+        public TypedDataTemplateFactory(IReadOnlyCollection<ITemplateDescriptor> descriptors,
+            IServiceFactory serviceFactory)
+        {
+            this.descriptors = descriptors;
+            this.serviceFactory = serviceFactory;
+        }
+
+        public virtual object? Create(Type type, params object[] parameters)
+        {
+            if (cache.TryGetValue(type, out object? data))
+            {
+                return data;
+            }
+
+            if (descriptors.FirstOrDefault(x => x.ContentType == type) is ITemplateDescriptor descriptor)
+            {
+                data = parameters is { Length: > 0 } ? serviceFactory.Create<object>(descriptor.ContentType, parameters) : serviceFactory.Create(descriptor.ContentType);
+                if (data is ICache cache)
+                {
+                    this.cache[type] = cache;
+                }
+            }
+
+            return data;
+        }
+    }
+}