Merge branch 'v5.x' of https://github.com/unitycontainer/container into v5.x

Author: ENikS

src/Extensions/DefaultLifetime.cs

@@ -0,0 +1,38 @@
+using System;
+using Unity.Extension;
+using Unity.Lifetime;
+
+namespace Unity
+{
+    public class DefaultLifetime : UnityContainerExtension
+    {
+        protected override void Initialize()
+        {
+        }
+
+        #region Public Members
+
+        public ITypeLifetimeManager TypeDefaultLifetime
+        {
+            get => (ITypeLifetimeManager)((UnityContainer)Container).TypeLifetimeManager;
+            set => ((UnityContainer)Container).TypeLifetimeManager = (LifetimeManager)value ??
+                throw new ArgumentNullException("Type Lifetime Manager can not be null");
+        }
+
+        public IInstanceLifetimeManager InstanceDefaultLifetime
+        {
+            get => (IInstanceLifetimeManager)((UnityContainer)Container).InstanceLifetimeManager;
+            set => ((UnityContainer)Container).InstanceLifetimeManager = (LifetimeManager)value ??
+                throw new ArgumentNullException("Instance Lifetime Manager can not be null");
+        }
+
+        public IFactoryLifetimeManager FactoryDefaultLifetime
+        {
+            get => (IFactoryLifetimeManager)((UnityContainer)Container).FactoryLifetimeManager;
+            set => ((UnityContainer)Container).FactoryLifetimeManager = (LifetimeManager)value ??
+                throw new ArgumentNullException("Factory Lifetime Manager can not be null");
+        }
+
+        #endregion
+    }
+}

src/Factories/EnumerableResolver.cs

@@ -0,0 +1,76 @@
+using System;
+using System.Linq;
+using System.Reflection;
+using Unity.Builder;
+using Unity.Policy;
+using Unity.Resolution;
+
+namespace Unity.Factories
+{
+    public class EnumerableResolver
+    {
+        #region Fields
+
+        private static readonly MethodInfo EnumerableMethod =
+            typeof(EnumerableResolver).GetTypeInfo()
+                                      .GetDeclaredMethod(nameof(EnumerableResolver.Resolver));
+
+        private static readonly MethodInfo EnumerableFactory =
+            typeof(EnumerableResolver).GetTypeInfo()
+                                      .GetDeclaredMethod(nameof(EnumerableResolver.ResolverFactory));
+
+        #endregion
+
+
+        #region ResolveDelegateFactory
+
+        public static ResolveDelegateFactory Factory = (ref BuilderContext context) =>
+        {
+
+#if NETSTANDARD1_0 || NETCOREAPP1_0 || NET40
+            var typeArgument = context.Type.GetTypeInfo().GenericTypeArguments.First();
+            if (typeArgument.GetTypeInfo().IsGenericType)
+#else
+            var typeArgument = context.Type.GenericTypeArguments.First();
+            if (typeArgument.IsGenericType)
+#endif
+            {
+                return ((EnumerableFactoryDelegate)
+                    EnumerableFactory.MakeGenericMethod(typeArgument)
+                                     .CreateDelegate(typeof(EnumerableFactoryDelegate)))();
+            }
+            else
+            {
+                return (ResolveDelegate<BuilderContext>)
+                    EnumerableMethod.MakeGenericMethod(typeArgument)
+                                    .CreateDelegate(typeof(ResolveDelegate<BuilderContext>));
+            }
+        };
+
+        #endregion
+
+
+        #region Implementation
+
+        private static object Resolver<TElement>(ref BuilderContext context)
+        {
+            return ((UnityContainer)context.Container).ResolveEnumerable<TElement>(context.Resolve,
+                                                                                   context.Name);
+        }
+
+        private static ResolveDelegate<BuilderContext> ResolverFactory<TElement>()
+        {
+            Type type = typeof(TElement).GetGenericTypeDefinition();
+            return (ref BuilderContext c) => ((UnityContainer)c.Container).ResolveEnumerable<TElement>(c.Resolve, type, c.Name);
+        }
+
+        #endregion
+
+
+        #region Nested Types
+
+        private delegate ResolveDelegate<BuilderContext> EnumerableFactoryDelegate();
+
+        #endregion
+    }
+}

src/Lifetime/ContainerLifetimeManager.cs

@@ -19,5 +19,7 @@ protected override LifetimeManager OnCreateLifetimeManager()
         {
             return new ContainerLifetimeManager();
         }
+
+        public override bool InUse { get => false; set => base.InUse = false; }
     }
 }

src/Processors/Abstracts/MemberExpression.cs

@@ -31,15 +31,13 @@ protected virtual IEnumerable<Expression> ExpressionsFromSelection(Type type, IE
 
                         yield return GetResolverExpression(info, value);
                         break;
-
 
                         // Injection Member
                     case InjectionMember<TMemberInfo, TData> injectionMember:
                         yield return GetResolverExpression(injectionMember.MemberInfo(type), 
                                                            injectionMember.Data);
                         break;
 
-
                     // Unknown
                     default:
                         throw new InvalidOperationException($"Unknown MemberInfo<{typeof(TMemberInfo)}> type");

src/Processors/Constructor/ConstructorExpression.cs

@@ -4,6 +4,7 @@
 using System.Linq.Expressions;
 using System.Reflection;
 using Unity.Builder;
+using Unity.Exceptions;
 using Unity.Injection;
 using Unity.Lifetime;
 using Unity.Policy;
@@ -96,13 +97,21 @@ protected override Expression GetResolverExpression(ConstructorInfo info, object
             var variable = Expression.Variable(info.DeclaringType);
             var parametersExpr = CreateParameterExpressions(info.GetParameters(), resolvers);
 
-            return Expression.IfThen(
-                Expression.Equal(Expression.Constant(null), BuilderContextExpression.Existing),
-                Expression.Block(new[] { variable }, new Expression[]
-                {
-                    Expression.Assign(variable, Expression.New(info, parametersExpr)),
-                    Expression.Assign(BuilderContextExpression.Existing, Expression.Convert(variable, typeof(object)))
-                }));
+            try
+            {
+                return Expression.IfThen(
+                    Expression.Equal(Expression.Constant(null), BuilderContextExpression.Existing),
+                    Expression.Block(new[] { variable }, new Expression[]
+                    {
+                        Expression.Assign(variable, Expression.New(info, parametersExpr)),
+                        Expression.Assign(BuilderContextExpression.Existing, Expression.Convert(variable, typeof(object)))
+                    }));
+            }
+            catch (ArgumentException ex)
+            {
+                throw new InvalidRegistrationException("Invalid Argument", ex);
+            }
+
         }
 
         #endregion

src/Processors/Methods/MethodProcessor.cs

@@ -4,6 +4,7 @@
 using System.Linq.Expressions;
 using System.Reflection;
 using Unity.Builder;
+using Unity.Exceptions;
 using Unity.Policy;
 using Unity.Resolution;
 
@@ -37,9 +38,16 @@ protected override IEnumerable<MethodInfo> DeclaredMembers(Type type)
 
         protected override Expression GetResolverExpression(MethodInfo info, object resolvers)
         {
-            return Expression.Call(
-                Expression.Convert(BuilderContextExpression.Existing, info.DeclaringType),
-                info, CreateParameterExpressions(info.GetParameters(), resolvers));
+            try
+            {
+                return Expression.Call(
+                    Expression.Convert(BuilderContextExpression.Existing, info.DeclaringType),
+                    info, CreateParameterExpressions(info.GetParameters(), resolvers));
+            }
+            catch (ArgumentException ex)
+            {
+                throw new InvalidRegistrationException("Invalid Argument", ex);
+            }
         }
 
         #endregion

src/Storage/QuickSet.cs

@@ -0,0 +1,146 @@
+using System;
+using System.Security;
+
+namespace Unity.Storage
+{
+    [SecuritySafeCritical]
+    public class QuickSet<TValue>
+    {
+        #region Fields
+
+        private int _prime;
+        private int[] Buckets;
+        private Entry[] Entries;
+        public int Count { get; private set; }
+
+        #endregion
+        
+
+        #region Constructors
+
+        public QuickSet()
+        {
+            var size = Primes[_prime];
+            Buckets = new int[size];
+            Entries = new Entry[size];
+
+#if !NET40
+            unsafe
+            {
+                fixed (int* bucketsPtr = Buckets)
+                {
+                    int* ptr = bucketsPtr;
+                    var end = bucketsPtr + Buckets.Length;
+                    while (ptr < end) *ptr++ = -1;
+                }
+            }
+#else
+            for(int i = 0; i < Buckets.Length; i++)
+                Buckets[i] = -1;
+#endif
+        }
+
+        #endregion
+
+
+        #region Public Methods
+
+        public bool Add(int hashCode, TValue value)
+        {
+            var collisions = 0;
+            var targetBucket = (hashCode & UnityContainer.HashMask) % Buckets.Length;
+
+            // Check for the existing 
+            for (var i = Buckets[targetBucket]; i >= 0; i = Entries[i].Next)
+            {
+                ref var candidate = ref Entries[i];
+                if (candidate.HashCode != hashCode || !Equals(candidate.Value, value))
+                {
+                    collisions++;
+                    continue;
+                }
+
+                // Already exists
+                return false;
+            }
+
+            // Expand if required
+            if (Count >= Entries.Length || 3 < collisions)
+            {
+                Expand();
+                targetBucket = (hashCode & UnityContainer.HashMask) % Buckets.Length;
+            }
+
+            // Add registration
+            ref var entry = ref Entries[Count];
+            entry.HashCode = hashCode;
+            entry.Value = value;
+            entry.Next = Buckets[targetBucket];
+            Buckets[targetBucket] = Count++;
+
+            return true;
+        }
+
+        #endregion
+
+
+        #region Entry Type
+
+        private struct Entry
+        {
+            public int HashCode;
+            public TValue Value;
+            public int Next;
+        }
+
+        #endregion
+
+
+        #region Implementation
+
+        private void Expand()
+        {
+            var entries = Entries;
+
+            _prime += 1;
+
+            var size = Primes[_prime];
+            Buckets = new int[size];
+            Entries = new Entry[size];
+
+#if !NET40
+            unsafe
+            {
+                fixed (int* bucketsPtr = Buckets)
+                {
+                    int* ptr = bucketsPtr;
+                    var end = bucketsPtr + Buckets.Length;
+                    while (ptr < end) *ptr++ = -1;
+                }
+            }
+#else
+            for(int i = 0; i < Buckets.Length; i++)
+                Buckets[i] = -1;
+#endif
+            Array.Copy(entries, 0, Entries, 0, Count);
+            for (var i = 0; i < Count; i++)
+            {
+                var hashCode = Entries[i].HashCode & UnityContainer.HashMask;
+                if (hashCode < 0) continue;
+
+                var bucket = hashCode % Buckets.Length;
+                Entries[i].Next = Buckets[bucket];
+                Buckets[bucket] = i;
+            }
+        }
+
+        public static readonly int[] Primes = {
+            11, 37, 71, 107, 131, 163, 197, 239, 293, 353, 431, 521, 631, 761, 919, 1103, 1327, 1597,
+            1931, 2333, 2801, 3371, 4049, 4861, 5839, 7013, 8419, 10103, 12143, 14591, 17519, 21023,
+            25229, 30293, 36353, 43627, 52361, 62851, 75431, 90523, 108631, 130363, 156437, 187751,
+            225307, 270371, 324449, 389357, 467237, 560689, 672827, 807403, 968897, 1162687, 1395263,
+            1674319, 2009191, 2411033, 2893249, 3471899, 4166287, 4999559, 5999471, 7199369};
+
+        #endregion
+    }
+}

src/Storage/RegistrationSet.cs

@@ -48,13 +48,13 @@ public ref Entry this[int index]
 
         public void Add(Type type, string name, InternalRegistration registration)
         {
-            var hashCode = ((type?.GetHashCode() ?? 0 + 37) ^ (name?.GetHashCode() ?? 0 + 17)) & 0x7FFFFFFF; 
+            var hashCode = (37 ^ (name?.GetHashCode() ?? 0 + 17)) & 0x7FFFFFFF; 
             var bucket = hashCode % _buckets.Length;
             var collisionCount = 0;
             for (int i = _buckets[bucket]; --i >= 0; i = _entries[i].Next)
             {
                 ref var entry = ref _entries[i];
-                if (entry.HashCode == hashCode && entry.RegisteredType == type)
+                if (entry.HashCode == hashCode && entry.Name == name)
                 {
                     entry.RegisteredType = type;
                     entry.Name = name;