Refactor BotApp and introduce TelegramBotHostedService

Significantly refactored the BotApp class to remove direct dependencies on the Telegram.Bot client, now utilizing a BotControllerMethodsContainer for managing controller methods. Introduced the TelegramBotHostedService to handle the bot's lifecycle and update processing. Updated the BotBuilder class to reflect these changes, including renaming the service addition method for clarity. Overall, these modifications enhance modularity, maintainability, and separation of concerns within the codebase.

Author: bvdcode

Sources/TelegramBot.ConsoleTest/Program.cs

@@ -11,7 +11,7 @@ public class Program
         public static void Main(string[] args)
         {
             BotBuilder builder = new BotBuilder(args)
-                .Setup(x => x.ReceiveUpdates = false)
+                .Setup(x => x.ReceiveUpdates = true)
                 .UseApiKey(x => x.FromConfiguration());
 
             builder.Services

Sources/TelegramBot/BotApp.cs

@@ -1,17 +1,11 @@
 using System;
 using System.Linq;
-using Telegram.Bot;
 using System.Threading;
 using System.Reflection;
-using Telegram.Bot.Types;
-using TelegramBot.Handlers;
 using TelegramBot.Services;
-using TelegramBot.Builders;
-using TelegramBot.Attributes;
 using System.Threading.Tasks;
-using TelegramBot.Extensions;
+using TelegramBot.Containers;
 using TelegramBot.Controllers;
-using TelegramBot.Abstractions;
 using System.Collections.Generic;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
@@ -26,10 +20,7 @@ public class BotApp : IBot
     {
         private bool _disposed = false;
         private readonly ILogger<BotApp> _logger;
-        private readonly TelegramBotClient _client;
         private readonly ServiceProvider _serviceProvider;
-        private readonly BotConfiguration _botConfiguration;
-        private IReadOnlyCollection<MethodInfo> _controllerMethods;
         private readonly CancellationTokenSource _cancellationTokenSource;
 
         /// <summary>
@@ -40,15 +31,10 @@ public class BotApp : IBot
         /// <summary>
         /// Creates a new instance of <see cref="BotApp"/>.
         /// </summary>
-        /// <param name="client">Telegram bot client.</param>
         /// <param name="serviceProvider">Service provider.</param>
-        /// <param name="botConfiguration">Bot configuration.</param>
-        public BotApp(TelegramBotClient client, ServiceProvider serviceProvider, BotConfiguration botConfiguration)
+        public BotApp(ServiceProvider serviceProvider)
         {
-            _client = client;
             _serviceProvider = serviceProvider;
-            _botConfiguration = botConfiguration;
-            _controllerMethods = new List<MethodInfo>();
             _cancellationTokenSource = new CancellationTokenSource();
             _logger = serviceProvider.GetRequiredService<ILogger<BotApp>>();
         }
@@ -68,9 +54,15 @@ public IBot MapControllers()
                     result.Add(type);
                 }
             }
-            _controllerMethods = result
+            var controllerMethods = result
                 .SelectMany(t => t.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly))
                 .ToList();
+            BotControllerMethodsContainer container = _serviceProvider.GetService<BotControllerMethodsContainer>()
+                ?? throw new InvalidOperationException("Bot controller methods container is not registered.");
+            foreach (var method in controllerMethods)
+            {
+                container.AddMethod(method);
+            }
             return this;
         }
 
@@ -104,28 +96,6 @@ public async Task StartAsync(CancellationToken cancellationToken = default)
             var mergedToken = MergeTokens(cancellationToken);
             AppDomain.CurrentDomain.ProcessExit += new EventHandler(OnProcessExit);
             CheckDisposed();
-            try
-            {
-                var botUser = _client.GetMe().Result;
-                if (_botConfiguration.ReceiveUpdates)
-                {
-                    _client.StartReceiving(UpdateHandler, ErrorHandler, cancellationToken: mergedToken);
-                    _logger.LogInformation("Bot '{botUser}' started - receiving updates.", botUser.Username);
-                }
-                else
-                {
-                    _logger.LogInformation("Bot '{botUser}' started - not receiving updates.", botUser.Username);
-                }
-            }
-            catch (Exception ex)
-            {
-                if (ex is AggregateException aggregateException)
-                {
-                    ex = aggregateException.InnerException;
-                }
-                _logger.LogError(ex, "Error occurred while starting the bot. Probably the bot token is invalid or the network is not available.");
-                throw ex;
-            }
 
             var hostApplicationLifetime = _serviceProvider.GetService<IHostApplicationLifetime>() as HostApplicationLifetime
                 ?? throw new InvalidOperationException("Host application lifetime is not registered.");
@@ -135,21 +105,7 @@ public async Task StartAsync(CancellationToken cancellationToken = default)
             foreach (var hostedService in hostedServices)
             {
                 await hostedService.StartAsync(mergedToken);
-                _logger.LogInformation("Started '{hostedService}'.", hostedService.GetType().Name);
-            }
-
-            var commandRegistrationBuilders = _serviceProvider.GetServices<CommandRegistrationBuilder>();
-            if (commandRegistrationBuilders != null && commandRegistrationBuilders.Any())
-            {
-                foreach (var builder in commandRegistrationBuilders)
-                {
-                    var commands = builder.Build();
-                    await _client.SetMyCommands(commands,
-                            languageCode: builder.Language,
-                            cancellationToken: mergedToken);
-                    _logger.LogInformation("Registered {count} commands for language '{language}'.",
-                        commands.Count(), builder.Language);
-                }
+                _logger.LogInformation("Started hosted service: '{hostedService}'.", hostedService.GetType().Name);
             }
         }
 
@@ -208,134 +164,6 @@ private CancellationToken MergeTokens(CancellationToken token)
             return CancellationTokenSource.CreateLinkedTokenSource(_cancellationTokenSource.Token, token).Token;
         }
 
-        private Task ErrorHandler(ITelegramBotClient client, Exception exception, CancellationToken token)
-        {
-            CheckDisposed();
-            _logger.LogError(exception, "Error occurred while receiving updates.");
-            return Task.CompletedTask;
-        }
-
-        private async Task UpdateHandler(ITelegramBotClient client, Update update, CancellationToken token)
-        {
-            CheckDisposed();
-            if (update.Message != null && !string.IsNullOrWhiteSpace(update.Message.Text) && !update.Message.Text.StartsWith('/'))
-            {
-                _logger.LogInformation("Received text message: {Text}.", update.Message.Text);
-                var handler = new TextMessageHandler(_controllerMethods, update);
-                await HandleRequestAsync(handler, update);
-            }
-            else if (update.Message != null && !string.IsNullOrWhiteSpace(update.Message.Text) && update.Message.Text.StartsWith('/'))
-            {
-                _logger.LogInformation("Received text command: {Text}.", update.Message.Text);
-                var handler = new TextCommandHandler(_controllerMethods, update);
-                await HandleRequestAsync(handler, update);
-            }
-            else if (update.CallbackQuery != null && update.CallbackQuery.Data != null)
-            {
-                _logger.LogInformation("Received inline query: {Data}.", update.CallbackQuery.Data);
-                var handler = new InlineQueryHandler(_controllerMethods, update);
-                await HandleRequestAsync(handler, update);
-            }
-            else
-            {
-                _logger.LogWarning("Unsupported update type: {UpdateType}.", update.Type);
-            }
-        }
-
-        private async Task HandleRequestAsync(ITelegramUpdateHandler handler, Update update)
-        {
-            CheckDisposed();
-            bool hasUser = update.TryGetUser(out User user);
-            if (!hasUser)
-            {
-                return;
-            }
-            var args = handler.GetArguments();
-            MethodInfo? method = handler.GetMethodInfo();
-            if (method == null)
-            {
-                _logger.LogWarning("Method not found for message: {Text}.", update.Message?.Text);
-                return;
-            }
-            bool isAuthorized = await AuthorizeAsync(method, user);
-            if (!isAuthorized)
-            {
-                return;
-            }
-            CheckMethodMatching(method, args);
-            BotControllerBase controller = (BotControllerBase)ActivatorUtilities.CreateInstance(_serviceProvider, method.DeclaringType!);
-            controller.Update = update;
-            controller.User = user;
-            controller.Client = _client;
-            if (_serviceProvider.GetService<IKeyValueProvider>() is IKeyValueProvider keyValueProvider)
-            {
-                controller.KeyValueProvider = keyValueProvider;
-            }
-            var result = method.Invoke(controller, args);
-            await ExecuteResultAsync(result, user.Id);
-            await DisposeAsync(controller);
-            await DisposeAsync(result);
-        }
-
-        private void CheckMethodMatching(MethodInfo method, object[]? args)
-        {
-            if (method.ReturnType != typeof(Task<IActionResult>) && method.ReturnType != typeof(IActionResult))
-            {
-                throw new InvalidOperationException("Invalid return type: " + method.ReturnType.Name);
-            }
-            if (args != null && method.GetParameters().Length != args?.Length)
-            {
-                throw new InvalidOperationException("Invalid arguments count: " + args?.Length);
-            }
-        }
-
-        private async Task<bool> AuthorizeAsync(MethodInfo method, User user)
-        {
-            if (method.GetCustomAttribute<AuthorizeAttribute>() != null
-                || method.DeclaringType?.GetCustomAttribute<AuthorizeAttribute>() != null)
-            {
-                if (_serviceProvider.GetService<IBotAuthorizationHandler>() is IBotAuthorizationHandler authorizationHandler)
-                {
-                    if (!authorizationHandler.Authorize(user))
-                    {
-                        await authorizationHandler
-                            .HandleUnauthorized(user)
-                            .ExecuteResultAsync(new ActionContext(_client, user.Id));
-                        return false;
-                    }
-                }
-            }
-            return true;
-        }
-
-        private async Task DisposeAsync(object obj)
-        {
-            if (obj is IAsyncDisposable asyncDisposable)
-            {
-                await asyncDisposable.DisposeAsync();
-            }
-            else if (obj is IDisposable disposable)
-            {
-                disposable.Dispose();
-            }
-        }
-
-        private async Task ExecuteResultAsync(object result, long userId)
-        {
-            if (result is Task<IActionResult> taskResult)
-            {
-                await (await taskResult).ExecuteResultAsync(new ActionContext(_client, userId));
-            }
-            else if (result is IActionResult actionResult)
-            {
-                await actionResult.ExecuteResultAsync(new ActionContext(_client, userId));
-            }
-            else
-            {
-                throw new InvalidOperationException("Invalid result type: " + result.GetType().Name);
-            }
-        }
-
         private void CheckDisposed()
         {
             if (_disposed)

Sources/TelegramBot/Builders/BotBuilder.cs

@@ -8,6 +8,7 @@
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
+using TelegramBot.Containers;
 
 namespace TelegramBot.Builders
 {
@@ -24,7 +25,7 @@ public class BotBuilder
         /// <summary>
         /// A collection of configuration providers for the application to compose. This is useful for adding new configuration sources and providers.
         /// </summary>
-        public ConfigurationManager Configuration { get; }
+        public IConfigurationManager Configuration { get; }
 
         /// <summary>
         /// A collection of logging providers for the application to compose. This is useful for adding new logging providers.
@@ -38,9 +39,9 @@ public class BotBuilder
         public BotBuilder() : this(Array.Empty<string>()) { }
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="BotBuilder"/> class with preconfigured defaults.
+        /// Initializes a new instance of the <see cref="BotBuilder"/> class with preconfigured defaults and command line arguments.
         /// </summary>
-        /// <param name="args">The command line arguments.</param>
+        /// <param name="args">Command line arguments.</param>
         /// <returns>The <see cref="BotBuilder"/>.</returns>
         public BotBuilder(params string[] args)
         {
@@ -58,7 +59,34 @@ public BotBuilder(params string[] args)
             Logging = new TelegramLoggerBuilder(Services);
             Services.AddSingleton(Configuration);
             Services.AddSingleton<IConfiguration>(Configuration);
-            Services.AddSingleton<IConfigurationRoot>(Configuration);
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BotBuilder"/> class with preconfigured defaults.
+        /// </summary>
+        /// <param name="hostBuilder">The host application builder.</param>
+        /// <returns>The <see cref="BotBuilder"/>.</returns>
+        public BotBuilder(IHostApplicationBuilder hostBuilder) : this()
+        {
+            if (hostBuilder == null)
+            {
+                throw new ArgumentNullException(nameof(hostBuilder), "Host application builder cannot be null.");
+            }
+            if (hostBuilder.Logging == null)
+            {
+                throw new ArgumentNullException(nameof(hostBuilder.Logging), "Host application builder logging cannot be null.");
+            }
+            if (hostBuilder.Services == null)
+            {
+                throw new ArgumentNullException(nameof(hostBuilder.Services), "Host application builder services cannot be null.");
+            }
+            if (hostBuilder.Configuration == null)
+            {
+                throw new ArgumentNullException(nameof(hostBuilder.Configuration), "Host application builder configuration cannot be null.");
+            }
+            Logging = hostBuilder.Logging;
+            Services = hostBuilder.Services;
+            Configuration = hostBuilder.Configuration;
         }
 
         private readonly BotConfiguration _botConfiguration = new BotConfiguration();
@@ -119,7 +147,7 @@ public BotBuilder UseApiKey(Action<TelegramApiKeyBuilder> setupApiKey)
         /// </summary>
         /// <param name="services">The services to use.</param>
         /// <returns>This instance of <see cref="BotBuilder"/>.</returns>
-        public BotBuilder UseServices(IServiceCollection services)
+        public BotBuilder AddServices(IServiceCollection services)
         {
             foreach (var service in services)
             {
@@ -158,7 +186,10 @@ public IBot Build()
                 Services.AddSingleton<IKeyValueProvider, InMemoryKeyValueProvider>();
             }
             Services.AddSingleton<IHostApplicationLifetime, HostApplicationLifetime>();
-            return new BotApp(client, Services.BuildServiceProvider(), _botConfiguration);
+            Services.AddHostedService<TelegramBotHostedService>();
+            Services.AddSingleton(_botConfiguration);
+            Services.AddSingleton<BotControllerMethodsContainer>();
+            return new BotApp(Services.BuildServiceProvider());
         }
     }
 }

Sources/TelegramBot/Containers/BotControllerMethodsContainer.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Reflection;
+using System.Collections.Generic;
+
+namespace TelegramBot.Containers
+{
+    internal class BotControllerMethodsContainer
+    {
+        internal IReadOnlyCollection<MethodInfo> Methods => _methods.AsReadOnly();
+        private readonly List<MethodInfo> _methods = new List<MethodInfo>();
+
+        internal void AddMethod(MethodInfo method)
+        {
+            if (method == null)
+            {
+                throw new ArgumentNullException(nameof(method), "Method cannot be null.");
+            }
+            if (!_methods.Contains(method))
+            {
+                _methods.Add(method);
+            }
+        }
+    }
+}