Enhance method handling and add parameter conversion

- Modify `ITelegramUpdateHandler` to return nullable `MethodInfo`
- Add null check and parameter count validation in `BotApp.cs`
- Update `TextMessageHandler.cs` to handle nullable `_methodInfo`
- Introduce `ObjectHelpers` for parameter type conversion

Author: bvdcode

Sources/TelegramBot/Abstractions/ITelegramUpdateHandler.cs

@@ -1,11 +1,10 @@
 using System.Reflection;
-using Telegram.Bot.Types;
 
 namespace TelegramBot.Handlers
 {
     internal interface ITelegramUpdateHandler
     {
-        MethodInfo GetMethodInfo();
+        MethodInfo? GetMethodInfo();
         object[]? GetArguments();
     }
 }

Sources/TelegramBot/BotApp.cs

@@ -201,11 +201,20 @@ private async Task HandleRequestAsync(ITelegramUpdateHandler handler, Update upd
                 return;
             }
             var args = handler.GetArguments();
-            MethodInfo method = handler.GetMethodInfo();
+            MethodInfo? method = handler.GetMethodInfo();
+            if (method == null)
+            {
+                _logger.LogWarning("Method not found for message: {Text}.", update.Message?.Text);
+                return;
+            }
             if (method.ReturnType != typeof(Task<IActionResult>) && method.ReturnType != typeof(IActionResult))
             {
                 throw new InvalidOperationException("Invalid return type: " + method.ReturnType.Name);
             }
+            if (method.GetParameters().Length != args?.Length)
+            {
+                throw new InvalidOperationException("Invalid arguments count: " + args?.Length);
+            }
             BotControllerBase controller = (BotControllerBase)ActivatorUtilities.CreateInstance(_serviceProvider, method.DeclaringType);
             controller.Update = update;
             controller.User = user;

Sources/TelegramBot/Handlers/TextMessageHandler.cs

@@ -1,6 +1,6 @@
-using System;
-using System.Reflection;
+using System.Reflection;
 using Telegram.Bot.Types;
+using TelegramBot.Helpers;
 using TelegramBot.Attributes;
 using System.Collections.Generic;
 
@@ -9,12 +9,12 @@ namespace TelegramBot.Handlers
     internal class TextMessageHandler : ITelegramUpdateHandler
     {
         private readonly List<object> _args;
-        private readonly MethodInfo _methodInfo;
+        private readonly MethodInfo? _methodInfo;
 
         public TextMessageHandler(IReadOnlyCollection<MethodInfo> controllerMethods, Update update)
         {
             _args = new List<object>();
-            _methodInfo = GetMethodInfo(controllerMethods, update) ?? throw new InvalidOperationException("Method not found for message " + update.Message?.Text);
+            _methodInfo = GetMethodInfo(controllerMethods, update);
         }
 
         private MethodInfo? GetMethodInfo(IReadOnlyCollection<MethodInfo> controllerMethods, Update update)
@@ -26,7 +26,16 @@ public TextMessageHandler(IReadOnlyCollection<MethodInfo> controllerMethods, Upd
             var message = update.Message;
             var parts = message.Text!.Split(' ');
             string command = parts[0];
+            if (!command.StartsWith("/"))
+            {
+                return null;
+            }
+            if (parts.Length > 1)
+            {
+                _args.AddRange(parts[1..]);
+            }
 
+            List<MethodInfo> methods = new List<MethodInfo>();
             foreach (var method in controllerMethods)
             {
                 var attributes = method.GetCustomAttributes(typeof(TextCommandAttribute), false);
@@ -36,15 +45,30 @@ public TextMessageHandler(IReadOnlyCollection<MethodInfo> controllerMethods, Upd
                     {
                         if (botCommandAttribute.Command == command)
                         {
-                            if (parts.Length == 2 && method.GetParameters().Length == 1)
+                            if (_args.Count == method.GetParameters().Length)
                             {
-                                _args.Add(parts[1]);
+                                bool converted = ObjectHelpers.TryConvertParameters(method, _args.ToArray());
+                                if (converted)
+                                {
+                                    methods.Add(method);
+                                }
                             }
-                            return method;
                         }
                     }
                 }
             }
+            if (methods.Count == 1)
+            {
+                var args = _args.ToArray();
+                ObjectHelpers.TryConvertParameters(methods[0], args);
+                _args.Clear();
+                _args.AddRange(args);
+                return methods[0];
+            }
+            else if (methods.Count > 1)
+            {
+                throw new AmbiguousMatchException("Multiple methods found with the same command and arguments: " + command);
+            }
             return null;
         }
 
@@ -54,7 +78,7 @@ public TextMessageHandler(IReadOnlyCollection<MethodInfo> controllerMethods, Upd
             return _args.Count > 0 ? _args.ToArray() : null;
         }
 
-        public MethodInfo GetMethodInfo()
+        public MethodInfo? GetMethodInfo()
         {
             return _methodInfo;
         }

Sources/TelegramBot/Helpers/ObjectHelpers.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Reflection;
+using System.Collections.Generic;
+
+namespace TelegramBot.Helpers
+{
+    internal static class ObjectHelpers
+    {
+        internal static bool TryConvertParameters(MethodInfo method, object[] args)
+        {
+            List<object> newArgs = new List<object>(args.Length);
+            var parameters = method.GetParameters();
+            foreach (var parameter in parameters)
+            {
+                if (parameter.ParameterType.IsPrimitive || parameter.ParameterType == typeof(string))
+                {
+                    try
+                    {
+                        var changedType = Convert.ChangeType(args[parameter.Position], parameter.ParameterType);
+                        newArgs.Add(changedType);
+                    }
+                    catch (Exception)
+                    {
+                        return false;
+                    }
+                }
+                else
+                {
+                    return false;
+                }
+            }
+            for (int i = 0; i < newArgs.Count; i++)
+            {
+                args[i] = newArgs[i];
+            }
+            return true;
+        }
+    }
+}