Minor refactoring

Author: ENikS

src/Abstracts/IUnityContainerAsync.cs

@@ -95,7 +95,7 @@ public interface IUnityContainerAsync : IDisposable
         /// <param name="name">Name of the object to retrieve.</param>
         /// <param name="overrides">Any overrides for the resolve call.</param>
         /// <returns>The retrieved object.</returns>
-        ValueTask<object> Resolve(Type type, string name, params ResolverOverride[] overrides);
+        ValueTask<object> ResolveAsync(Type type, string name, params ResolverOverride[] overrides);
 
 
         /// <summary>

src/Extensions/Container/UnityContainerAsync.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Runtime.CompilerServices;
+using System.Security;
 using System.Threading.Tasks;
 using Unity.Injection;
 using Unity.Lifetime;
@@ -801,10 +802,28 @@ public static IUnityContainerAsync RegisterFactory(this IUnityContainerAsync con
         /// <param name="overrides">Any overrides for the resolve call.</param>
         /// <returns>The retrieved object.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ValueTask<object> Resolve<T>(this IUnityContainerAsync container, params ResolverOverride[] overrides)
+        [SecuritySafeCritical]
+        public static T ResolveAsync<T>(this IUnityContainerAsync container, params ResolverOverride[] overrides)
         {
-            return (container ?? throw new ArgumentNullException(nameof(container)))
-                .Resolve(typeof(T), (string)null, overrides);
+            var unity = container ?? throw new ArgumentNullException(nameof(container));
+            var value  = unity.ResolveAsync(typeof(T), null, overrides);
+
+            if (value.IsCompleted) return (T) value.Result;
+
+            try
+            {
+                var task = value.AsTask();
+                task.Wait();
+
+                return (T) task.Result;
+            }
+            catch (AggregateException ex)
+            {
+                if (1 == ex.InnerExceptions.Count)
+                    throw ex.InnerException;
+
+                throw;
+            }
         }
 
         /// <summary>
@@ -816,10 +835,28 @@ public static ValueTask<object> Resolve<T>(this IUnityContainerAsync container,
         /// <param name="overrides">Any overrides for the resolve call.</param>
         /// <returns>The retrieved object.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ValueTask<object> Resolve<T>(this IUnityContainerAsync container, string name, params ResolverOverride[] overrides)
+        [SecuritySafeCritical]
+        public static T ResolveAsync<T>(this IUnityContainerAsync container, string name, params ResolverOverride[] overrides)
         {
-            return (container ?? throw new ArgumentNullException(nameof(container)))
-                .Resolve(typeof(T), name, overrides);
+            var unity = container ?? throw new ArgumentNullException(nameof(container));
+            var value = unity.ResolveAsync(typeof(T), name, overrides);
+
+            if (value.IsCompleted) return (T)value.Result;
+
+            try
+            {
+                var task = value.AsTask();
+                task.Wait();
+
+                return (T)task.Result;
+            }
+            catch (AggregateException ex)
+            {
+                if (1 == ex.InnerExceptions.Count)
+                    throw ex.InnerException;
+
+                throw;
+            }
         }
 
         /// <summary>
@@ -830,9 +867,10 @@ public static ValueTask<object> Resolve<T>(this IUnityContainerAsync container,
         /// <param name="overrides">Any overrides for the resolve call.</param>
         /// <returns>The retrieved object.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ValueTask<object> Resolve(this IUnityContainerAsync container, Type t, params ResolverOverride[] overrides)
+        [SecuritySafeCritical]
+        public static ValueTask<object> ResolveAsync(this IUnityContainerAsync container, Type t, params ResolverOverride[] overrides)
         {
-            return (container ?? throw new ArgumentNullException(nameof(container))).Resolve(t, (string)null, overrides);
+            return (container ?? throw new ArgumentNullException(nameof(container))).ResolveAsync(t, null, overrides);
         }
 
         #endregion

src/Lifetime/Abstracts/ILifetimeManagerAsync.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Threading;
-using System.Threading.Tasks;
 
 namespace Unity.Lifetime
 {
@@ -25,73 +24,33 @@ public abstract class SynchronizedLifetimeManager : LifetimeManager, IDisposable
     {
         #region Fields
 
+        private readonly object _lock = new object();
+
         /// <summary>
-        /// This field controls how long the monitor will wait to 
+        /// This field controlls how long the monitor will wait to 
         /// enter the lock. It is <see cref="Timeout.Infinite"/> by default or number of 
         /// milliseconds from 0 to 2147483647.
         /// </summary>
         public static int ResolveTimeout = Timeout.Infinite;
 
         #endregion
 
-
-        #region Constructors
-
-        public SynchronizedLifetimeManager()
-        {
-            GetResult = GetValue;
-            SetResult = SetValue;
-
-            GetTask = (c) => throw new NotImplementedException();
-            SetTask = (t, c) => throw new NotImplementedException();
-        }
-
-        #endregion
-
-
-        #region ILifetimeManagerAsync
-
-        public Func<ILifetimeContainer, object> GetResult { get; protected set; }
-
-        public Action<object, ILifetimeContainer> SetResult { get; protected set; }
-
-        public Func<ILifetimeContainer, Task<object>> GetTask { get; protected set; }
-
-        public Func<Task<object>, ILifetimeContainer, Task<object>> SetTask { get; protected set; }
-
-        #endregion
-
-
-        #region LifetimeManager
-
         /// <inheritdoc/>
         public override object GetValue(ILifetimeContainer container = null)
         {
-            if (Monitor.TryEnter(SyncRoot, ResolveTimeout))
+            if (Monitor.TryEnter(_lock, ResolveTimeout))
             {
                 var result = SynchronizedGetValue(container);
                 if (NoValue != result)
                 {
-                    Monitor.Exit(SyncRoot);
+                    Monitor.Exit(_lock);
                 }
                 return result;
             }
             else
                 throw new TimeoutException($"Failed to enter a monitor");
         }
 
-        /// <inheritdoc/>
-        public override void SetValue(object newValue, ILifetimeContainer container = null)
-        {
-            SynchronizedSetValue(newValue, container);
-            TryExit();
-        }
-
-        #endregion
-
-
-        #region SynchronizedLifetimeManager
-
         /// <summary>
         /// Performs the actual retrieval of a value from the backing store associated 
         /// with this Lifetime policy.
@@ -102,6 +61,14 @@ public override void SetValue(object newValue, ILifetimeContainer container = nu
         /// <returns>the object desired, or null if no such object is currently stored.</returns>
         protected abstract object SynchronizedGetValue(ILifetimeContainer container);
 
+
+        /// <inheritdoc/>
+        public override void SetValue(object newValue, ILifetimeContainer container = null)
+        {
+            SynchronizedSetValue(newValue, container);
+            TryExit();
+        }
+
         /// <summary>
         /// Performs the actual storage of the given value into backing store for retrieval later.
         /// </summary>
@@ -125,41 +92,34 @@ public void Recover()
             TryExit();
         }
 
-        #endregion
-
-
-        #region IDisposable
-
-        /// <summary>
-        /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
-        /// </summary>
-        public void Dispose()
-        {
-            Dispose(true);
-            GC.SuppressFinalize(this);
-        }
-
-        #endregion
-
-
-        #region Implementation
-
         protected virtual void TryExit()
         {
 #if !NET40
             // Prevent first chance exception when abandoning a lock that has not been entered
-            if (!Monitor.IsEntered(SyncRoot)) return;
+            if (!Monitor.IsEntered(_lock)) return;
 #endif
             try
             {
-                Monitor.Exit(SyncRoot);
+                Monitor.Exit(_lock);
             }
             catch (SynchronizationLockException)
             {
-                // Ignore.
+                // Noop here - we don't hold the lock and that's ok.
             }
         }
 
+
+        #region IDisposable
+
+        /// <summary>
+        /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
+        /// </summary>
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
         /// <summary>		
         /// Standard Dispose pattern implementation.		
         /// </summary>