fix issue 166 (#181)

Author: liuhaoyang

core/src/AspectCore.Abstractions/DynamicProxy/ServiceInterceptorAttribute.cs

@@ -1,10 +1,11 @@
 using System;
 using System.Reflection;
+using System.Runtime;
 using System.Threading.Tasks;
 
 namespace AspectCore.DynamicProxy
 {
-    public sealed class ServiceInterceptorAttribute : AbstractInterceptorAttribute
+    public sealed class ServiceInterceptorAttribute : AbstractInterceptorAttribute, IEquatable<ServiceInterceptorAttribute>
     {
         private readonly Type _interceptorType;
 
@@ -16,6 +17,7 @@ public ServiceInterceptorAttribute(Type interceptorType)
             {
                 throw new ArgumentNullException(nameof(interceptorType));
             }
+
             if (!typeof(IInterceptor).GetTypeInfo().IsAssignableFrom(interceptorType.GetTypeInfo()))
             {
                 throw new ArgumentException($"{interceptorType} is not an interceptor.", nameof(interceptorType));
@@ -31,7 +33,28 @@ public override Task Invoke(AspectContext context, AspectDelegate next)
             {
                 throw new InvalidOperationException($"Cannot resolve type  '{_interceptorType}' of service interceptor.");
             }
+
             return instance.Invoke(context, next);
         }
+
+        public bool Equals(ServiceInterceptorAttribute other)
+        {
+            if (other == null)
+            {
+                return false;
+            }
+            return _interceptorType == other._interceptorType;
+        }
+        
+        public override bool Equals(object obj)
+        {
+            var other = obj as ServiceInterceptorAttribute;
+            return Equals(other);
+        }
+
+        public override int GetHashCode()
+        {
+            return _interceptorType.GetHashCode();
+        }
     }
 }

core/src/AspectCore.Core/DynamicProxy/AttributeAdditionalInterceptorSelector.cs

@@ -10,16 +10,23 @@ public sealed class AttributeAdditionalInterceptorSelector : IAdditionalIntercep
     {
         public IEnumerable<IInterceptor> Select(MethodInfo serviceMethod, MethodInfo implementationMethod)
         {
+            if (serviceMethod == implementationMethod)
+            {
+                yield break;
+            }
+
             foreach (var attribute in implementationMethod.DeclaringType.GetTypeInfo().GetReflector().GetCustomAttributes())
             {
                 if (attribute is IInterceptor interceptor)
                     yield return interceptor;
             }
+
             foreach (var attribute in implementationMethod.GetReflector().GetCustomAttributes())
             {
                 if (attribute is IInterceptor interceptor)
                     yield return interceptor;
             }
+
             if (!serviceMethod.DeclaringType.GetTypeInfo().IsClass)
             {
                 foreach (var interceptor in SelectFromBase(implementationMethod))
@@ -36,6 +43,7 @@ private IEnumerable<IInterceptor> SelectFromBase(MethodInfo implementationMethod
             {
                 return interceptors;
             }
+
             var baseMethod = baseType.GetTypeInfo().GetMethodBySignature(new MethodSignature(implementationMethod));
             if (baseMethod != null)
             {
@@ -44,13 +52,16 @@ private IEnumerable<IInterceptor> SelectFromBase(MethodInfo implementationMethod
                     if (attribute is IInterceptor interceptor && interceptor.Inherited)
                         interceptors.Add(interceptor);
                 }
+
                 foreach (var attribute in baseMethod.GetReflector().GetCustomAttributes())
                 {
                     if (attribute is IInterceptor interceptor && interceptor.Inherited)
                         interceptors.Add(interceptor);
                 }
+
                 interceptors.AddRange(SelectFromBase(baseMethod).Where(x => x.Inherited));
             }
+
             return interceptors;
         }
     }

core/src/AspectCore.Core/DynamicProxy/InterceptorCollector.cs

@@ -60,7 +60,7 @@ public IEnumerable<IInterceptor> Collect(MethodInfo serviceMethod, MethodInfo im
                return HandleInjector(CollectFromService(serviceMethod).
                     Concat(CollectFromAdditionalSelector(serviceMethod, implementationMethod)).
                     HandleSort().
-                    HandleMultiple()).ToArray();
+                    HandleMultiple()).Distinct().ToArray();
             });
         }
 

core/test/AspectCore.Tests/Integrate/ServiceInterceptorTests.cs

@@ -0,0 +1,49 @@
+using System.Threading.Tasks;
+using AspectCore.Configuration;
+using AspectCore.DynamicProxy;
+using AspectCore.Injector;
+using Xunit;
+
+namespace AspectCore.Tests.Integrate
+{
+    public class ServiceInterceptorTests : IntegrateTestBase
+    {
+        [Fact]
+        public void Service_Interceptor_Tests()
+        {
+            var service = ServiceResolver.Resolve<IProxyTransient>();
+            Assert.Equal(1, service.Foo());
+        }
+
+        protected override void ConfigureService(IServiceContainer serviceContainer)
+        {
+            serviceContainer.AddType<Test>();
+            serviceContainer.AddType<IProxyTransient,ProxyTransient>();
+        }
+
+        public class Test : AbstractInterceptor
+        {
+            public override async Task Invoke(AspectContext context, AspectDelegate next)
+            {
+                await next(context);
+                var val = (int) context.ReturnValue;
+                context.ReturnValue = val + 1;
+            }
+        }
+
+        [ServiceInterceptor(typeof(Test))]
+        public interface IProxyTransient
+        {
+            int Foo();
+        }
+
+        [ServiceInterceptor(typeof(Test))]
+        public class ProxyTransient : IProxyTransient
+        {
+            public virtual int Foo()
+            {
+                return 0;
+            }
+        }
+    }
+}