Initial split of the modules

NadekoBot.Core/Services/ServiceProvider.cs

@@ -0,0 +1,142 @@
+using System;
+using System.Collections;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Reflection;
+using System.Linq;
+using System.Diagnostics;
+using NLog;
+#if GLOBAL_NADEKO
+using NadekoBot.Common;
+#endif
+
+
+namespace NadekoBot.Services
+{
+    public interface INServiceProvider : IServiceProvider, IEnumerable<object>
+    {
+        T GetService<T>();
+    }
+
+    public class NServiceProvider : INServiceProvider
+    {
+        public class ServiceProviderBuilder
+        {
+            private ConcurrentDictionary<Type, object> _dict = new ConcurrentDictionary<Type, object>();
+            private readonly Logger _log;
+
+            public ServiceProviderBuilder()
+            {
+                _log = LogManager.GetCurrentClassLogger();
+            }
+
+            public ServiceProviderBuilder AddManual<T>(T obj)
+            {
+                _dict.TryAdd(typeof(T), obj);
+                return this;
+            }
+
+            public NServiceProvider Build()
+            {
+                return new NServiceProvider(_dict);
+            }
+
+            public ServiceProviderBuilder LoadFrom(Assembly assembly)
+            {
+                var allTypes = assembly.GetTypes();
+                var services = new Queue<Type>(allTypes
+                        .Where(x => x.GetInterfaces().Contains(typeof(INService)) 
+                            && !x.GetTypeInfo().IsInterface && !x.GetTypeInfo().IsAbstract
+
+#if GLOBAL_NADEKO
+                            && x.GetTypeInfo().GetCustomAttribute<NoPublicBot>() == null
+#endif
+                            )
+                        .ToArray());
+
+                var interfaces = new HashSet<Type>(allTypes
+                        .Where(x => x.GetInterfaces().Contains(typeof(INService)) 
+                            && x.GetTypeInfo().IsInterface));
+
+                var alreadyFailed = new Dictionary<Type, int>();
+
+                var sw = Stopwatch.StartNew();
+                var swInstance = new Stopwatch();
+                while (services.Count > 0)
+                {
+                    var type = services.Dequeue(); //get a type i need to make an instance of
+
+                    if (_dict.TryGetValue(type, out _)) // if that type is already instantiated, skip
+                        continue;
+
+                    var ctor = type.GetConstructors()[0];
+                    var argTypes = ctor
+                        .GetParameters()
+                        .Select(x => x.ParameterType)
+                        .ToArray(); // get constructor argument types i need to pass in
+
+                    var args = new List<object>(argTypes.Length);
+                    foreach (var arg in argTypes) //get constructor arguments from the dictionary of already instantiated types
+                    {
+                        if (_dict.TryGetValue(arg, out var argObj)) //if i got current one, add it to the list of instances and move on
+                            args.Add(argObj);
+                        else //if i failed getting it, add it to the end, and break
+                        {
+                            services.Enqueue(type);
+                            if (alreadyFailed.ContainsKey(type))
+                            {
+                                alreadyFailed[type]++;
+                                if (alreadyFailed[type] > 3)
+                                    _log.Warn(type.Name + " wasn't instantiated in the first 3 attempts. Missing " + arg.Name + " type");
+                            }
+                            else
+                                alreadyFailed.Add(type, 1);
+                            break;
+                        }
+                    }
+                    if (args.Count != argTypes.Length)
+                        continue;
+                    // _log.Info("Loading " + type.Name);
+                    swInstance.Restart();
+                    var instance = ctor.Invoke(args.ToArray());
+                    swInstance.Stop();
+                    if (swInstance.Elapsed.TotalSeconds > 5)
+                        _log.Info($"{type.Name} took {swInstance.Elapsed.TotalSeconds:F2}s to load.");
+                    var interfaceType = interfaces.FirstOrDefault(x => instance.GetType().GetInterfaces().Contains(x));
+                    if (interfaceType != null)
+                        _dict.TryAdd(interfaceType, instance);
+
+                    _dict.TryAdd(type, instance);
+                }
+                sw.Stop();
+                _log.Info($"All services loaded in {sw.Elapsed.TotalSeconds:F2}s");
+
+                return this;
+            }
+        }
+
+        private readonly ImmutableDictionary<Type, object> _services;
+
+        private NServiceProvider() { }
+        public NServiceProvider(IDictionary<Type, object> services)
+        {
+            this._services = services.ToImmutableDictionary();
+        }
+
+        public T GetService<T>()
+        {
+            return (T)((IServiceProvider)(this)).GetService(typeof(T));
+        }
+
+        object IServiceProvider.GetService(Type serviceType)
+        {
+            _services.TryGetValue(serviceType, out var toReturn);
+            return toReturn;
+        }
+
+        IEnumerator IEnumerable.GetEnumerator() => _services.Values.GetEnumerator();
+
+        public IEnumerator<object> GetEnumerator() => _services.Values.GetEnumerator();
+    }
+}