From: <fab...@us...> - 2009-04-24 16:07:52
|
Revision: 4212 http://nhibernate.svn.sourceforge.net/nhibernate/?rev=4212&view=rev Author: fabiomaulo Date: 2009-04-24 16:07:40 +0000 (Fri, 24 Apr 2009) Log Message: ----------- - last available Spring libraries (now signed) - inclusion of Spring stuff in default build Modified Paths: -------------- trunk/nhibernate/default.build trunk/nhibernate/lib/net/3.5/Spring.Aop.dll trunk/nhibernate/lib/net/3.5/Spring.Aop.xml trunk/nhibernate/lib/net/3.5/Spring.Core.dll trunk/nhibernate/lib/net/3.5/Spring.Core.xml Modified: trunk/nhibernate/default.build =================================================================== --- trunk/nhibernate/default.build 2009-04-24 06:46:40 UTC (rev 4211) +++ trunk/nhibernate/default.build 2009-04-24 16:07:40 UTC (rev 4212) @@ -30,6 +30,8 @@ <include name="NHibernate.ByteCode.LinFu.Tests/ByteCode.Test.build" /> <include name="NHibernate.ByteCode.Castle/ByteCode.build" /> <include name="NHibernate.ByteCode.Castle.Tests/ByteCode.Test.build" /> + <include name="NHibernate.ByteCode.Spring/ByteCode.build" /> + <include name="NHibernate.ByteCode.Spring.Tests/ByteCode.Test.build" /> <include name="NHibernate.DomainModel/NHibernate.DomainModel.build" /> <include name="NHibernate.Test/NHibernate.Test.build" /> <include name="NHibernate.Test.Performance/NHibernate.Test.Performance.build" /> @@ -41,6 +43,7 @@ <include name="Iesi.Collections.Test/Iesi.Collections.Test.build" /> <include name="NHibernate.ByteCode.LinFu.Tests/ByteCode.Test.build" /> <include name="NHibernate.ByteCode.Castle.Tests/ByteCode.Test.build" /> + <include name="NHibernate.ByteCode.Spring.Tests/ByteCode.Test.build" /> <include name="NHibernate.Test/NHibernate.Test.build" /> <include name="NHibernate.Test.Performance/NHibernate.Test.Performance.build" if="${run.performance.tests}" /> Modified: trunk/nhibernate/lib/net/3.5/Spring.Aop.dll =================================================================== (Binary files differ) Modified: trunk/nhibernate/lib/net/3.5/Spring.Aop.xml =================================================================== --- trunk/nhibernate/lib/net/3.5/Spring.Aop.xml 2009-04-24 06:46:40 UTC (rev 4211) +++ trunk/nhibernate/lib/net/3.5/Spring.Aop.xml 2009-04-24 16:07:40 UTC (rev 4212) @@ -4,885 +4,1020 @@ <name>Spring.Aop</name> </assembly> <members> - <member name="T:Spring.Aop.Target.AbstractPoolingTargetSource"> + <member name="T:Spring.Aop.Config.AopNamespaceParser"> <summary> - Abstract superclass for pooling <see cref="T:Spring.Aop.ITargetSource"/>s. + Namespace parser for the aop namespace. </summary> <remarks> - <p> - Maintains a pool of target instances, acquiring and releasing a target - object from the pool for each method invocation. - </p> - <p> - This class is independent of pooling technology. - </p> - <p> - Subclasses must implement the - <see cref="M:Spring.Aop.Target.AbstractPoolingTargetSource.GetTarget"/> and - <see cref="M:Spring.Aop.Target.AbstractPoolingTargetSource.ReleaseTarget(System.Object)"/> - methods to work with their chosen pool. The - <see cref="M:Spring.Aop.Target.AbstractPrototypeTargetSource.NewPrototypeInstance"/> - method inherited from the - <see cref="T:Spring.Aop.Target.AbstractPrototypeTargetSource"/> base class - can be used to create objects to put in the pool. Subclasses must also - implement some of the monitoring methods from the - <see cref="T:Spring.Aop.Target.PoolingConfig"/> interface. This class - provides the - <see cref="M:Spring.Aop.Target.AbstractPoolingTargetSource.GetPoolingConfigMixin"/> - method to return an <see cref="T:Spring.Aop.IIntroductionAdvisor"/> - making these statistics available on proxied objects. - </p> - <p> - This class implements the <see cref="T:System.IDisposable"/> interface in - order to force subclasses to implement the - <see cref="M:System.IDisposable.Dispose"/> method to cleanup and close - down their pool. - </p> + Using the <code>advisor</code> tag you can configure an <see cref="T:Spring.Aop.IAdvisor"/> and have it + applied to all the relevant objects in your application context automatically. The + <code>advisor</code> tag supports only referenced <see cref="T:Spring.Aop.IPointcut"/>s. </remarks> + <author>Rob harrop</author> + <author>Adrian Colyer</author> <author>Rod Johnson</author> - <author>Federico Spinazzi (.NET)</author> + <author>Mark Pollack (.NET)</author> </member> - <member name="T:Spring.Aop.Target.AbstractPrototypeTargetSource"> + <member name="M:Spring.Aop.Config.AopNamespaceParser.Init"> <summary> - Base class for dynamic <see cref="T:Spring.Aop.ITargetSource"/> - implementations that can create new prototype object instances to - support a pooling or new-instance-per-invocation strategy. + Register the <see cref="T:Spring.Objects.Factory.Xml.IObjectDefinitionParser"/> for the '<code>config</code>' tag. </summary> - <remarks> - <p> - All such <see cref="T:Spring.Aop.ITargetSource"/>s must run in an - <see cref="T:Spring.Objects.Factory.IObjectFactory"/>, as they need to - call the <see cref="M:Spring.Objects.Factory.IObjectFactory.GetObject(System.String)"/> - method to create a new prototype instance. - </p> - </remarks> - <author>Rod Johnson</author> - <author>Federico Spinazzi (.NET)</author> </member> - <member name="T:Spring.Aop.ITargetSource"> + <member name="T:Spring.Aop.Config.AopNamespaceUtils"> <summary> - Used to obtain the current "target" of an AOP invocation + Utility class for handling registration of auto-proxy creators used internally by the + <code>aop</code> namespace tags. </summary> - <remarks> - <p> - This target will be invoked via reflection if no around advice chooses - to end the interceptor chain itself. - </p> - <p> - If an <see cref="T:Spring.Aop.ITargetSource"/> is <c>"static"</c>, it - will always return the same target, allowing optimizations in the AOP - framework. Dynamic target sources can support pooling, hot swapping etc. - </p> - <p> - Application developers don't usually need to work with target sources - directly: this is an AOP framework interface. - </p> - </remarks> - <author>Rod Johnson</author> - <author>Aleksandar Seovic (.NET)</author> + <author>Rob Harrop</author> + <author>Juergen Hoeller</author> + <author>Mark Pollack (.NET)</author> </member> - <member name="M:Spring.Aop.ITargetSource.GetTarget"> + <member name="F:Spring.Aop.Config.AopNamespaceUtils.AUTO_PROXY_CREATOR_OBJECT_NAME"> <summary> - Returns the target object. + The object name of the internally managed auto-proxy creator. </summary> - <returns>The target object.</returns> - <exception cref="T:System.Exception"> - If unable to obtain the target object. - </exception> </member> - <member name="M:Spring.Aop.ITargetSource.ReleaseTarget(System.Object)"> + <member name="M:Spring.Aop.Config.AopNamespaceUtils.RegisterAutoProxyCreatorIfNecessary(Spring.Objects.Factory.Xml.ParserContext,System.Xml.XmlElement)"> <summary> - Releases the target object. + Registers the auto proxy creator if necessary. </summary> - <param name="target">The target object to release.</param> + <param name="parserContext">The parser context.</param> + <param name="sourceElement">The source element.</param> </member> - <member name="P:Spring.Aop.ITargetSource.TargetType"> + <member name="M:Spring.Aop.Config.AopNamespaceUtils.RegisterApcAsRequired(System.Type,Spring.Objects.Factory.Xml.ParserContext)"> <summary> - The <see cref="T:System.Type"/> of the target object. + Registries the or escalate apc as required. </summary> + <param name="type">The type.</param> + <param name="parserContext">The parser context.</param> </member> - <member name="P:Spring.Aop.ITargetSource.IsStatic"> + <member name="M:Spring.Aop.Config.AopNamespaceUtils.ForceAutoProxyCreatorToUseDecoratorProxy(Spring.Objects.Factory.Support.IObjectDefinitionRegistry)"> <summary> - Is the target source static? + Forces the auto proxy creator to use decorator proxy. </summary> - <value> - <see langword="true"/> if the target source is static. - </value> + <param name="registry">The registry.</param> </member> - <member name="M:Spring.Aop.Target.AbstractPrototypeTargetSource.#ctor"> + <member name="T:Spring.Aop.Config.ConfigObjectDefinitionParser"> <summary> - Creates a new instance of the - <see cref="T:Spring.Aop.Target.AbstractPrototypeTargetSource"/> - class. + The <see cref="T:Spring.Objects.Factory.Xml.IObjectDefinitionParser"/> for the <code><aop:config></code> tag. </summary> - <remarks> - <p> - This is an <see langword="abstract"/> class, and as such exposes no - public constructors. - </p> - </remarks> + <author>Mark Pollack (.NET)</author> </member> - <member name="M:Spring.Aop.Target.AbstractPrototypeTargetSource.NewPrototypeInstance"> + <member name="F:Spring.Aop.Config.ConfigObjectDefinitionParser.PROXY_TARGET_TYPE"> <summary> - Subclasses should use this method to create a new prototype instance. + The '<code>proxy-target-type</code>' attribute </summary> </member> - <member name="M:Spring.Aop.Target.AbstractPrototypeTargetSource.GetTarget"> + <member name="M:Spring.Aop.Config.ConfigObjectDefinitionParser.ParseElement(System.Xml.XmlElement,Spring.Objects.Factory.Xml.ParserContext)"> <summary> - Returns the target object. + Parse the specified XmlElement and register the resulting + ObjectDefinitions with the <see cref="P:Spring.Objects.Factory.Xml.ParserContext.Registry"/> IObjectDefinitionRegistry + embedded in the supplied <see cref="T:Spring.Objects.Factory.Xml.ParserContext"/> </summary> - <returns>The target object.</returns> - <exception cref="T:System.Exception"> - If unable to obtain the target object. - </exception> + <param name="element">The element to be parsed.</param> + <param name="parserContext">The object encapsulating the current state of the parsing process. + Provides access to a IObjectDefinitionRegistry</param> + <returns>The primary object definition.</returns> + <remarks> + <p> + This method is never invoked if the parser is namespace aware + and was called to process the root node. + </p> + </remarks> </member> - <member name="M:Spring.Aop.Target.AbstractPrototypeTargetSource.ReleaseTarget(System.Object)"> + <member name="M:Spring.Aop.Config.ConfigObjectDefinitionParser.ParseAdvisor(System.Xml.XmlElement,Spring.Objects.Factory.Xml.ParserContext)"> <summary> - Releases the target object. + Parses the supplied advisor element and registers the resulting <see cref="T:Spring.Aop.IAdvisor"/> </summary> - <param name="target">The target object to release.</param> + <param name="advisorElement">The advisor element.</param> + <param name="parserContext">The parser context.</param> </member> - <member name="M:Spring.Aop.Target.AbstractPrototypeTargetSource.AfterPropertiesSet"> + <member name="T:Spring.Aop.Framework.Adapter.AdvisorAdapterRegistrationManager"> <summary> - Invoked by an <see cref="T:Spring.Objects.Factory.IObjectFactory"/> - after it has set all object properties supplied - (and satisfied the - <see cref="T:Spring.Objects.Factory.IObjectFactoryAware"/> - and <see cref="T:Spring.Context.IApplicationContextAware"/> - interfaces). + <see cref="T:Spring.Objects.Factory.Config.IObjectPostProcessor"/> implementation + that registers instances of any non-default + <see cref="T:Spring.Aop.Framework.Adapter.IAdvisorAdapter"/> instances with the + <see cref="T:Spring.Aop.Framework.Adapter.GlobalAdvisorAdapterRegistry"/> + singleton. </summary> <remarks> <p> - Ensures that the <see cref="P:Spring.Aop.Target.AbstractPrototypeTargetSource.TargetObjectName"/> property has been - set to a valid value (i.e. is not <see langword="null"/> or a string - that consists solely of whitespace). + The only requirement for it to work is that it needs to be defined + in an application context along with any arbitrary "non-native" Spring.NET + <see cref="T:Spring.Aop.Framework.Adapter.IAdvisorAdapter"/> instances that need + to be recognized by Spring.NET's AOP framework. </p> </remarks> - <exception cref="T:System.Exception"> - In the event of misconfiguration (such as failure to set an essential - property) or if initialization fails. - </exception> - <seealso cref="M:Spring.Objects.Factory.IInitializingObject.AfterPropertiesSet"/> + <author>Dmitriy Kopylenko</author> + <author>Aleksandar Seovic (.NET)</author> </member> - <member name="F:Spring.Aop.Target.AbstractPrototypeTargetSource.logger"> + <member name="M:Spring.Aop.Framework.Adapter.AdvisorAdapterRegistrationManager.PostProcessBeforeInitialization(System.Object,System.String)"> <summary> - The shared <see cref="T:Common.Logging.ILog"/> instance for this class (and derived classes). + Apply this <see cref="T:Spring.Objects.Factory.Config.IObjectPostProcessor"/> + to the given new object instance <i>before</i> any object initialization callbacks. </summary> + <remarks> + <p> + Does nothing, simply returns the supplied <paramref name="instance"/> as is. + </p> + </remarks> + <param name="instance"> + The new object instance. + </param> + <param name="name"> + The name of the object. + </param> + <returns> + The object instance to use, either the original or a wrapped one. + </returns> + <exception cref="T:Spring.Objects.ObjectsException"> + In case of errors. + </exception> </member> - <member name="P:Spring.Aop.Target.AbstractPrototypeTargetSource.TargetObjectName"> + <member name="M:Spring.Aop.Framework.Adapter.AdvisorAdapterRegistrationManager.PostProcessAfterInitialization(System.Object,System.String)"> <summary> - The name of the target object to be created on each invocation. + Apply this <see cref="T:Spring.Objects.Factory.Config.IObjectPostProcessor"/> to the + given new object instance <i>after</i> any object initialization callbacks. </summary> <remarks> <p> - This object should be a prototype, or the same instance will always - be obtained from the owning <see cref="P:Spring.Aop.Target.AbstractPrototypeTargetSource.ObjectFactory"/>. + Registers the supplied <paramref name="instance"/> with the + <see cref="T:Spring.Aop.Framework.Adapter.GlobalAdvisorAdapterRegistry"/> + singleton if it is an <see cref="T:Spring.Aop.Framework.Adapter.IAdvisorAdapter"/> + instance. </p> </remarks> + <param name="instance"> + The new object instance. + </param> + <param name="objectName"> + The name of the object. + </param> + <returns> + The object instance to use, either the original or a wrapped one. + </returns> + <exception cref="T:Spring.Objects.ObjectsException"> + In case of errors. + </exception> </member> - <member name="P:Spring.Aop.Target.AbstractPrototypeTargetSource.TargetType"> + <member name="T:Spring.Aop.Framework.Adapter.AfterReturningAdviceAdapter"> <summary> - The <see cref="T:System.Type"/> of the target object. + <see cref="T:Spring.Aop.Framework.Adapter.IAdvisorAdapter"/> implementation + to enable <see cref="T:Spring.Aop.IAfterReturningAdvice"/> to be used in the + Spring.NET AOP framework. </summary> + <author>Rod Johnson</author> + <author>Aleksandar Seovic (.NET)</author> </member> - <member name="P:Spring.Aop.Target.AbstractPrototypeTargetSource.IsStatic"> + <member name="T:Spring.Aop.Framework.Adapter.IAdvisorAdapter"> <summary> - Is the target source static? + Permits the handling of new advisors and advice types as extensions to + the Spring AOP framework. </summary> - <value> - <see langword="true"/> if the target source is static. - </value> + <remarks> + <p> + Implementors can create AOP Alliance + <see cref="T:AopAlliance.Intercept.IInterceptor"/>s from custom advice + types, enabling these advice types to be used in the Spring.NET AOP + framework, which uses interception under the covers. + </p> + <p> + There is no need for most Spring.NET users to implement this interface; + do so only if you need to introduce more + <see cref="T:Spring.Aop.IAdvisor"/> or <see cref="T:AopAlliance.Aop.IAdvice"/> + types to Spring.NET. + </p> + </remarks> + <author>Rod Johnson</author> + <author>Aleksandar Seovic (.NET)</author> </member> - <member name="P:Spring.Aop.Target.AbstractPrototypeTargetSource.ObjectFactory"> + <member name="M:Spring.Aop.Framework.Adapter.IAdvisorAdapter.SupportsAdvice(AopAlliance.Aop.IAdvice)"> <summary> - The target factory that will be used to perform the lookup - of the object referred to by the <see cref="P:Spring.Aop.Target.AbstractPrototypeTargetSource.TargetObjectName"/> - property. + Does this adapter understand the supplied <paramref name="advice"/>? </summary> <remarks> <p> - Needed so that prototype instances can be created as necessary. + Is it valid to invoke the + <see cref="M:Spring.Aop.Framework.Adapter.IAdvisorAdapterRegistry.Wrap(System.Object)"/> + method with the given advice as an argument? </p> </remarks> - <value> - The owning <see cref="T:Spring.Objects.Factory.IObjectFactory"/> - (will never be <see langword="null"/>). - </value> - <exception cref="T:Spring.Objects.ObjectsException"> - In case of initialization errors. - </exception> - <seealso cref="P:Spring.Objects.Factory.IObjectFactoryAware.ObjectFactory"/> + <param name="advice"> + <see cref="T:AopAlliance.Aop.IAdvice"/> such as + <see cref="T:Spring.Aop.IBeforeAdvice"/>. + </param> + <returns><see langword="true"/> if this adapter understands the + supplied <paramref name="advice"/>. + </returns> </member> - <member name="T:Spring.Aop.Target.PoolingConfig"> + <member name="M:Spring.Aop.Framework.Adapter.IAdvisorAdapter.GetInterceptor(Spring.Aop.IAdvisor)"> <summary> - Configuration interface for a pooling invoker. + Return an AOP Alliance + <see cref="T:AopAlliance.Intercept.IInterceptor"/> exposing the + behaviour of the given advice to an interception-based AOP + framework. </summary> - <author>Rod Johnson</author> - <author>Aleksandar Seovic (.NET)</author> + <remarks> + <p> + Don't worry about any <see cref="T:Spring.Aop.IPointcut"/> + contained in the supplied <see cref="T:Spring.Aop.IAdvisor"/>; + the AOP framework will take care of checking the pointcut. + </p> + </remarks> + <param name="advisor"> + The advice. The + <see cref="M:Spring.Aop.Framework.Adapter.IAdvisorAdapter.SupportsAdvice(AopAlliance.Aop.IAdvice)"/> + method must have previously returned <see langword="true"/> on the + supplied <paramref name="advisor"/>. + </param> + <returns> + An AOP Alliance + <see cref="T:AopAlliance.Intercept.IInterceptor"/> exposing the + behaviour of the given advice to an interception-based AOP + framework. + </returns> </member> - <member name="P:Spring.Aop.Target.PoolingConfig.Active"> + <member name="M:Spring.Aop.Framework.Adapter.AfterReturningAdviceAdapter.SupportsAdvice(AopAlliance.Aop.IAdvice)"> <summary> - The number of active object instances in a pool. + Returns <see langword="true"/> if the supplied + <paramref name="advice"/> is an instance of the + <see cref="T:Spring.Aop.IAfterReturningAdvice"/> interface. </summary> + <param name="advice">The advice to check.</param> + <returns> + <see langword="true"/> if the supplied <paramref name="advice"/> is + an instance of the <see cref="T:Spring.Aop.IAfterReturningAdvice"/> interface; + <see langword="false"/> if not or if the supplied + <paramref name="advice"/> is <cref lang="null"/>. + </returns> </member> - <member name="P:Spring.Aop.Target.PoolingConfig.Free"> + <member name="M:Spring.Aop.Framework.Adapter.AfterReturningAdviceAdapter.GetInterceptor(Spring.Aop.IAdvisor)"> <summary> - The number of free object instances in a pool. + Wraps the supplied <paramref name="advisor"/>'s + <see cref="P:Spring.Aop.IAdvisor.Advice"/> within a + <see cref="T:Spring.Aop.Framework.Adapter.AfterReturningAdviceInterceptor"/> + instance. </summary> + <param name="advisor"> + The advisor exposing the <see cref="T:AopAlliance.Aop.IAdvice"/> that + is to be wrapped. + </param> + <returns> + The supplied <paramref name="advisor"/>'s + <see cref="P:Spring.Aop.IAdvisor.Advice"/> wrapped within a + <see cref="T:Spring.Aop.Framework.Adapter.AfterReturningAdviceInterceptor"/> + instance. + </returns> </member> - <member name="P:Spring.Aop.Target.PoolingConfig.MaxSize"> + <member name="T:Spring.Aop.Framework.Adapter.AfterReturningAdviceInterceptor"> <summary> - The maximum number of object instances in a pool. + Interceptor to wrap an <see cref="T:Spring.Aop.IAfterReturningAdvice"/> + instance. </summary> + <remarks> + <p> + A more efficient alternative solution in cases where there is no + interception advice and therefore no need to create an + <see cref="T:AopAlliance.Intercept.IMethodInvocation"/> object may be + offered in future. + </p> + <p> + Used internally by the AOP framework: application developers should not need + to use this class directly. + </p> + </remarks> + <author>Rod Johnson</author> + <author>Aleksandar Seovic (.NET)</author> </member> - <member name="T:AopAlliance.Aop.IAdvice"> + <member name="T:AopAlliance.Intercept.IMethodInterceptor"> <summary> - Tag interface for advice. + Intercepts calls on an interface on its way to the target. </summary> <remarks> <p> - Implementations can be any type of advice, such as interceptors. + Such interceptions are nested "on top" of the target. </p> </remarks> </member> - <member name="M:Spring.Aop.Target.AbstractPoolingTargetSource.#ctor"> + <member name="T:AopAlliance.Intercept.IInterceptor"> <summary> - Creates a new instance of the - <see cref="T:Spring.Aop.Target.AbstractPoolingTargetSource"/> - class. + Represents a generic interceptor. </summary> <remarks> <p> - This is an <see langword="abstract"/> class, and as such exposes no - public constructors. + A generic interceptor can intercept runtime events that occur within a + base program. Those events are materialized by (reified in) joinpoints. + Runtime joinpoints can be invocations, field access, exceptions, etc. </p> + <p> + This interface is not used directly. Use the various derived interfaces + to intercept specific events. + </p> </remarks> + <seealso cref="T:AopAlliance.Intercept.IJoinpoint"/> </member> - <member name="M:Spring.Aop.Target.AbstractPoolingTargetSource.GetTarget"> + <member name="T:AopAlliance.Aop.IAdvice"> <summary> - Returns the target object (acquired from the pool). + Tag interface for advice. </summary> - <returns>The target object (acquired from the pool).</returns> - <exception cref="T:System.Exception"> - If unable to obtain the target object. - </exception> + <remarks> + <p> + Implementations can be any type of advice, such as interceptors. + </p> + </remarks> </member> - <member name="M:Spring.Aop.Target.AbstractPoolingTargetSource.GetPoolingConfigMixin"> + <member name="M:AopAlliance.Intercept.IMethodInterceptor.Invoke(AopAlliance.Intercept.IMethodInvocation)"> <summary> - Gets the <see cref="T:Spring.Aop.Target.PoolingConfig"/> mixin. + Implement this method to perform extra treatments before and after + the call to the supplied <paramref name="invocation"/>. </summary> + <remarks> + <p> + Polite implementations would certainly like to invoke + <see cref="M:AopAlliance.Intercept.IJoinpoint.Proceed"/>. + </p> + </remarks> + <param name="invocation"> + The method invocation that is being intercepted. + </param> <returns> - An <see cref="T:Spring.Aop.IIntroductionAdvisor"/> exposing statistics - about the pool maintained by this object. + The result of the call to the + <see cref="M:AopAlliance.Intercept.IJoinpoint.Proceed"/> method of + the supplied <paramref name="invocation"/>; this return value may + well have been intercepted by the interceptor. </returns> + <exception cref="T:System.Exception"> + If any of the interceptors in the chain or the target object itself + throws an exception. + </exception> </member> - <member name="M:Spring.Aop.Target.AbstractPoolingTargetSource.CreatePool(Spring.Objects.Factory.IObjectFactory)"> + <member name="M:Spring.Aop.Framework.Adapter.AfterReturningAdviceInterceptor.#ctor(Spring.Aop.IAfterReturningAdvice)"> <summary> - Create the pool. + Creates a new instance of the + <see cref="T:Spring.Aop.Framework.Adapter.AfterReturningAdviceInterceptor"/> + class. </summary> - <param name="factory"> - The owning <see cref="T:Spring.Objects.Factory.IObjectFactory"/>, in - case one needs collaborators from it (normally one's own properties - are sufficient). + <param name="advice"> + The advice to be applied after a target method successfully + returns. </param> - <exception cref="T:System.Exception"> - In the case of errors encountered during the creation of the pool. + <exception cref="T:System.ArgumentNullException"> + If the supplied <paramref name="advice"/> is <see langword="null"/>. </exception> </member> - <member name="M:Spring.Aop.Target.AbstractPoolingTargetSource.ReleaseTarget(System.Object)"> + <member name="M:Spring.Aop.Framework.Adapter.AfterReturningAdviceInterceptor.Invoke(AopAlliance.Intercept.IMethodInvocation)"> <summary> - Releases the target object (returns it to the pool). + Executes interceptor after the target method successfully returns. </summary> - <param name="target"> - The target object to release (return to the pool). + <param name="invocation"> + The method invocation that is being intercepted. </param> + <returns> + The result of the call to the + <see cref="M:AopAlliance.Intercept.IJoinpoint.Proceed"/> method of + the supplied <paramref name="invocation"/>; this return value may + well have been intercepted by the interceptor. + </returns> <exception cref="T:System.Exception"> - In the case that the <paramref name="target"/> could not be released. + If any of the interceptors in the chain or the target object itself + throws an exception. </exception> </member> - <member name="M:Spring.Aop.Target.AbstractPoolingTargetSource.Dispose"> + <member name="T:Spring.Aop.Framework.Adapter.BeforeAdviceAdapter"> <summary> - Performs application-defined tasks associated with freeing, releasing, or - resetting unmanaged resources. + <see cref="T:Spring.Aop.Framework.Adapter.IAdvisorAdapter"/> implementation + to enable <see cref="T:Spring.Aop.IMethodBeforeAdvice"/> to be used in the + Spring.NET AOP framework. </summary> - <remarks> - <p> - Disposes of the pool. - </p> - </remarks> + <author>Rod Johnson</author> + <author>Aleksandar Seovic (.NET)</author> </member> - <member name="P:Spring.Aop.Target.AbstractPoolingTargetSource.MaxSize"> + <member name="M:Spring.Aop.Framework.Adapter.BeforeAdviceAdapter.SupportsAdvice(AopAlliance.Aop.IAdvice)"> <summary> - The maximum number of object instances in this pool. + Returns <see langword="true"/> if the supplied + <paramref name="advice"/> is an instance of the + <see cref="T:Spring.Aop.IMethodBeforeAdvice"/> interface. </summary> + <param name="advice">The advice to check.</param> + <returns> + <see langword="true"/> if the supplied <paramref name="advice"/> is + an instance of the <see cref="T:Spring.Aop.IMethodBeforeAdvice"/> interface; + <see langword="false"/> if not or if the supplied + <paramref name="advice"/> is <cref lang="null"/>. + </returns> </member> - <member name="P:Spring.Aop.Target.AbstractPoolingTargetSource.Active"> + <member name="M:Spring.Aop.Framework.Adapter.BeforeAdviceAdapter.GetInterceptor(Spring.Aop.IAdvisor)"> <summary> - The number of active object instances in this pool. + Wraps the supplied <paramref name="advisor"/>'s + <see cref="P:Spring.Aop.IAdvisor.Advice"/> within a + <see cref="T:Spring.Aop.Framework.Adapter.MethodBeforeAdviceInterceptor"/> + instance. </summary> + <param name="advisor"> + The advisor exposing the <see cref="T:AopAlliance.Aop.IAdvice"/> that + is to be wrapped. + </param> + <returns> + The supplied <paramref name="advisor"/>'s + <see cref="P:Spring.Aop.IAdvisor.Advice"/> wrapped within a + <see cref="T:Spring.Aop.Framework.Adapter.MethodBeforeAdviceInterceptor"/> + instance. + </returns> </member> - <member name="P:Spring.Aop.Target.AbstractPoolingTargetSource.Free"> + <member name="T:Spring.Aop.Framework.Adapter.DefaultAdvisorAdapterRegistry"> <summary> - The number of free object instances in this pool. + Default implementation of the + <see cref="T:Spring.Aop.Framework.Adapter.IAdvisorAdapterRegistry"/> + interface. </summary> - </member> - <member name="P:Spring.Aop.Target.AbstractPoolingTargetSource.ObjectFactory"> - <summary> - The target factory that will be used to perform the lookup - of the object referred to by the - <see cref="P:Spring.Aop.Target.AbstractPrototypeTargetSource.TargetObjectName"/> - property. - </summary> - <value> - The owning <see cref="T:Spring.Objects.Factory.IObjectFactory"/> - (will never be <see langword="null"/>). - </value> - <exception cref="T:Spring.Objects.ObjectsException"> - In case of initialization errors. - </exception> - <seealso cref="P:Spring.Aop.Target.AbstractPrototypeTargetSource.ObjectFactory"/> - </member> - <member name="T:Spring.Aop.Support.DynamicMethodMatcher"> - <summary> - Convenient abstract superclass for dynamic method matchers that do - care about arguments at runtime. - </summary> <author>Rod Johnson</author> <author>Aleksandar Seovic (.NET)</author> </member> - <member name="T:Spring.Aop.IMethodMatcher"> + <member name="T:Spring.Aop.Framework.Adapter.IAdvisorAdapterRegistry"> <summary> - That part of an <see cref="T:Spring.Aop.IPointcut"/> that checks whether a - target method is eligible for advice. + A registry of + <see cref="T:Spring.Aop.Framework.Adapter.IAdvisorAdapter"/> instances. </summary> <remarks> <p> - An <see cref="T:Spring.Aop.IMethodMatcher"/> may be evaluated - <b>statically</b> or at runtime (<b>dynamically</b>). Static - matching involves only the method signature and (possibly) any - <see cref="T:System.Attribute"/>s that have been applied to a method. - Dynamic matching additionally takes into account the actual argument - values passed to a method invocation. + Implementations <b>must</b> also automatically register adapters for + <see cref="T:AopAlliance.Intercept.IInterceptor"/> types. </p> - <p> - If the value of the <see cref="P:Spring.Aop.IMethodMatcher.IsRuntime"/> - property of an implementation instance returns <see langword="false"/>, - evaluation can be performed statically, and the result will be the same - for all invocations of this method, whatever their arguments. This - means that if the value of the - <see cref="P:Spring.Aop.IMethodMatcher.IsRuntime"/> is - <see langword="false"/>, the three argument - <see cref="M:Spring.Aop.IMethodMatcher.Matches(System.Reflection.MethodInfo,System.Type,System.Object[])"/> - method will never be invoked for the lifetime of the - <see cref="T:Spring.Aop.IMethodMatcher"/>. - </p> - <p> - If an implementation returns <see langword="true"/> in its two argument - <see cref="M:Spring.Aop.IMethodMatcher.Matches(System.Reflection.MethodInfo,System.Type)"/> - method, and the value of it's - <see cref="P:Spring.Aop.IMethodMatcher.IsRuntime"/> property is - <see langword="true"/>, the three argument - <see cref="M:Spring.Aop.IMethodMatcher.Matches(System.Reflection.MethodInfo,System.Type,System.Object[])"/> - method will be invoked <i>immediately before each and every potential - execution of the related advice</i>, to decide whether the advice - should run. All previous advice, such as earlier interceptors in an - interceptor chain, will have run, so any state changes they have - produced in parameters or thread local storage, will be available at - the time of evaluation. - </p> + <note> + This is an SPI interface, that should not need to be implemented by any + Spring.NET user. + </note> </remarks> <author>Rod Johnson</author> <author>Aleksandar Seovic (.NET)</author> - <seealso cref="T:Spring.Aop.TrueMethodMatcher"/> </member> - <member name="M:Spring.Aop.IMethodMatcher.Matches(System.Reflection.MethodInfo,System.Type)"> + <member name="M:Spring.Aop.Framework.Adapter.IAdvisorAdapterRegistry.Wrap(System.Object)"> <summary> - Does the supplied <paramref name="method"/> satisfy this matcher? + Returns an <see cref="T:Spring.Aop.IAdvisor"/> wrapping the supplied + <paramref name="advice"/>. </summary> - <remarks> - <p> - This is a static check. If this method invocation returns - <see langword="false"/>,or if the - <see cref="P:Spring.Aop.IMethodMatcher.IsRuntime"/> property is - <see langword="false"/>, then no runtime check will be made. - </p> - </remarks> - <param name="method">The candidate method.</param> - <param name="targetType"> - The target <see cref="T:System.Type"/> (may be <see langword="null"/>, - in which case the candidate <see cref="T:System.Type"/> must be taken - to be the <paramref name="method"/>'s declaring class). + <param name="advice"> + The object that should be an advice, such as + <see cref="T:Spring.Aop.IBeforeAdvice"/> or + <see cref="T:Spring.Aop.IThrowsAdvice"/>. </param> - <returns> - <see langword="true"/> if this this method matches statically. + <returns> + An <see cref="T:Spring.Aop.IAdvisor"/> wrapping the supplied + <paramref name="advice"/>. Never returns <cref lang="null"/>. If + the <paramref name="advice"/> parameter is an + <see cref="T:Spring.Aop.IAdvisor"/>, it will simply be returned. </returns> + <exception cref="T:Spring.Aop.Framework.Adapter.UnknownAdviceTypeException"> + If no registered + <see cref="T:Spring.Aop.Framework.Adapter.IAdvisorAdapter"/> can wrap + the supplied <paramref name="advice"/>. + </exception> </member> - <member name="M:Spring.Aop.IMethodMatcher.Matches(System.Reflection.MethodInfo,System.Type,System.Object[])"> + <member name="M:Spring.Aop.Framework.Adapter.IAdvisorAdapterRegistry.GetInterceptor(Spring.Aop.IAdvisor)"> <summary> - Is there a runtime (dynamic) match for the supplied - <paramref name="method"/>? + Returns an <see cref="T:AopAlliance.Intercept.IInterceptor"/> to + allow the use of the supplied <paramref name="advisor"/> in an + interception-based framework. </summary> <remarks> <p> - In order for this method to have even been invoked, the supplied - <paramref name="method"/> must have matched - statically. This method is invoked only if the two argument - <see cref="M:Spring.Aop.IMethodMatcher.Matches(System.Reflection.MethodInfo,System.Type)"/> - method returns <see langword="true"/> for the supplied - <paramref name="method"/> and <paramref name="targetType"/>, and - if the <see cref="P:Spring.Aop.IMethodMatcher.IsRuntime"/> property - is <see langword="true"/>. + Don't worry about the pointcut associated with the + <see cref="T:Spring.Aop.IAdvisor"/>; if it's an + <see cref="T:Spring.Aop.IPointcutAdvisor"/>, just return an + interceptor. </p> - <p> - Invoked immediately <b>before</b> any potential running of the - advice, and <b>after</b> any advice earlier in the advice chain has - run. - </p> </remarks> - <param name="method">The candidate method.</param> - <param name="targetType"> - The target <see cref="T:System.Type"/>. + <param name="advisor"> + The advisor to find an interceptor for. </param> - <param name="args">The arguments to the method</param> <returns> - <see langword="true"/> if there is a runtime match.</returns> + An interceptor to expose this advisor's behaviour. + </returns> + <exception cref="T:Spring.Aop.Framework.Adapter.UnknownAdviceTypeException"> + If the advisor type is not understood by any registered + <see cref="T:Spring.Aop.Framework.Adapter.IAdvisorAdapter"/>. + </exception> </member> - <member name="P:Spring.Aop.IMethodMatcher.IsRuntime"> + <member name="M:Spring.Aop.Framework.Adapter.IAdvisorAdapterRegistry.RegisterAdvisorAdapter(Spring.Aop.Framework.Adapter.IAdvisorAdapter)"> <summary> - Is this <see cref="T:Spring.Aop.IMethodMatcher"/> dynamic? + Register the given <see cref="T:Spring.Aop.Framework.Adapter.IAdvisorAdapter"/>. </summary> <remarks> <p> - If <see langword="true"/>, the three argument - <see cref="M:Spring.Aop.IMethodMatcher.Matches(System.Reflection.MethodInfo,System.Type,System.Object[])"/> - method will be invoked if the two argument - <see cref="M:Spring.Aop.IMethodMatcher.Matches(System.Reflection.MethodInfo,System.Type)"/> - method returns <see langword="true"/>. + Note that it is not necessary to register adapters for + <see cref="T:AopAlliance.Intercept.IInterceptor"/> instances: these + must be automatically recognized by an + <see cref="T:Spring.Aop.Framework.Adapter.IAdvisorAdapterRegistry"/> + implementation. </p> - <p> - Note that this property can be checked when an AOP proxy is created, - and implementations need not check the value of this property again - before each method invocation. - </p> </remarks> - <value> - <see langword="true"/> if this - <see cref="T:Spring.Aop.IMethodMatcher"/> is dynamic. - </value> + <param name="adapter"> + An <see cref="T:Spring.Aop.Framework.Adapter.IAdvisorAdapter"/> that + understands the particular advisor and advice types. + </param> </member> - <member name="M:Spring.Aop.Support.DynamicMethodMatcher.#ctor"> + <member name="M:Spring.Aop.Framework.Adapter.DefaultAdvisorAdapterRegistry.#ctor"> <summary> Creates a new instance of the - <see cref="T:Spring.Aop.Support.DynamicMethodMatcher"/> - class. + <see cref="T:Spring.Aop.Framework.Adapter.DefaultAdvisorAdapterRegistry"/> class. </summary> <remarks> <p> - This is an <see langword="abstract"/> class, and as such exposes no - public constructors. + This constructor will also register the well-known + <see cref="T:Spring.Aop.Framework.Adapter.IAdvisorAdapter"/> types. </p> </remarks> + <seealso cref="T:Spring.Aop.Framework.Adapter.IAdvisorAdapter"/> </member> - <member name="M:Spring.Aop.Support.DynamicMethodMatcher.Matches(System.Reflection.MethodInfo,System.Type)"> + <member name="M:Spring.Aop.Framework.Adapter.DefaultAdvisorAdapterRegistry.Wrap(System.Object)"> <summary> - Does the supplied <paramref name="method"/> satisfy this matcher? + Returns an <see cref="T:Spring.Aop.IAdvisor"/> wrapping the supplied + <paramref name="advice"/>. </summary> - <remarks> - <p> - Derived classes can override this method to add preconditions for - dynamic matching. - </p> - <p> - This implementation always returns <see langword="true"/>. - </p> - </remarks> - <param name="method">The candidate method.</param> - <param name="targetType"> - The target <see cref="T:System.Type"/> (may be <see langword="null"/>, - in which case the candidate <see cref="T:System.Type"/> must be taken - to be the <paramref name="method"/>'s declaring class). + <param name="advice"> + The object that should be an advice, such as + <see cref="T:Spring.Aop.IBeforeAdvice"/> or + <see cref="T:Spring.Aop.IThrowsAdvice"/>. </param> + <returns> + An <see cref="T:Spring.Aop.IAdvisor"/> wrapping the supplied + <paramref name="advice"/>. Never returns <cref lang="null"/>. If + the <paramref name="advice"/> parameter is an + <see cref="T:Spring.Aop.IAdvisor"/>, it will simply be returned. + </returns> + <exception cref="T:Spring.Aop.Framework.Adapter.UnknownAdviceTypeException"> + If no registered + <see cref="T:Spring.Aop.Framework.Adapter.IAdvisorAdapter"/> can wrap + the supplied <paramref name="advice"/>. + </exception> + </member> + <member name="M:Spring.Aop.Framework.Adapter.DefaultAdvisorAdapterRegistry.GetInterceptor(Spring.Aop.IAdvisor)"> + <summary> + Returns an <see cref="T:AopAlliance.Intercept.IInterceptor"/> to + allow the use of the supplied <paramref name="advisor"/> in an + interception-based framework. + </summary> + <param name="advisor">The advisor to find an interceptor for.</param> <returns> - <see langword="true"/> if this this method matches statically. + An interceptor to expose this advisor's behaviour. </returns> + <exception cref="T:Spring.Aop.Framework.Adapter.UnknownAdviceTypeException"> + If the advisor type is not understood by any registered + <see cref="T:Spring.Aop.Framework.Adapter.IAdvisorAdapter"/>. + </exception> </member> - <member name="M:Spring.Aop.Support.DynamicMethodMatcher.Matches(System.Reflection.MethodInfo,System.Type,System.Object[])"> + <member name="M:Spring.Aop.Framework.Adapter.DefaultAdvisorAdapterRegistry.RegisterAdvisorAdapter(Spring.Aop.Framework.Adapter.IAdvisorAdapter)"> <summary> - Is there a runtime (dynamic) match for the supplied - <paramref name="method"/>? + Register the given <see cref="T:Spring.Aop.Framework.Adapter.IAdvisorAdapter"/>. </summary> - <remarks> - <p> - Must be overriden by derived classes to provide criteria for dynamic matching. - </p> - </remarks> - <param name="method">The candidate method.</param> - <param name="targetType"> - The target <see cref="T:System.Type"/>. + <param name="adapter"> + An <see cref="T:Spring.Aop.Framework.Adapter.IAdvisorAdapter"/> that + understands the particular advisor and advice types. </param> - <param name="args">The arguments to the method</param> - <returns> - <see langword="true"/> if there is a runtime match.</returns> </member> - <member name="P:Spring.Aop.Support.DynamicMethodMatcher.IsRuntime"> + <member name="T:Spring.Aop.Framework.Adapter.GlobalAdvisorAdapterRegistry"> <summary> - Is this <see cref="T:Spring.Aop.IMethodMatcher"/> dynamic? + Provides Singleton-style access to the default + <see cref="T:Spring.Aop.Framework.Adapter.IAdvisorAdapterRegistry"/> instance. </summary> - <value> - Always returns <see langword="true"/>, to specify that this is a - dynamic matcher. - </value> + <author>Rod Johnson</author> + <author>Aleksandar Seovic (.NET)</author> </member> - <member name="T:Spring.Aop.Support.ComposablePointcut"> + <member name="M:Spring.Aop.Framework.Adapter.GlobalAdvisorAdapterRegistry.#ctor"> <summary> - Convenient class for building up pointcuts. + Creates a new instance of the + <see cref="T:Spring.Aop.Framework.Adapter.GlobalAdvisorAdapterRegistry"/> class. </summary> <remarks> <p> - All methods return a <see cref="T:Spring.Aop.Support.ComposablePointcut"/> - instance, which facilitates the following concise usage pattern... + This contructor is marked as <see langword="private"/> to enforce the + Singleton pattern </p> - <code language="C#"> - IPointcut pointcut = new ComposablePointcut() - .Union(typeFilter) - .Intersection(methodMatcher) - .Intersection(pointcut); - </code> - <p> - There is no <c>Union()</c> method on this class. Use the - <see cref="M:Spring.Aop.Support.Pointcuts.Union(Spring.Aop.IPointcut,Spring.Aop.IPointcut)"/> method for such functionality. - </p> - </remarks> - <author>Rod Johnson</author> - <author>Aleksandar Seovic (.NET)</author> + </remarks> </member> - <member name="T:Spring.Aop.IPointcut"> + <member name="P:Spring.Aop.Framework.Adapter.GlobalAdvisorAdapterRegistry.Instance"> <summary> - Spring.NET's core pointcut abstraction. + The default <see cref="T:Spring.Aop.Framework.Adapter.IAdvisorAdapterRegistry"/> instance. </summary> + </member> + <member name="T:Spring.Aop.Framework.Adapter.MethodBeforeAdviceInterceptor"> + <summary> + <see cref="T:AopAlliance.Intercept.IInterceptor"/> implementation that + wraps <see cref="T:Spring.Aop.IMethodBeforeAdvice"/> instances. + </summary> <remarks> <p> - A pointcut is composed of <see cref="T:Spring.Aop.ITypeFilter"/>s and - <see cref="T:Spring.Aop.IMethodMatcher"/>s. Both these basic terms and an - <see cref="T:Spring.Aop.IPointcut"/> itself can be combined to build up - sophisticated combinations. + In the future Spring.NET may also offer a more efficient alternative + solution in cases where there is no interception advice and therefore + no need to create an <see cref="T:AopAlliance.Intercept.IMethodInvocation"/> + object. </p> + <p> + Used internally by the Spring.NET AOP framework: application developers + should not need to use this class directly. + </p> </remarks> <author>Rod Johnson</author> <author>Aleksandar Seovic (.NET)</author> </member> - <member name="P:Spring.Aop.IPointcut.TypeFilter"> + <member name="M:Spring.Aop.Framework.Adapter.MethodBeforeAdviceInterceptor.#ctor(Spring.Aop.IMethodBeforeAdvice)"> <summary> - The <see cref="T:Spring.Aop.ITypeFilter"/> for this pointcut. + Creates a new instance of the + <see cref="T:Spring.Aop.Framework.Adapter.MethodBeforeAdviceInterceptor"/> + class. </summary> - <value> - The current <see cref="T:Spring.Aop.ITypeFilter"/>. - </value> + <param name="advice"> + The <see cref="T:Spring.Aop.IMethodBeforeAdvice"/> that is to be wrapped. + </param> + <exception cref="T:System.ArgumentNullException"> + If the supplied <paramref name="advice"/> is <see langword="null"/>. + </exception> </member> - <member name="P:Spring.Aop.IPointcut.MethodMatcher"> + <member name="M:Spring.Aop.Framework.Adapter.MethodBeforeAdviceInterceptor.Invoke(AopAlliance.Intercept.IMethodInvocation)"> <summary> - The <see cref="T:Spring.Aop.IMethodMatcher"/> for this pointcut. + Executes interceptor before the target method successfully returns. </summary> - <value> - The current <see cref="T:Spring.Aop.IMethodMatcher"/>. - </value> + <param name="invocation"> + The method invocation that is being intercepted. + </param> + <returns> + The result of the call to the + <see cref="M:AopAlliance.Intercept.IJoinpoint.Proceed"/> method of + the supplied <paramref name="invocation"/>. + </returns> + <exception cref="T:System.Exception"> + If any of the interceptors in the chain or the target object itself + throws an exception. + </exception> </member> - <member name="M:Spring.Aop.Support.ComposablePointcut.#ctor"> + <member name="T:Spring.Aop.Framework.Adapter.ThrowsAdviceAdapter"> <summary> - Creates a new instance of the - <see cref="T:Spring.Aop.Support.ComposablePointcut"/> class - that matches all the methods on all <see cref="T:System.Type"/>s. + <see cref="T:Spring.Aop.Framework.Adapter.IAdvisorAdapter"/> implementation + to enable <see cref="T:Spring.Aop.IThrowsAdvice"/> to be used in the + Spring.NET AOP framework. </summary> + <author>Rod Johnson</author> + <author>Aleksandar Seovic (.NET)</author> </member> - <member name="M:Spring.Aop.Support.ComposablePointcut.#ctor(Spring.Aop.ITypeFilter,Spring.Aop.IMethodMatcher)"> + <member name="M:Spring.Aop.Framework.Adapter.ThrowsAdviceAdapter.SupportsAdvice(AopAlliance.Aop.IAdvice)"> <summary> - Creates a new instance of the - <see cref="T:Spring.Aop.Support.ComposablePointcut"/> class - that uses the supplied <paramref name="typeFilter"/> and - <paramref name="methodMatcher"/>. + Returns <see langword="true"/> if the supplied + <paramref name="advice"/> is an instance of the + <see cref="T:Spring.Aop.IThrowsAdvice"/> interface. </summary> - <param name="typeFilter"> - The type filter to use. - </param> - <param name="methodMatcher"> - The method matcher to use. - </param> + <param name="advice">The advice to check.</param> + <returns> + <see langword="true"/> if the supplied <paramref name="advice"/> is + an instance of the <see cref="T:Spring.Aop.IThrowsAdvice"/> interface; + <see langword="false"/> if not or if the supplied + <paramref name="advice"/> is <cref lang="null"/>. + </returns> </member> - <member name="M:Spring.Aop.Support.ComposablePointcut.Union(Spring.Aop.ITypeFilter)"> + <member name="M:Spring.Aop.Framework.Adapter.ThrowsAdviceAdapter.GetInterceptor(Spring.Aop.IAdvisor)"> <summary> - Changes the current type filter to be the union of the existing filter and the - supplied <paramref name="filter"/>. + Wraps the supplied <paramref name="advisor"/>'s + <see cref="P:Spring.Aop.IAdvisor.Advice"/> within a + <see cref="T:Spring.Aop.Framework.Adapter.ThrowsAdviceInterceptor"/> + instance. </summary> - <param name="filter">The filter to union with.</param> + <param name="advisor"> + The advisor exposing the <see cref="T:AopAlliance.Aop.IAdvice"/> that + is to be wrapped. + </param> <returns> - The union of the existing filter and the supplied <paramref name="filter"/>. + The supplied <paramref name="advisor"/>'s + <see cref="P:Spring.Aop.IAdvisor.Advice"/> wrapped within a + <see cref="T:Spring.Aop.Framework.Adapter.ThrowsAdviceInterceptor"/> + instance. </returns> </member> - <member name="M:Spring.Aop.Support.ComposablePointcut.Intersection(Spring.Aop.ITypeFilter)"> + <member name="T:Spring.Aop.Framework.Adapter.ThrowsAdviceInterceptor"> + <summary>Interceptor to wrap an after throwing advice.</summary> + <remarks> + <p> + Implementations of the <see cref="T:Spring.Aop.IThrowsAdvice"/> interface + <b>must</b> define methods of the form... + <code lang="C#"> + AfterThrowing([MethodInfo method, Object[] args, Object target], Exception subclass); + </code> + The method name is fixed (i.e. your methods <b>must</b> be named + <c>AfterThrowing</c>. The first three arguments (<i>as a whole</i>) are + optional, and only useful if futher information about the joinpoint is + required. The return type <i>can</i> be anything, but is almost always + <see langword="void"/> by convention. + </p> + <p> + Please note that the object encapsulating the throws advice does not + need to implement the <see cref="T:S... [truncated message content] |