0.2 version

Remouse.DI/BindingConfigurator.cs → ReDI/BindingConfigurator.cs

@@ -1,16 +1,21 @@
 using System;
 using System.Collections.Generic;
 
-namespace Remouse.DI
+namespace ReDI
 {
     internal class BindingInfo
     {
-        public bool alwaysNewInstance;
-        public readonly HashSet<Type> associatedInterfaces = new HashSet<Type>();
-        public Type boundType;
-        public object instance;
-        public bool constructOnBuild;
-        public bool isDisposable;
+        public bool AlwaysNewInstance { get; set; }
+        public HashSet<Type> AssociatedInterfaces { get; } = new HashSet<Type>();
+        public Type BoundType { get; }
+        public object? Instance { get; set; }
+        public bool CreateOnBuild { get; set; }
+        public bool IsDisposable { get; set; }
+
+        public BindingInfo(Type boundType)
+        {
+            BoundType = boundType; 
+        }
     }
 
     public class BindingConfigurator<T>
@@ -24,32 +29,31 @@ internal BindingConfigurator(BindingInfo binding)
 
         public BindingConfigurator<T> ImplementingInterfaces()
         {
-            _binding.associatedInterfaces.UnionWith(_binding.boundType.GetInterfaces());
+            _binding.AssociatedInterfaces.UnionWith(_binding.BoundType.GetInterfaces());
             return this;
         }
 
         public BindingConfigurator<T> AsDisposable()
         {
-
-            _binding.isDisposable = true;
+            _binding.IsDisposable = true;
             return this;
         }
 
         public BindingConfigurator<T> As<TInterface>()
         {
-            _binding.associatedInterfaces.Add(typeof(TInterface));
+            _binding.AssociatedInterfaces.Add(typeof(TInterface));
             return this;
         }
 
         public BindingConfigurator<T> FromInstance(T instance)
         {
-            _binding.instance = instance;
+            _binding.Instance = instance;
             return this;
         }
 
-        public BindingConfigurator<T> ConstructOnContainerBuild()
+        public BindingConfigurator<T> CreateOnContainerBuild()
         {
-            _binding.constructOnBuild = true;
+            _binding.CreateOnBuild = true;
             return this;
         }
     }

ReDI/Container.cs

@@ -0,0 +1,161 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace ReDI
+{
+    public class Container : IDisposable
+    {
+
+        private readonly List<ServiceRegistration> _registrations = new List<ServiceRegistration>();
+        private readonly Dictionary<Type, HashSet<ServiceRegistration>> _registrationsByInterface = new Dictionary<Type, HashSet<ServiceRegistration>>();
+
+        private bool _isDisposed;
+        private HashSet<Type> _constructingTypes = new HashSet<Type>();
+
+        internal Container(IEnumerable<BindingInfo> bindings)
+        {
+            var toBuild = new HashSet<ServiceRegistration>();
+
+            foreach (var binding in bindings)
+            {
+                var registration = new ServiceRegistration(binding.BoundType, binding.AlwaysNewInstance, binding.IsDisposable, binding.Instance);
+
+                foreach (var interfaceType in binding.AssociatedInterfaces)
+                {
+                    if (!_registrationsByInterface.TryGetValue(interfaceType, out var existingRegistrations))
+                    {
+                        existingRegistrations = new HashSet<ServiceRegistration>();
+                        _registrationsByInterface[interfaceType] = existingRegistrations;
+                    }
+
+                    existingRegistrations.Add(registration);
+                }
+
+                if (binding.CreateOnBuild)
+                    toBuild.Add(registration);
+
+                _registrations.Add(registration);
+            }
+
+            foreach (var buildingService in toBuild)
+            {
+                Build(buildingService);
+            }
+        }
+
+        public void Dispose()
+        {
+            if (_isDisposed)
+            {
+#if DEBUG
+                throw new ObjectDisposedException("Container is already disposed");
+#endif
+                return;
+            }
+
+            foreach (var registration in _registrations)
+            {
+                if (registration.IsDisposable && registration.Instance is IDisposable disposable)
+                    disposable.Dispose();
+            }
+
+            _isDisposed = true;
+        }
+
+        public T? Resolve<T>() where T : class
+        {
+            var obj = Resolve(typeof(T));
+            return obj != null ? (T)obj : null;
+        }
+
+        public object? Resolve(Type type)
+        {
+            CheckIfDisposed();
+
+            if (IsGenericList(type))
+            {
+                return ResolveList(type);
+            }
+            else
+            {
+                return ResolveSingle(type);
+            }
+        }
+
+        private object? ResolveSingle(Type type)
+        {
+            if (!_registrationsByInterface.TryGetValue(type, out var registrations))
+            {
+                return null;
+            }
+
+            return Build(registrations.First());
+        }
+
+        private object? ResolveList(Type type)
+        {
+            var serviceType = GetListTypeArgument(type);
+
+            if (!_registrationsByInterface.TryGetValue(serviceType, out var registrations))
+            {
+                return null;
+            }
+
+            var listType = typeof(List<>);
+            var constructedListType = listType.MakeGenericType(serviceType);
+
+            var instance = Activator.CreateInstance(constructedListType, registrations.Count) as IList;
+            foreach (var registration in registrations)
+            {
+                instance.Add(Build(registration));
+            }
+
+            return instance;
+        }
+
+        private bool IsGenericList(Type type)
+        {
+            return type.IsGenericType && (type.GetGenericTypeDefinition() == typeof(List<>));
+        }
+
+        private Type GetListTypeArgument(Type type)
+        {
+            return type.GetGenericArguments()[0];
+        }
+
+        private void CheckIfDisposed()
+        {
+#if DEBUG
+            if (_isDisposed)
+                throw new ObjectDisposedException("Container is disposed");
+#endif
+        }
+
+        private object Build(ServiceRegistration registration)
+        {
+            if (registration.AlwaysNewInstance || registration.Instance == null)
+            {
+                CheckForCircularDependency(registration);
+                registration.Instance = registration.Create(this);
+                _constructingTypes.Remove(registration.ServiceType);
+            }
+
+            if (!registration.IsInjected)
+            {
+                registration.Inject(registration.Instance, this);
+            }
+
+            return registration.Instance;
+        }
+
+        private void CheckForCircularDependency(ServiceRegistration registration)
+        {
+            if (!_constructingTypes.Add(registration.ServiceType))
+            {
+                throw new CircularDependencyFoundException(registration.ServiceType);
+            }
+        }
+    }
+}

Remouse.DI/ContainerBuilder.cs → ReDI/ContainerBuilder.cs

@@ -1,4 +1,4 @@
-namespace Remouse.DI
+namespace ReDI
 {
     public class ContainerBuilder
     {

ReDI/Exceptions/CircularDependencyFoundException.cs

@@ -0,0 +1,13 @@
+using System;
+
+namespace ReDI
+{
+    public class CircularDependencyFoundException : Exception
+    {
+        private readonly Type _type;
+
+        public CircularDependencyFoundException(Type type) { _type = type; }
+
+        public override string Message { get => $"{_type} refers to circular dependency"; }
+    }
+}

ReDI/Exceptions/InjectingServiceNotRegisteredException.cs

@@ -0,0 +1,18 @@
+using System;
+
+namespace ReDI
+{
+    public class InjectingServiceNotRegisteredException : Exception
+    {
+        private readonly Type _serviceType;
+        private readonly Type _injectingType;
+
+        public InjectingServiceNotRegisteredException(Type serviceType, Type injectingType)
+        {
+            _serviceType = serviceType;
+            _injectingType = injectingType;
+        }
+
+        public override string Message { get => $"Not found service of type {_injectingType}, required for service {_serviceType}"; }
+    }
+}

ReDI/Exceptions/ModuleInstanceAlreadyRegisteredException.cs

@@ -0,0 +1,16 @@
+using System;
+
+namespace ReDI
+{
+    public class ModuleInstanceAlreadyRegisteredException : Exception
+    {
+        private readonly Module _module;
+
+        public ModuleInstanceAlreadyRegisteredException(Module module)
+        {
+            _module = module;
+        }
+
+        public override string Message { get => $"Instance of module {_module.GetType()} already registered"; }
+    }
+}

ReDI/Exceptions/ModuleNotAssignedException.cs

@@ -0,0 +1,16 @@
+using System;
+
+namespace ReDI
+{
+    public class ModuleNotAssignedException : Exception
+    {
+        private readonly Type _moduleType;
+
+        public ModuleNotAssignedException(Type moduleType)
+        {
+            _moduleType = moduleType;
+        }
+
+        public override string Message { get => $"Not find module instance of {_moduleType}, probably null registration"; }
+    }
+}

ReDI/Exceptions/NotFoundInjectingConstructorException.cs

@@ -0,0 +1,13 @@
+using System;
+
+namespace ReDI
+{
+    public class NotFoundInjectingConstructorException : Exception
+    {
+        private readonly Type _type;
+
+        public NotFoundInjectingConstructorException(Type type) { _type = type; }
+
+        public override string Message { get => $"Not found constructor with [Inject] attribute, multiple constructor's defined in {_type}"; }
+    }
+}

ReDI/Exceptions/SecondCallBuildServiceInternalException.cs

@@ -0,0 +1,13 @@
+using System;
+
+namespace ReDI
+{
+    public class SecondCallBuildServiceInternalException : Exception
+    {
+        private readonly Type _type;
+
+        public SecondCallBuildServiceInternalException(Type type) { _type = type; }
+
+        public override string Message { get => $"Build of serivce {_type} was called second time"; }
+    }
+}

ReDI/Exceptions/TooManyInjectingConstructorsException.cs

@@ -0,0 +1,13 @@
+using System;
+
+namespace ReDI
+{
+    public class TooManyInjectingConstructorsException: Exception
+    {
+        private readonly Type _type;
+
+        public TooManyInjectingConstructorsException(Type type) { _type = type; }
+
+        public override string Message { get => $"{_type} contain more than 1 constructor with injecting attributes"; }
+    }
+}

ReDI/InjectAttribute.cs

@@ -0,0 +1,10 @@
+using System;
+
+namespace ReDI
+{
+    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property | AttributeTargets.Constructor | AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
+    public class InjectAttribute : Attribute
+    {
+
+    }
+}

Remouse.DI/Module.cs → ReDI/Module.cs

@@ -1,4 +1,4 @@
-namespace Remouse.DI
+namespace ReDI
 {
     public abstract class Module
     {