fix #279 (#295)

PurplestViper · web-flow · commit aa00865dbfb9 · 2022-12-30T15:04:35.000+08:00
* fix #279 * Change AspectExceptionWrapper lifetime to Transient
diff --git a/src/AspectCore.Abstractions/DynamicProxy/AspectExceptionWrapper.cs b/src/AspectCore.Abstractions/DynamicProxy/AspectExceptionWrapper.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Runtime.ExceptionServices;
 using AspectCore.Configuration;
 
 namespace AspectCore.DynamicProxy
@@ -7,25 +8,27 @@ namespace AspectCore.DynamicProxy
     public class AspectExceptionWrapper : IAspectExceptionWrapper
     {
         private readonly IAspectConfiguration _configuration;
+        private ExceptionDispatchInfo _exceptionInfo;
 
         public AspectExceptionWrapper(IAspectConfiguration configuration)
         {
             _configuration = configuration;
         }
 
-        public Exception Wrap(AspectContext aspectContext, Exception exception)
+        public void Wrap(AspectContext aspectContext, Exception exception)
         {
-            if (!_configuration.ThrowAspectException)
+            if (!_configuration.ThrowAspectException || exception is AspectInvocationException _)
             {
-                return exception;
+                _exceptionInfo = ExceptionDispatchInfo.Capture(exception);
+                return;
             }
 
-            if (exception is AspectInvocationException aspectInvocationException)
-            {
-                return aspectInvocationException;
-            }
+            _exceptionInfo = ExceptionDispatchInfo.Capture(new AspectInvocationException(aspectContext, exception));
+        }
 
-            return new AspectInvocationException(aspectContext, exception);
+        public void ThrowIfFailed()
+        {
+            _exceptionInfo?.Throw();
         }
     }
 }
diff --git a/src/AspectCore.Abstractions/DynamicProxy/IAspectExceptionWrapper.cs b/src/AspectCore.Abstractions/DynamicProxy/IAspectExceptionWrapper.cs
@@ -4,6 +4,8 @@ namespace AspectCore.DynamicProxy
 {
     public interface IAspectExceptionWrapper
     {
-        Exception Wrap(AspectContext aspectContext, Exception exception);
+        void Wrap(AspectContext aspectContext, Exception exception);
+
+        void ThrowIfFailed();
     }
 }
diff --git a/src/AspectCore.Core/DependencyInjection/ServiceContext.cs b/src/AspectCore.Core/DependencyInjection/ServiceContext.cs
@@ -100,7 +100,7 @@ private void AddInternalServices()
             if (!Contains(typeof(IAspectCachingProvider)))
                 Singletons.AddType<IAspectCachingProvider, AspectCachingProvider>();
             if (!Contains(typeof(IAspectExceptionWrapper)))
-                Singletons.AddType<IAspectExceptionWrapper, AspectExceptionWrapper>();
+                Transients.AddType<IAspectExceptionWrapper, AspectExceptionWrapper>();
         }
 
         public int Count => _collection.Count;
diff --git a/src/AspectCore.Core/DynamicProxy/AspectActivator.cs b/src/AspectCore.Core/DynamicProxy/AspectActivator.cs
@@ -1,8 +1,6 @@
-﻿using System;
-using System.Diagnostics;
+﻿using AspectCore.Core.Utils;
+using System;
 using System.Threading.Tasks;
-using AspectCore.Core.Utils;
-using AspectCore.Utils;
 
 namespace AspectCore.DynamicProxy
 {
@@ -29,7 +27,10 @@ public TResult Invoke<TResult>(AspectActivatorContext activatorContext)
                 var aspectBuilder = _aspectBuilderFactory.Create(context);
                 var task = aspectBuilder.Build()(context);
                 if (task.IsFaulted)
-                    throw _aspectExceptionWrapper.Wrap(context, task.Exception.InnerException);
+                {
+                    _aspectExceptionWrapper.Wrap(context, task.Exception.InnerException);
+                    return default;
+                }
                 if (!task.IsCompleted)
                 {
                     // try to avoid potential deadlocks.
@@ -41,10 +42,12 @@ public TResult Invoke<TResult>(AspectActivatorContext activatorContext)
             }
             catch (Exception ex)
             {
-                throw _aspectExceptionWrapper.Wrap(context, ex);
+                _aspectExceptionWrapper.Wrap(context, ex);
+                return default;
             }
             finally
             {
+                _aspectExceptionWrapper.ThrowIfFailed();
                 _aspectContextFactory.ReleaseContext(context);
             }
         }
@@ -59,7 +62,8 @@ public async Task<TResult> InvokeTask<TResult>(AspectActivatorContext activatorC
 
                 if (invoke.IsFaulted)
                 {
-                    throw _aspectExceptionWrapper.Wrap(context, invoke.Exception?.InnerException);
+                    _aspectExceptionWrapper.Wrap(context, invoke.Exception.InnerException);
+                    return default;
                 }
 
                 if (!invoke.IsCompleted)
@@ -70,22 +74,25 @@ public async Task<TResult> InvokeTask<TResult>(AspectActivatorContext activatorC
                 switch (context.ReturnValue)
                 {
                     case null:
-                        return default(TResult);
+                        return default;
                     case Task<TResult> taskWithResult:
                         return taskWithResult.Result;
                     case Task _:
-                        return default(TResult);
+                        return default;
                     default:
-                        throw _aspectExceptionWrapper.Wrap(context, new InvalidCastException(
+                        _aspectExceptionWrapper.Wrap(context, new InvalidCastException(
                             $"Unable to cast object of type '{context.ReturnValue.GetType()}' to type '{typeof(Task<TResult>)}'."));
+                        return default;
                 }
             }
             catch (Exception ex)
             {
-                throw _aspectExceptionWrapper.Wrap(context, ex);
+                _aspectExceptionWrapper.Wrap(context, ex);
+                return default;
             }
             finally
             {
+                _aspectExceptionWrapper.ThrowIfFailed();
                 _aspectContextFactory.ReleaseContext(context);
             }
         }
@@ -100,7 +107,8 @@ public async ValueTask<TResult> InvokeValueTask<TResult>(AspectActivatorContext
                 
                 if (invoke.IsFaulted)
                 {
-                    throw _aspectExceptionWrapper.Wrap(context, invoke.Exception?.InnerException);
+                    _aspectExceptionWrapper.Wrap(context, invoke.Exception.InnerException);
+                    return default;
                 }
                 
                 if (!invoke.IsCompleted)
@@ -111,22 +119,25 @@ public async ValueTask<TResult> InvokeValueTask<TResult>(AspectActivatorContext
                 switch (context.ReturnValue)
                 {
                     case null:
-                        return default(TResult);
+                        return default;
                     case ValueTask<TResult> taskWithResult:
                         return taskWithResult.Result;
                     case ValueTask task:
-                        return default(TResult);
+                        return default;
                     default:
-                        throw _aspectExceptionWrapper.Wrap(context, new InvalidCastException(
+                        _aspectExceptionWrapper.Wrap(context, new InvalidCastException(
                             $"Unable to cast object of type '{context.ReturnValue.GetType()}' to type '{typeof(ValueTask<TResult>)}'."));
+                        return default;
                 }
             }
             catch (Exception ex)
             {
-                throw _aspectExceptionWrapper.Wrap(context, ex);
+                _aspectExceptionWrapper.Wrap(context, ex);
+                return default;
             }
             finally
             {
+                _aspectExceptionWrapper.ThrowIfFailed();
                 _aspectContextFactory.ReleaseContext(context);
             }
         }
diff --git a/src/AspectCore.Extensions.Autofac/ContainerBuilderExtensions.cs b/src/AspectCore.Extensions.Autofac/ContainerBuilderExtensions.cs
@@ -58,7 +58,7 @@ public static ContainerBuilder RegisterDynamicProxy(this ContainerBuilder contai
             containerBuilder.RegisterType<AspectBuilderFactory>().As<IAspectBuilderFactory>().SingleInstance();
             containerBuilder.RegisterType<ProxyTypeGenerator>().As<IProxyTypeGenerator>().SingleInstance();
             containerBuilder.RegisterType<AspectCachingProvider>().As<IAspectCachingProvider>().SingleInstance();
-            containerBuilder.RegisterType<AspectExceptionWrapper>().As<IAspectExceptionWrapper>().SingleInstance();
+            containerBuilder.RegisterType<AspectExceptionWrapper>().As<IAspectExceptionWrapper>().InstancePerDependency();
 
             //全局注册中间件
             containerBuilder.ComponentRegistryBuilder.Registered += (sender, args) =>
diff --git a/src/AspectCore.Extensions.DependencyInjection/ServiceCollectionExtensions.cs b/src/AspectCore.Extensions.DependencyInjection/ServiceCollectionExtensions.cs
@@ -59,7 +59,7 @@ internal static IServiceCollection TryAddDynamicProxyServices(this IServiceColle
             services.TryAddSingleton<IAspectBuilderFactory, AspectBuilderFactory>();
             services.TryAddSingleton<IProxyTypeGenerator, ProxyTypeGenerator>();
             services.TryAddSingleton<IAspectCachingProvider, AspectCachingProvider>();
-            services.TryAddSingleton<IAspectExceptionWrapper, AspectExceptionWrapper>();
+            services.TryAddTransient<IAspectExceptionWrapper, AspectExceptionWrapper>();
 
             services.AddSingleton<IInterceptorSelector, ConfigureInterceptorSelector>();
             services.AddSingleton<IInterceptorSelector, AttributeInterceptorSelector>();
diff --git a/src/AspectCore.Extensions.LightInject/ContainerBuilderExtensions.cs b/src/AspectCore.Extensions.LightInject/ContainerBuilderExtensions.cs
@@ -73,7 +73,7 @@ public static IServiceContainer RegisterDynamicProxy(this IServiceContainer cont
                 .AddSingleton<IAspectBuilderFactory, AspectBuilderFactory>()
                 .AddSingleton<IProxyTypeGenerator, ProxyTypeGenerator>()
                 .AddSingleton<IAspectCachingProvider, AspectCachingProvider>()
-                .AddSingleton<IAspectExceptionWrapper, AspectExceptionWrapper>();
+                .AddTransient(typeof(IAspectExceptionWrapper), typeof(AspectExceptionWrapper));
 
             var aspectValidator = new AspectValidatorBuilder(aspectConfig).Build();
             container.Decorate(aspectValidator.CreateDecorator());
diff --git a/src/AspectCore.Extensions.Windsor/AspectCoreFacility.cs b/src/AspectCore.Extensions.Windsor/AspectCoreFacility.cs
@@ -36,7 +36,7 @@ public void Init(IKernel kernel, IConfiguration facilityConfig)
                 Component.For<IInterceptorCollector>().ImplementedBy<InterceptorCollector>().LifestyleSingleton(),
                 Component.For<IAspectContextFactory>().ImplementedBy<AspectContextFactory>().LifestyleSingleton(),
                 Component.For<IAspectCachingProvider>().ImplementedBy<AspectCachingProvider>().LifestyleSingleton(),
-                Component.For<IAspectExceptionWrapper>().ImplementedBy<AspectExceptionWrapper>().LifestyleSingleton(),
+                Component.For<IAspectExceptionWrapper>().ImplementedBy<AspectExceptionWrapper>().LifestyleTransient(),
                 Component.For<IAspectActivatorFactory>().ImplementedBy<AspectActivatorFactory>().LifestyleSingleton(),
                 Component.For<IAspectValidatorBuilder>().ImplementedBy<AspectValidatorBuilder>().LifestyleSingleton(),
                 Component.For<IPropertyInjectorFactory>().ImplementedBy<PropertyInjectorFactory>().LifestyleSingleton(),

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`using System;`
	`2`	`+using System.Runtime.ExceptionServices;`
`2`	`3`	`using AspectCore.Configuration;`
`3`	`4`
`4`	`5`	`namespace AspectCore.DynamicProxy`
`@@ -7,25 +8,27 @@ namespace AspectCore.DynamicProxy`
`7`	`8`	`public class AspectExceptionWrapper : IAspectExceptionWrapper`
`8`	`9`	`{`
`9`	`10`	`private readonly IAspectConfiguration _configuration;`
	`11`	`+ private ExceptionDispatchInfo _exceptionInfo;`
`10`	`12`
`11`	`13`	`public AspectExceptionWrapper(IAspectConfiguration configuration)`
`12`	`14`	`{`
`13`	`15`	`_configuration = configuration;`
`14`	`16`	`}`
`15`	`17`
`16`		`- public Exception Wrap(AspectContext aspectContext, Exception exception)`
	`18`	`+ public void Wrap(AspectContext aspectContext, Exception exception)`
`17`	`19`	`{`
`18`		`- if (!_configuration.ThrowAspectException)`
	`20`	`+ if (!_configuration.ThrowAspectException \|\| exception is AspectInvocationException _)`
`19`	`21`	`{`
`20`		`- return exception;`
	`22`	`+ _exceptionInfo = ExceptionDispatchInfo.Capture(exception);`
	`23`	`+ return;`
`21`	`24`	`}`
`22`	`25`
`23`		`- if (exception is AspectInvocationException aspectInvocationException)`
`24`		`- {`
`25`		`- return aspectInvocationException;`
`26`		`- }`
	`26`	`+ _exceptionInfo = ExceptionDispatchInfo.Capture(new AspectInvocationException(aspectContext, exception));`
	`27`	`+ }`
`27`	`28`
`28`		`- return new AspectInvocationException(aspectContext, exception);`
	`29`	`+ public void ThrowIfFailed()`
	`30`	`+ {`
	`31`	`+ _exceptionInfo?.Throw();`
`29`	`32`	`}`
`30`	`33`	`}`
`31`	`34`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,8 @@ namespace AspectCore.DynamicProxy`
`4`	`4`	`{`
`5`	`5`	`public interface IAspectExceptionWrapper`
`6`	`6`	`{`
`7`		`- Exception Wrap(AspectContext aspectContext, Exception exception);`
	`7`	`+ void Wrap(AspectContext aspectContext, Exception exception);`
	`8`	`+`
	`9`	`+ void ThrowIfFailed();`
`8`	`10`	`}`
`9`	`11`	`}`
Original file line number	Diff line number	Diff line change
`@@ -100,7 +100,7 @@ private void AddInternalServices()`
`100`	`100`	`if (!Contains(typeof(IAspectCachingProvider)))`
`101`	`101`	`Singletons.AddType<IAspectCachingProvider, AspectCachingProvider>();`
`102`	`102`	`if (!Contains(typeof(IAspectExceptionWrapper)))`
`103`		`- Singletons.AddType<IAspectExceptionWrapper, AspectExceptionWrapper>();`
	`103`	`+ Transients.AddType<IAspectExceptionWrapper, AspectExceptionWrapper>();`
`104`	`104`	`}`
`105`	`105`
`106`	`106`	`public int Count => _collection.Count;`
Original file line number	Diff line number	Diff line change
`@@ -1,8 +1,6 @@`
`1`		`-using System;`
`2`		`-using System.Diagnostics;`
	`1`	`+using AspectCore.Core.Utils;`
	`2`	`+using System;`
`3`	`3`	`using System.Threading.Tasks;`
`4`		`-using AspectCore.Core.Utils;`
`5`		`-using AspectCore.Utils;`
`6`	`4`
`7`	`5`	`namespace AspectCore.DynamicProxy`
`8`	`6`	`{`
`@@ -29,7 +27,10 @@ public TResult Invoke<TResult>(AspectActivatorContext activatorContext)`
`29`	`27`	`var aspectBuilder = _aspectBuilderFactory.Create(context);`
`30`	`28`	`var task = aspectBuilder.Build()(context);`
`31`	`29`	`if (task.IsFaulted)`
`32`		`- throw _aspectExceptionWrapper.Wrap(context, task.Exception.InnerException);`
	`30`	`+ {`
	`31`	`+ _aspectExceptionWrapper.Wrap(context, task.Exception.InnerException);`
	`32`	`+ return default;`
	`33`	`+ }`
`33`	`34`	`if (!task.IsCompleted)`
`34`	`35`	`{`
`35`	`36`	`// try to avoid potential deadlocks.`
`@@ -41,10 +42,12 @@ public TResult Invoke<TResult>(AspectActivatorContext activatorContext)`
`41`	`42`	`}`
`42`	`43`	`catch (Exception ex)`
`43`	`44`	`{`
`44`		`- throw _aspectExceptionWrapper.Wrap(context, ex);`
	`45`	`+ _aspectExceptionWrapper.Wrap(context, ex);`
	`46`	`+ return default;`
`45`	`47`	`}`
`46`	`48`	`finally`
`47`	`49`	`{`
	`50`	`+ _aspectExceptionWrapper.ThrowIfFailed();`
`48`	`51`	`_aspectContextFactory.ReleaseContext(context);`
`49`	`52`	`}`
`50`	`53`	`}`
`@@ -59,7 +62,8 @@ public async Task<TResult> InvokeTask<TResult>(AspectActivatorContext activatorC`
`59`	`62`
`60`	`63`	`if (invoke.IsFaulted)`
`61`	`64`	`{`
`62`		`- throw _aspectExceptionWrapper.Wrap(context, invoke.Exception?.InnerException);`
	`65`	`+ _aspectExceptionWrapper.Wrap(context, invoke.Exception.InnerException);`
	`66`	`+ return default;`
`63`	`67`	`}`
`64`	`68`
`65`	`69`	`if (!invoke.IsCompleted)`
`@@ -70,22 +74,25 @@ public async Task<TResult> InvokeTask<TResult>(AspectActivatorContext activatorC`
`70`	`74`	`switch (context.ReturnValue)`
`71`	`75`	`{`
`72`	`76`	`case null:`
`73`		`- return default(TResult);`
	`77`	`+ return default;`
`74`	`78`	`case Task<TResult> taskWithResult:`
`75`	`79`	`return taskWithResult.Result;`
`76`	`80`	`case Task _:`
`77`		`- return default(TResult);`
	`81`	`+ return default;`
`78`	`82`	`default:`
`79`		`- throw _aspectExceptionWrapper.Wrap(context, new InvalidCastException(`
	`83`	`+ _aspectExceptionWrapper.Wrap(context, new InvalidCastException(`
`80`	`84`	`$"Unable to cast object of type '{context.ReturnValue.GetType()}' to type '{typeof(Task<TResult>)}'."));`
	`85`	`+ return default;`
`81`	`86`	`}`
`82`	`87`	`}`
`83`	`88`	`catch (Exception ex)`
`84`	`89`	`{`
`85`		`- throw _aspectExceptionWrapper.Wrap(context, ex);`
	`90`	`+ _aspectExceptionWrapper.Wrap(context, ex);`
	`91`	`+ return default;`
`86`	`92`	`}`
`87`	`93`	`finally`
`88`	`94`	`{`
	`95`	`+ _aspectExceptionWrapper.ThrowIfFailed();`
`89`	`96`	`_aspectContextFactory.ReleaseContext(context);`
`90`	`97`	`}`
`91`	`98`	`}`
`@@ -100,7 +107,8 @@ public async ValueTask<TResult> InvokeValueTask<TResult>(AspectActivatorContext`
`100`	`107`
`101`	`108`	`if (invoke.IsFaulted)`
`102`	`109`	`{`
`103`		`- throw _aspectExceptionWrapper.Wrap(context, invoke.Exception?.InnerException);`
	`110`	`+ _aspectExceptionWrapper.Wrap(context, invoke.Exception.InnerException);`
	`111`	`+ return default;`
`104`	`112`	`}`
`105`	`113`
`106`	`114`	`if (!invoke.IsCompleted)`
`@@ -111,22 +119,25 @@ public async ValueTask<TResult> InvokeValueTask<TResult>(AspectActivatorContext`
`111`	`119`	`switch (context.ReturnValue)`
`112`	`120`	`{`
`113`	`121`	`case null:`
`114`		`- return default(TResult);`
	`122`	`+ return default;`
`115`	`123`	`case ValueTask<TResult> taskWithResult:`
`116`	`124`	`return taskWithResult.Result;`
`117`	`125`	`case ValueTask task:`
`118`		`- return default(TResult);`
	`126`	`+ return default;`
`119`	`127`	`default:`
`120`		`- throw _aspectExceptionWrapper.Wrap(context, new InvalidCastException(`
	`128`	`+ _aspectExceptionWrapper.Wrap(context, new InvalidCastException(`
`121`	`129`	`$"Unable to cast object of type '{context.ReturnValue.GetType()}' to type '{typeof(ValueTask<TResult>)}'."));`
	`130`	`+ return default;`
`122`	`131`	`}`
`123`	`132`	`}`
`124`	`133`	`catch (Exception ex)`
`125`	`134`	`{`
`126`		`- throw _aspectExceptionWrapper.Wrap(context, ex);`
	`135`	`+ _aspectExceptionWrapper.Wrap(context, ex);`
	`136`	`+ return default;`
`127`	`137`	`}`
`128`	`138`	`finally`
`129`	`139`	`{`
	`140`	`+ _aspectExceptionWrapper.ThrowIfFailed();`
`130`	`141`	`_aspectContextFactory.ReleaseContext(context);`
`131`	`142`	`}`
`132`	`143`	`}`