Merge pull request #7 from servicetitan/disposable-implementation-fix

Do not call Dispose method in case proxied instance not created

Author: AlexUstinov

LazyProxy.Tests/DisposableLazyTests.cs

@@ -0,0 +1,61 @@
+using System;
+using Moq;
+using Xunit;
+
+namespace LazyProxy.Tests
+{
+    public class DisposableLazyTests
+    {
+        public interface IHaveDisposeBusinessMethod
+        {
+            void Dispose();
+        }
+
+        public interface IImplementIDisposable: IDisposable
+        {
+            void DoSomething();
+        }
+
+        [Fact]
+        public void BusinessDisposeMethodIsCalled()
+        {
+            var mock = new Mock<IHaveDisposeBusinessMethod>(MockBehavior.Strict);
+            mock.Setup(s => s.Dispose()).Verifiable();
+
+            var proxy = LazyProxyBuilder.CreateInstance(() => mock.Object);
+
+            proxy.Dispose();
+
+            mock.Verify(s => s.Dispose());
+        }
+
+        [Fact]
+        public void RegularDisposeMethodIsCalledIfInstanceIsCreated()
+        {
+            var mock = new Mock<IImplementIDisposable>(MockBehavior.Strict);
+            mock.Setup(s => s.DoSomething());
+            mock.Setup(s => s.Dispose()).Verifiable();
+
+            var proxy = LazyProxyBuilder.CreateInstance(() => mock.Object);
+
+            proxy.DoSomething();
+            proxy.Dispose();
+
+            mock.Verify(s => s.Dispose());
+        }
+
+        [Fact]
+        public void RegularDisposeMethodIsNotCalledIfNoInstanceIsCreated()
+        {
+            var mock = new Mock<IImplementIDisposable>(MockBehavior.Strict);
+            var callCounter = 0;
+            mock.Setup(s => s.Dispose()).Callback(() => callCounter++);
+
+            var proxy = LazyProxyBuilder.CreateInstance(() => mock.Object);
+
+            proxy.Dispose();
+
+            Assert.Equal(0, callCounter);
+        }
+    }
+}

LazyProxy/LazyBuilder.cs

@@ -11,6 +11,6 @@ public abstract class LazyProxyBase
         /// Initializes inner <see cref="Lazy{T}"/> instance with the valueFactory provided.
         /// </summary>
         /// <param name="valueFactory">Function that returns a value.</param>
-        public abstract void Initialize(Func<object> valueFactory);
+        protected internal abstract void Initialize(Func<object> valueFactory);
     }
 }

LazyProxy/LazyProxyBase.cs

@@ -25,8 +25,17 @@ public static class LazyProxyBuilder
         private static readonly ConcurrentDictionary<Type, Lazy<Type>> ProxyTypes =
             new ConcurrentDictionary<Type, Lazy<Type>>();
 
-        private static readonly MethodInfo CreateLazyMethod = typeof(LazyBuilder)
-            .GetMethod("CreateInstance", BindingFlags.Public | BindingFlags.Static);
+        private static readonly MethodInfo CreateLazyMethod = typeof(LazyProxyImplementation)
+            .GetMethod(nameof(LazyProxyImplementation.CreateInstance), BindingFlags.Public | BindingFlags.Static);
+
+        private static readonly MethodInfo DisposeLazyMethod = typeof(LazyProxyImplementation)
+            .GetMethod(nameof(LazyProxyImplementation.DisposeInstance), BindingFlags.Public | BindingFlags.Static);
+
+        private static readonly Type DisposableInterface = typeof(IDisposable);
+
+        private static readonly MethodInfo DisposeMethod = DisposableInterface
+            .GetMethod(nameof(IDisposable.Dispose), BindingFlags.Public | BindingFlags.Instance);
+
 
         /// <summary>
         /// Defines at runtime a class that implements interface T
@@ -89,7 +98,7 @@ public static object CreateInstance(Type type, Func<object> valueFactory)
             var proxyType = GetType(type);
 
             // Using 'Initialize' method after the instance creation allows to improve performance
-            // because Activator.CreateInstance executed with arguments is much slower.
+            // because Activator.CreateInstance method performance is much worse with arguments.
             var instance = (LazyProxyBase) Activator.CreateInstance(proxyType);
             instance.Initialize(valueFactory);
 
@@ -134,6 +143,7 @@ private static Type DefineProxyType(Type type)
                 .AddServiceField(type, out var serviceField)
                 .AddInitializeMethod(type, serviceField)
                 .AddMethods(type, serviceField)
+                .AddDisposeMethodIfNeeded(type, serviceField)
                 .CreateTypeInfo();
         }
 
@@ -167,8 +177,8 @@ private static TypeBuilder AddServiceField(this TypeBuilder typeBuilder,
         private static TypeBuilder AddInitializeMethod(this TypeBuilder typeBuilder, Type type, FieldInfo serviceField)
         {
             var methodBuilder = typeBuilder.DefineMethod(
-                "Initialize",
-                MethodAttributes.Public | MethodAttributes.Virtual,
+                nameof(LazyProxyBase.Initialize),
+                MethodAttributes.Family | MethodAttributes.Virtual,
                 null,
                 new [] { typeof(Func<object>) }
             );
@@ -229,13 +239,42 @@ private static TypeBuilder AddMethods(this TypeBuilder typeBuilder, Type type, F
             return typeBuilder;
         }
 
+        private static TypeBuilder AddDisposeMethodIfNeeded(this TypeBuilder typeBuilder, Type type, FieldInfo serviceField)
+        {
+            if (!DisposableInterface.IsAssignableFrom(type)) {
+                return typeBuilder;
+            }
+
+            var methodBuilder = typeBuilder.DefineMethod(
+                DisposeMethod.Name,
+                MethodAttributes.Public | MethodAttributes.Virtual,
+                DisposeMethod.ReturnType,
+                Array.Empty<Type>()
+            );
+
+            var disposeLazyMethod = DisposeLazyMethod.MakeGenericMethod(type);
+
+            var generator = methodBuilder.GetILGenerator();
+
+            generator.Emit(OpCodes.Ldarg_0);
+            generator.Emit(OpCodes.Ldfld, serviceField);
+            generator.Emit(OpCodes.Call, disposeLazyMethod);
+            generator.Emit(OpCodes.Ret);
+
+            typeBuilder.DefineMethodOverride(methodBuilder, DisposeMethod);
+
+            return typeBuilder;
+        }
+
         private static IEnumerable<MethodInfo> GetMethods(Type type)
         {
             const BindingFlags flags = BindingFlags.Public | BindingFlags.Instance;
 
+            var isDisposable = DisposableInterface.IsAssignableFrom(type);
             return type.GetMethods(flags)
                 .Concat(type.GetInterfaces()
                     .SelectMany(@interface => @interface.GetMethods(flags)))
+                .Where(method => !isDisposable || method.Name != nameof(IDisposable.Dispose))
                 .Distinct();
         }
 

LazyProxy/LazyProxyBuilder.cs

@@ -0,0 +1,35 @@
+using System;
+
+namespace LazyProxy
+{
+    /// <summary>
+    /// This type hosts methods being used by lazy proxy implementations.
+    /// </summary>
+    public static class LazyProxyImplementation
+    {
+        /// <summary>
+        /// Creates an instance of <see cref="Lazy{T}"/>.
+        /// </summary>
+        /// <param name="valueFactory">Function that returns a value.</param>
+        /// <typeparam name="T">Type of lazy value.</typeparam>
+        /// <returns>Instance of <see cref="Lazy{T}"/></returns>
+        public static Lazy<T> CreateInstance<T>(Func<object> valueFactory)
+        {
+            return new Lazy<T>(() => (T) valueFactory());
+        }
+
+        /// <summary>
+        /// Disposes an instance owned by <see cref="Lazy{T}"/> if any.
+        /// </summary>
+        /// <param name="instanceOwner"><see cref="Lazy{T}"/> object.</param>
+        /// <typeparam name="T">Type of lazy value. It must implement <see cref="IDisposable"/> interface.</typeparam>
+        public static void DisposeInstance<T>(Lazy<T> instanceOwner)
+            where T: IDisposable
+        {
+            if (instanceOwner.IsValueCreated)
+            {
+                instanceOwner.Value.Dispose();
+            }
+        }
+    }
+}