Removing serialize call due to existing operator

- right now only in DEBUG compilation and only for the static operator

Experiments/ExternalActionManager/DemoBot/DemoBot.csproj

@@ -0,0 +1,16 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net7.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\TelegramBotBase\TelegramBotBase.csproj" />
+    <ProjectReference Include="..\TelegramBotBase.Experiments\TelegramBotBase.Experiments.ActionManager.csproj" />
+  </ItemGroup>
+
+
+</Project>

Experiments/ExternalActionManager/DemoBot/Forms/HiddenForm.cs

@@ -0,0 +1,52 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.WebSockets;
+using System.Text;
+using System.Threading.Tasks;
+using TelegramBotBase.Base;
+using TelegramBotBase.Form;
+
+namespace DemoBot.Forms
+{
+    public class HiddenForm : AutoCleanForm
+    {
+        public String value {  get; set; }
+
+        public HiddenForm() {
+
+            DeleteMode = TelegramBotBase.Enums.EDeleteMode.OnLeavingForm;
+            DeleteSide = TelegramBotBase.Enums.EDeleteSide.Both;
+        }
+
+        public override async Task Action(MessageResult message)
+        {
+            if (message.RawData != "start")
+            {
+                return;
+            }
+
+            await message.ConfirmAction("Lets go");
+
+            message.Handled = true;
+
+            var st = new StartForm();
+
+            await NavigateTo(st);
+        }
+
+        public override async Task Render(MessageResult message)
+        {
+
+            var bf = new ButtonForm();
+
+            bf.AddButtonRow("Goto Start", "start");
+
+            value = value.Replace("_", "\\_");
+
+            await Device.Send($"Welcome to Hidden form\n\nThe given value is {value}", bf);
+
+        }
+
+    }
+}

Experiments/ExternalActionManager/DemoBot/Forms/HiddenForm_EndsWith.cs

@@ -0,0 +1,52 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.WebSockets;
+using System.Text;
+using System.Threading.Tasks;
+using TelegramBotBase.Base;
+using TelegramBotBase.Form;
+
+namespace DemoBot.Forms
+{
+    public class HiddenForm_EndsWith : AutoCleanForm
+    {
+        public String value {  get; set; }
+
+        public HiddenForm_EndsWith() {
+
+            DeleteMode = TelegramBotBase.Enums.EDeleteMode.OnLeavingForm;
+            DeleteSide = TelegramBotBase.Enums.EDeleteSide.Both;
+        }
+
+        public override async Task Action(MessageResult message)
+        {
+            if (message.RawData != "start")
+            {
+                return;
+            }
+
+            await message.ConfirmAction("Lets go");
+
+            message.Handled = true;
+
+            var st = new StartForm();
+
+            await NavigateTo(st);
+        }
+
+        public override async Task Render(MessageResult message)
+        {
+
+            var bf = new ButtonForm();
+
+            bf.AddButtonRow("Goto Start", "start");
+
+            value = value.Replace("_", "\\_");
+
+            await Device.Send($"Welcome to Hidden ends with form\n\nThe given value is {value}", bf);
+
+        }
+
+    }
+}

Experiments/ExternalActionManager/DemoBot/Forms/HiddenLetterForm.cs

@@ -0,0 +1,53 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TelegramBotBase.Base;
+using TelegramBotBase.Form;
+
+namespace DemoBot.Forms
+{
+    public class HiddenLetterForm : AutoCleanForm
+    {
+
+        public Guid letterId {  get; set; }
+
+        public HiddenLetterForm()
+        {
+
+            DeleteMode = TelegramBotBase.Enums.EDeleteMode.OnLeavingForm;
+            DeleteSide = TelegramBotBase.Enums.EDeleteSide.Both;
+        }
+
+        public override async Task Action(MessageResult message)
+        {
+            if (message.RawData != "start")
+            {
+                return;
+            }
+
+
+            await message.ConfirmAction("Lets go");
+
+            message.Handled = true;
+
+            var st = new StartForm();
+
+            await NavigateTo(st);
+        }
+
+        public override async Task Render(MessageResult message)
+        {
+
+            var bf = new ButtonForm();
+
+            bf.AddButtonRow("Goto Start", "start");
+
+            await Device.Send($"Welcome to Hidden letter form\n\nYour letter Id is: {letterId}", bf);
+
+
+        }
+
+    }
+}

Experiments/ExternalActionManager/DemoBot/Forms/HiddenOpenForm.cs

@@ -0,0 +1,52 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TelegramBotBase.Base;
+using TelegramBotBase.Form;
+
+namespace DemoBot.Forms
+{
+    public class HiddenOpenForm : AutoCleanForm
+    {
+
+        public Guid guid {  get; set; }
+
+        public HiddenOpenForm()
+        {
+
+            DeleteMode = TelegramBotBase.Enums.EDeleteMode.OnLeavingForm;
+            DeleteSide = TelegramBotBase.Enums.EDeleteSide.Both;
+        }
+
+        public override async Task Action(MessageResult message)
+        {
+            if (message.RawData != "start")
+            {
+                return;
+            }
+
+            await message.ConfirmAction("Lets go");
+
+            message.Handled = true;
+
+            var st = new StartForm();
+
+            await NavigateTo(st);
+        }
+
+        public override async Task Render(MessageResult message)
+        {
+
+            var bf = new ButtonForm();
+
+            bf.AddButtonRow("Goto Start", "start");
+
+            await Device.Send($"Welcome to Hidden open form\n\nYour guid is: {guid}", bf);
+
+
+        }
+
+    }
+}

Experiments/ExternalActionManager/DemoBot/Forms/HiddenTicketForm.cs

@@ -0,0 +1,53 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TelegramBotBase.Base;
+using TelegramBotBase.Form;
+
+namespace DemoBot.Forms
+{
+    public class HiddenTicketForm : AutoCleanForm
+    {
+
+        public Guid ticketId {  get; set; }
+
+        public HiddenTicketForm()
+        {
+
+            DeleteMode = TelegramBotBase.Enums.EDeleteMode.OnLeavingForm;
+            DeleteSide = TelegramBotBase.Enums.EDeleteSide.Both;
+        }
+
+        public override async Task Action(MessageResult message)
+        {
+            if (message.RawData != "start")
+            {
+                return;
+            }
+
+
+            await message.ConfirmAction("Lets go");
+
+            message.Handled = true;
+
+            var st = new StartForm();
+
+            await NavigateTo(st);
+        }
+
+        public override async Task Render(MessageResult message)
+        {
+
+            var bf = new ButtonForm();
+
+            bf.AddButtonRow("Goto Start", "start");
+
+            await Device.Send($"Welcome to Hidden ticket form\n\nYour ticket Id is: {ticketId}", bf);
+
+
+        }
+
+    }
+}

Experiments/ExternalActionManager/DemoBot/Forms/StartForm.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TelegramBotBase.Base;
+using TelegramBotBase.Form;
+
+namespace DemoBot.Forms
+{
+    internal class StartForm : AutoCleanForm
+    {
+        public StartForm()
+        {
+
+            DeleteMode = TelegramBotBase.Enums.EDeleteMode.OnLeavingForm;
+            DeleteSide = TelegramBotBase.Enums.EDeleteSide.Both;
+
+            Opened += StartForm_Opened;
+        }
+
+        private async Task StartForm_Opened(object sender, EventArgs e)
+        {
+            await Device.Send("Hey!\r\n\r\nChoose the /test command to get a message from outside.", disableNotification: true);
+        }
+
+        public override async Task Load(MessageResult message)
+        {
+            
+            
+
+
+        }
+
+    }
+}

Experiments/ExternalActionManager/DemoBot/Program.cs

@@ -0,0 +1,310 @@
+using DemoBot.Forms;
+using Telegram.Bot;
+using Telegram.Bot.Types.ReplyMarkups;
+using TelegramBotBase.Builder;
+using TelegramBotBase.Commands;
+using TelegramBotBase.Form;
+using TelegramBotBase.Base;
+using TelegramBotBase.Experiments.ActionManager;
+using TelegramBotBase.Experiments.ActionManager.Actions;
+using TelegramBotBase.Experiments.ActionManager.Navigation;
+using Telegram.Bot.Types;
+
+namespace DemoBot
+{
+    internal class Program
+    {
+        public static String Token = Environment.GetEnvironmentVariable("API_KEY") ?? throw new Exception("API_KEY is not set");
+
+        static async Task Main(string[] args)
+        {
+
+            //Using a custom FormBase message loop which is based on the original FormBaseMessageLoop within the framework.
+            //Would integrate this later into the BotBaseBuilder -> MessageLoop step.
+            //var cfb = new CustomFormBaseMessageLoop();
+
+            //Example 1: Long version
+            var eam = ExternalActionManager.Configure(config =>
+            {
+                //Waiting for input starting with 'n_'
+                config.AddStartsWithNavigation<HiddenForm>("n_", (a, b) =>
+                {
+                    a.value = b;
+                });
+
+
+                //Minimal version, using reflection right now
+                config.AddStartsWithNavigation<HiddenForm>("a_", (a, b) =>
+                {
+                    a.value = b;
+                });
+
+
+                //Waiting for input starting with 't_'
+                config.AddStartsWithNavigation(typeof(HiddenForm), "t_", (a, b) =>
+                {
+                    var hf = a as HiddenForm;
+                    if (hf == null)
+                        return;
+
+                    hf.value = b;
+                });
+
+
+                //Minimal version, using reflection right now
+                config.AddEndsWithNavigation<HiddenForm_EndsWith>("_u", (a, b) =>
+                {
+                    a.value = b;
+                });
+
+
+                //Deserialize input and waiting for the method property to has value 'tickets'
+                config.AddGuidNavigation<HiddenTicketForm>("tickets", (a, b) =>
+                {
+                    a.ticketId = b;
+                });
+
+
+                //Minimal version, using reflection right now
+                config.AddGuidNavigation<HiddenLetterForm>("letters", (a, b) =>
+                {
+                    a.letterId = b;
+                });
+
+
+                //Deserialize input and waiting for the method property to has value 'open'
+                config.AddGuidNavigation<HiddenOpenForm>("open", (a, b) =>
+                {
+                    a.guid = b;
+                });
+
+
+                //Do custom action
+                config.AddStartsWithAction("p_", StartsWithActionCallback_Demo);
+
+                //Do custom action
+                config.AddStartsWithAction("p2_", async (value, update, message) =>
+                {
+                    if (message.UpdateData.CallbackQuery == null)
+                        return;
+
+                    await update.Device.ConfirmAction(message.UpdateData.CallbackQuery.Id, "Confirmed!");
+                });
+
+            });
+
+            //Example 2: Short version
+            var eam2 = ExternalActionManager.Configure(config =>
+            {
+                //Waiting for input starting with 'n_'
+                config.AddStartsWithNavigation<HiddenForm>("n_", a => a.value);
+
+
+                //Waiting for input starting with 'a_'
+                config.AddStartsWithNavigation<HiddenForm>("a_", a => a.value);
+
+
+                //Waiting for input starting with 't_' (Non generic version)
+                config.AddStartsWithNavigation(typeof(HiddenForm), "t_", a => ((HiddenForm)a).value);
+
+
+                //Waiting for input ending with 'n_'
+                config.AddEndsWithNavigation<HiddenForm_EndsWith>("_u", a => a.value);
+
+
+                //Deserialize input and waiting for the method property to has value 'tickets'
+                config.AddGuidNavigation<HiddenTicketForm>("tickets", a => a.ticketId);
+
+
+                //Minimal version, using reflection right now
+                config.AddGuidNavigation<HiddenLetterForm>("letters", a => a.letterId);
+
+
+                //Deserialize input and waiting for the method property to has value 'open'
+                config.AddGuidNavigation<HiddenOpenForm>("open", a => a.guid);
+
+
+                //Do custom action
+                config.AddStartsWithAction("p_", StartsWithActionCallback_Demo);
+
+
+                //Do custom action
+                config.AddStartsWithAction("p2_", async (value, update, message) =>
+                {
+                    if (message.UpdateData.CallbackQuery == null)
+                        return;
+
+                    await update.Device.ConfirmAction(message.UpdateData.CallbackQuery.Id, "Confirmed!");
+                });
+
+
+                config.AddGuidAction("guid.test.too.long", async (g, c, u, m) =>
+                {
+                    if (m.UpdateData.CallbackQuery == null)
+                        return;
+
+                    await u.Device.ConfirmAction(m.UpdateData.CallbackQuery.Id, "Confirmed!");
+                });
+            });
+
+
+            var bb = BotBaseBuilder.Create()
+                                    .WithAPIKey(Token)
+                                    .ActionMessageLoop(eam2)
+                                    .WithStartForm<Forms.StartForm>()
+                                    .NoProxy()
+                                    .CustomCommands(a =>
+                                    {
+                                        a.Start("Starts the bot");
+                                        a.Add("test", "Sends a test notification");
+                                        a.Add("invalid", "Try to send an invalid data message");
+
+                                    })
+                                    .NoSerialization()
+                                    .UseGerman()
+                                    .UseSingleThread()
+                                    .Build();
+
+            bb.BotCommand += Bb_BotCommand;
+
+            bb.UnhandledCall += Bb_UnhandledCall;
+
+            await bb.Start();
+
+            await bb.UploadBotCommands();
+
+            Console.WriteLine("Bot started.");
+
+
+            Console.ReadLine();
+
+
+            await bb.Stop();
+
+
+        }
+
+        private static async Task StartsWithActionCallback_Demo(String value, UpdateResult ur, MessageResult mr)
+        {
+            if (mr.UpdateData.CallbackQuery == null)
+                return;
+
+            await ur.Device.ConfirmAction(mr.UpdateData.CallbackQuery.Id, "Confirmed!");
+        }
+
+        private static void Bb_UnhandledCall(object? sender, TelegramBotBase.Args.UnhandledCallEventArgs e)
+        {
+
+            Console.WriteLine($"Unhandled call: {e.RawData}");
+
+        }
+
+        private static async Task Bb_BotCommand(object sender, TelegramBotBase.Args.BotCommandEventArgs e)
+        {
+
+            var current_form = e.Device.ActiveForm;
+
+            switch (e.Command)
+            {
+                case "/start":
+
+                    //Already on start form
+                    if (current_form.GetType() == typeof(Forms.StartForm))
+                    {
+                        return;
+                    }
+
+                    var st = new Forms.StartForm();
+
+                    await current_form.NavigateTo(st);
+
+                    break;
+
+                case "/test":
+
+                    //Send test notification
+
+                    //Test values
+
+                    String max_value = "n_".PadRight(32, '1'); //Starts with
+
+                    String max_value2 = "t_".PadRight(32, '2'); //Starts with
+
+                    String max_value3 = "a_".PadRight(32, '3'); //Starts with
+
+                    String max_value4 = "_u".PadLeft(32, '4'); //Ends with
+
+                    String max_value5 = "p_".PadRight(32, '5'); //Ends with
+
+                    String max_value6 = "p2_".PadRight(32, '6'); //Ends with
+
+                    Guid test_value = Guid.NewGuid(); //Unhandled caller
+
+                    var callback_guid = GuidNavigation.GetCallback("open", Guid.NewGuid()); //HiddenOpenForm
+
+                    var callback_tickets = GuidNavigation.GetCallback("tickets", Guid.NewGuid()); //HiddenTicketForm
+
+                    var callback_letters = GuidNavigation.GetCallback("letters", Guid.NewGuid()); //HiddenLetterForm
+
+
+                    String message = $"Test notification from 'outside'\n\nTest values are:\n\nTest: {max_value}\nTest2: {max_value2}\nTest3: {max_value3}\nTest (Guid): {test_value.ToString()}\nTest (Callback Guid): {callback_guid.Value}\nTickets (Guid): {callback_tickets.Value}\nLetters (Guid): {callback_letters.Value}\n";
+
+
+                    var tb = new TelegramBotClient(Token);
+
+                    var bf = new ButtonForm();
+
+                    bf.AddButtonRow(new ButtonBase("Ok", "n_ok"), new ButtonBase("Later", "n_later"));
+
+                    bf.AddButtonRow("Test (n_)", max_value);
+
+                    bf.AddButtonRow("Test2 (t_)", max_value2);
+
+                    bf.AddButtonRow("Test3 (a_)", max_value3);
+
+                    bf.AddButtonRow("Test4 (_u)", max_value4);
+
+                    bf.AddButtonRow("Test5 (p_)", max_value5);
+
+                    bf.AddButtonRow("Test6 (p2_)", max_value6);
+
+                    bf.AddButtonRow("Test (Guid)", test_value.ToString());
+
+                    bf.AddButtonRow("Test (Callback Gui)", callback_guid);
+
+                    bf.AddButtonRow("Tickets", callback_tickets);
+
+                    bf.AddButtonRow("Letters", callback_letters);
+
+                    bf.AddButtonRow("Close", "close");
+
+                    await tb.SendTextMessageAsync(e.DeviceId, message, disableNotification: true, replyMarkup: (InlineKeyboardMarkup)bf);
+
+                    break;
+
+                case "/invalid":
+
+                    Guid g = Guid.NewGuid();
+
+                    var tb2 = new TelegramBotClient(Token);
+
+                    var bf2 = new ButtonForm();
+
+                    bf2.AddButtonRow("Test test", GuidAction.GetCallback("guid.test.too.long", g));
+
+                    String message2 = "This is an invalid test message.";
+
+                    await tb2.SendTextMessageAsync(e.DeviceId, message2, disableNotification: true, replyMarkup: (InlineKeyboardMarkup)bf2);
+
+
+                    break;
+
+
+            }
+
+
+
+
+        }
+    }
+}

Experiments/ExternalActionManager/DemoBot/Readme.md

@@ -0,0 +1,29 @@
+# ExternalActionManager
+
+Idea of this experiment is to find a good intuitive way for handling "Unhandled calls".
+Right now they are "thrown" into an event handler and you have to take care over them on yourself.
+
+
+Source of them would be in most cases Telegram Bot messages which has an Inlinekeyboard attached and comes from outside of the framework. (via webservice or other remote channels)
+
+And the button press should navigate to a different form, or invoke a different action.
+
+
+## How does it work ?
+
+
+- Open the Bot
+- Run the "/start" command
+- Now you are on the only FormBase where you can get without interaction
+- Use the "/test" command to invoke an "outside" message with some different buttons.
+- Use them to navigate to different "hidden" forms
+
+
+## Future ideas
+
+- adding an Action for int and/or long datatypes
+
+
+- 
+
+Begin: 18.01.2024

Experiments/ExternalActionManager/TelegramBotBase.Experiments/ActionManager/Actions/EndsWithAction.Extensions.cs

@@ -0,0 +1,13 @@
+using TelegramBotBase.Base;
+
+namespace TelegramBotBase.Experiments.ActionManager.Actions
+{
+    public static class EndsWithAction_Extensions
+    {
+        public static void AddEndsWithAction(this ExternalActionManager manager, string value, Func<String, UpdateResult, MessageResult, Task> action)
+        {
+            manager.Add(new EndsWithAction(value, action));
+        }
+    }
+
+}

Experiments/ExternalActionManager/TelegramBotBase.Experiments/ActionManager/Actions/EndsWithAction.cs

@@ -0,0 +1,29 @@
+using TelegramBotBase.Base;
+using TelegramBotBase.Form;
+
+namespace TelegramBotBase.Experiments.ActionManager.Actions
+{
+
+    public class EndsWithAction : IExternalAction
+    {
+        public string SearchForString { get; set; }
+
+        public Action<FormBase, string> SetProperty { get; set; }
+
+        Func<String, UpdateResult, MessageResult, Task> Action;
+
+
+        public EndsWithAction(string searchFor, Func<String, UpdateResult, MessageResult, Task> action)
+        {
+            SearchForString = searchFor;
+            Action = action;
+        }
+
+        public bool DoesFit(string raw_data) => raw_data.EndsWith(SearchForString);
+
+
+        public async Task DoAction(UpdateResult ur, MessageResult mr) => await Action(mr.RawData, ur, mr);
+
+    }
+
+}

Experiments/ExternalActionManager/TelegramBotBase.Experiments/ActionManager/Actions/GuidAction.Extensions.cs

@@ -0,0 +1,14 @@
+using TelegramBotBase.Base;
+using TelegramBotBase.Form;
+
+namespace TelegramBotBase.Experiments.ActionManager.Actions
+{
+    public static class GuidAction_Extensions
+    {
+
+        public static void AddGuidAction(this ExternalActionManager manager, string method, Func<Guid, CallbackData, UpdateResult, MessageResult, Task> action)
+        {
+            manager.Add(new GuidAction(method, action));
+        }
+    }
+}

Experiments/ExternalActionManager/TelegramBotBase.Experiments/ActionManager/Actions/GuidAction.cs

@@ -0,0 +1,85 @@
+using TelegramBotBase.Base;
+using TelegramBotBase.Form;
+
+namespace TelegramBotBase.Experiments.ActionManager.Actions
+{
+    public class GuidAction : IExternalAction
+    {
+        public string Method { get; set; }
+
+        CallbackData? _lastData { get; set; }
+
+        Guid? _lastValue { get; set; }
+
+        Func<Guid, CallbackData, UpdateResult, MessageResult, Task> Action;
+
+        public GuidAction(string method, Func<Guid, CallbackData, UpdateResult, MessageResult, Task> action)
+        {
+            Method = method;
+            Action = action;
+        }
+
+        public bool DoesFit(string raw_data)
+        {
+            var cd = CallbackData.Deserialize(raw_data);
+
+            if (cd == null)
+                return false;
+
+            if (cd.Method != Method)
+                return false;
+
+            Guid g;
+
+            if (Guid.TryParse(cd.Value, out g))
+                _lastValue = g;
+
+            _lastData = cd;
+
+            return true;
+        }
+
+
+        public async Task DoAction(UpdateResult ur, MessageResult mr) => await Action(_lastValue.Value, _lastData, ur, mr);
+
+        public static CallbackData GetCallback(string method, Guid guid) => new CallbackData(method, guid.ToString());
+
+    }
+
+    public class GuidAction<TForm> : IExternalAction
+        where TForm : FormBase
+    {
+        public string Method { get; set; }
+
+        Guid? _lastValue { get; set; }
+
+        Func<Guid, UpdateResult, MessageResult, Task> Action;
+
+        public GuidAction(string method, Func<Guid, UpdateResult, MessageResult, Task> action)
+        {
+            Method = method;
+            Action = action;
+        }
+
+        public bool DoesFit(string raw_data)
+        {
+            var cd = CallbackData.Deserialize(raw_data);
+
+            if (cd == null)
+                return false;
+
+            if (cd.Method != Method)
+                return false;
+
+            Guid g;
+
+            if (Guid.TryParse(cd.Value, out g))
+                _lastValue = g;
+
+            return true;
+        }
+
+
+        public async Task DoAction(UpdateResult ur, MessageResult mr) => await Action(_lastValue.Value, ur, mr);
+    }
+}

Experiments/ExternalActionManager/TelegramBotBase.Experiments/ActionManager/Actions/Int32Action.Extensions.cs

@@ -0,0 +1,14 @@
+using TelegramBotBase.Base;
+using TelegramBotBase.Form;
+
+namespace TelegramBotBase.Experiments.ActionManager.Actions
+{
+    public static class Int32Action_Extensions
+    {
+
+        public static void AddInt32Action(this ExternalActionManager manager, string method, Func<int, CallbackData, UpdateResult, MessageResult, Task> action)
+        {
+            manager.Add(new Int32Action(method, action));
+        }
+    }
+}

Experiments/ExternalActionManager/TelegramBotBase.Experiments/ActionManager/Actions/Int32Action.cs

@@ -0,0 +1,90 @@
+using TelegramBotBase.Base;
+using TelegramBotBase.Form;
+
+namespace TelegramBotBase.Experiments.ActionManager.Actions
+{
+    public class Int32Action : IExternalAction
+    {
+        public string Method { get; set; }
+
+        CallbackData? _lastData { get; set; }
+
+        int? _lastValue { get; set; }
+
+        Func<int, CallbackData, UpdateResult, MessageResult, Task> Action;
+
+        public Int32Action(string method, Func<int, CallbackData, UpdateResult, MessageResult, Task> action)
+        {
+            Method = method;
+            Action = action;
+        }
+
+
+        public bool DoesFit(string raw_data)
+        {
+            var cd = CallbackData.Deserialize(raw_data);
+
+            if (cd == null)
+                return false;
+
+            if (cd.Method != Method)
+                return false;
+
+            int i;
+
+            if (int.TryParse(cd.Value, out i))
+                _lastValue = i;
+
+            _lastData = cd;
+
+            return true;
+        }
+
+
+        public async Task DoAction(UpdateResult ur, MessageResult mr) => await Action(_lastValue.Value, _lastData, ur, mr);
+
+        public static CallbackData GetCallback(string method, long l) => new CallbackData(method, l.ToString());
+
+    }
+
+    public class Int32Action<TForm> : IExternalAction
+        where TForm : FormBase
+    {
+        public string Method { get; set; }
+
+        CallbackData? _lastData { get; set; }
+
+        int? _lastValue { get; set; }
+
+        Func<int, CallbackData, UpdateResult, MessageResult, Task> Action;
+
+        public Int32Action(string method, Func<int, CallbackData, UpdateResult, MessageResult, Task> action)
+        {
+            Method = method;
+            Action = action;
+        }
+
+        public bool DoesFit(string raw_data)
+        {
+            var cd = CallbackData.Deserialize(raw_data);
+
+            if (cd == null)
+                return false;
+
+            if (cd.Method != Method)
+                return false;
+
+            int i;
+
+            if (int.TryParse(cd.Value, out i))
+                _lastValue = i;
+
+            _lastData = cd;
+
+            return true;
+        }
+
+
+        public async Task DoAction(UpdateResult ur, MessageResult mr) => await Action(_lastValue.Value, _lastData, ur, mr);
+    }
+}

Experiments/ExternalActionManager/TelegramBotBase.Experiments/ActionManager/Actions/Int64Action.Extensions.cs

@@ -0,0 +1,14 @@
+using TelegramBotBase.Base;
+using TelegramBotBase.Form;
+
+namespace TelegramBotBase.Experiments.ActionManager.Actions
+{
+    public static class Int64Action_Extensions
+    {
+
+        public static void AddInt64Action(this ExternalActionManager manager, string method, Func<long, CallbackData, UpdateResult, MessageResult, Task> action)
+        {
+            manager.Add(new Int64Action(method, action));
+        }
+    }
+}

Experiments/ExternalActionManager/TelegramBotBase.Experiments/ActionManager/Actions/Int64Action.cs

@@ -0,0 +1,89 @@
+using TelegramBotBase.Base;
+using TelegramBotBase.Form;
+
+namespace TelegramBotBase.Experiments.ActionManager.Actions
+{
+    public class Int64Action : IExternalAction
+    {
+        public string Method { get; set; }
+
+        CallbackData? _lastData { get; set; }
+
+        long? _lastValue { get; set; }
+
+        Func<long, CallbackData, UpdateResult, MessageResult, Task> Action;
+
+        public Int64Action(string method, Func<long, CallbackData, UpdateResult, MessageResult, Task> action)
+        {
+            Method = method;
+            Action = action;
+        }
+
+        public bool DoesFit(string raw_data)
+        {
+            var cd = CallbackData.Deserialize(raw_data);
+
+            if (cd == null)
+                return false;
+
+            if (cd.Method != Method)
+                return false;
+
+            long l;
+
+            if (long.TryParse(cd.Value, out l))
+                _lastValue = l;
+
+            _lastData = cd;
+
+            return true;
+        }
+
+
+        public async Task DoAction(UpdateResult ur, MessageResult mr) => await Action(_lastValue.Value, _lastData, ur, mr);
+
+        public static CallbackData GetCallback(string method, long l) => new CallbackData(method, l.ToString());
+
+    }
+
+    public class Int64Action<TForm> : IExternalAction
+        where TForm : FormBase
+    {
+        public string Method { get; set; }
+
+        CallbackData? _lastData { get; set; }
+
+        long? _lastValue { get; set; }
+
+        Func<long, CallbackData, UpdateResult, MessageResult, Task> Action;
+
+        public Int64Action(string method, Func<long, CallbackData, UpdateResult, MessageResult, Task> action)
+        {
+            Method = method;
+            Action = action;
+        }
+
+        public bool DoesFit(string raw_data)
+        {
+            var cd = CallbackData.Deserialize(raw_data);
+
+            if (cd == null)
+                return false;
+
+            if (cd.Method != Method)
+                return false;
+
+            long g;
+
+            if (long.TryParse(cd.Value, out g))
+                _lastValue = g;
+
+            _lastData = cd;
+
+            return true;
+        }
+
+
+        public async Task DoAction(UpdateResult ur, MessageResult mr) => await Action(_lastValue.Value, _lastData, ur, mr);
+    }
+}

Experiments/ExternalActionManager/TelegramBotBase.Experiments/ActionManager/Actions/StartWithAction.Extensions.cs

@@ -0,0 +1,13 @@
+using TelegramBotBase.Base;
+
+namespace TelegramBotBase.Experiments.ActionManager.Actions
+{
+    public static class StartWithAction_Extensions
+    {
+        public static void AddStartsWithAction(this ExternalActionManager manager, string value, Func<String, UpdateResult, MessageResult, Task> action)
+        {
+            manager.Add(new StartWithAction(value, action));
+        }
+    }
+
+}

Experiments/ExternalActionManager/TelegramBotBase.Experiments/ActionManager/Actions/StartWithAction.cs

@@ -0,0 +1,29 @@
+using TelegramBotBase.Base;
+using TelegramBotBase.Form;
+
+namespace TelegramBotBase.Experiments.ActionManager.Actions
+{
+
+    public class StartWithAction : IExternalAction
+    {
+        public string SearchForString { get; set; }
+
+        public Action<FormBase, string> SetProperty { get; set; }
+
+        Func<String, UpdateResult, MessageResult, Task> Action;
+
+
+        public StartWithAction(string searchFor, Func<String, UpdateResult, MessageResult, Task> action)
+        {
+            SearchForString = searchFor;
+            Action = action;
+        }
+
+        public bool DoesFit(string raw_data) => raw_data.StartsWith(SearchForString);
+      
+
+        public async Task DoAction(UpdateResult ur, MessageResult mr) => await Action(mr.RawData, ur, mr);
+
+    }
+
+}

Experiments/ExternalActionManager/TelegramBotBase.Experiments/ActionManager/Actions/StringAction.Extensions.cs

@@ -0,0 +1,14 @@
+using TelegramBotBase.Base;
+using TelegramBotBase.Form;
+
+namespace TelegramBotBase.Experiments.ActionManager.Actions
+{
+    public static class StringAction_Extensions
+    {
+
+        public static void AddStringAction(this ExternalActionManager manager, string method, Func<String, CallbackData, UpdateResult, MessageResult, Task> action)
+        {
+            manager.Add(new StringAction(method, action));
+        }
+    }
+}

Experiments/ExternalActionManager/TelegramBotBase.Experiments/ActionManager/Actions/StringAction.cs

@@ -0,0 +1,85 @@
+using TelegramBotBase.Base;
+using TelegramBotBase.Form;
+
+namespace TelegramBotBase.Experiments.ActionManager.Actions
+{
+    public class StringAction : IExternalAction
+    {
+        public string Method { get; set; }
+
+        CallbackData? _lastData { get; set; }
+
+        String? _lastValue { get; set; }
+
+        Func<string, CallbackData, UpdateResult, MessageResult, Task> Action;
+
+        public StringAction(string method, Func<string, CallbackData, UpdateResult, MessageResult, Task> action)
+        {
+            Method = method;
+            Action = action;
+        }
+
+
+        public bool DoesFit(string raw_data)
+        {
+            var cd = CallbackData.Deserialize(raw_data);
+
+            if (cd == null)
+                return false;
+
+            if (cd.Method != Method)
+                return false;
+
+            _lastValue = cd.Value;
+
+            _lastData = cd;
+
+            return true;
+        }
+
+
+        public async Task DoAction(UpdateResult ur, MessageResult mr) => await Action(_lastValue, _lastData, ur, mr);
+
+        public static CallbackData GetCallback(string method, string str) => new CallbackData(method, str);
+
+    }
+
+    public class StringAction<TForm> : IExternalAction
+        where TForm : FormBase
+    {
+        public string Method { get; set; }
+
+        CallbackData? _lastData { get; set; }
+
+        String? _lastValue { get; set; }
+
+        Func<String, CallbackData, UpdateResult, MessageResult, Task> Action;
+
+        public StringAction(string method, Func<String, CallbackData, UpdateResult, MessageResult, Task> action)
+        {
+            Method = method;
+            Action = action;
+        }
+
+        public bool DoesFit(string raw_data)
+        {
+            var cd = CallbackData.Deserialize(raw_data);
+
+            if (cd == null)
+                return false;
+
+            if (cd.Method != Method)
+                return false;
+
+            _lastValue = cd.Value;
+
+            _lastData = cd;
+
+            return true;
+        }
+
+
+        public async Task DoAction(UpdateResult ur, MessageResult mr) => await Action(_lastValue, _lastData, ur, mr);
+
+    }
+}

Experiments/ExternalActionManager/TelegramBotBase.Experiments/ActionManager/ExternalActionManager.cs

@@ -0,0 +1,46 @@
+using TelegramBotBase.Base;
+
+namespace TelegramBotBase.Experiments.ActionManager
+{
+    public partial class ExternalActionManager
+    {
+
+        List<IExternalAction> actions = new List<IExternalAction>();
+
+        public void Add(IExternalAction action)
+        {
+            actions.Add(action);
+        }
+
+        public async Task<bool> ManageCall(UpdateResult ur, MessageResult mr)
+        {
+
+            foreach (var action in actions)
+            {
+                if (!action.DoesFit(mr.RawData))
+                    continue;
+
+                await action.DoAction(ur, mr);
+
+                return true;
+            }
+
+
+            return false;
+        }
+
+        /// <summary>
+        /// Creates an instance of the ExternalActionManager for configuration.
+        /// </summary>
+        /// <param name="action"></param>
+        /// <returns></returns>
+        public static ExternalActionManager Configure(Action<ExternalActionManager> action)
+        {
+            var eam = new ExternalActionManager();
+
+            action(eam);
+
+            return eam;
+        }
+    }
+}

Experiments/ExternalActionManager/TelegramBotBase.Experiments/ActionManager/IExternalAction.cs

@@ -0,0 +1,13 @@
+using TelegramBotBase.Base;
+
+namespace TelegramBotBase.Experiments.ActionManager
+{
+
+    public interface IExternalAction
+    {
+        bool DoesFit(string raw_data);
+
+        Task DoAction(UpdateResult ur, MessageResult mr);
+    }
+
+}

Experiments/ExternalActionManager/TelegramBotBase.Experiments/ActionManager/Navigation/EndsWithNavigation.Extensions.cs

@@ -0,0 +1,63 @@
+using System.Linq.Expressions;
+using TelegramBotBase.Form;
+
+namespace TelegramBotBase.Experiments.ActionManager.Navigation
+{
+    public static class EndsWithNavigation_Extensions
+    {
+        public static void AddEndsWithNavigation<TForm>(this ExternalActionManager manager, string method, Expression<Func<TForm, string>> propertySelector)
+            where TForm : FormBase
+        {
+            if (!typeof(FormBase).IsAssignableFrom(typeof(TForm)))
+            {
+                throw new ArgumentException($"{nameof(TForm)} argument must be a {nameof(FormBase)} type");
+            }
+
+            var newValue = Expression.Parameter(propertySelector.Body.Type);
+
+            var assign = Expression.Lambda<Action<TForm, string>>(Expression.Assign(propertySelector.Body, newValue), propertySelector.Parameters[0], newValue);
+
+            var setter = assign.Compile(true);
+
+            manager.Add(new EndsWithNavigation<TForm>(method, setter));
+        }
+        public static void AddEndsWithNavigation<TForm>(this ExternalActionManager manager, string value, Action<TForm, string> setProperty)
+            where TForm : FormBase
+        {
+            if (!typeof(FormBase).IsAssignableFrom(typeof(TForm)))
+            {
+                throw new ArgumentException($"{nameof(TForm)} argument must be a {nameof(FormBase)} type");
+            }
+
+            manager.Add(new EndsWithNavigation<TForm>(value, setProperty));
+        }
+
+        public static void AddEndsWithNavigation(this ExternalActionManager manager, Type formType, string value, Expression<Func<FormBase, string>> propertySelector)
+        {
+            if (!typeof(FormBase).IsAssignableFrom(formType))
+            {
+                throw new ArgumentException($"{nameof(formType)} argument must be a {nameof(FormBase)} type");
+            }
+
+            var newValue = Expression.Parameter(propertySelector.Body.Type);
+
+            var assign = Expression.Lambda<Action<FormBase, string>>(Expression.Assign(propertySelector.Body, newValue), propertySelector.Parameters[0], newValue);
+
+            var setter = assign.Compile(true);
+
+            manager.Add(new EndsWithNavigation(formType, value, setter));
+        }
+
+        public static void AddEndsWithNavigation(this ExternalActionManager manager, Type formType, string value, Action<FormBase, string> setProperty)
+        {
+            if (!typeof(FormBase).IsAssignableFrom(formType))
+            {
+                throw new ArgumentException($"{nameof(formType)} argument must be a {nameof(FormBase)} type");
+            }
+
+            manager.Add(new EndsWithNavigation(formType, value, setProperty));
+        }
+
+    }
+
+}

Experiments/ExternalActionManager/TelegramBotBase.Experiments/ActionManager/Navigation/EndsWithNavigation.cs

@@ -0,0 +1,77 @@
+using TelegramBotBase.Base;
+using TelegramBotBase.Form;
+
+namespace TelegramBotBase.Experiments.ActionManager.Navigation
+{
+    public class EndsWithNavigation : IExternalAction
+    {
+        public Type FormType { get; }
+
+        public string Value { get; set; }
+
+        public Action<FormBase, string> SetProperty { get; set; }
+
+        public EndsWithNavigation(Type formType, string value, Action<FormBase, string> setProperty)
+        {
+            FormType = formType;
+            Value = value;
+            SetProperty = setProperty;
+        }
+
+
+        public bool DoesFit(string raw_data) => raw_data.EndsWith(Value);
+
+
+        public async Task DoAction(UpdateResult ur, MessageResult mr)
+        {
+            await mr.ConfirmAction();
+
+            var new_form = FormType.GetConstructor(new Type[] { })?.Invoke(new object[] { }) as FormBase;
+
+            if (mr.RawData != null)
+            {
+                SetProperty(new_form, mr.RawData);
+            }
+
+            await ur.Device.ActiveForm.NavigateTo(new_form);
+        }
+    }
+
+    public class EndsWithNavigation<TForm> : IExternalAction
+       where TForm : FormBase
+    {
+        public string Value { get; set; }
+
+        public Action<TForm, string> SetProperty { get; set; }
+
+        public EndsWithNavigation(string value, Action<TForm, string> setProperty)
+        {
+            Value = value;
+            SetProperty = setProperty;
+        }
+
+
+        public bool DoesFit(string raw_data) => raw_data.EndsWith(Value);
+
+
+        public async Task DoAction(UpdateResult ur, MessageResult mr)
+        {
+            await mr.ConfirmAction();
+
+            var type = typeof(TForm);
+
+            TForm new_form = type.GetConstructor(new Type[] { })?.Invoke(new object[] { }) as TForm;
+
+            if (mr.RawData != null)
+            {
+                SetProperty(new_form, mr.RawData);
+            }
+
+            await ur.Device.ActiveForm.NavigateTo(new_form);
+        }
+
+
+
+    }
+
+}

Experiments/ExternalActionManager/TelegramBotBase.Experiments/ActionManager/Navigation/GuidNavigation.Extensions.cs

@@ -0,0 +1,63 @@
+using System.Linq.Expressions;
+using TelegramBotBase.Form;
+
+namespace TelegramBotBase.Experiments.ActionManager.Navigation
+{
+    public static class GuidNavigation_Extensions
+    {
+
+        public static void AddGuidNavigation<TForm>(this ExternalActionManager manager, string method, Expression<Func<TForm, Guid>> propertySelector)
+            where TForm : FormBase
+        {
+            if (!typeof(FormBase).IsAssignableFrom(typeof(TForm)))
+            {
+                throw new ArgumentException($"{nameof(TForm)} argument must be a {nameof(FormBase)} type");
+            }
+
+            var newValue = Expression.Parameter(propertySelector.Body.Type);
+
+            var assign = Expression.Lambda<Action<TForm, Guid>>(Expression.Assign(propertySelector.Body, newValue), propertySelector.Parameters[0], newValue);
+
+            var setter = assign.Compile(true);
+
+            manager.Add(new GuidNavigation<TForm>(method, setter));
+        }
+
+        public static void AddGuidNavigation<TForm>(this ExternalActionManager manager, string method, Action<TForm, Guid> action)
+            where TForm : FormBase
+        {
+            if (!typeof(FormBase).IsAssignableFrom(typeof(TForm)))
+            {
+                throw new ArgumentException($"{nameof(TForm)} argument must be a {nameof(FormBase)} type");
+            }
+
+            manager.Add(new GuidNavigation<TForm>(method, action));
+        }
+
+        public static void AddGuidNavigation(this ExternalActionManager manager, Type formType, string value, Expression<Func<FormBase, Guid>> propertySelector)
+        {
+            if (!typeof(FormBase).IsAssignableFrom(formType))
+            {
+                throw new ArgumentException($"{nameof(formType)} argument must be a {nameof(FormBase)} type");
+            }
+
+            var newValue = Expression.Parameter(propertySelector.Body.Type);
+
+            var assign = Expression.Lambda<Action<FormBase, Guid>>(Expression.Assign(propertySelector.Body, newValue), propertySelector.Parameters[0], newValue);
+
+            var setter = assign.Compile(true);
+
+            manager.Add(new GuidNavigation(formType, value, setter));
+        }
+
+        public static void AddGuidNavigation(this ExternalActionManager manager, Type formType, string method, Action<FormBase, Guid> action)
+        {
+            if (!typeof(FormBase).IsAssignableFrom(formType))
+            {
+                throw new ArgumentException($"{nameof(formType)} argument must be a {nameof(FormBase)} type");
+            }
+
+            manager.Add(new GuidNavigation(formType, method, action));
+        }
+    }
+}

Experiments/ExternalActionManager/TelegramBotBase.Experiments/ActionManager/Navigation/GuidNavigation.cs

@@ -0,0 +1,106 @@
+using TelegramBotBase.Base;
+using TelegramBotBase.Form;
+
+namespace TelegramBotBase.Experiments.ActionManager.Navigation
+{
+    public class GuidNavigation : IExternalAction
+    {
+        public Type FormType { get; }
+
+        public string Method { get; set; }
+
+        public Action<FormBase, Guid> SetProperty { get; set; }
+
+        Guid? _lastValue { get; set; }
+
+        public GuidNavigation(Type formType, string method, Action<FormBase, Guid> setProperty)
+        {
+            FormType = formType;
+            Method = method;
+            SetProperty = setProperty;
+        }
+
+        public bool DoesFit(string raw_action)
+        {
+            var cd = CallbackData.Deserialize(raw_action);
+
+            if (cd == null)
+                return false;
+
+            if (cd.Method != Method)
+                return false;
+
+            Guid g;
+
+            if (Guid.TryParse(cd.Value, out g))
+                _lastValue = g;
+
+            return true;
+        }
+
+
+        public async Task DoAction(UpdateResult ur, MessageResult mr)
+        {
+            await mr.ConfirmAction();
+
+            var new_form = FormType.GetConstructor(new Type[] { })?.Invoke(new object[] { }) as FormBase;
+
+            if (_lastValue != null)
+                SetProperty(new_form, _lastValue.Value);
+
+            await ur.Device.ActiveForm.NavigateTo(new_form);
+        }
+
+
+        public static CallbackData GetCallback(string method, Guid guid) => new CallbackData(method, guid.ToString());
+    }
+
+    public class GuidNavigation<TForm> : IExternalAction
+        where TForm : FormBase
+    {
+        public string Method { get; set; }
+
+        public Action<TForm, Guid> SetProperty { get; set; }
+
+        Guid? _lastValue { get; set; }
+
+        public GuidNavigation(string method, Action<TForm, Guid> setProperty)
+        {
+            Method = method;
+            SetProperty = setProperty;
+        }
+
+        public bool DoesFit(string raw_data)
+        {
+            var cd = CallbackData.Deserialize(raw_data);
+
+            if (cd == null)
+                return false;
+
+            if (cd.Method != Method)
+                return false;
+
+            Guid g;
+
+            if (Guid.TryParse(cd.Value, out g))
+                _lastValue = g;
+
+            return true;
+        }
+
+
+        public async Task DoAction(UpdateResult ur, MessageResult mr)
+        {
+            await mr.ConfirmAction();
+
+            var type = typeof(TForm);
+
+            TForm new_form = type.GetConstructor(new Type[] { })?.Invoke(new object[] { }) as TForm;
+
+            if (_lastValue != null)
+                SetProperty(new_form, _lastValue.Value);
+
+            await ur.Device.ActiveForm.NavigateTo(new_form);
+        }
+    }
+}

Experiments/ExternalActionManager/TelegramBotBase.Experiments/ActionManager/Navigation/Int32Navigation.Extensions.cs

@@ -0,0 +1,63 @@
+using System.Linq.Expressions;
+using TelegramBotBase.Form;
+
+namespace TelegramBotBase.Experiments.ActionManager.Navigation
+{
+    public static class Int32Navigation_Extensions
+    {
+
+        public static void AddInt32Navigation<TForm>(this ExternalActionManager manager, string method, Expression<Func<TForm, int>> propertySelector)
+            where TForm : FormBase
+        {
+            if (!typeof(FormBase).IsAssignableFrom(typeof(TForm)))
+            {
+                throw new ArgumentException($"{nameof(TForm)} argument must be a {nameof(FormBase)} type");
+            }
+
+            var newValue = Expression.Parameter(propertySelector.Body.Type);
+
+            var assign = Expression.Lambda<Action<TForm, int>>(Expression.Assign(propertySelector.Body, newValue), propertySelector.Parameters[0], newValue);
+
+            var setter = assign.Compile(true);
+
+            manager.Add(new Int32Navigation<TForm>(method, setter));
+        }
+
+        public static void AddInt32Navigation<TForm>(this ExternalActionManager manager, string method, Action<TForm, int> action)
+            where TForm : FormBase
+        {
+            if (!typeof(FormBase).IsAssignableFrom(typeof(TForm)))
+            {
+                throw new ArgumentException($"{nameof(TForm)} argument must be a {nameof(FormBase)} type");
+            }
+
+            manager.Add(new Int32Navigation<TForm>(method, action));
+        }
+
+        public static void AddInt32Navigation(this ExternalActionManager manager, Type formType, string value, Expression<Func<FormBase, int>> propertySelector)
+        {
+            if (!typeof(FormBase).IsAssignableFrom(formType))
+            {
+                throw new ArgumentException($"{nameof(formType)} argument must be a {nameof(FormBase)} type");
+            }
+
+            var newValue = Expression.Parameter(propertySelector.Body.Type);
+
+            var assign = Expression.Lambda<Action<FormBase, int>>(Expression.Assign(propertySelector.Body, newValue), propertySelector.Parameters[0], newValue);
+
+            var setter = assign.Compile(true);
+
+            manager.Add(new Int32Navigation(formType, value, setter));
+        }
+
+        public static void AddInt32Navigation(this ExternalActionManager manager, Type formType, string method, Action<FormBase, int> action)
+        {
+            if (!typeof(FormBase).IsAssignableFrom(formType))
+            {
+                throw new ArgumentException($"{nameof(formType)} argument must be a {nameof(FormBase)} type");
+            }
+
+            manager.Add(new Int32Navigation(formType, method, action));
+        }
+    }
+}

Experiments/ExternalActionManager/TelegramBotBase.Experiments/ActionManager/Navigation/Int32Navigation.cs

@@ -0,0 +1,106 @@
+using TelegramBotBase.Base;
+using TelegramBotBase.Form;
+
+namespace TelegramBotBase.Experiments.ActionManager.Navigation
+{
+    public class Int32Navigation : IExternalAction
+    {
+        public Type FormType { get; }
+
+        public string Method { get; set; }
+
+        public Action<FormBase, int> SetProperty { get; set; }
+
+        int? _lastValue { get; set; }
+
+        public Int32Navigation(Type formType, string method, Action<FormBase, int> setProperty)
+        {
+            FormType = formType;
+            Method = method;
+            SetProperty = setProperty;
+        }
+
+        public bool DoesFit(string raw_action)
+        {
+            var cd = CallbackData.Deserialize(raw_action);
+
+            if (cd == null)
+                return false;
+
+            if (cd.Method != Method)
+                return false;
+
+            int i;
+
+            if (int.TryParse(cd.Value, out i))
+                _lastValue = i;
+
+            return true;
+        }
+
+
+        public async Task DoAction(UpdateResult ur, MessageResult mr)
+        {
+            await mr.ConfirmAction();
+
+            var new_form = FormType.GetConstructor(new Type[] { })?.Invoke(new object[] { }) as FormBase;
+
+            if (_lastValue != null)
+                SetProperty(new_form, _lastValue.Value);
+
+            await ur.Device.ActiveForm.NavigateTo(new_form);
+        }
+
+
+        public static CallbackData GetCallback(string method, int i) => new CallbackData(method, i.ToString());
+    }
+
+    public class Int32Navigation<TForm> : IExternalAction
+        where TForm : FormBase
+    {
+        public string Method { get; set; }
+
+        public Action<TForm, int> SetProperty { get; set; }
+
+        int? _lastValue { get; set; }
+
+        public Int32Navigation(string method, Action<TForm, int> setProperty)
+        {
+            Method = method;
+            SetProperty = setProperty;
+        }
+
+        public bool DoesFit(string raw_data)
+        {
+            var cd = CallbackData.Deserialize(raw_data);
+
+            if (cd == null)
+                return false;
+
+            if (cd.Method != Method)
+                return false;
+
+            int g;
+
+            if (int.TryParse(cd.Value, out g))
+                _lastValue = g;
+
+            return true;
+        }
+
+
+        public async Task DoAction(UpdateResult ur, MessageResult mr)
+        {
+            await mr.ConfirmAction();
+
+            var type = typeof(TForm);
+
+            TForm new_form = type.GetConstructor(new Type[] { })?.Invoke(new object[] { }) as TForm;
+
+            if (_lastValue != null)
+                SetProperty(new_form, _lastValue.Value);
+
+            await ur.Device.ActiveForm.NavigateTo(new_form);
+        }
+    }
+}

Experiments/ExternalActionManager/TelegramBotBase.Experiments/ActionManager/Navigation/Int64Navigation.Extensions.cs

@@ -0,0 +1,63 @@
+using System.Linq.Expressions;
+using TelegramBotBase.Form;
+
+namespace TelegramBotBase.Experiments.ActionManager.Navigation
+{
+    public static class Int64Navigation_Extensions
+    {
+
+        public static void AddInt64Navigation<TForm>(this ExternalActionManager manager, string method, Expression<Func<TForm, long>> propertySelector)
+            where TForm : FormBase
+        {
+            if (!typeof(FormBase).IsAssignableFrom(typeof(TForm)))
+            {
+                throw new ArgumentException($"{nameof(TForm)} argument must be a {nameof(FormBase)} type");
+            }
+
+            var newValue = Expression.Parameter(propertySelector.Body.Type);
+
+            var assign = Expression.Lambda<Action<TForm, long>>(Expression.Assign(propertySelector.Body, newValue), propertySelector.Parameters[0], newValue);
+
+            var setter = assign.Compile(true);
+
+            manager.Add(new Int64Navigation<TForm>(method, setter));
+        }
+
+        public static void AddInt64Navigation<TForm>(this ExternalActionManager manager, string method, Action<TForm, long> action)
+            where TForm : FormBase
+        {
+            if (!typeof(FormBase).IsAssignableFrom(typeof(TForm)))
+            {
+                throw new ArgumentException($"{nameof(TForm)} argument must be a {nameof(FormBase)} type");
+            }
+
+            manager.Add(new Int64Navigation<TForm>(method, action));
+        }
+
+        public static void AddInt64Navigation(this ExternalActionManager manager, Type formType, string value, Expression<Func<FormBase, long>> propertySelector)
+        {
+            if (!typeof(FormBase).IsAssignableFrom(formType))
+            {
+                throw new ArgumentException($"{nameof(formType)} argument must be a {nameof(FormBase)} type");
+            }
+
+            var newValue = Expression.Parameter(propertySelector.Body.Type);
+
+            var assign = Expression.Lambda<Action<FormBase, long>>(Expression.Assign(propertySelector.Body, newValue), propertySelector.Parameters[0], newValue);
+
+            var setter = assign.Compile(true);
+
+            manager.Add(new Int64Navigation(formType, value, setter));
+        }
+
+        public static void AddInt64Navigation(this ExternalActionManager manager, Type formType, string method, Action<FormBase, long> action)
+        {
+            if (!typeof(FormBase).IsAssignableFrom(formType))
+            {
+                throw new ArgumentException($"{nameof(formType)} argument must be a {nameof(FormBase)} type");
+            }
+
+            manager.Add(new Int64Navigation(formType, method, action));
+        }
+    }
+}

Experiments/ExternalActionManager/TelegramBotBase.Experiments/ActionManager/Navigation/Int64Navigation.cs

@@ -0,0 +1,106 @@
+using TelegramBotBase.Base;
+using TelegramBotBase.Form;
+
+namespace TelegramBotBase.Experiments.ActionManager.Navigation
+{
+    public class Int64Navigation : IExternalAction
+    {
+        public Type FormType { get; }
+
+        public string Method { get; set; }
+
+        public Action<FormBase, long> SetProperty { get; set; }
+
+        long? _lastValue { get; set; }
+
+        public Int64Navigation(Type formType, string method, Action<FormBase, long> setProperty)
+        {
+            FormType = formType;
+            Method = method;
+            SetProperty = setProperty;
+        }
+
+        public bool DoesFit(string raw_action)
+        {
+            var cd = CallbackData.Deserialize(raw_action);
+
+            if (cd == null)
+                return false;
+
+            if (cd.Method != Method)
+                return false;
+
+            long l;
+
+            if (long.TryParse(cd.Value, out l))
+                _lastValue = l;
+
+            return true;
+        }
+
+
+        public async Task DoAction(UpdateResult ur, MessageResult mr)
+        {
+            await mr.ConfirmAction();
+
+            var new_form = FormType.GetConstructor(new Type[] { })?.Invoke(new object[] { }) as FormBase;
+
+            if (_lastValue != null)
+                SetProperty(new_form, _lastValue.Value);
+
+            await ur.Device.ActiveForm.NavigateTo(new_form);
+        }
+
+
+        public static CallbackData GetCallback(string method, long l) => new CallbackData(method, l.ToString());
+    }
+
+    public class Int64Navigation<TForm> : IExternalAction
+        where TForm : FormBase
+    {
+        public string Method { get; set; }
+
+        public Action<TForm, long> SetProperty { get; set; }
+
+        long? _lastValue { get; set; }
+
+        public Int64Navigation(string method, Action<TForm, long> setProperty)
+        {
+            Method = method;
+            SetProperty = setProperty;
+        }
+
+        public bool DoesFit(string raw_data)
+        {
+            var cd = CallbackData.Deserialize(raw_data);
+
+            if (cd == null)
+                return false;
+
+            if (cd.Method != Method)
+                return false;
+
+            long l;
+
+            if (long.TryParse(cd.Value, out l))
+                _lastValue = l;
+
+            return true;
+        }
+
+
+        public async Task DoAction(UpdateResult ur, MessageResult mr)
+        {
+            await mr.ConfirmAction();
+
+            var type = typeof(TForm);
+
+            TForm new_form = type.GetConstructor(new Type[] { })?.Invoke(new object[] { }) as TForm;
+
+            if (_lastValue != null)
+                SetProperty(new_form, _lastValue.Value);
+
+            await ur.Device.ActiveForm.NavigateTo(new_form);
+        }
+    }
+}

Experiments/ExternalActionManager/TelegramBotBase.Experiments/ActionManager/Navigation/StartWithNavigation.Extensions.cs

@@ -0,0 +1,63 @@
+using System.Linq.Expressions;
+using TelegramBotBase.Form;
+
+namespace TelegramBotBase.Experiments.ActionManager.Navigation
+{
+    public static class StartWithNavigation_Extensions
+    {
+        public static void AddStartsWithNavigation<TForm>(this ExternalActionManager manager, string method, Expression<Func<TForm, string>> propertySelector)
+            where TForm : FormBase
+        {
+            if (!typeof(FormBase).IsAssignableFrom(typeof(TForm)))
+            {
+                throw new ArgumentException($"{nameof(TForm)} argument must be a {nameof(FormBase)} type");
+            }
+
+            var newValue = Expression.Parameter(propertySelector.Body.Type);
+
+            var assign = Expression.Lambda<Action<TForm, string>>(Expression.Assign(propertySelector.Body, newValue), propertySelector.Parameters[0], newValue);
+
+            var setter = assign.Compile(true);
+
+            manager.Add(new StartWithNavigation<TForm>(method, setter));
+        }
+        public static void AddStartsWithNavigation<TForm>(this ExternalActionManager manager, string value, Action<TForm, string> setProperty)
+            where TForm : FormBase
+        {
+            if (!typeof(FormBase).IsAssignableFrom(typeof(TForm)))
+            {
+                throw new ArgumentException($"{nameof(TForm)} argument must be a {nameof(FormBase)} type");
+            }
+
+            manager.Add(new StartWithNavigation<TForm>(value, setProperty));
+        }
+
+        public static void AddStartsWithNavigation(this ExternalActionManager manager, Type formType, string value, Expression<Func<FormBase, string>> propertySelector)
+        {
+            if (!typeof(FormBase).IsAssignableFrom(formType))
+            {
+                throw new ArgumentException($"{nameof(formType)} argument must be a {nameof(FormBase)} type");
+            }
+
+            var newValue = Expression.Parameter(propertySelector.Body.Type);
+
+            var assign = Expression.Lambda<Action<FormBase, string>>(Expression.Assign(propertySelector.Body, newValue), propertySelector.Parameters[0], newValue);
+
+            var setter = assign.Compile(true);
+
+            manager.Add(new StartWithNavigation(formType, value, setter));
+        }
+
+        public static void AddStartsWithNavigation(this ExternalActionManager manager, Type formType, string value, Action<FormBase, string> setProperty)
+        {
+            if (!typeof(FormBase).IsAssignableFrom(formType))
+            {
+                throw new ArgumentException($"{nameof(formType)} argument must be a {nameof(FormBase)} type");
+            }
+
+            manager.Add(new StartWithNavigation(formType, value, setProperty));
+        }
+
+    }
+
+}

Experiments/ExternalActionManager/TelegramBotBase.Experiments/ActionManager/Navigation/StartWithNavigation.cs

@@ -0,0 +1,74 @@
+using TelegramBotBase.Base;
+using TelegramBotBase.Form;
+
+namespace TelegramBotBase.Experiments.ActionManager.Navigation
+{
+    public class StartWithNavigation : IExternalAction
+    {
+        public Type FormType { get; }
+
+        public string Value { get; set; }
+
+        public Action<FormBase, string> SetProperty { get; set; }
+
+
+        public StartWithNavigation(Type formType, string value, Action<FormBase, string> setProperty)
+        {
+            FormType = formType;
+            Value = value;
+            SetProperty = setProperty;
+        }
+
+        public bool DoesFit(string raw_data) => raw_data.StartsWith(Value);
+
+        public async Task DoAction(UpdateResult ur, MessageResult mr)
+        {
+            await mr.ConfirmAction();
+
+            var new_form = FormType.GetConstructor(new Type[] { })?.Invoke(new object[] { }) as FormBase;
+
+            if (mr.RawData != null)
+            {
+                SetProperty(new_form, mr.RawData);
+            }
+
+            await ur.Device.ActiveForm.NavigateTo(new_form);
+        }
+    }
+
+    public class StartWithNavigation<TForm> : IExternalAction
+       where TForm : FormBase
+    {
+        public string Value { get; set; }
+
+        public Action<TForm, string> SetProperty { get; set; }
+
+        public StartWithNavigation(string value, Action<TForm, string> setProperty)
+        {
+            Value = value;
+            SetProperty = setProperty;
+        }
+
+
+        public bool DoesFit(string raw_data) => raw_data.StartsWith(Value);
+
+
+        public async Task DoAction(UpdateResult ur, MessageResult mr)
+        {
+            await mr.ConfirmAction();
+
+            var type = typeof(TForm);
+
+            TForm new_form = type.GetConstructor(new Type[] { })?.Invoke(new object[] { }) as TForm;
+
+            if (mr.RawData != null)
+            {
+                SetProperty(new_form, mr.RawData);
+            }
+
+            await ur.Device.ActiveForm.NavigateTo(new_form);
+        }
+
+    }
+
+}

Experiments/ExternalActionManager/TelegramBotBase.Experiments/ActionManager/Navigation/StringNavigation.Extensions.cs

@@ -0,0 +1,63 @@
+using System.Linq.Expressions;
+using TelegramBotBase.Form;
+
+namespace TelegramBotBase.Experiments.ActionManager.Navigation
+{
+    public static class StringNavigation_Extensions
+    {
+
+        public static void AddStringNavigation<TForm>(this ExternalActionManager manager, string method, Expression<Func<TForm, String>> propertySelector)
+            where TForm : FormBase
+        {
+            if (!typeof(FormBase).IsAssignableFrom(typeof(TForm)))
+            {
+                throw new ArgumentException($"{nameof(TForm)} argument must be a {nameof(FormBase)} type");
+            }
+
+            var newValue = Expression.Parameter(propertySelector.Body.Type);
+
+            var assign = Expression.Lambda<Action<TForm, String>>(Expression.Assign(propertySelector.Body, newValue), propertySelector.Parameters[0], newValue);
+
+            var setter = assign.Compile(true);
+
+            manager.Add(new StringNavigation<TForm>(method, setter));
+        }
+
+        public static void AddStringNavigation<TForm>(this ExternalActionManager manager, string method, Action<TForm, String> action)
+            where TForm : FormBase
+        {
+            if (!typeof(FormBase).IsAssignableFrom(typeof(TForm)))
+            {
+                throw new ArgumentException($"{nameof(TForm)} argument must be a {nameof(FormBase)} type");
+            }
+
+            manager.Add(new StringNavigation<TForm>(method, action));
+        }
+
+        public static void AddStringNavigation(this ExternalActionManager manager, Type formType, string value, Expression<Func<FormBase, String>> propertySelector)
+        {
+            if (!typeof(FormBase).IsAssignableFrom(formType))
+            {
+                throw new ArgumentException($"{nameof(formType)} argument must be a {nameof(FormBase)} type");
+            }
+
+            var newValue = Expression.Parameter(propertySelector.Body.Type);
+
+            var assign = Expression.Lambda<Action<FormBase, String>>(Expression.Assign(propertySelector.Body, newValue), propertySelector.Parameters[0], newValue);
+
+            var setter = assign.Compile(true);
+
+            manager.Add(new StringNavigation(formType, value, setter));
+        }
+
+        public static void AddStringNavigation(this ExternalActionManager manager, Type formType, string method, Action<FormBase, String> action)
+        {
+            if (!typeof(FormBase).IsAssignableFrom(formType))
+            {
+                throw new ArgumentException($"{nameof(formType)} argument must be a {nameof(FormBase)} type");
+            }
+
+            manager.Add(new StringNavigation(formType, method, action));
+        }
+    }
+}

Experiments/ExternalActionManager/TelegramBotBase.Experiments/ActionManager/Navigation/StringNavigation.cs

@@ -0,0 +1,100 @@
+using TelegramBotBase.Base;
+using TelegramBotBase.Form;
+
+namespace TelegramBotBase.Experiments.ActionManager.Navigation
+{
+    public class StringNavigation : IExternalAction
+    {
+        public Type FormType { get; }
+
+        public string Method { get; set; }
+
+        public Action<FormBase, String> SetProperty { get; set; }
+
+        String? _lastValue { get; set; }
+
+        public StringNavigation(Type formType, string method, Action<FormBase, String> setProperty)
+        {
+            FormType = formType;
+            Method = method;
+            SetProperty = setProperty;
+        }
+
+        public bool DoesFit(string raw_action)
+        {
+            var cd = CallbackData.Deserialize(raw_action);
+
+            if (cd == null)
+                return false;
+
+            if (cd.Method != Method)
+                return false;
+
+            _lastValue = cd.Value;
+
+            return true;
+        }
+
+
+        public async Task DoAction(UpdateResult ur, MessageResult mr)
+        {
+            await mr.ConfirmAction();
+
+            var new_form = FormType.GetConstructor(new Type[] { })?.Invoke(new object[] { }) as FormBase;
+
+            if (_lastValue != null)
+                SetProperty(new_form, _lastValue);
+
+            await ur.Device.ActiveForm.NavigateTo(new_form);
+        }
+
+
+        public static CallbackData GetCallback(string method, String str) => new CallbackData(method, str);
+    }
+
+    public class StringNavigation<TForm> : IExternalAction
+        where TForm : FormBase
+    {
+        public string Method { get; set; }
+
+        public Action<TForm, String> SetProperty { get; set; }
+
+        String? _lastValue { get; set; }
+
+        public StringNavigation(string method, Action<TForm, String> setProperty)
+        {
+            Method = method;
+            SetProperty = setProperty;
+        }
+
+        public bool DoesFit(string raw_data)
+        {
+            var cd = CallbackData.Deserialize(raw_data);
+
+            if (cd == null)
+                return false;
+
+            if (cd.Method != Method)
+                return false;
+
+            _lastValue = cd.Value;
+
+            return true;
+        }
+
+
+        public async Task DoAction(UpdateResult ur, MessageResult mr)
+        {
+            await mr.ConfirmAction();
+
+            var type = typeof(TForm);
+
+            TForm new_form = type.GetConstructor(new Type[] { })?.Invoke(new object[] { }) as TForm;
+
+            if (_lastValue != null)
+                SetProperty(new_form, _lastValue);
+
+            await ur.Device.ActiveForm.NavigateTo(new_form);
+        }
+    }
+}

Experiments/ExternalActionManager/TelegramBotBase.Experiments/CustomFormBaseMessageLoop.cs

@@ -0,0 +1,146 @@
+using System.ComponentModel;
+using Telegram.Bot.Types.Enums;
+using TelegramBotBase;
+using TelegramBotBase.Args;
+using TelegramBotBase.Base;
+using TelegramBotBase.Interfaces;
+using TelegramBotBase.Sessions;
+
+namespace TelegramBotBase.Experiments.ActionManager
+{
+    public class CustomFormBaseMessageLoop : IMessageLoopFactory
+    {
+        private static readonly object EvUnhandledCall = new();
+
+        private readonly EventHandlerList _events = new();
+
+        public ExternalActionManager ExternalActionManager { get; set; }
+
+        public async Task MessageLoop(BotBase bot, DeviceSession s, UpdateResult ur, MessageResult mr)
+        {
+            var update = ur.RawData;
+
+            if (update.Type != UpdateType.Message
+                && update.Type != UpdateType.EditedMessage
+                && update.Type != UpdateType.CallbackQuery)
+            {
+                return;
+            }
+
+            //Remove unecessary parameter from method call in the future
+            var session = ur.Device;
+
+            //Is this a bot command ?
+            if (mr.IsFirstHandler && mr.IsBotCommand && bot.IsKnownBotCommand(mr.BotCommand))
+            {
+                var sce = new BotCommandEventArgs(mr.BotCommand, mr.BotCommandParameters, mr.Message, session.DeviceId,
+                                                  session);
+                await bot.OnBotCommand(sce);
+
+                if (sce.Handled)
+                {
+                    return;
+                }
+            }
+
+            mr.Device = session;
+            ur.Device = session;
+
+            var activeForm = session.ActiveForm;
+
+            //Pre Loading Event
+            await activeForm.PreLoad(mr);
+
+            //Send Load event to controls
+            await activeForm.LoadControls(mr);
+
+            //Loading Event
+            await activeForm.Load(mr);
+
+
+            //Is Attachment ? (Photo, Audio, Video, Contact, Location, Document) (Ignore Callback Queries)
+            if (update.Type == UpdateType.Message)
+            {
+                if ((mr.MessageType == MessageType.Contact)
+                    | (mr.MessageType == MessageType.Document)
+                    | (mr.MessageType == MessageType.Location)
+                    | (mr.MessageType == MessageType.Photo)
+                    | (mr.MessageType == MessageType.Video)
+                    | (mr.MessageType == MessageType.Audio))
+                {
+                    await activeForm.SentData(new DataResult(ur));
+                }
+            }
+
+            //Message edited ?
+            if (update.Type == UpdateType.EditedMessage)
+            {
+                await activeForm.Edited(mr);
+            }
+
+            //Action Event
+            if (!session.FormSwitched && mr.IsAction)
+            {
+                //Send Action event to controls
+                await activeForm.ActionControls(mr);
+
+                //Send Action event to form itself
+                await activeForm.Action(mr);
+
+                if (!mr.Handled)
+                {
+                    var handled = await ExternalActionManager?.ManageCall(ur, mr);
+
+                    if (handled)
+                    {
+                        mr.Handled = true;
+                        if (!session.FormSwitched)
+                        {
+                            return;
+                        }
+                    }
+                    else
+                    {
+                        var uhc = new UnhandledCallEventArgs(ur.Message.Text, mr.RawData, session.DeviceId, mr.MessageId, ur.Message, session);
+
+                        OnUnhandledCall(uhc);
+
+                        if (uhc.Handled)
+                        {
+                            mr.Handled = true;
+                            if (!session.FormSwitched)
+                            {
+                                return;
+                            }
+                        }
+                    }
+
+                }
+            }
+
+            if (!session.FormSwitched)
+            {
+                //Render Event
+                await activeForm.RenderControls(mr);
+
+                await activeForm.Render(mr);
+            }
+        }
+
+        /// <summary>
+        ///     Will be called if no form handled this call
+        /// </summary>
+        public event EventHandler<UnhandledCallEventArgs> UnhandledCall
+        {
+            add => _events.AddHandler(EvUnhandledCall, value);
+            remove => _events.RemoveHandler(EvUnhandledCall, value);
+        }
+
+        public void OnUnhandledCall(UnhandledCallEventArgs e)
+        {
+            (_events[EvUnhandledCall] as EventHandler<UnhandledCallEventArgs>)?.Invoke(this, e);
+        }
+
+
+    }
+}

Experiments/ExternalActionManager/TelegramBotBase.Experiments/StaticExtensions.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TelegramBotBase.Builder.Interfaces;
+using TelegramBotBase.Interfaces;
+
+namespace TelegramBotBase.Experiments.ActionManager
+{
+    public static class StaticExtensions
+    {
+        public static IStartFormSelectionStage ActionMessageLoop(this IMessageLoopSelectionStage loopSelection, ExternalActionManager managerInstance)
+        {
+            var cfb = new CustomFormBaseMessageLoop();
+
+            cfb.ExternalActionManager = managerInstance;
+            
+            return loopSelection.CustomMessageLoop(cfb);
+        }
+
+
+
+
+    }
+}

Experiments/ExternalActionManager/TelegramBotBase.Experiments/TelegramBotBase.Experiments.ActionManager.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net7.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\TelegramBotBase\TelegramBotBase.csproj" />
+  </ItemGroup>
+
+</Project>

README.md

@@ -1,3 +1,24 @@
+# Development Lab
+
+Attention: This is a lab for **experimental features**.  Here we can try out different ideas and scenarios if they will work and what can be improved.
+There is no guarantee that any of these ideas comes in the main project. 
+
+Please try everything on your own. Nothing can work, so everything can as well.
+
+You will find all experiments within the ["Experiments"](Experiments) sub folder.
+
+For feedback please join our Telegram group.
+
+**Support group: [@tgbotbase](https://t.me/tgbotbase)**
+
+## current experiments
+
+- [ExternalActionManager](Experiments/ExternalActionManager/DemoBot) => Manager for unhandled actions from "outside"
+
+
+---
+
+
 # .NET Telegram Bot Framework - Context based addon
 
 [![NuGet version (TelegramBotBase)](https://img.shields.io/nuget/vpre/TelegramBotBase.svg?style=flat-square)](https://www.nuget.org/packages/TelegramBotBase/)

TelegramBotBase/BotBase.cs

@@ -115,12 +115,13 @@ public sealed class BotBase
             if (ds == null)
             {
                 ds = await Sessions.StartSession(e.DeviceId);
-                e.Device = ds;
                 ds.LastMessage = e.RawData.Message;
 
-                OnSessionBegins(new SessionBeginEventArgs(e.DeviceId, ds));
+                OnSessionBegins(new SessionBeginEventArgs(e.DeviceId, ds)); 
             }
 
+            e.Device = ds;
+
             var mr = new MessageResult(e.RawData);
 
             var i = 0;
@@ -210,6 +211,7 @@ public sealed class BotBase
         try
         {
             var ds = Sessions.GetSession(deviceId);
+
             e.Device = ds;
 
             await MessageLoopFactory.MessageLoop(this, ds, new UpdateResult(e.UpdateData, ds), e);

TelegramBotBase/Constants/Telegram.cs

@@ -16,4 +16,9 @@ public static class Telegram
     public const int MaxReplyKeyboardCols = 12;
 
     public const int MessageDeletionsPerSecond = 30;
+
+    /// <summary>
+    /// The maximum length of callback data. Will raise an exception of it exceeds it.
+    /// </summary>
+    public const int MaxCallBackDataBytes = 64;
 }

TelegramBotBase/Exceptions/CallbackDataTooLongException.cs

@@ -0,0 +1,21 @@
+using System;
+using Telegram.Bot.Exceptions;
+
+namespace TelegramBotBase.Exceptions;
+
+public sealed class CallbackDataTooLongException : Exception
+{
+    //public override string Message =>
+    //    $"You have exceeded the maximum {Constants.Telegram.MaxCallBackDataBytes} bytes.";
+
+    static ApiRequestException _innerException = new Telegram.Bot.Exceptions.ApiRequestException("Bad Request: BUTTON_DATA_INVALID", 400);
+
+    static String _message = $"You have exceeded the maximum {Constants.Telegram.MaxCallBackDataBytes} bytes of callback data.\r\nThis is a pre-sending message from the TelegramBotBase framework.\r\nread more: https://core.telegram.org/bots/api#inlinekeyboardbutton";
+
+    public CallbackDataTooLongException() : base(_message, _innerException)
+    {
+
+    }
+
+
+}

TelegramBotBase/Form/CallbackData.cs

@@ -1,4 +1,6 @@
 using Newtonsoft.Json;
+using System.Text;
+using TelegramBotBase.Exceptions;
 
 namespace TelegramBotBase.Form;
 
@@ -30,7 +32,7 @@ public class CallbackData
     ///     Serializes data to json string
     /// </summary>
     /// <returns></returns>
-    public string Serialize()
+    public string Serialize(bool throwExceptionOnOverflow = false)
     {
         var s = "";
         try
@@ -41,6 +43,16 @@ public class CallbackData
         {
         }
 
+#if DEBUG
+
+        //Data is over 64 bytes
+        if(throwExceptionOnOverflow && Encoding.UTF8.GetByteCount(s) > Constants.Telegram.MaxCallBackDataBytes)
+        {
+            throw new CallbackDataTooLongException();
+        }
+
+#endif
+
         return s;
     }
 
@@ -65,5 +77,5 @@ public class CallbackData
         return null;
     }
 
-    public static implicit operator string(CallbackData callbackData) => callbackData.Serialize();
+    public static implicit operator string(CallbackData callbackData) => callbackData.Serialize(true);
 }

TelegramBotFramework.sln

@@ -36,6 +36,14 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DependencyInjection", "Exam
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TelegramBotBase.Extensions.Images.IronSoftware", "TelegramBotBase.Extensions.Images.IronSoftware\TelegramBotBase.Extensions.Images.IronSoftware.csproj", "{DC521A4C-7446-46F7-845B-AAF10EDCF8C6}"
 EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Experiments", "Experiments", "{2E1FF127-4DC2-40A1-849C-ED1432204E8A}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DemoBot", "Experiments\ExternalActionManager\DemoBot\DemoBot.csproj", "{5184D3F8-8526-413D-8EB0-23636EA7A4EF}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TelegramBotBase.Experiments.ActionManager", "Experiments\ExternalActionManager\TelegramBotBase.Experiments\TelegramBotBase.Experiments.ActionManager.csproj", "{625F84FE-6809-4CA4-9C58-3453382D1C65}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "ExternalActionManager", "ExternalActionManager", "{359F7D60-362C-4F42-9606-A138FB1293E9}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -90,6 +98,14 @@ Global
 		{DC521A4C-7446-46F7-845B-AAF10EDCF8C6}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{DC521A4C-7446-46F7-845B-AAF10EDCF8C6}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{DC521A4C-7446-46F7-845B-AAF10EDCF8C6}.Release|Any CPU.Build.0 = Release|Any CPU
+		{5184D3F8-8526-413D-8EB0-23636EA7A4EF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{5184D3F8-8526-413D-8EB0-23636EA7A4EF}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{5184D3F8-8526-413D-8EB0-23636EA7A4EF}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{5184D3F8-8526-413D-8EB0-23636EA7A4EF}.Release|Any CPU.Build.0 = Release|Any CPU
+		{625F84FE-6809-4CA4-9C58-3453382D1C65}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{625F84FE-6809-4CA4-9C58-3453382D1C65}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{625F84FE-6809-4CA4-9C58-3453382D1C65}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{625F84FE-6809-4CA4-9C58-3453382D1C65}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -105,6 +121,9 @@ Global
 		{067E8EBE-F90A-4AFF-A0FF-20578216486E} = {BFA71E3F-31C0-4FC1-A320-4DCF704768C5}
 		{689B16BC-200E-4C68-BB2E-8B209070849B} = {BFA71E3F-31C0-4FC1-A320-4DCF704768C5}
 		{DC521A4C-7446-46F7-845B-AAF10EDCF8C6} = {E3193182-6FDA-4FA3-AD26-A487291E7681}
+		{5184D3F8-8526-413D-8EB0-23636EA7A4EF} = {359F7D60-362C-4F42-9606-A138FB1293E9}
+		{625F84FE-6809-4CA4-9C58-3453382D1C65} = {359F7D60-362C-4F42-9606-A138FB1293E9}
+		{359F7D60-362C-4F42-9606-A138FB1293E9} = {2E1FF127-4DC2-40A1-849C-ED1432204E8A}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {59CB40E1-9FA7-4867-A56F-4F418286F057}