- Fix issues #148 #117

src/Scrutor/ServiceCollectionExtensions.Decoration.cs

@@ -341,9 +341,16 @@ private static object GetInstance(this IServiceProvider provider, ServiceDescrip
                 return descriptor.ImplementationInstance;
             }
 
-            if (descriptor.ImplementationType != null)
+            // Not suppose to be abstract. 
+            Type implementationType = descriptor.ImplementationType;
+            if (implementationType != null)
             {
-                return provider.GetServiceOrCreateInstance(descriptor.ImplementationType);
+                if (implementationType != descriptor.ServiceType)
+                    return provider.GetServiceOrCreateInstance(implementationType);
+
+                // Since implementationType is equal to ServiceType we need explicitly create an implementation type through reflections in order to avoid infinite recursion.
+                // Should not cause issue with singletons, since singleton will be a decorator and after this fact we can don't care about lifecycle of decorable service (for sure, if IDisposable of decorator disposes underlying type:))
+                return provider.CreateInstance(implementationType);
             }
 
             return descriptor.ImplementationFactory(provider);

test/Scrutor.Tests/DecorationTests.cs

@@ -217,8 +217,47 @@ public void DecoratingNonRegisteredServiceThrows()
             Assert.Throws<MissingTypeRegistrationException>(() => ConfigureProvider(services => services.Decorate<IDecoratedService, Decorator>()));
         }
 
+        [Fact]
+        public void Issue148_Decorate_IsAbleToDecorateConcreateTypes()
+        {
+            var sp = ConfigureProvider(sc =>
+            {
+                sc
+                    .AddTransient<IService, SomeRandomService>()
+                    .AddTransient<DecoratedService>()
+                    .Decorate<DecoratedService, Decorator2>();
+            });
+
+            var result = sp.GetService<DecoratedService>() as Decorator2;
+
+            Assert.NotNull(result);  
+            Assert.NotNull(result.Inner);
+            Assert.NotNull(result.Inner.Dependency);
+        }
+
         public interface IDecoratedService { }
 
+        public class DecoratedService
+        {
+            public DecoratedService(IService dependency)
+            {
+                Dependency = dependency;
+            }
+
+            public IService Dependency { get; }
+        }
+
+        public class Decorator2 : DecoratedService
+        {
+            public Decorator2(DecoratedService decoratedService)
+                : base(null)
+            {
+                Inner = decoratedService;
+            }
+
+            public DecoratedService Inner { get; }
+        }
+
         public interface IService { }
 
         private class SomeRandomService : IService { }