diff --git a/src/Spring/Spring.Aop/Aop/Framework/AutoProxy/AbstractAutoProxyCreator.cs b/src/Spring/Spring.Aop/Aop/Framework/AutoProxy/AbstractAutoProxyCreator.cs
index ed1be482..a01dba61 100644
--- a/src/Spring/Spring.Aop/Aop/Framework/AutoProxy/AbstractAutoProxyCreator.cs
+++ b/src/Spring/Spring.Aop/Aop/Framework/AutoProxy/AbstractAutoProxyCreator.cs
@@ -1,5 +1,5 @@
-#region License
-
+#region License
+
 /*
  * Copyright © 2002-2005 the original author or authors.
  *
@@ -14,633 +14,674 @@
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
-
-#endregion
-
-#region Imports
-
-using System;
-using System.Collections;
-using System.Reflection;
-using System.Runtime.Remoting;
-using AopAlliance.Aop;
-using Common.Logging;
-using Spring.Aop.Framework.Adapter;
-using Spring.Aop.Target;
-using Spring.Collections;
-using Spring.Core;
-using Spring.Objects;
-using Spring.Objects.Factory;
-using Spring.Objects.Factory.Config;
-using Spring.Util;
-
-#endregion
-
-namespace Spring.Aop.Framework.AutoProxy
-{
-    /// <summary>
-    /// ObjectPostProcessor implementation that wraps a group of objects with AOP proxies
-    /// that delegate to the given interceptors before invoking the object itself.
-    /// </summary>
-    /// <remarks>
-    /// <p>This class distinguishes between "common" interceptors: shared for all proxies it
-    /// creates, and "specific" interceptors: unique per object instance. There need not
-    /// be any common interceptors. If there are, they are set using the interceptorNames
-    /// property. As with ProxyFactoryObject, interceptors names in the current factory
-    /// are used rather than object references to allow correct handling of prototype
-    /// advisors and interceptors: for example, to support stateful mixins.
-    /// Any advice type is supported for "interceptorNames" entries.</p>
-    /// <p>Such autoproxying is particularly useful if there's a large number of objects that need
-    /// to be wrapped with similar proxies, i.e. delegating to the same interceptors.
-    /// Instead of x repetitive proxy definitions for x target objects, you can register
-    /// one single such post processor with the object factory to achieve the same effect.</p>
-    /// <p>Subclasses can apply any strategy to decide if a object is to be proxied,
-    /// e.g. by type, by name, by definition details, etc. They can also return
-    /// additional interceptors that should just be applied to the specific object
-    /// instance. The default concrete implementation is ObjectNameAutoProxyCreator,
-    /// identifying the objects to be proxied via a list of object names.</p>
-    /// <p>Any number of TargetSourceCreator implementations can be used with any subclass,
-    /// to create a custom target source - for example, to pool prototype objects.
-    /// Autoproxying will occur even if there is no advice if a TargetSourceCreator specifies
-    /// a custom TargetSource. If there are no TargetSourceCreators set, or if none matches,
-    /// a SingletonTargetSource will be used by default to wrap the object to be autoproxied.</p>
-    /// </remarks>
-    /// <author>Juergen Hoeller</author>
-    /// <author>Rod Johnson</author>
-    /// <author>Adhari C Mahendra (.NET)</author>
-    /// <seealso cref="Spring.Aop.Framework.AutoProxy.AbstractAutoProxyCreator.InterceptorNames"/>
-    /// <seealso cref="Spring.Aop.Framework.AutoProxy.ObjectNameAutoProxyCreator"/>
-    public abstract class AbstractAutoProxyCreator : ProxyConfig, IInstantiationAwareObjectPostProcessor, IObjectFactoryAware, IOrdered
-    {
-        #region Protected Fields
-
-        /// <summary>
-        /// The logger for this class hierarchy.
-        /// </summary>
-        protected readonly ILog logger = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
-
-        /// <summary>
-        /// Convenience constant for subclasses: Return value for "do not proxy".
-        /// </summary>
-        protected static readonly object[] DO_NOT_PROXY = null;
-
-        /// <summary>
-        /// Convenience constant for subclasses: Return value for
-        /// "proxy without additional interceptors, just the common ones".
-        /// </summary>
-        protected static readonly object[] PROXY_WITHOUT_ADDITIONAL_INTERCEPTORS = new object[0];
-
-        #endregion
-
-        #region Private Fields
-
-        /// <summary>
-        /// Default value is same as non-ordered
-        /// </summary>
-        private int order = int.MaxValue;
-
-        /// <summary>
-        /// Default is global AdvisorAdapterRegistry
-        /// </summary>
-        private IAdvisorAdapterRegistry advisorAdapterRegistry = GlobalAdvisorAdapterRegistry.Instance;
-
-
-        /// <summary>
-        /// 
-        /// </summary>
-        private bool freezeProxy = false;
-
-        /// <summary>
-        /// Names of common interceptors. 
-        /// We must use object name rather than object references
-        /// to handle prototype advisors/interceptors.
-        /// Default is the empty array: no common interceptors.
-        /// </summary>
-        private string[] interceptorNames = new string[0];
-
-        private bool applyCommonInterceptorsFirst = true;
-        private IList customTargetSourceCreators = new ArrayList();
-        private IObjectFactory owningObjectFactory;
-
-        /// <summary>
-        /// Set of object type + name strings, referring to all objects that this auto-proxy
-        /// creator created a custom TargetSource for.  Used to detect own pre-built proxies
-        /// (from "PostProcessBeforeInstantiation") in the "PostProcessAfterInitialization" method.
-        /// </summary>
-        private ISet targetSourcedObjects = new SynchronizedSet(new HashedSet());
-
-        private ISet advisedObjects = new SynchronizedSet(new HashedSet());
-
-        private ISet nonAdvisedObjects = new SynchronizedSet(new HashedSet());
-
-        #endregion
-
-        #region Properties
-
-        /// <summary>
-        /// Sets the AdvisorAdapterRegistry to use. 
-        /// </summary>
-        /// <remarks>
-        /// Default is the global AdvisorAdapterRegistry.
-        /// </remarks>
-        public IAdvisorAdapterRegistry AdvisorAdapterRegistry
-        {
-            set { advisorAdapterRegistry = value; }
-        }
-
-        /// <summary>
-        /// Sets custom TargetSourceCreators to be applied in this order.
-        /// </summary>
-        /// <remarks>
-        /// <para>
-        /// If the list is empty, or they all return null, a SingletonTargetSource
-        /// will be created.
-        /// </para>
-        /// <para>
-        /// TargetSourceCreators can only be invoked if this post processor is used
-        /// in a IObjectFactory, and its ObjectFactoryAware callback is used.
-        /// </para>
-        /// </remarks>
-        public IList CustomTargetSourceCreators
-        {
-            set { customTargetSourceCreators = value; }
-        }
-
-        /// <summary> 
-        /// Sets the common interceptors, a list of <see cref="AopAlliance.Aop.IAdvice"/>, 
-        /// <see cref="Spring.Aop.IAdvisor"/> and introduction object names.
-        /// </summary>
-        /// <remarks>
-        /// <para>
-        /// If this property isn't set, there will be zero common interceptors. 
-        /// This is perfectly valid, if "specific" interceptors such as
-        /// matching Advisors are all we want.
-        /// </para>
-        /// </remarks>
-        /// <value>
-        /// The list of <see cref="AopAlliance.Aop.IAdvice"/>, 
-        /// <see cref="Spring.Aop.IAdvisor"/> and introduction object names.
-        /// </value>
-        /// <seealso cref="AopAlliance.Aop.IAdvice"/>
-        /// <seealso cref="Spring.Aop.IAdvisor"/>
-        public string[] InterceptorNames
-        {
-            set { interceptorNames = value; }
-        }
-
-        /// <summary>
-        /// Sets whether the common interceptors should be applied before
-        /// object-specific ones. 
-        /// </summary>
-        /// <remarks>
-        /// Default is true; else, object-specific interceptors will get applied first.
-        /// </remarks>
-        public bool ApplyCommonInterceptorsFirst
-        {
-            set { applyCommonInterceptorsFirst = value; }
-        }
-
-        /// <summary>
-        /// Set whether or not the proxy should be frozen, preventing advice
-        /// from being added to it once it is created.
-        /// </summary>
-        /// <remarks>
-        /// 	<p>Overridden from the super class to prevent the proxy configuration
-        /// from being frozen before the proxy is created. The default is not frozen.
-        ///     </p>
-        /// </remarks>
-        public override bool IsFrozen
-        {
-            get { return freezeProxy; }
-            set { this.freezeProxy = value; }
-        }
-
-        #endregion
-
-        #region IObjectPostProcessor Members
-
-        /// <summary>
-        /// Create a proxy with the configured interceptors if the object is
-        /// identified as one to proxy by the subclass.
-        /// </summary>
-        public virtual object PostProcessAfterInitialization(object obj, string objectName)
-        {
-            if (targetSourcedObjects.Contains(objectName))
-            {
-                return obj;
-            }
-
-            object cacheKey = GetCacheKey(obj.GetType(), objectName);
-            if (nonAdvisedObjects.Contains(cacheKey))
-            {
-                return obj;
-            }
-            if (IsInfrastructureType(obj.GetType(), objectName) || ShouldSkip(obj.GetType(), objectName))
-            {
-                #region Instrumentation
-
-                if (logger.IsDebugEnabled)
-                {
-                    logger.Debug(string.Format("Did not attempt to autoproxy infrastructure type [{0}]", obj.GetType().ToString()));
-                }
-
-                #endregion
-
-                nonAdvisedObjects.Add(cacheKey);
-                return obj;
-            }
-
-            //ITargetSource targetSource = GetCustomTargetSource(obj.GetType(), objectName);
-            object[] specificInterceptors;
-            if (RemotingServices.IsTransparentProxy(obj))
-            {
-                specificInterceptors = GetAdvicesAndAdvisorsForObject(ObjectFactory.GetType(objectName), objectName, null);                
-            }
-            else
-            {
-                specificInterceptors = GetAdvicesAndAdvisorsForObject(obj.GetType(), objectName, null);
-            }
-            
-
-            // proxy if we have advice or if a TargetSourceCreator wants to do some
-            // fancy stuff such as pooling
-            if (specificInterceptors != DO_NOT_PROXY)
-            {
-                advisedObjects.Add(cacheKey);
-                return CreateProxy(obj.GetType(), objectName, specificInterceptors, new SingletonTargetSource(obj));
-            }
-            nonAdvisedObjects.Add(cacheKey);
-            return obj;
-        }
-
-        /// <summary>
-        /// No-op for before initialization.
-        /// </summary>
-        /// <param name="obj">The obj.</param>
-        /// <param name="name">The name.</param>
-        /// <returns></returns>
-        public virtual object PostProcessBeforeInitialization(object obj, string name)
-        {
-            return obj;
-        }
-
-        #endregion
-
-        #region IObjectFactoryAware Members
-
-        /// <summary>
-        /// Callback that supplies the owning factory to an object instance.
-        /// </summary>
-        /// <value>
-        /// Owning <see cref="T:Spring.Objects.Factory.IObjectFactory"/>
-        /// (may not be <see langword="null"/>). The object can immediately
-        /// call methods on the factory.
-        /// </value>
-        /// <remarks>
-        /// 	<p>
-        /// Invoked after population of normal object properties but before an init
-        /// callback like <see cref="T:Spring.Objects.Factory.IInitializingObject"/>'s
-        /// <see cref="M:Spring.Objects.Factory.IInitializingObject.AfterPropertiesSet"/>
-        /// method or a custom init-method.
-        /// </p>
-        /// </remarks>
-        /// <exception cref="T:Spring.Objects.ObjectsException">
-        /// In case of initialization errors.
-        /// </exception>
-        public virtual IObjectFactory ObjectFactory
-        {
-            get { return owningObjectFactory; }
-            set { owningObjectFactory = value; }
-        }
-
-        #endregion
-
-        #region IOrdered Members
-
-        /// <summary>
-        /// Propery Order
-        /// </summary>
-        /// <remarks>
-        /// Ordering which will apply to this class's implementation
-        /// of Ordered, used when applying multiple ObjectPostProcessors.
-        /// Default value is int.MaxValue, meaning that it's non-ordered.
-        /// </remarks>
-        public virtual int Order
-        {
-            get { return order; }
-            set { order = value; }
-        }
-
-        #endregion
-
-        #region Protected Methods
-
-        /// <summary>
-        /// Subclasses should override this method to return true if this
-        /// object should not be considered for autoproxying by this post processor.
-        /// Sometimes we need to be able to avoid this happening if it will lead to
-        /// a circular reference. This implementation returns false.
-        /// </summary>
-        /// <param name="objectType">the type of the object</param>
-        /// <param name="objectName">the name of the object</param>
-        /// <returns>if remarkable to skip</returns>
-        protected virtual bool ShouldSkip(Type objectType, string objectName)
-        {
-            return false;
-        }
-
-        /// <summary>
-        /// Subclasses may choose to implement this: for example,
-        /// to change the interfaces exposed
-        /// </summary>
-        /// <param name="pf">
-        /// ProxyFactory that will be used to create the proxy immediably after this method returns.
-        /// </param>
-        protected virtual void CustomizeProxyFactory(ProxyFactory pf)
-        {
-            // This implementation does nothing
-        }
-
-        /// <summary>
-        /// Determines whether the object is an infrastructure type,
-        /// IAdvisor, IAdvice, IAdvisors or AbstractAutoProxyCreator
-        /// </summary>
-        /// <param name="type">The object type to compare</param>
-        /// <param name="name">The name of the object</param>
-        /// <returns>
-        /// <c>true</c> if [is infrastructure type] [the specified obj]; otherwise, <c>false</c>.
-        /// </returns>
-        protected virtual bool IsInfrastructureType(Type type, String name)
-        {
-            return typeof (IAdvisor).IsAssignableFrom(type)
-                || typeof (IAdvice).IsAssignableFrom(type)
-                || typeof (IAdvisors).IsAssignableFrom(type)
-                || typeof (AbstractAutoProxyCreator).IsAssignableFrom(type);
-        }
-    
-
-        /// <summary>
-        /// Create a target source for object instances. Uses any
-        /// TargetSourceCreators if set. Returns null if no Custom TargetSource
-        /// should be used.
-        /// This implementation uses the customTargetSourceCreators property.
-        /// Subclasses can override this method to use a different mechanism.
-        /// </summary>
-        /// <param name="objectType">the type of the object to create a TargetSource for</param>
-        /// <param name="name">the name of the object</param>
-        /// <returns>a TargetSource for this object</returns>
-        protected virtual ITargetSource GetCustomTargetSource(Type objectType, string name)
-        {
-            // We can't create fancy target sources for directly registered singletons.
-            if (customTargetSourceCreators != null && 
-                owningObjectFactory != null && owningObjectFactory.ContainsObject(name))
-            {
-                for (int i = 0; i < customTargetSourceCreators.Count; i++)
-                {
-                    ITargetSourceCreator tsc = (ITargetSourceCreator) customTargetSourceCreators[i];
-                    ITargetSource ts = tsc.GetTargetSource(objectType, name, owningObjectFactory);
-                    if (ts != null)
-                    {
-                        // found a match
-                        if (logger.IsInfoEnabled)
-                        {
-                            logger.Info(string.Format("TargetSourceCreator [{0} found custom TargetSource for object with objectName '{1}'", tsc, name));
-                        }
-                        return ts;
-                    }
-                }
-            }
-
-            // no custom TargetSource found
-            return null;
-        }
-
-        /// <summary>
-        /// Return whether the given object is to be proxied, what additional
-        /// advices (e.g. AOP Alliance interceptors) and advisors to apply.
-        /// </summary>
-        /// <remarks>
-        /// <p>The previous name of this method was "GetInterceptorAndAdvisorForObject".
-        /// It has been renamed in the course of general terminology clarification
-        /// in Spring 1.1. An AOP Alliance Interceptor is just a special form of
-        /// Advice, so the generic Advice term is preferred now.</p>
-        /// <p>The third parameter, customTargetSource, is new in Spring 1.1;
-        /// add it to existing implementations of this method.</p>
-        /// </remarks>
-        /// <param name="objType">the new object instance</param>
-        /// <param name="name">the name of the object</param>
-        /// <param name="customTargetSource">targetSource returned by TargetSource property:
-        /// may be ignored. Will be null unless a custom target source is in use.</param>
-        /// <returns>an array of additional interceptors for the particular object;
-        /// or an empty array if no additional interceptors but just the common ones;
-        /// or null if no proxy at all, not even with the common interceptors.</returns>
-        protected abstract object[] GetAdvicesAndAdvisorsForObject(Type objType, string name, ITargetSource customTargetSource);
-
-        /// <summary>
-        /// Create an AOP proxy for the given object.
-        /// </summary>
-        /// <param name="objectType">Type of the object.</param>
-        /// <param name="objectName">The name of the object.</param>
-        /// <param name="specificInterceptors">The set of interceptors that is specific to this
-        /// object (may be empty but not null)</param>
-        /// <param name="targetSource">The target source for the proxy, already pre-configured to access the object.</param>
-        /// <returns>The AOP Proxy for the object.</returns>
-        protected virtual object CreateProxy(Type objectType, string objectName, object[] specificInterceptors, ITargetSource targetSource)
-        {
-            ProxyFactory proxyFactory = CreateProxyFactory();
-            // copy our properties (proxyTargetClass) inherited from ProxyConfig
-            proxyFactory.CopyFrom(this);
-
-            object target = targetSource.GetTarget();
-
-            
-            if(!ProxyTargetType)
-            {
-                // Must allow for introductions; can't just set interfaces to
-                // the target's interfaces only.
-                Type[] targetInterfaceTypes = AopUtils.GetAllInterfaces(target);
-                foreach (Type interfaceType in targetInterfaceTypes)
-                {
-                    proxyFactory.AddInterface(interfaceType);
-                }
-            }   
-            
-
-            IAdvisor[] advisors = BuildAdvisors(objectName, specificInterceptors);
-
-            foreach (IAdvisor advisor in advisors)
-            {
-                if (advisor is IIntroductionAdvisor)
-                {
-                    proxyFactory.AddIntroduction((IIntroductionAdvisor)advisor);
-                }
-                else
-                {
-                    proxyFactory.AddAdvisor(advisor);
-                }
-            }
-            proxyFactory.TargetSource = targetSource;
-            CustomizeProxyFactory(proxyFactory);
-
-            proxyFactory.IsFrozen = freezeProxy;
-            return proxyFactory.GetProxy();
-        }
-
-        /// <summary>
-        /// Obtain a new proxy factory instance to be used for proxying a particular object
-        /// </summary>
-        /// <returns>A proxy factory instance for proxying a particular object</returns>
-        protected virtual ProxyFactory CreateProxyFactory()
-        {
-            return new ProxyFactory();
-        }
-
-        /// <summary>
-        /// Determines the advisors for the given object, including the specific interceptors
-        /// as well as the common interceptor, all adapted to the Advisor interface.
-        /// </summary>
-        /// <param name="objectName">The name of the object.</param>
-        /// <param name="specificInterceptors">The set of interceptors that is specific to this
-        /// object (may be empty, but not null)</param>
-        /// <returns>The list of Advisors for the given object</returns>
-        protected virtual IAdvisor[] BuildAdvisors(string objectName, object[] specificInterceptors)
-        {
-            // handle prototypes correctly
-            IAdvisor[] commonInterceptors = ResolveInterceptorNames();
-
-            ArrayList allInterceptors = new ArrayList();
-            if (specificInterceptors != null)
-            {
-                allInterceptors.AddRange(specificInterceptors);
-                if (commonInterceptors != null)
-                {
-                    if (applyCommonInterceptorsFirst)
-                    {
-                        allInterceptors.InsertRange(0, commonInterceptors);
-                    }
-                    else
-                    {
-                        allInterceptors.AddRange(commonInterceptors);
-                    }
-                }
-            }
-            if (logger.IsInfoEnabled)
-            {
-                int nrOfCommonInterceptors = commonInterceptors != null ? commonInterceptors.Length : 0;
-                int nrOfSpecificInterceptors = specificInterceptors != null ? specificInterceptors.Length : 0;
-                logger.Info(string.Format("Creating implicit proxy for object '{0}' with {1} common interceptors and {2} specific interceptors", objectName, nrOfCommonInterceptors, nrOfSpecificInterceptors));
-            }
-
-
-            IAdvisor[] advisors = new IAdvisor[allInterceptors.Count];
-            for (int i = 0; i < allInterceptors.Count; i++)
-            {
-                advisors[i] = advisorAdapterRegistry.Wrap(allInterceptors[i]);
-            }
-            return advisors;
-        }
-
-        /// <summary>
-        /// Build a cache key for the given object type and object name
-        /// </summary>
-        /// <param name="objectType">The object type.</param>
-        /// <param name="objectName">The object name.</param>
-        /// <returns>The cache key for the given type and name</returns>
-        protected virtual object GetCacheKey(Type objectType, string objectName)
-        {
-            return objectType.FullName + "_" + objectName;
-        }
-
-
-        #endregion
-
-        #region Private Methods
-
-        private IAdvisor[] ResolveInterceptorNames()
-        {
-            ArrayList advisors = new ArrayList();
-            foreach(string name in interceptorNames)
-            {
-                object next = owningObjectFactory.GetObject(name);
-                if (next is IAdvisors)
-                {
-                    advisors.AddRange(((IAdvisors)next).Advisors);
-                }
-                else
-                {
-                    advisors.Add(advisorAdapterRegistry.Wrap(next));
-                }
-            }
-            return (IAdvisor[])advisors.ToArray(typeof(IAdvisor));
-        }
-
-        #endregion
-
-        #region IInstantiationAwareObjectPostProcessor Members
-
-        /// <summary>
-        /// Create the proxy if have a custom TargetSource
-        /// </summary>
-        /// <param name="objectType">The object type</param>
-        /// <param name="objectName">The object name</param>
-        /// <returns>null if not creating a proxy, otherwise return the proxy.</returns>
-        public object PostProcessBeforeInstantiation(Type objectType, string objectName)
-        {
-            object cacheKey = GetCacheKey(objectType, objectName);
-            if (!targetSourcedObjects.Contains(cacheKey))
-            {
-                if (advisedObjects.Contains(cacheKey) || nonAdvisedObjects.Contains(cacheKey))
-                {
-                    return null;
-                }
-                if (IsInfrastructureType(objectType, objectName) || ShouldSkip(objectType, objectName))
-                {
-                    nonAdvisedObjects.Add(cacheKey);
-                    return null;
-                }
-            }
-            // Create proxy here if we have a custom TargetSource.
-            // Suppresses unnecessary default instantiation of the target object:
-            // The TargetSource will handle target instances in a custom fashion.
-            ITargetSource targetSource = GetCustomTargetSource(objectType, objectName);
-            if (targetSource != null)
-            {
-                targetSourcedObjects.Add(objectName);
-                object[] specificInterceptors = GetAdvicesAndAdvisorsForObject(objectType, objectName, targetSource);
-                return CreateProxy(objectType, objectName, specificInterceptors, targetSource);
-            }
-            return null;
-        }
-
-
-        /// <summary>
-        /// Default behavior, return true and continue processing.
-        /// </summary>
-        /// <param name="objectInstance">The object instance</param>
-        /// <param name="objectName">The object name.</param>
-        /// <returns>true</returns>
-        public bool PostProcessAfterInstantiation(object objectInstance, string objectName)
-        {
-            return true;
-        }
-
-        /// <summary>
-        /// Default behavior, return passed in PropertyValues
-        /// </summary>
-        /// <param name="pvs">The property values that the factory is about to apply (never <code>null</code>).</param>
-        /// <param name="pis">he relevant property infos for the target object (with ignored
-        /// dependency types - which the factory handles specifically - already filtered out)</param>
-        /// <param name="objectInstance">The object instance created, but whose properties have not yet 
-        /// been set.</param>
-        /// <param name="objectName">Name of the object.</param>
-        /// <returns>The passed in PropertyValues</returns>
-        public IPropertyValues PostProcessPropertyValues(IPropertyValues pvs, PropertyInfo[] pis, object objectInstance,
-                                                         string objectName)
-        {
-            return pvs;
-        }
-
-        #endregion
-    }
+ */
+
+#endregion
+
+#region Imports
+
+using System;
+using System.Collections;
+using System.Reflection;
+using System.Runtime.Remoting;
+using AopAlliance.Aop;
+using Common.Logging;
+using Spring.Aop.Framework.Adapter;
+using Spring.Aop.Target;
+using Spring.Collections;
+using Spring.Core;
+using Spring.Objects;
+using Spring.Objects.Factory;
+using Spring.Objects.Factory.Config;
+using Spring.Util;
+
+#endregion
+
+namespace Spring.Aop.Framework.AutoProxy
+{
+    /// <summary>
+    /// ObjectPostProcessor implementation that wraps a group of objects with AOP proxies
+    /// that delegate to the given interceptors before invoking the object itself.
+    /// </summary>
+    /// <remarks>
+    /// <p>This class distinguishes between "common" interceptors: shared for all proxies it
+    /// creates, and "specific" interceptors: unique per object instance. There need not
+    /// be any common interceptors. If there are, they are set using the interceptorNames
+    /// property. As with ProxyFactoryObject, interceptors names in the current factory
+    /// are used rather than object references to allow correct handling of prototype
+    /// advisors and interceptors: for example, to support stateful mixins.
+    /// Any advice type is supported for "interceptorNames" entries.</p>
+    /// <p>Such autoproxying is particularly useful if there's a large number of objects that need
+    /// to be wrapped with similar proxies, i.e. delegating to the same interceptors.
+    /// Instead of x repetitive proxy definitions for x target objects, you can register
+    /// one single such post processor with the object factory to achieve the same effect.</p>
+    /// <p>Subclasses can apply any strategy to decide if a object is to be proxied,
+    /// e.g. by type, by name, by definition details, etc. They can also return
+    /// additional interceptors that should just be applied to the specific object
+    /// instance. The default concrete implementation is ObjectNameAutoProxyCreator,
+    /// identifying the objects to be proxied via a list of object names.</p>
+    /// <p>Any number of TargetSourceCreator implementations can be used with any subclass,
+    /// to create a custom target source - for example, to pool prototype objects.
+    /// Autoproxying will occur even if there is no advice if a TargetSourceCreator specifies
+    /// a custom TargetSource. If there are no TargetSourceCreators set, or if none matches,
+    /// a SingletonTargetSource will be used by default to wrap the object to be autoproxied.</p>
+    /// </remarks>
+    /// <author>Juergen Hoeller</author>
+    /// <author>Rod Johnson</author>
+    /// <author>Adhari C Mahendra (.NET)</author>
+    /// <seealso cref="Spring.Aop.Framework.AutoProxy.AbstractAutoProxyCreator.InterceptorNames"/>
+    /// <seealso cref="Spring.Aop.Framework.AutoProxy.ObjectNameAutoProxyCreator"/>
+    public abstract class AbstractAutoProxyCreator : ProxyConfig, IInstantiationAwareObjectPostProcessor, IObjectFactoryAware, IOrdered
+    {
+        #region Protected Fields
+
+        /// <summary>
+        /// The logger for this class hierarchy.
+        /// </summary>
+        protected readonly ILog logger = LogManager.GetLogger( System.Reflection.MethodBase.GetCurrentMethod().DeclaringType );
+
+        /// <summary>
+        /// Convenience constant for subclasses: Return value for "do not proxy".
+        /// </summary>
+        protected static readonly object[] DO_NOT_PROXY = null;
+
+        /// <summary>
+        /// Convenience constant for subclasses: Return value for
+        /// "proxy without additional interceptors, just the common ones".
+        /// </summary>
+        protected static readonly object[] PROXY_WITHOUT_ADDITIONAL_INTERCEPTORS = new object[0];
+
+        #endregion
+
+        #region Private Fields
+
+        /// <summary>
+        /// Default value is same as non-ordered
+        /// </summary>
+        private int order = int.MaxValue;
+
+        /// <summary>
+        /// Default is global AdvisorAdapterRegistry
+        /// </summary>
+        private IAdvisorAdapterRegistry advisorAdapterRegistry = GlobalAdvisorAdapterRegistry.Instance;
+
+
+        /// <summary>
+        /// 
+        /// </summary>
+        private bool freezeProxy = false;
+
+        /// <summary>
+        /// Names of common interceptors. 
+        /// We must use object name rather than object references
+        /// to handle prototype advisors/interceptors.
+        /// Default is the empty array: no common interceptors.
+        /// </summary>
+        private string[] interceptorNames = new string[0];
+
+        private bool applyCommonInterceptorsFirst = true;
+        private IList customTargetSourceCreators = new ArrayList();
+        private IObjectFactory owningObjectFactory;
+
+        /// <summary>
+        /// Set of object type + name strings, referring to all objects that this auto-proxy
+        /// creator created a custom TargetSource for.  Used to detect own pre-built proxies
+        /// (from "PostProcessBeforeInstantiation") in the "PostProcessAfterInitialization" method.
+        /// </summary>
+        private ISet targetSourcedObjects = new SynchronizedSet( new HashedSet() );
+
+        private ISet advisedObjects = new SynchronizedSet( new HashedSet() );
+
+        private ISet nonAdvisedObjects = new SynchronizedSet( new HashedSet() );
+
+        #endregion
+
+        #region Properties
+
+        /// <summary>
+        /// Sets the AdvisorAdapterRegistry to use. 
+        /// </summary>
+        /// <remarks>
+        /// Default is the global AdvisorAdapterRegistry.
+        /// </remarks>
+        public IAdvisorAdapterRegistry AdvisorAdapterRegistry
+        {
+            set { advisorAdapterRegistry = value; }
+        }
+
+        /// <summary>
+        /// Sets custom TargetSourceCreators to be applied in this order.
+        /// </summary>
+        /// <remarks>
+        /// <para>
+        /// If the list is empty, or they all return null, a SingletonTargetSource
+        /// will be created.
+        /// </para>
+        /// <para>
+        /// TargetSourceCreators can only be invoked if this post processor is used
+        /// in a IObjectFactory, and its ObjectFactoryAware callback is used.
+        /// </para>
+        /// </remarks>
+        public IList CustomTargetSourceCreators
+        {
+            set { customTargetSourceCreators = value; }
+        }
+
+        /// <summary> 
+        /// Sets the common interceptors, a list of <see cref="AopAlliance.Aop.IAdvice"/>, 
+        /// <see cref="Spring.Aop.IAdvisor"/> and introduction object names.
+        /// </summary>
+        /// <remarks>
+        /// <para>
+        /// If this property isn't set, there will be zero common interceptors. 
+        /// This is perfectly valid, if "specific" interceptors such as
+        /// matching Advisors are all we want.
+        /// </para>
+        /// </remarks>
+        /// <value>
+        /// The list of <see cref="AopAlliance.Aop.IAdvice"/>, 
+        /// <see cref="Spring.Aop.IAdvisor"/> and introduction object names.
+        /// </value>
+        /// <seealso cref="AopAlliance.Aop.IAdvice"/>
+        /// <seealso cref="Spring.Aop.IAdvisor"/>
+        public string[] InterceptorNames
+        {
+            set { interceptorNames = value; }
+        }
+
+        /// <summary>
+        /// Sets whether the common interceptors should be applied before
+        /// object-specific ones. 
+        /// </summary>
+        /// <remarks>
+        /// Default is true; else, object-specific interceptors will get applied first.
+        /// </remarks>
+        public bool ApplyCommonInterceptorsFirst
+        {
+            set { applyCommonInterceptorsFirst = value; }
+        }
+
+        /// <summary>
+        /// Set whether or not the proxy should be frozen, preventing advice
+        /// from being added to it once it is created.
+        /// </summary>
+        /// <remarks>
+        /// 	<p>Overridden from the super class to prevent the proxy configuration
+        /// from being frozen before the proxy is created. The default is not frozen.
+        ///     </p>
+        /// </remarks>
+        public override bool IsFrozen
+        {
+            get { return freezeProxy; }
+            set { this.freezeProxy = value; }
+        }
+
+        #endregion
+
+        #region IObjectPostProcessor Members
+
+        /// <summary>
+        /// Create a proxy with the configured interceptors if the object is
+        /// identified as one to proxy by the subclass.
+        /// </summary>
+        public virtual object PostProcessAfterInitialization( object obj, string objectName )
+        {
+            if (targetSourcedObjects.Contains( objectName ))
+            {
+                return obj;
+            }
+
+            object cacheKey = GetCacheKey( obj.GetType(), objectName );
+            if (nonAdvisedObjects.Contains( cacheKey ))
+            {
+                return obj;
+            }
+
+            if (IsInfrastructureType( obj.GetType(), objectName ))
+            {
+                #region Instrumentation
+
+                if (logger.IsDebugEnabled)
+                {
+                    logger.Debug( string.Format( "Did not attempt to autoproxy infrastructure type [{0}]", obj.GetType() ) );
+                }
+
+                #endregion
+
+                nonAdvisedObjects.Add( cacheKey );
+                return obj;
+            }
+
+            if (ShouldSkip( obj.GetType(), objectName ))
+            {
+                #region Instrumentation
+
+                if (logger.IsDebugEnabled)
+                {
+                    logger.Debug( string.Format( "Skipping  type [{0}]", obj.GetType() ) );
+                }
+
+                #endregion
+
+                nonAdvisedObjects.Add( cacheKey );
+                return obj;
+            }
+
+            //ITargetSource targetSource = GetCustomTargetSource(obj.GetType(), objectName);
+            object[] specificInterceptors;
+            if (RemotingServices.IsTransparentProxy( obj ))
+            {
+                specificInterceptors = GetAdvicesAndAdvisorsForObject( ObjectFactory.GetType( objectName ), objectName, null );
+            }
+            else
+            {
+                specificInterceptors = GetAdvicesAndAdvisorsForObject( obj.GetType(), objectName, null );
+            }
+
+
+            // proxy if we have advice or if a TargetSourceCreator wants to do some
+            // fancy stuff such as pooling
+            if (specificInterceptors != DO_NOT_PROXY)
+            {
+                advisedObjects.Add( cacheKey );
+                return CreateProxy( obj.GetType(), objectName, specificInterceptors, new SingletonTargetSource( obj ) );
+            }
+            nonAdvisedObjects.Add( cacheKey );
+            return obj;
+        }
+
+        /// <summary>
+        /// No-op for before initialization.
+        /// </summary>
+        /// <param name="obj">The obj.</param>
+        /// <param name="name">The name.</param>
+        /// <returns></returns>
+        public virtual object PostProcessBeforeInitialization( object obj, string name )
+        {
+            return obj;
+        }
+
+        #endregion
+
+        #region IObjectFactoryAware Members
+
+        /// <summary>
+        /// Callback that supplies the owning factory to an object instance.
+        /// </summary>
+        /// <value>
+        /// Owning <see cref="T:Spring.Objects.Factory.IObjectFactory"/>
+        /// (may not be <see langword="null"/>). The object can immediately
+        /// call methods on the factory.
+        /// </value>
+        /// <remarks>
+        /// 	<p>
+        /// Invoked after population of normal object properties but before an init
+        /// callback like <see cref="T:Spring.Objects.Factory.IInitializingObject"/>'s
+        /// <see cref="M:Spring.Objects.Factory.IInitializingObject.AfterPropertiesSet"/>
+        /// method or a custom init-method.
+        /// </p>
+        /// </remarks>
+        /// <exception cref="T:Spring.Objects.ObjectsException">
+        /// In case of initialization errors.
+        /// </exception>
+        public virtual IObjectFactory ObjectFactory
+        {
+            get { return owningObjectFactory; }
+            set { owningObjectFactory = value; }
+        }
+
+        #endregion
+
+        #region IOrdered Members
+
+        /// <summary>
+        /// Propery Order
+        /// </summary>
+        /// <remarks>
+        /// Ordering which will apply to this class's implementation
+        /// of Ordered, used when applying multiple ObjectPostProcessors.
+        /// Default value is int.MaxValue, meaning that it's non-ordered.
+        /// </remarks>
+        public virtual int Order
+        {
+            get { return order; }
+            set { order = value; }
+        }
+
+        #endregion
+
+        #region Protected Methods
+
+        /// <summary>
+        /// Subclasses should override this method to return true if this
+        /// object should not be considered for autoproxying by this post processor.
+        /// Sometimes we need to be able to avoid this happening if it will lead to
+        /// a circular reference. This implementation returns false.
+        /// </summary>
+        /// <param name="objectType">the type of the object</param>
+        /// <param name="objectName">the name of the object</param>
+        /// <returns>if remarkable to skip</returns>
+        protected virtual bool ShouldSkip( Type objectType, string objectName )
+        {
+            return false;
+        }
+
+        /// <summary>
+        /// Subclasses may choose to implement this: for example,
+        /// to change the interfaces exposed
+        /// </summary>
+        /// <param name="pf">
+        /// ProxyFactory that will be used to create the proxy immediably after this method returns.
+        /// </param>
+        protected virtual void CustomizeProxyFactory( ProxyFactory pf )
+        {
+            // This implementation does nothing
+        }
+
+        /// <summary>
+        /// Determines whether the object is an infrastructure type,
+        /// IAdvisor, IAdvice, IAdvisors or AbstractAutoProxyCreator
+        /// </summary>
+        /// <param name="type">The object type to compare</param>
+        /// <param name="name">The name of the object</param>
+        /// <returns>
+        /// <c>true</c> if [is infrastructure type] [the specified obj]; otherwise, <c>false</c>.
+        /// </returns>
+        protected virtual bool IsInfrastructureType( Type type, String name )
+        {
+            return typeof( IAdvisor ).IsAssignableFrom( type )
+                || typeof( IAdvice ).IsAssignableFrom( type )
+                || typeof( IAdvisors ).IsAssignableFrom( type )
+                || typeof( AbstractAutoProxyCreator ).IsAssignableFrom( type );
+        }
+
+
+        /// <summary>
+        /// Create a target source for object instances. Uses any
+        /// TargetSourceCreators if set. Returns null if no Custom TargetSource
+        /// should be used.
+        /// This implementation uses the customTargetSourceCreators property.
+        /// Subclasses can override this method to use a different mechanism.
+        /// </summary>
+        /// <param name="objectType">the type of the object to create a TargetSource for</param>
+        /// <param name="name">the name of the object</param>
+        /// <returns>a TargetSource for this object</returns>
+        protected virtual ITargetSource GetCustomTargetSource( Type objectType, string name )
+        {
+            // We can't create fancy target sources for directly registered singletons.
+            if (customTargetSourceCreators != null &&
+                owningObjectFactory != null && owningObjectFactory.ContainsObject( name ))
+            {
+                for (int i = 0; i < customTargetSourceCreators.Count; i++)
+                {
+                    ITargetSourceCreator tsc = (ITargetSourceCreator)customTargetSourceCreators[i];
+                    ITargetSource ts = tsc.GetTargetSource( objectType, name, owningObjectFactory );
+                    if (ts != null)
+                    {
+                        // found a match
+                        if (logger.IsInfoEnabled)
+                        {
+                            logger.Info( string.Format( "TargetSourceCreator [{0} found custom TargetSource for object with objectName '{1}'", tsc, name ) );
+                        }
+                        return ts;
+                    }
+                }
+            }
+
+            // no custom TargetSource found
+            return null;
+        }
+
+        /// <summary>
+        /// Return whether the given object is to be proxied, what additional
+        /// advices (e.g. AOP Alliance interceptors) and advisors to apply.
+        /// </summary>
+        /// <remarks>
+        /// <p>The previous name of this method was "GetInterceptorAndAdvisorForObject".
+        /// It has been renamed in the course of general terminology clarification
+        /// in Spring 1.1. An AOP Alliance Interceptor is just a special form of
+        /// Advice, so the generic Advice term is preferred now.</p>
+        /// <p>The third parameter, customTargetSource, is new in Spring 1.1;
+        /// add it to existing implementations of this method.</p>
+        /// </remarks>
+        /// <param name="objType">the new object instance</param>
+        /// <param name="name">the name of the object</param>
+        /// <param name="customTargetSource">targetSource returned by TargetSource property:
+        /// may be ignored. Will be null unless a custom target source is in use.</param>
+        /// <returns>an array of additional interceptors for the particular object;
+        /// or an empty array if no additional interceptors but just the common ones;
+        /// or null if no proxy at all, not even with the common interceptors.</returns>
+        protected abstract object[] GetAdvicesAndAdvisorsForObject( Type objType, string name, ITargetSource customTargetSource );
+
+        /// <summary>
+        /// Create an AOP proxy for the given object.
+        /// </summary>
+        /// <param name="objectType">Type of the object.</param>
+        /// <param name="objectName">The name of the object.</param>
+        /// <param name="specificInterceptors">The set of interceptors that is specific to this
+        /// object (may be empty but not null)</param>
+        /// <param name="targetSource">The target source for the proxy, already pre-configured to access the object.</param>
+        /// <returns>The AOP Proxy for the object.</returns>
+        protected virtual object CreateProxy( Type objectType, string objectName, object[] specificInterceptors, ITargetSource targetSource )
+        {
+            ProxyFactory proxyFactory = CreateProxyFactory();
+            // copy our properties (proxyTargetClass) inherited from ProxyConfig
+            proxyFactory.CopyFrom( this );
+
+            object target = targetSource.GetTarget();
+
+
+            if (!ProxyTargetType)
+            {
+                // Must allow for introductions; can't just set interfaces to
+                // the target's interfaces only.
+                Type[] targetInterfaceTypes = AopUtils.GetAllInterfaces( target );
+                foreach (Type interfaceType in targetInterfaceTypes)
+                {
+                    proxyFactory.AddInterface( interfaceType );
+                }
+            }
+
+
+            IAdvisor[] advisors = BuildAdvisors( objectName, specificInterceptors );
+
+            foreach (IAdvisor advisor in advisors)
+            {
+                if (advisor is IIntroductionAdvisor)
+                {
+                    proxyFactory.AddIntroduction( (IIntroductionAdvisor)advisor );
+                }
+                else
+                {
+                    proxyFactory.AddAdvisor( advisor );
+                }
+            }
+            proxyFactory.TargetSource = targetSource;
+            CustomizeProxyFactory( proxyFactory );
+
+            proxyFactory.IsFrozen = freezeProxy;
+            return proxyFactory.GetProxy();
+        }
+
+        /// <summary>
+        /// Obtain a new proxy factory instance to be used for proxying a particular object
+        /// </summary>
+        /// <returns>A proxy factory instance for proxying a particular object</returns>
+        protected virtual ProxyFactory CreateProxyFactory()
+        {
+            return new ProxyFactory();
+        }
+
+        /// <summary>
+        /// Determines the advisors for the given object, including the specific interceptors
+        /// as well as the common interceptor, all adapted to the Advisor interface.
+        /// </summary>
+        /// <param name="objectName">The name of the object.</param>
+        /// <param name="specificInterceptors">The set of interceptors that is specific to this
+        /// object (may be empty, but not null)</param>
+        /// <returns>The list of Advisors for the given object</returns>
+        protected virtual IAdvisor[] BuildAdvisors( string objectName, object[] specificInterceptors )
+        {
+            // handle prototypes correctly
+            IAdvisor[] commonInterceptors = ResolveInterceptorNames();
+
+            ArrayList allInterceptors = new ArrayList();
+            if (specificInterceptors != null)
+            {
+                allInterceptors.AddRange( specificInterceptors );
+                if (commonInterceptors != null)
+                {
+                    if (applyCommonInterceptorsFirst)
+                    {
+                        allInterceptors.InsertRange( 0, commonInterceptors );
+                    }
+                    else
+                    {
+                        allInterceptors.AddRange( commonInterceptors );
+                    }
+                }
+            }
+            if (logger.IsInfoEnabled)
+            {
+                int nrOfCommonInterceptors = commonInterceptors != null ? commonInterceptors.Length : 0;
+                int nrOfSpecificInterceptors = specificInterceptors != null ? specificInterceptors.Length : 0;
+                logger.Info( string.Format( "Creating implicit proxy for object '{0}' with {1} common interceptors and {2} specific interceptors", objectName, nrOfCommonInterceptors, nrOfSpecificInterceptors ) );
+            }
+
+
+            IAdvisor[] advisors = new IAdvisor[allInterceptors.Count];
+            for (int i = 0; i < allInterceptors.Count; i++)
+            {
+                advisors[i] = advisorAdapterRegistry.Wrap( allInterceptors[i] );
+            }
+            return advisors;
+        }
+
+        /// <summary>
+        /// Build a cache key for the given object type and object name
+        /// </summary>
+        /// <param name="objectType">The object type.</param>
+        /// <param name="objectName">The object name.</param>
+        /// <returns>The cache key for the given type and name</returns>
+        protected virtual object GetCacheKey( Type objectType, string objectName )
+        {
+            return objectType.FullName + "_" + objectName;
+        }
+
+
+        #endregion
+
+        #region Private Methods
+
+        private IAdvisor[] ResolveInterceptorNames()
+        {
+            ArrayList advisors = new ArrayList();
+            foreach (string name in interceptorNames)
+            {
+                object next = owningObjectFactory.GetObject( name );
+                if (next is IAdvisors)
+                {
+                    advisors.AddRange( ((IAdvisors)next).Advisors );
+                }
+                else
+                {
+                    advisors.Add( advisorAdapterRegistry.Wrap( next ) );
+                }
+            }
+            return (IAdvisor[])advisors.ToArray( typeof( IAdvisor ) );
+        }
+
+        #endregion
+
+        #region IInstantiationAwareObjectPostProcessor Members
+
+        /// <summary>
+        /// Create the proxy if have a custom TargetSource
+        /// </summary>
+        /// <param name="objectType">The object type</param>
+        /// <param name="objectName">The object name</param>
+        /// <returns>null if not creating a proxy, otherwise return the proxy.</returns>
+        public object PostProcessBeforeInstantiation( Type objectType, string objectName )
+        {
+            object cacheKey = GetCacheKey( objectType, objectName );
+            if (!targetSourcedObjects.Contains( cacheKey ))
+            {
+                if (advisedObjects.Contains( cacheKey ) || nonAdvisedObjects.Contains( cacheKey ))
+                {
+                    return null;
+                }
+
+                if (IsInfrastructureType( objectType, objectName ))
+                {
+                    #region Instrumentation
+
+                    if (logger.IsDebugEnabled)
+                    {
+                        logger.Debug( string.Format( "Did not attempt to autoproxy infrastructure type [{0}]", objectType ) );
+                    }
+
+                    #endregion
+
+                    nonAdvisedObjects.Add( cacheKey );
+                    return null;
+                }
+
+                if (ShouldSkip( objectType, objectName ))
+                {
+                    #region Instrumentation
+
+                    if (logger.IsDebugEnabled)
+                    {
+                        logger.Debug( string.Format( "Skipping  type [{0}]", objectType ) );
+                    }
+
+                    #endregion
+
+                    nonAdvisedObjects.Add( cacheKey );
+                    return null;
+                }
+            }
+            // Create proxy here if we have a custom TargetSource.
+            // Suppresses unnecessary default instantiation of the target object:
+            // The TargetSource will handle target instances in a custom fashion.
+            ITargetSource targetSource = GetCustomTargetSource( objectType, objectName );
+            if (targetSource != null)
+            {
+                targetSourcedObjects.Add( objectName );
+                object[] specificInterceptors = GetAdvicesAndAdvisorsForObject( objectType, objectName, targetSource );
+                return CreateProxy( objectType, objectName, specificInterceptors, targetSource );
+            }
+            return null;
+        }
+
+
+        /// <summary>
+        /// Default behavior, return true and continue processing.
+        /// </summary>
+        /// <param name="objectInstance">The object instance</param>
+        /// <param name="objectName">The object name.</param>
+        /// <returns>true</returns>
+        public bool PostProcessAfterInstantiation( object objectInstance, string objectName )
+        {
+            return true;
+        }
+
+        /// <summary>
+        /// Default behavior, return passed in PropertyValues
+        /// </summary>
+        /// <param name="pvs">The property values that the factory is about to apply (never <code>null</code>).</param>
+        /// <param name="pis">he relevant property infos for the target object (with ignored
+        /// dependency types - which the factory handles specifically - already filtered out)</param>
+        /// <param name="objectInstance">The object instance created, but whose properties have not yet 
+        /// been set.</param>
+        /// <param name="objectName">Name of the object.</param>
+        /// <returns>The passed in PropertyValues</returns>
+        public IPropertyValues PostProcessPropertyValues( IPropertyValues pvs, PropertyInfo[] pis, object objectInstance,
+                                                         string objectName )
+        {
+            return pvs;
+        }
+
+        #endregion
+    }
 }
\ No newline at end of file
diff --git a/src/Spring/Spring.Aop/Aop/Framework/AutoProxy/AbstractFilteringAutoProxyCreator.cs b/src/Spring/Spring.Aop/Aop/Framework/AutoProxy/AbstractFilteringAutoProxyCreator.cs
new file mode 100644
index 00000000..5462b463
--- /dev/null
+++ b/src/Spring/Spring.Aop/Aop/Framework/AutoProxy/AbstractFilteringAutoProxyCreator.cs
@@ -0,0 +1,81 @@
+#region License
+
+/*
+ * Copyright © 2002-2008 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#endregion
+
+#region Imports
+
+using System;
+using System.Collections;
+using Spring.Objects.Factory;
+using Spring.Util;
+
+#endregion
+
+namespace Spring.Aop.Framework.AutoProxy
+{
+    /// <summary>
+    /// The base class for AutoProxyCreator implementations that mark objects 
+    /// eligible for proxying based on arbitrary criteria.
+    /// </summary>
+    /// <author>Erich Eichinger</author>
+    public abstract class AbstractFilteringAutoProxyCreator : AbstractAutoProxyCreator
+    {
+        /// <summary>
+        ///Overridden to call <see cref="IsEligibleForProxying"/>.
+        /// </summary>
+        /// <param name="objectType">the type of the object</param>
+        /// <param name="objectName">the name of the object</param>
+        /// <returns>if remarkable to skip</returns>
+        protected override bool ShouldSkip( Type objectType, string objectName )
+        {
+            bool shouldSkip = !IsEligibleForProxying( objectType, objectName );
+            return shouldSkip;
+        }
+
+        /// <summary>
+        /// Override to always return <see cref="AbstractAutoProxyCreator.PROXY_WITHOUT_ADDITIONAL_INTERCEPTORS"/>.
+        /// </summary>
+        /// <remarks>
+        /// Whether an object shall be proxied or not is determined by the result of <see cref="IsEligibleForProxying"/>.
+        /// </remarks>
+        /// <param name="objType">ingored</param>
+        /// <param name="name">ignored</param>
+        /// <param name="customTargetSource">ignored</param>
+        /// <returns>
+        /// Always <see cref="AbstractAutoProxyCreator.PROXY_WITHOUT_ADDITIONAL_INTERCEPTORS"/> to indicate, that the object shall be proxied.
+        /// </returns>
+        /// <seealso cref="AbstractAutoProxyCreator.PROXY_WITHOUT_ADDITIONAL_INTERCEPTORS"/>
+        protected override object[] GetAdvicesAndAdvisorsForObject( Type objType, string name, ITargetSource customTargetSource )
+        {
+            return PROXY_WITHOUT_ADDITIONAL_INTERCEPTORS;
+        }
+
+        /// <summary>
+        /// Decide, whether the given object is eligible for proxying.
+        /// </summary>
+        /// <remarks>
+        /// Override this method to allow or reject proxying for the given object.
+        /// </remarks>
+        /// <param name="objType">the object's type</param>
+        /// <param name="name">the name of the object</param>
+        /// <seealso cref="AbstractAutoProxyCreator.ShouldSkip"/>        
+        /// <returns>whether the given object shall be proxied.</returns>
+        protected abstract bool IsEligibleForProxying( Type objType, string name );
+    }
+}
\ No newline at end of file
diff --git a/src/Spring/Spring.Aop/Aop/Framework/AutoProxy/AttributeAutoProxyCreator.cs b/src/Spring/Spring.Aop/Aop/Framework/AutoProxy/AttributeAutoProxyCreator.cs
new file mode 100644
index 00000000..66d6de06
--- /dev/null
+++ b/src/Spring/Spring.Aop/Aop/Framework/AutoProxy/AttributeAutoProxyCreator.cs
@@ -0,0 +1,115 @@
+#region License
+
+/*
+ * Copyright © 2002-2008 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#endregion
+
+#region Imports
+
+using System;
+using System.Collections;
+using Spring.Aop.Support;
+using Spring.Util;
+
+#endregion
+
+namespace Spring.Aop.Framework.AutoProxy
+{
+    /// <summary>
+    /// An AutoProxyCreator, that identifies objects to be proxied by checking <see cref="Attribute"/>s defined on their type.
+    /// </summary>
+    /// <author>Erich Eichinger</author>
+    public class AttributeAutoProxyCreator : AbstractFilteringAutoProxyCreator
+    {
+        private bool _checkInherited = false;
+        private Type[] _attributeTypes = null;
+
+        /// <summary>
+        /// Indicates, whether to consider base types for filtering when checking declared attributes. Defaults to <c>false</c>.
+        /// </summary>
+        public bool CheckInherited
+        {
+            get { return _checkInherited; }
+            set { _checkInherited = value; }
+        }
+
+        /// <summary>
+        /// The list of attribute types marking object types as eligible for auto-proxying by this AutoProxyCreator. Must not be <c>null</c>.
+        /// </summary>
+        public Type[] AttributeTypes
+        {
+            get { return _attributeTypes; }
+            set
+            {
+                AssertUtils.ArgumentNotNull( value, "AttributeTypes" );
+                _attributeTypes = value;
+            }
+        }
+
+        /// <summary>
+        /// Determines, whether the given object shall be proxied by matching <paramref name="objType"/> against <see cref="AttributeTypes"/>.
+        /// </summary>
+        /// <param name="objType">the object's type</param>
+        /// <param name="name">the name of the object</param>
+        protected override bool IsEligibleForProxying( Type objType, string name )
+        {
+            AssertUtils.ArgumentNotNull(this.AttributeTypes, "AttributeTypes");
+
+            bool shallProxy = IsAnnotatedWithAnyOfAttribute( objType, this.AttributeTypes, this.CheckInherited );
+            return shallProxy;
+        }
+
+        /// <summary>
+        /// Checks if <paramref name="objectType"/> is annotated with any of the attributes within the given list of <paramref name="attributeTypes"/>.
+        /// </summary>
+        /// <param name="objectType">the object's type</param>
+        /// <param name="attributeTypes">the list of <see cref="Attribute"/> types to match agains.</param>
+        /// <param name="checkInherited">whether to check base classes and intefaces for any of the given attributes.</param>
+        /// <returns><see langword="true"/> if any of the attributes is found</returns>
+        protected virtual bool IsAnnotatedWithAnyOfAttribute( Type objectType, Type[] attributeTypes, bool checkInherited )
+        {
+            foreach(Type attributeType in attributeTypes)
+            {
+                if (IsAnnotatedWithAttribute(objectType, attributeType, checkInherited))
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// Checks if <paramref name="objectType"/> is annotated with the specified <paramref name="attributeType"/>.
+        /// </summary>
+        /// <param name="objectType">the object's type</param>
+        /// <param name="attributeType">the <see cref="Attribute"/> type to match agains.</param>
+        /// <param name="checkInherited">whether to check base classes and intefaces for the specified attribute.</param>
+        /// <returns><see langword="true"/> if the attributes is found</returns>
+        protected virtual bool IsAnnotatedWithAttribute( Type objectType, Type attributeType, bool checkInherited )
+        {
+            if (checkInherited)
+            {
+                return AttributeUtils.FindAttribute( objectType, attributeType ) != null;
+            }
+            else
+            {
+                object[] atts = objectType.GetCustomAttributes( attributeType, false );
+                return ArrayUtils.HasLength( atts );
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Spring/Spring.Aop/Aop/Framework/AutoProxy/ObjectNameAutoProxyCreator.cs b/src/Spring/Spring.Aop/Aop/Framework/AutoProxy/ObjectNameAutoProxyCreator.cs
index 5d63b4b9..137ad39a 100644
--- a/src/Spring/Spring.Aop/Aop/Framework/AutoProxy/ObjectNameAutoProxyCreator.cs
+++ b/src/Spring/Spring.Aop/Aop/Framework/AutoProxy/ObjectNameAutoProxyCreator.cs
@@ -30,7 +30,7 @@ using Spring.Util;
 namespace Spring.Aop.Framework.AutoProxy
 {
     /// <summary>
-    /// Object Auto Proxy Creator
+    /// AutoProxyCreator that identifies objects to proxy via a list of names.
     /// </summary>
     /// <remarks>
     /// <para>
@@ -46,10 +46,16 @@ namespace Spring.Aop.Framework.AutoProxy
     /// <seealso cref="Spring.Aop.Framework.AutoProxy.ObjectNameAutoProxyCreator.IsMatch"/>
     /// <author>Juergen Hoeller</author>
     /// <author>Adhari C Mahendra (.NET)</author>
-    public class ObjectNameAutoProxyCreator : AbstractAutoProxyCreator
+    public class ObjectNameAutoProxyCreator : AbstractFilteringAutoProxyCreator
     {
         private IList objectNames;
 
+        /// <summary>
+        /// Initializes a new instance of <see cref="ObjectNameAutoProxyCreator"/>.
+        /// </summary>
+        public ObjectNameAutoProxyCreator()
+        {}
+
         /// <summary>
         /// Set the names of the objects in IList fashioned way that should automatically 
         /// get wrapped with proxies.
@@ -62,47 +68,15 @@ namespace Spring.Aop.Framework.AutoProxy
             get { return objectNames; }
         }
 
-        /// <summary>
-        /// Determines, whether the given object shall be proxied.
-        /// </summary>
-        /// <returns>
-        /// <see cref="AbstractAutoProxyCreator.PROXY_WITHOUT_ADDITIONAL_INTERCEPTORS"/> if the object shall be proxied.<br/>
-        /// <see cref="AbstractAutoProxyCreator.DO_NOT_PROXY"/> otherwise.
-        /// </returns>
-        protected override object[] GetAdvicesAndAdvisorsForObject( Type objType, string name, ITargetSource customTargetSource )
-        {
-            if (ShallProxy( objType, name, customTargetSource ))
-            {
-                return PROXY_WITHOUT_ADDITIONAL_INTERCEPTORS;
-            }
-            return DO_NOT_PROXY;
-        }
-
         /// <summary>
         /// Identify as object to proxy if the object name is in the configured list of names.
         /// </summary>
-        protected virtual bool ShallProxy( Type objType, string name, ITargetSource customTargetSource )
+        protected override bool IsEligibleForProxying( Type objType, string name )
         {
-            if (objectNames != null)
-            {
-                for (int i = 0; i < objectNames.Count; i++)
-                {
-                    string mappedName = String.Copy( (string)objectNames[i] );
-                    if (typeof( IFactoryObject ).IsAssignableFrom( objType ))
-                    {
-                        if (!name.StartsWith( ObjectFactoryUtils.FactoryObjectPrefix ))
-                        {
-                            continue;
-                        }
-                        mappedName = mappedName.Substring( ObjectFactoryUtils.FactoryObjectPrefix.Length );
-                    }
-                    if (IsMatch( name, mappedName ))
-                    {
-                        return true;
-                    }
-                }
-            }
-            return false;
+            AssertUtils.ArgumentNotNull(this.ObjectNames, "ObjectNames");
+            
+            bool shallProxy = PatternMatchUtils.IsObjectNameMatch(objType, name, this.ObjectNames, new PatternMatchUtils.ObjectNameMatchPredicate(IsMatch), ObjectFactoryUtils.FactoryObjectPrefix);
+            return shallProxy;
         }
 
         /// <summary>
diff --git a/src/Spring/Spring.Aop/Aop/Framework/AutoProxy/PointcutFilteringAutoProxyCreator.cs b/src/Spring/Spring.Aop/Aop/Framework/AutoProxy/PointcutFilteringAutoProxyCreator.cs
index 18b09d7a..38df5772 100644
--- a/src/Spring/Spring.Aop/Aop/Framework/AutoProxy/PointcutFilteringAutoProxyCreator.cs
+++ b/src/Spring/Spring.Aop/Aop/Framework/AutoProxy/PointcutFilteringAutoProxyCreator.cs
@@ -34,7 +34,7 @@ namespace Spring.Aop.Framework.AutoProxy
     /// be further restricted by specifying object name patterns like with <see cref="ObjectNameAutoProxyCreator"/>.
     /// </summary>
     /// <author>Erich Eichinger</author>
-    public class PointcutFilteringAutoProxyCreator : ObjectNameAutoProxyCreator
+    public class PointcutFilteringAutoProxyCreator : AbstractFilteringAutoProxyCreator
     {
         private IPointcut _pointcut;
 
@@ -44,34 +44,18 @@ namespace Spring.Aop.Framework.AutoProxy
         public IPointcut Pointcut
         {
             set { _pointcut = value; }
+            get { return _pointcut; }
         }
 
         /// <summary>
         /// Determines, whether the given object shall be proxied.
         /// </summary>
-        protected override bool ShallProxy( Type objType, string name, ITargetSource customTargetSource )
+        protected override bool IsEligibleForProxying( Type objType, string name )
         {
-            if (CollectionUtils.IsEmpty( ObjectNames ) && _pointcut == null)
-            {
-                throw new ArgumentException("At least one of ObjectNames and Pointcut criteria are required");
-            }
+            AssertUtils.ArgumentNotNull(_pointcut, "Pointcut");
 
-            bool isObjectNameMatch = base.ShallProxy( objType, name, customTargetSource );
-
-            // we have a name match, but empty pointcut -> ok
-            if (isObjectNameMatch && _pointcut==null)
-            {
-                return true;
-            }
-
-            // positive name match or no names specified -> get the pointcut match
-            if ( (isObjectNameMatch || CollectionUtils.IsEmpty(ObjectNames) )
-                && _pointcut != null)
-            {
-                return AopUtils.CanApply( _pointcut, objType, null );
-            }
-
-            return false;
+            bool shallProxy = AopUtils.CanApply( _pointcut, objType, null );
+            return shallProxy;
         }
     }
 }
\ No newline at end of file
diff --git a/src/Spring/Spring.Aop/Aop/Framework/AutoProxy/TypeNameAutoProxyCreator.cs b/src/Spring/Spring.Aop/Aop/Framework/AutoProxy/TypeNameAutoProxyCreator.cs
new file mode 100644
index 00000000..777c03a4
--- /dev/null
+++ b/src/Spring/Spring.Aop/Aop/Framework/AutoProxy/TypeNameAutoProxyCreator.cs
@@ -0,0 +1,70 @@
+#region License
+
+/*
+ * Copyright © 2002-2008 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#endregion
+
+#region Imports
+
+using System;
+using Spring.Aop.Support;
+using Spring.Util;
+
+#endregion
+
+namespace Spring.Aop.Framework.AutoProxy
+{
+    /// <summary>
+    /// AutoProxyCreator, that identifies objects to proxy by matching their <see cref="Type.FullName"/> against a list of patterns.
+    /// </summary>
+    /// <author>Erich Eichinger</author>
+    public class TypeNameAutoProxyCreator : AbstractFilteringAutoProxyCreator
+    {
+        private TypeNameTypeFilter _typeNameFilter = null;
+
+        ///<summary>
+        /// The list of patterns to match <see cref="Type.FullName"/> against. For pattern syntax, see <see cref="TypeNameTypeFilter"/>
+        ///</summary>
+        public string[] TypeNames
+        {
+            get { return _typeNameFilter.TypeNamePatterns; }
+            set
+            {
+                AssertUtils.ArgumentNotNull(value, "TypeNames");
+                _typeNameFilter = new TypeNameTypeFilter(value);
+            }
+        }
+
+        /// <summary>
+        /// Decide, whether the given object is eligible for proxying.
+        /// </summary>
+        /// <remarks>
+        /// Override this method to allow or reject proxying for the given object.
+        /// </remarks>
+        /// <param name="objType">the object's type</param>
+        /// <param name="name">the name of the object</param>
+        /// <seealso cref="AbstractAutoProxyCreator.ShouldSkip"/>        
+        /// <returns>whether the given object shall be proxied.</returns>
+        protected override bool IsEligibleForProxying(Type objType, string name)
+        {
+            AssertUtils.ArgumentNotNull(_typeNameFilter, "TypeNames");
+
+            bool shallProxy = _typeNameFilter.Matches(objType);
+            return shallProxy;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Spring/Spring.Aop/Aop/Support/AttributeTypeFilter.cs b/src/Spring/Spring.Aop/Aop/Support/AttributeTypeFilter.cs
index 84fbeb14..3633df19 100644
--- a/src/Spring/Spring.Aop/Aop/Support/AttributeTypeFilter.cs
+++ b/src/Spring/Spring.Aop/Aop/Support/AttributeTypeFilter.cs
@@ -31,9 +31,24 @@ namespace Spring.Aop.Support
     public class AttributeTypeFilter : ITypeFilter
     {
         private readonly Type attributeType;
-
         private readonly bool checkInherited;
 
+        /// <summary>
+        /// The attribute <see cref="Type"/> for this filter.
+        /// </summary>
+        public Type AttributeType
+        {
+            get { return attributeType; }
+        }
+
+        /// <summary>
+        /// Indicates, whether this filter considers base types for filtering.
+        /// </summary>
+        public bool CheckInherited
+        {
+            get { return checkInherited; }
+        }
+
         /// <summary>
         /// Initializes a new instance of the <see cref="AttributeTypeFilter"/> class for the
         /// given attribute type. 
@@ -80,9 +95,11 @@ namespace Spring.Aop.Support
             if (checkInherited)
             {
                 return AttributeUtils.FindAttribute(type, attributeType) != null;                
-            } else
+            }
+            else
             {
-                return Attribute.GetCustomAttributes(type, attributeType, false) != null; 
+                object[] atts = type.GetCustomAttributes(attributeType, false);
+                return ArrayUtils.HasLength(atts);
             }                    
         }
 
diff --git a/src/Spring/Spring.Aop/Aop/Support/TypeNameTypeFilter.cs b/src/Spring/Spring.Aop/Aop/Support/TypeNameTypeFilter.cs
new file mode 100644
index 00000000..49688927
--- /dev/null
+++ b/src/Spring/Spring.Aop/Aop/Support/TypeNameTypeFilter.cs
@@ -0,0 +1,75 @@
+#region License
+
+/*
+ * Copyright © 2002-2008 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#endregion
+
+#region Imports
+
+using System;
+using Spring.Util;
+
+#endregion
+
+namespace Spring.Aop.Support
+{
+	/// <summary>
+	/// Simple <see cref="Spring.Aop.ITypeFilter"/> implementation that matches
+	/// a given <see cref="Type"/>'s <see cref="Type.FullName"/> against <see cref="TypeNamePatterns"/>.
+	/// For a list of supported pattern syntax see <see cref="PatternMatchUtils.SimpleMatch(string[],string)"/>.
+	/// </summary>
+    /// <author>Erich Eichinger</author>
+    /// <seealso cref="PatternMatchUtils.SimpleMatch(string[],string)"/>
+    public class TypeNameTypeFilter : ITypeFilter
+    {
+        private string[] _typeNamePatterns;
+
+        ///<summary>
+        /// Returns the list of type name patterns for this filter.
+        ///</summary>
+        /// <seealso cref="PatternMatchUtils.SimpleMatch(string[],string)"/>
+        public string[] TypeNamePatterns
+        {
+            get { return _typeNamePatterns; }
+        }
+
+        ///<summary>
+        ///Creates a new instance of <see cref="TypeNameTypeFilter"/> using a list of given <paramref name="patterns"/>.
+        ///</summary>
+        ///<param name="patterns">the list patterns to match typenames against. Must not be <c>null</c>.</param>
+        /// <seealso cref="PatternMatchUtils.SimpleMatch(string[],string)"/>
+        public TypeNameTypeFilter(string[] patterns)
+        {
+            AssertUtils.ArgumentNotNull(patterns, "patterns");
+            _typeNamePatterns = patterns;
+        }
+
+	    /// <summary>
+	    /// Does the supplied type's <see cref="Type.FullName"/> match any of the <see cref="TypeNamePatterns"/>?
+	    /// </summary>
+	    /// <param name="type">
+	    /// The candidate <see cref="System.Type"/>.
+	    /// </param>
+	    /// <returns>
+	    /// <see langword="true"/> if the <paramref name="type"/> matches any of the <see cref="TypeNamePatterns"/>.
+	    /// </returns>
+	    public bool Matches(Type type)
+        {
+            return PatternMatchUtils.SimpleMatch(_typeNamePatterns, type.FullName);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Spring/Spring.Aop/Spring.Aop.2008.csproj b/src/Spring/Spring.Aop/Spring.Aop.2008.csproj
index 57c87c8c..13bd5343 100644
--- a/src/Spring/Spring.Aop/Spring.Aop.2008.csproj
+++ b/src/Spring/Spring.Aop/Spring.Aop.2008.csproj
@@ -136,8 +136,11 @@
     <Compile Include="Aop\Config\AopNamespaceUtils.cs" />
     <Compile Include="Aop\Config\ConfigObjectDefinitionParser.cs" />
     <Compile Include="Aop\Framework\AopUtils.cs" />
+    <Compile Include="Aop\Framework\AutoProxy\AbstractFilteringAutoProxyCreator.cs" />
+    <Compile Include="Aop\Framework\AutoProxy\AttributeAutoProxyCreator.cs" />
     <Compile Include="Aop\Framework\AutoProxy\InheritanceBasedAopConfigurer.cs" />
     <Compile Include="Aop\Framework\AutoProxy\PointcutFilteringAutoProxyCreator.cs" />
+    <Compile Include="Aop\Framework\AutoProxy\TypeNameAutoProxyCreator.cs" />
     <Compile Include="Aop\Framework\DynamicMethodInvocation.cs" />
     <Compile Include="Aop\Framework\DynamicProxy\CachedAopProxyFactory.cs" />
     <Compile Include="Aop\Framework\DynamicProxy\DefaultAopProxyFactory.cs" />
@@ -359,6 +362,7 @@
     <Compile Include="Aop\Support\TypeFilters.cs">
       <SubType>Code</SubType>
     </Compile>
+    <Compile Include="Aop\Support\TypeNameTypeFilter.cs" />
     <Compile Include="Aop\Support\UnionPointcut.cs">
       <SubType>Code</SubType>
     </Compile>
diff --git a/src/Spring/Spring.Core/Util/PatternMatchUtils.cs b/src/Spring/Spring.Core/Util/PatternMatchUtils.cs
index c577ce0e..8feae635 100644
--- a/src/Spring/Spring.Core/Util/PatternMatchUtils.cs
+++ b/src/Spring/Spring.Core/Util/PatternMatchUtils.cs
@@ -21,8 +21,10 @@
 #region Imports
 
 using System;
+using System.Collections;
 using System.Reflection;
-using System.Text.RegularExpressions;
+using System.Text.RegularExpressions;
+using Spring.Objects.Factory;
 
 #endregion
 
@@ -94,5 +96,56 @@ namespace Spring.Util
             }
             return false;
         }
+
+        /// <summary>
+        /// Signature of callbacks that may be used for matching object names.
+        /// </summary>
+        /// <param name="objectName">the object name to check.</param>
+        /// <param name="namePattern">the pattern to match <paramref name="objectName"/> against.</param>
+        /// <returns>true, if the <paramref name="objectName"/> matches <paramref name="namePattern"/></returns>
+        /// <see cref="IsObjectNameMatch"/>
+        public delegate bool ObjectNameMatchPredicate(string objectName, string namePattern);
+
+        /// <summary>
+        /// Convenience method that may be used by derived classes. Iterates over the list of <paramref name="objectNamePatterns"/> to match <paramref name="objectName"/> against.
+        /// </summary>
+        /// <param name="objType">the object's type. Must not be <c>null</c>.</param>
+        /// <param name="objectName">the name of the object Must not be <c>null</c>.</param>
+        /// <param name="objectNamePatterns">the list of patterns, that <paramref name="objectName"/> shall be matched against. Must not be <c>null</c>.</param>
+        /// <param name="isMatchPredicate">
+        /// the <see cref="ObjectNameMatchPredicate"/> used for 
+        /// matching <paramref name="objectName"/> against each pattern in <paramref name="objectNamePatterns"/>. Must not be <c>null</c>.
+        /// </param>
+        /// <param name="factoryObjectPrefix">the prefix to be used for dereferencing factory object names.</param>
+        /// <returns>
+        /// If <paramref name="objectNamePatterns"/> is <c>null</c>, will always return <c>true</c>, otherwise
+        /// if <paramref name="objectName"/> matches any of the patterns specified in <paramref name="objectNamePatterns"/>. 
+        /// </returns>
+        public static bool IsObjectNameMatch(Type objType, string objectName, IList objectNamePatterns, ObjectNameMatchPredicate isMatchPredicate, string factoryObjectPrefix)
+        {
+            AssertUtils.ArgumentNotNull(objType, "objType");
+            AssertUtils.ArgumentNotNull(objectName, "objectName");
+            AssertUtils.ArgumentNotNull(objectNamePatterns, "objectNamePatterns");
+            AssertUtils.ArgumentNotNull(isMatchPredicate, "isMatchPredicate");
+            AssertUtils.ArgumentNotNull(factoryObjectPrefix, "factoryObjectPrefix");
+
+            for (int i = 0; i < objectNamePatterns.Count; i++)
+            {
+                string mappedName = (string)objectNamePatterns[i];
+                if (typeof( IFactoryObject ).IsAssignableFrom( objType ))
+                {
+                    if (!objectName.StartsWith( factoryObjectPrefix ))
+                    {
+                        continue;
+                    }
+                    mappedName = mappedName.Substring( factoryObjectPrefix.Length );
+                }
+                if (isMatchPredicate( objectName, mappedName ))
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
     }
 }
\ No newline at end of file
diff --git a/test/Spring/Spring.Aop.Tests/Aop/Framework/AutoProxy/AttributeAutoProxyCreatorTests.cs b/test/Spring/Spring.Aop.Tests/Aop/Framework/AutoProxy/AttributeAutoProxyCreatorTests.cs
new file mode 100644
index 00000000..4ea9f5ba
--- /dev/null
+++ b/test/Spring/Spring.Aop.Tests/Aop/Framework/AutoProxy/AttributeAutoProxyCreatorTests.cs
@@ -0,0 +1,150 @@
+#region License
+
+/*
+ * Copyright © 2002-2008 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#endregion
+
+#region Imports
+
+using System;
+using NUnit.Framework;
+using Spring.Objects;
+using Spring.Stereotype;
+
+#endregion
+
+namespace Spring.Aop.Framework.AutoProxy
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <author>Erich Eichinger</author>
+    [TestFixture]
+    public class AttributeAutoProxyCreatorTests
+    {
+        public interface IEmptyInterface
+        {}
+
+        [AttributeUsage( AttributeTargets.Class|AttributeTargets.Method, Inherited=false )]
+        private class ApcTestAttribute : Attribute {}
+
+        private class ApcTestObject: IEmptyInterface {}
+
+        [ApcTest]
+        private class AttributedApcTestObject : ApcTestObject
+        {}
+
+        private class DerivedAttributedApcTestObject : AttributedApcTestObject
+        {
+            [ApcTest]
+            public void SomeMethod() {}
+        }
+
+        [Test]
+        [ExpectedException( typeof( ArgumentNullException ) )]
+        public void ThrowsOnMissingAttributeTypeList()
+        {
+            AttributeAutoProxyCreator apc = new AttributeAutoProxyCreator();
+            apc.PostProcessAfterInitialization( new ApcTestObject(), "testObject" );
+        }
+
+        [Test]
+        [ExpectedException( typeof( ArgumentNullException ) )]
+        public void ThrowsOnAssigningNullAttributeList()
+        {
+            AttributeAutoProxyCreator apc = new AttributeAutoProxyCreator();
+            apc.AttributeTypes = null;
+        }
+
+        [Test]
+        public void AllowsEmptyAttributeList()
+        {
+            AttributeAutoProxyCreator apc = new AttributeAutoProxyCreator();
+            apc.AttributeTypes = new Type[0];     
+            apc.PostProcessAfterInitialization( new ApcTestObject(), "testObject" );
+        }
+
+        [Test]
+        public void DefaultsToNotCheckInherited()
+        {
+            AttributeAutoProxyCreator apc = new AttributeAutoProxyCreator();
+            Assert.IsFalse(apc.CheckInherited);            
+        }
+
+        [Test]
+        public void CreatesProxyOnAttributeMatch()
+        {
+            AttributeAutoProxyCreator apc = new AttributeAutoProxyCreator();
+            apc.AttributeTypes = new Type[] { typeof(ApcTestAttribute) };
+            
+            object result = apc.PostProcessAfterInitialization( new AttributedApcTestObject(), "testObject" );
+            Assert.IsTrue( AopUtils.IsAopProxy( result ) );
+        }
+
+        [Test]
+        public void CreatesProxyOnInheritedAttributeMatchWhenCheckInherited()
+        {
+            AttributeAutoProxyCreator apc = new AttributeAutoProxyCreator();
+            apc.AttributeTypes = new Type[] { typeof(ApcTestAttribute) };
+            apc.CheckInherited = true;            
+            object result = apc.PostProcessAfterInitialization( new DerivedAttributedApcTestObject(), "testObject" );
+            Assert.IsTrue( AopUtils.IsAopProxy( result ) );
+        }
+
+        [Test]
+        public void DoesNotCreateProxyOnInheritedAttributeMatchWhenNotCheckInherited()
+        {
+            AttributeAutoProxyCreator apc = new AttributeAutoProxyCreator();
+            apc.AttributeTypes = new Type[] { typeof(ApcTestAttribute) };
+            apc.CheckInherited = false;            
+            object result = apc.PostProcessAfterInitialization( new DerivedAttributedApcTestObject(), "testObject" );
+            Assert.IsFalse( AopUtils.IsAopProxy( result ) );
+        }
+
+        [Test]
+        public void DoesNotCreateProxyIfNoAttributeMatch()
+        {
+            AttributeAutoProxyCreator apc = new AttributeAutoProxyCreator();
+            apc.AttributeTypes = new Type[] { typeof(ApcTestAttribute) };
+            
+            object result = apc.PostProcessAfterInitialization( new TestObject(), "testObject" );
+            Assert.IsFalse( AopUtils.IsAopProxy( result ) );
+        }
+
+        [Test]
+        public void DoesNotCheckMethodLevelAttributes()
+        {
+            AttributeAutoProxyCreator apc = new AttributeAutoProxyCreator();
+            apc.AttributeTypes = new Type[] { typeof(ApcTestAttribute) };
+            apc.CheckInherited = false; // (!)
+
+            // does not check method level attributes!
+            object result = apc.PostProcessAfterInitialization( new DerivedAttributedApcTestObject(), "testObject" );
+            Assert.IsFalse( AopUtils.IsAopProxy( result ) );
+        }
+
+        [Test]
+        public void DoesNotCreateProxyIfEmptyAtributeList()
+        {
+            AttributeAutoProxyCreator apc = new AttributeAutoProxyCreator();
+            apc.AttributeTypes = new Type[0];
+            
+            object result = apc.PostProcessAfterInitialization( new ApcTestObject(), "testObject" );
+            Assert.IsFalse( AopUtils.IsAopProxy( result ) );
+        }
+    }
+}
\ No newline at end of file
diff --git a/test/Spring/Spring.Aop.Tests/Aop/Framework/AutoProxy/PointcutFilteringAutoProxyCreatorTests.cs b/test/Spring/Spring.Aop.Tests/Aop/Framework/AutoProxy/PointcutFilteringAutoProxyCreatorTests.cs
index 549d3ec8..3554c421 100644
--- a/test/Spring/Spring.Aop.Tests/Aop/Framework/AutoProxy/PointcutFilteringAutoProxyCreatorTests.cs
+++ b/test/Spring/Spring.Aop.Tests/Aop/Framework/AutoProxy/PointcutFilteringAutoProxyCreatorTests.cs
@@ -36,58 +36,30 @@ namespace Spring.Aop.Framework.AutoProxy
     [TestFixture]
     public class PointcutFilteringAutoProxyCreatorTests
     {
-        [Test]
-        public void CreatesProxyOnlyIfPointcutAndObjectNameMatch()
-        {
-            // is match
-            PointcutFilteringAutoProxyCreator apc = new PointcutFilteringAutoProxyCreator();
-            apc.ObjectNames = new string[] { "test*" } ;;
-            apc.Pointcut = new SdkRegularExpressionMethodPointcut(".*\\.GetHashCode");
-            object result = apc.PostProcessAfterInitialization( new TestObject(), "testObject" );
-            Assert.IsTrue(AopUtils.IsAopProxy(result));
-
-            apc = new PointcutFilteringAutoProxyCreator();
-            apc.ObjectNames = new string[] { "test*" } ;;
-            apc.Pointcut = new SdkRegularExpressionMethodPointcut(".*\\.GetHashCODE");
-            result = apc.PostProcessAfterInitialization( new TestObject(), "testObject" );
-            Assert.IsFalse(AopUtils.IsAopProxy(result));
-
-            apc = new PointcutFilteringAutoProxyCreator();
-            apc.ObjectNames = new string[] { "tesT*" } ;;
-            apc.Pointcut = new SdkRegularExpressionMethodPointcut(".*\\.GetHashCode");
-            result = apc.PostProcessAfterInitialization( new TestObject(), "testObject" );
-            Assert.IsFalse(AopUtils.IsAopProxy(result));
-        }
-
         [Test]
         public void CreatesProxyOnPointcutMatch()
         {
             PointcutFilteringAutoProxyCreator apc = new PointcutFilteringAutoProxyCreator();
-            apc.ObjectNames = null;
             apc.Pointcut = new SdkRegularExpressionMethodPointcut(".*\\.GetHashCode");
             object result = apc.PostProcessAfterInitialization( new TestObject(), "testObject" );
             Assert.IsTrue(AopUtils.IsAopProxy(result));
         }
 
         [Test]
-        public void CreatesProxyOnNameMatch()
+        public void DoesNotCreateProxyIfNoPointcutMatch()
         {
             PointcutFilteringAutoProxyCreator apc = new PointcutFilteringAutoProxyCreator();
-            apc.ObjectNames = new string[] { "test*" } ;
-            apc.Pointcut = null;
+            apc.Pointcut = new SdkRegularExpressionMethodPointcut(".*\\.DOEsNOTExist");
             object result = apc.PostProcessAfterInitialization( new TestObject(), "testObject" );
-            Assert.IsTrue(AopUtils.IsAopProxy(result));
+            Assert.IsFalse(AopUtils.IsAopProxy(result));
         }
 
         [Test]
-        [ExpectedException(typeof(ArgumentException))]
+        [ExpectedException(typeof(ArgumentNullException))]
         public void ThrowsArgumentExceptionIfNoCriteriaSpecified()
         {
             PointcutFilteringAutoProxyCreator apc = new PointcutFilteringAutoProxyCreator();
-            apc.ObjectNames = new string[] {} ;
-            apc.Pointcut = null;
-            object result = apc.PostProcessAfterInitialization( new TestObject(), "testObject" );
-            Assert.IsTrue(AopUtils.IsAopProxy(result));
+            apc.PostProcessAfterInitialization( new TestObject(), "testObject" );
         }
     }
 }
\ No newline at end of file
diff --git a/test/Spring/Spring.Aop.Tests/Aop/Framework/AutoProxy/TypeNameAutoProxyCreatorTests.cs b/test/Spring/Spring.Aop.Tests/Aop/Framework/AutoProxy/TypeNameAutoProxyCreatorTests.cs
new file mode 100644
index 00000000..818bdd9f
--- /dev/null
+++ b/test/Spring/Spring.Aop.Tests/Aop/Framework/AutoProxy/TypeNameAutoProxyCreatorTests.cs
@@ -0,0 +1,98 @@
+#region License
+
+/*
+ * Copyright © 2002-2008 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#endregion
+
+#region Imports
+
+using System;
+using NUnit.Framework;
+using Spring.Objects;
+
+#endregion
+
+namespace Spring.Aop.Framework.AutoProxy
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <author>Erich Eichinger</author>
+    [TestFixture]
+    public class TypeNameAutoProxyCreatorTests
+    {
+        private class MyLocalTestObject: TestObject
+        {}
+
+        [Test]
+        [ExpectedException( typeof( ArgumentNullException ) )]
+        public void ThrowsOnMissingTypeNames()
+        {
+            TypeNameAutoProxyCreator apc = new TypeNameAutoProxyCreator();
+            apc.PostProcessAfterInitialization( new TestObject(), "testObject" );
+        }
+
+        [Test]
+        [ExpectedException( typeof( ArgumentNullException ) )]
+        public void ThrowsOnAssigningNullTypeNames()
+        {
+            TypeNameAutoProxyCreator apc = new TypeNameAutoProxyCreator();
+            apc.TypeNames = null;
+        }
+
+        [Test]
+        public void AllowsEmptyTypeNameList()
+        {
+            TypeNameAutoProxyCreator apc = new TypeNameAutoProxyCreator();
+            apc.TypeNames = new string[] {};       
+     
+            apc.PostProcessAfterInitialization( new TestObject(), "testObject" );
+        }
+
+        [Test]
+        public void CreatesProxyOnTypeNameMatch()
+        {
+            TypeNameAutoProxyCreator apc = new TypeNameAutoProxyCreator();
+            apc.TypeNames = new string[] { "Spring.Objects.Test*", "*MyLocal*" };
+            
+            object result = apc.PostProcessAfterInitialization( new TestObject(), "testObject" );
+            Assert.IsTrue( AopUtils.IsAopProxy( result ) );
+            result = apc.PostProcessAfterInitialization( new MyLocalTestObject(), "myLocalTestObject" );
+            Assert.IsTrue( AopUtils.IsAopProxy( result ) );
+        }
+
+        [Test]
+        public void DoesNotCreateProxyIfNoTypeNameMatch()
+        {
+            TypeNameAutoProxyCreator apc = new TypeNameAutoProxyCreator();
+            apc.TypeNames = new string[] { "Foo*" };
+            
+            object result = apc.PostProcessAfterInitialization( new TestObject(), "testObject" );
+            Assert.IsFalse( AopUtils.IsAopProxy( result ) );
+        }
+
+        [Test]
+        public void DoesNotCreateProxyIfEmptyTypeNameList()
+        {
+            TypeNameAutoProxyCreator apc = new TypeNameAutoProxyCreator();
+            apc.TypeNames = new string[] {};
+            
+            object result = apc.PostProcessAfterInitialization( new TestObject(), "testObject" );
+            Assert.IsFalse( AopUtils.IsAopProxy( result ) );
+        }
+    }
+}
\ No newline at end of file
diff --git a/test/Spring/Spring.Aop.Tests/Spring.Aop.Tests.2008.csproj b/test/Spring/Spring.Aop.Tests/Spring.Aop.Tests.2008.csproj
index 10e9d433..153b74f4 100644
--- a/test/Spring/Spring.Aop.Tests/Spring.Aop.Tests.2008.csproj
+++ b/test/Spring/Spring.Aop.Tests/Spring.Aop.Tests.2008.csproj
@@ -125,6 +125,7 @@
     </Compile>
     <Compile Include="Aop\Framework\AutoProxy\AdvisorAutoProxyCreatorCircularReferencesTests.cs" />
     <Compile Include="Aop\Framework\AutoProxy\AdvisorAutoProxyCreatorTests.cs" />
+    <Compile Include="Aop\Framework\AutoProxy\AttributeAutoProxyCreatorTests.cs" />
     <Compile Include="Aop\Framework\AutoProxy\LogicalThreadContextAdvice.cs" />
     <Compile Include="Aop\Framework\AutoProxy\NoSetterProperties.cs" />
     <Compile Include="Aop\Framework\AutoProxy\ObjectNameAutoProxyCreatorTests.cs" />
@@ -132,6 +133,7 @@
     <Compile Include="Aop\Framework\AbstractMethodInvocationTests.cs" />
     <Compile Include="Aop\Framework\AutoProxy\CreatesTestObject.cs" />
     <Compile Include="Aop\Framework\AutoProxy\PointcutFilteringAutoProxyCreatorTests.cs" />
+    <Compile Include="Aop\Framework\AutoProxy\TypeNameAutoProxyCreatorTests.cs" />
     <Compile Include="Aop\Framework\DynamicMethodInvocationTests.cs" />
     <Compile Include="Aop\Framework\CountingAfterReturningAdvice.cs" />
     <Compile Include="Aop\Framework\CountingBeforeAdvice.cs">