/// <summary>
/// Intercepts an exported value.
/// </summary>
/// <param name="value">The value to be intercepted.</param>
/// <returns>Intercepted value.</returns>
public object Intercept(object value)
{
var interfaces = value.GetType().GetInterfaces();
ProxyFactory factory = new ProxyFactory(value);
foreach (var intf in interfaces)
{
factory.AddInterface(intf);
}
if (this.advices != null)
{
foreach (var advice in this.advices)
{
factory.AddAdvice(advice);
}
}
else
{
foreach (var advisor in this.advisors)
{
factory.AddAdvisor(advisor);
}
}
return factory.GetProxy();
}
/// <summary>
/// Initialize the proxy.
/// </summary>
private void InitializeProxy()
{
if (this.adviceChain.Length == 0)
{
return;
}
var factory = new ProxyFactory();
foreach (var advice in this.adviceChain)
{
factory.AddAdvisor(new DefaultPointcutAdvisor(TruePointcut.True, advice));
}
factory.ProxyTargetType = false;
factory.AddInterface(typeof(IContainerDelegate));
factory.Target = this.containerDelegate;
this.proxy = (IContainerDelegate)factory.GetProxy();
}
public void Example_of_how_to_use_Spring_programmatic_interception_with_pointcuts()
{
ProxyFactory factory = new ProxyFactory(new ServiceCommand());
factory.AddAdvisor(new DefaultPointcutAdvisor(
new SdkRegularExpressionMethodPointcut("DoExecute"),
new ConsoleLoggingAroundAdvice()
));
ICommand command = (ICommand)factory.GetProxy();
command.DoExecute();
// Console output:
// Advice executing...
// DoExecute()
// Advice executed
command.Execute();
// Console output:
// Execute()
}
/// <summary>
/// Create an AOP proxy for the given object.
/// </summary>
/// <param name="targetType">Type of the object.</param>
/// <param name="targetName">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 targetType, string targetName, 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.GetAllInterfacesFromType(targetType);
foreach (Type interfaceType in targetInterfaceTypes)
{
proxyFactory.AddInterface(interfaceType);
}
}
IAdvisor[] advisors = BuildAdvisors(targetName, 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());
}
public T Create <T>(params Aspect[] with) where T : new()
{
var proxy = new ProxyFactory
{
ProxyTargetType = true,
TargetSource = new InheritanceBasedAopTargetSource(typeof(T))
};
foreach (var aspect in with)
{
proxy.AddAdvisor(new SpringAspect
{
Aspect = aspect
});
}
var proxyTypeBuilder = new InheritanceAopProxyTypeBuilder(proxy);
var proxyType = proxyTypeBuilder.BuildProxyType();
return((T)proxyType.GetConstructors()[0].Invoke(new object[] { proxy }));
}
/// <summary>
/// Add PersistenceExceptionTranslationAdvice to candidate object if it is a match.
/// Create AOP proxy if necessary or add advice to existing advice chain.
/// </summary>
/// <param name="instance">The new object instance.</param>
/// <param name="objectName">The name of the object.</param>
/// <returns>
/// The object instance to use, wrapped with either the original or a wrapped one.
/// </returns>
/// <exception cref="Spring.Objects.ObjectsException">
/// In case of errors.
/// </exception>
public object PostProcessAfterInitialization(object instance, string objectName)
{
IAdvised advised = instance as IAdvised;
Type targetType;
if (advised != null)
{
targetType = advised.TargetSource.TargetType;
}
else
{
targetType = instance.GetType();
}
if (targetType == null)
{
// Can't do much here
return(instance);
}
if (AopUtils.CanApply(this.persistenceExceptionTranslationAdvisor, targetType, ReflectionUtils.GetInterfaces(targetType)))
{
if (advised != null)
{
advised.AddAdvisor(this.persistenceExceptionTranslationAdvisor);
return(instance);
}
else
{
ProxyFactory proxyFactory = new ProxyFactory(instance);
// copy our properties inherited from ProxyConfig
proxyFactory.CopyFrom(this);
proxyFactory.AddAdvisor(this.persistenceExceptionTranslationAdvisor);
return(proxyFactory.GetProxy());
}
}
else
{
return(instance);
}
}
protected virtual void AddPersistenceExceptionTranslation(ProxyFactory pf, IPersistenceExceptionTranslator pet)
{
pf.AddAdvisor(new PersistenceExceptionTranslationAdvisor(pet, typeof(RepositoryAttribute)));
}
/// <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>
/// <returns>The AOP Proxy for the object.</returns>
protected virtual ProxyFactory CreateProxyFactory(Type objectType, string objectName)
{
ProxyFactory proxyFactory = new ProxyFactory();
proxyFactory.ProxyTargetAttributes = this.ProxyTargetAttributes;
proxyFactory.TargetSource = new InheritanceBasedAopTargetSource(objectType);
if (!ProxyInterfaces)
{
proxyFactory.Interfaces = Type.EmptyTypes;
}
IList<IAdvisor> advisors = ResolveInterceptorNames();
foreach (IAdvisor advisor in advisors)
{
if (advisor is IIntroductionAdvisor)
{
proxyFactory.AddIntroduction((IIntroductionAdvisor)advisor);
}
else
{
proxyFactory.AddAdvisor(advisor);
}
}
return proxyFactory;
}