* Moved source code projects directory to 'src'

* Updatedt Solution format

src/Telegrator.Hosting/Providers/Components/IHostHandlersCollection.cs

@@ -0,0 +1,16 @@
+using Telegrator.MadiatorCore;
+
+namespace Telegrator.Hosting.Providers.Components
+{
+    /// <summary>
+    /// Collection class for managing handler descriptors organized by update type for host apps.
+    /// Provides functionality for collecting, adding, scanning, and organizing handlers.
+    /// </summary>
+    public interface IHostHandlersCollection : IHandlersCollection
+    {
+        /// <summary>
+        /// List of tasks that should be completed right before building the bot
+        /// </summary>
+        public List<PreBuildingRoutine> PreBuilderRoutines { get; }
+    }
+}

src/Telegrator.Hosting/Providers/HostAwaitingProvider.cs

@@ -0,0 +1,12 @@
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using Telegrator.Providers;
+
+namespace Telegrator.Hosting.Providers
+{
+    /// <inheritdoc/>
+    public class HostAwaitingProvider(IOptions<TelegratorOptions> options, ILogger<HostAwaitingProvider> logger) : AwaitingProvider(options.Value)
+    {
+        private readonly ILogger<HostAwaitingProvider> _logger = logger;
+    }
+}

src/Telegrator.Hosting/Providers/HostHandlersCollection.cs

@@ -0,0 +1,81 @@
+using Microsoft.Extensions.DependencyInjection;
+using System.Reflection;
+using Telegrator.Configuration;
+using Telegrator.Hosting.Components;
+using Telegrator.Hosting.Providers.Components;
+using Telegrator.MadiatorCore;
+using Telegrator.MadiatorCore.Descriptors;
+using Telegrator.Providers;
+
+namespace Telegrator.Hosting.Providers
+{
+    /// <summary>
+    /// Pre host building task
+    /// </summary>
+    /// <param name="builder"></param>
+    public delegate void PreBuildingRoutine(ITelegramBotHostBuilder builder);
+
+    /// <inheritdoc/>
+    public class HostHandlersCollection(IServiceCollection hostServiceColletion, ITelegratorOptions options) : HandlersCollection(options), IHostHandlersCollection
+    {
+        private readonly IServiceCollection Services = hostServiceColletion;
+
+        /// <inheritdoc/>
+        protected override bool MustHaveParameterlessCtor => false;
+
+        /// <summary>
+        /// List of tasks that should be completed right before building the bot
+        /// </summary>
+        public List<PreBuildingRoutine> PreBuilderRoutines { get; } = [];
+
+        /// <inheritdoc/>
+        public override IHandlersCollection AddDescriptor(HandlerDescriptor descriptor)
+        {
+            if (descriptor.HandlerType.IsPreBuildingRoutine(out MethodInfo? routineMethod))
+                PreBuilderRoutines.Add(routineMethod.CreateDelegate<PreBuildingRoutine>(null));
+
+            switch (descriptor.Type)
+            {
+                case DescriptorType.General:
+                    {
+                        if (descriptor.InstanceFactory != null)
+                            Services.AddScoped(descriptor.HandlerType, _ => descriptor.InstanceFactory.Invoke());
+                        else
+                            Services.AddScoped(descriptor.HandlerType);
+
+                        break;
+                    }
+
+                case DescriptorType.Keyed:
+                    {
+                        if (descriptor.InstanceFactory != null)
+                            Services.AddKeyedScoped(descriptor.HandlerType, descriptor.ServiceKey, (_, _) => descriptor.InstanceFactory.Invoke());
+                        else
+                            Services.AddKeyedScoped(descriptor.HandlerType, descriptor.ServiceKey);
+
+                        break;
+                    }
+
+                case DescriptorType.Singleton:
+                    {
+                        Services.AddSingleton(descriptor.HandlerType, descriptor.SingletonInstance ?? (descriptor.InstanceFactory != null
+                            ? descriptor.InstanceFactory.Invoke()
+                            : throw new Exception()));
+
+                        break;
+                    }
+
+                case DescriptorType.Implicit:
+                    {
+                        Services.AddKeyedSingleton(descriptor.HandlerType, descriptor.ServiceKey, descriptor.SingletonInstance ?? (descriptor.InstanceFactory != null
+                            ? descriptor.InstanceFactory.Invoke()
+                            : throw new Exception()));
+                        
+                        break;
+                    }
+            }
+
+            return base.AddDescriptor(descriptor);
+        }
+    }
+}

src/Telegrator.Hosting/Providers/HostHandlersProvider.cs

@@ -0,0 +1,46 @@
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using Telegrator.Handlers.Components;
+using Telegrator.MadiatorCore;
+using Telegrator.MadiatorCore.Descriptors;
+using Telegrator.Providers;
+
+namespace Telegrator.Hosting.Providers
+{
+    /// <inheritdoc/>
+    public class HostHandlersProvider : HandlersProvider
+    {
+        private readonly IServiceProvider Services;
+        private readonly ILogger<HostHandlersProvider> Logger;
+
+        /// <inheritdoc/>
+        public HostHandlersProvider(
+            IHandlersCollection handlers,
+            IOptions<TelegratorOptions> options,
+            IServiceProvider serviceProvider,
+            ILogger<HostHandlersProvider> logger) : base(handlers, options.Value)
+        {
+            Services = serviceProvider;
+            Logger = logger;
+        }
+
+        /// <inheritdoc/>
+        public override UpdateHandlerBase GetHandlerInstance(HandlerDescriptor descriptor, CancellationToken cancellationToken = default)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            IServiceScope scope = Services.CreateScope();
+
+            object handlerInstance = descriptor.ServiceKey == null
+                ? scope.ServiceProvider.GetRequiredService(descriptor.HandlerType)
+                : scope.ServiceProvider.GetRequiredKeyedService(descriptor.HandlerType, descriptor.ServiceKey);
+
+            if (handlerInstance is not UpdateHandlerBase updateHandler)
+                throw new InvalidOperationException("Failed to resolve " + descriptor.HandlerType + " as UpdateHandlerBase");
+
+            descriptor.LazyInitialization?.Invoke(updateHandler);
+            updateHandler.LifetimeToken.OnLifetimeEnded += _ => scope.Dispose();
+            return updateHandler;
+        }
+    }
+}