public override void Proceed()
{
var expectation = stubMessageBus.GetExpectationFor(Request.GetType());
if (expectation == null)
{
var response = (Response)Activator.CreateInstance(Request.GetResponseType());
response.CorrelationGuid = Request.CorrelationGuid;
Response = GetSerializedVersion(response);
}
else
{
Response = GetSerializedVersion(expectation.Execute(Request));
}
if(Request.IsSideEffectFree)
{
try
{
var options = new ProxyGenerationOptions(new NonVirtualCheckProxyGenerationHook());
var proxyGen = new ProxyGenerator();
proxyGen.CreateClassProxy(Request.GetResponseType(), options);
}
catch (Exception ex)
{
throw new ColomboTestSupportException(string.Format("Response {0} cannot be proxied, probably because one or several of its members are not virtual.", Request.GetResponseType()), ex);
}
}
}
/// <summary>
/// Decoration request
/// </summary>
/// <param name="context">Context info</param>
/// <remarks>do not have to decorate, but may if it wants to. sorta..</remarks>
public void Decorate(DecoratorContext context)
{
if (!CanDecorate(context))
return;
var options = new ProxyGenerationOptions();
var services = context.Services;
if (IgnoreClassAsService && services.Length > 1)
services = services.Where(x => !x.IsClass).ToArray();
var generator = new ProxyGenerator();
if (services.Any(x => x.IsClass))
{
if (services.Length > 1)
throw new InvalidOperationException(
"A class that register itself as a service may not also be registered with interfaces. See the remarks in the IgnoreClassAsService property.");
var clazz = context.Services.Single(x => x.IsClass);
context.Instance = generator.CreateClassProxyWithTarget(clazz, context.Instance,
CreateInterceptor(context));
}
else
{
var others = services.Where(x => x.IsInterface).Skip(1);
var first = services.First();
context.Instance = generator.CreateInterfaceProxyWithTarget
(first, others.ToArray(), context.Instance,
CreateInterceptor(context));
}
}
public object Generate(IProxyBuilder builder, ProxyGenerationOptions options, IInterceptor[] interceptors)
{
var type = GetProxyType(builder);
var instance = GetProxyInstance(type,interceptors);
var method = GetInvokeDelegate(instance);
return method;
}
private static ProxyGeneratorResult GenerateProxy(
Type typeOfProxy,
ProxyGenerationOptions options,
IEnumerable<Type> additionalInterfacesToImplement,
IEnumerable<object> argumentsForConstructor,
IFakeCallProcessorProvider fakeCallProcessorProvider)
{
Guard.AgainstNull(typeOfProxy, nameof(typeOfProxy));
Guard.AgainstNull(additionalInterfacesToImplement, nameof(additionalInterfacesToImplement));
Guard.AgainstNull(fakeCallProcessorProvider, nameof(fakeCallProcessorProvider));
if (typeOfProxy.GetTypeInfo().IsValueType)
{
return GetProxyResultForValueType(typeOfProxy);
}
if (typeOfProxy.GetTypeInfo().IsSealed)
{
return new ProxyGeneratorResult(DynamicProxyResources.ProxyIsSealedTypeMessage.FormatInvariant(typeOfProxy));
}
GuardAgainstConstructorArgumentsForInterfaceType(typeOfProxy, argumentsForConstructor);
return CreateProxyGeneratorResult(typeOfProxy, options, additionalInterfacesToImplement, argumentsForConstructor, fakeCallProcessorProvider);
}
public void CanCreateMixinWithClassInterceptors()
{
var options = new ProxyGenerationOptions();
options.AddMixinInstance(new Dictionary<int, int>());
var builder = new ContainerBuilder();
builder.RegisterType<C>().EnableClassInterceptors(options);
builder.RegisterType<AddOneInterceptor>();
builder.RegisterType<AddTenInterceptor>();
var container = builder.Build();
var i = 10;
var cpt = container.Resolve<C>(TypedParameter.From(i));
var dict = cpt as IDictionary<int, int>;
Assert.NotNull(dict);
dict.Add(1, 2);
Assert.Equal(2, dict[1]);
dict.Clear();
Assert.Empty(dict);
}
internal static IController TrySetActionInvoker(this IController iController, IGlimpseLogger logger)
{
var controller = iController as Controller;
if (controller == null)
{
//TODO: Add Logging
return iController;
}
var actionInvoker = controller.ActionInvoker;
if (actionInvoker.CanSupportDynamicProxy(logger))
{
var proxyConfig = new Dictionary<string, IInterceptor>
{
{"GetFilters", new GetFiltersInterceptor()},
{"InvokeActionResult", new InvokeActionResultInterceptor()},
{"InvokeActionMethod",new InvokeActionMethodInterceptor()}
};
var proxyGenerator = new ProxyGenerator();
var proxyGenOptions = new ProxyGenerationOptions(new SimpleProxyGenerationHook(logger, proxyConfig.Keys.ToArray())) { Selector = new SimpleInterceptorSelector(proxyConfig) };
var newInvoker = (ControllerActionInvoker)proxyGenerator.CreateClassProxy(actionInvoker.GetType(), proxyGenOptions, proxyConfig.Values.ToArray());
controller.ActionInvoker = newInvoker;
}
return controller;
}
public override object GetFieldInterceptionProxy()
{
var proxyGenerationOptions = new ProxyGenerationOptions();
var interceptor = new LazyFieldInterceptor();
proxyGenerationOptions.AddMixinInstance(interceptor);
return ProxyGenerator.CreateClassProxy(PersistentClass, proxyGenerationOptions, interceptor);
}
public void Register(ContainerBuilder builder)
{
Assembly assembly = Assembly.GetExecutingAssembly();
ProxyGenerationOptions ProxyOption = new ProxyGenerationOptions()
{
Selector = new InterceptorSelector()
};
//注册所有服务
builder.RegisterAssemblyTypes(assembly)
.Where(type => type.FullName.EndsWith("ApplicationService") && type.IsClass)
.AsImplementedInterfaces()
.EnableInterfaceInterceptors(ProxyOption)
;//.InterceptedBy(typeof(MethodInvacationValidateInterceptor), typeof(UnitOfWorkInterceptor));
//注册DbContext
builder.RegisterType<SampleEntities>().As<DbContext>();
//注册所有泛型仓储
var finder = new WebAppTypeFinder();
var allEntityTypes = finder.FindClassOfType(typeof(IEntity));
foreach (var entityType in allEntityTypes)
{
var genericRepositoryType = typeof(IRepository<>).MakeGenericType(entityType);
var implType = typeof(EfRepository<,>).MakeGenericType(typeof(DbContext), entityType);
builder.RegisterType(implType).As(genericRepositoryType);
}
builder.RegisterType<CallCurrentUnitOfWorkProvider>().As<ICurrentUnitOfWorkProvider>();
builder.RegisterType<UnitOfWorkDbContextProvider<DbContext>>().As<IDbContextProvider<DbContext>>();
builder.RegisterType<EfDbContextProvider<DbContext>>().Keyed<IDbContextProvider<DbContext>>("Default");
builder.RegisterType<UnitOfWorkManager>().As<IUnitOfWorkManager>();
builder.RegisterType<EfUnitOfWork>().As<IUnitOfWork>();
}
/// <inheritdoc />
public object Create(object target, Type typeOfProxy,
Type[] additionalInterfacesOfProxy)
{
Check.MustNotNull("target", "target");
Check.MustNotNull("typeToProxy", "typeToProxy");
var aspects = _aspectsFinder.FindAspects(target.GetType());
if (!aspects.Any())
{
return target;
}
var options = new ProxyGenerationOptions
{
Selector = new PointcutAspectInterceptorSelector()
};
foreach (var instance in this.GetMixinInstances(target.GetType(), aspects))
{
options.AddMixinInstance(instance);
}
var interceptors = this.GetInterceptors(target.GetType(), aspects);
if (typeOfProxy.IsInterface)
{
return _proxyGenerator.CreateInterfaceProxyWithTarget(typeOfProxy,
additionalInterfacesOfProxy,
target, options, interceptors);
}
else
{
return _proxyGenerator.CreateClassProxyWithTarget(typeOfProxy,
additionalInterfacesOfProxy,
target, options, interceptors);
}
}
public Type CreateInterfaceProxyTypeWithoutTarget(Type interfaceToProxy, Type[] additionalInterfacesToProxy, ProxyGenerationOptions options)
{
AssertValidType(interfaceToProxy);
AssertValidTypes(additionalInterfacesToProxy);
var generator = new InterfaceProxyWithoutTargetGenerator(scope, interfaceToProxy) { Logger = logger };
return generator.GenerateCode(typeof(object), additionalInterfacesToProxy, options);
}
// 重载 InterfaceProxyWithTargetInterfaceContributor 中的方法，以指定使用扩展的 InvocationType 生成方法执行类
protected override MethodGenerator GetMethodGenerator(MetaMethod method, ClassEmitter @class, ProxyGenerationOptions options, OverrideMethodDelegate overrideMethod)
{
if (!method.Proxyable)
{
return new MinimialisticMethodGenerator(method, overrideMethod);
}
return new MethodWithInvocationGenerator(method, @class.GetField("__interceptors"), this.GetInvocationType(method, @class, options), this.getTargetExpression, overrideMethod, null);
}
// 重载 InterfaceProxyWithTargetInterfaceContributor 中的方法，以指定使用扩展的 InvocationType 生成方法执行类
protected override MethodGenerator GetMethodGenerator(MetaMethod method, ClassEmitter @class, ProxyGenerationOptions options, OverrideMethodDelegate overrideMethod)
{
if (!method.Proxyable)
{
return new ForwardingMethodGenerator(method, overrideMethod, (c, m) => c.GetField("__target"));
}
return new MethodWithInvocationGenerator(method, @class.GetField("__interceptors"), this.GetInvocationType(method, @class, options), (c, m) => c.GetField("__target").ToExpression(), overrideMethod, null);
}
private void ReleaseHook(ProxyGenerationOptions proxyGenOptions, IKernel kernel)
{
if (proxyGenOptions.Hook == null)
{
return;
}
kernel.ReleaseComponent(proxyGenOptions.Hook);
}
public virtual Type CreateClassProxy(Type theClass, ProxyGenerationOptions options)
{
AssertValidType(theClass);
ClassProxyGenerator generator = new ClassProxyGenerator(scope, theClass);
return generator.GenerateCode(null, options);
}
public Type CreateClassProxyType(Type classToProxy, Type[] additionalInterfacesToProxy, ProxyGenerationOptions options)
{
AssertValidType(classToProxy);
AssertValidTypes(additionalInterfacesToProxy);
var generator = new ClassProxyGenerator(scope, classToProxy) { Logger = logger };
return generator.GenerateCode(additionalInterfacesToProxy, options);
}
public Type CreateInterfaceProxyTypeWithTargetInterface(Type theInterface, ProxyGenerationOptions options)
{
AssertValidType(theInterface);
InterfaceProxyWithTargetInterfaceGenerator generator =
new InterfaceProxyWithTargetInterfaceGenerator(scope, theInterface);
return generator.GenerateCode(theInterface, null, options);
}
public Type CreateClassProxy(Type theClass, Type[] interfaces, ProxyGenerationOptions options)
{
AssertValidType(theClass);
AssertValidTypes(interfaces);
ClassProxyGenerator generator = new ClassProxyGenerator(scope, theClass);
return generator.GenerateCode(interfaces, options);
}
/// <summary>
/// Creates a context - which is used to guid custom proxy
/// generation.
/// </summary>
/// <param name="mixins">Array of mixins to be registered</param>
/// <returns>A GeneratorContext instance</returns>
private static ProxyGenerationOptions CreateProxyGenerationOptions(object[] mixins)
{
ProxyGenerationOptions options = new ProxyGenerationOptions();
foreach (object mixin in mixins)
{
options.AddMixinInstance(mixin);
}
return options;
}
public TypedPageActivator()
{
_generator = new ProxyGenerator();
_options = new ProxyGenerationOptions(new PageTypePropertiesProxyGenerationHook());
_interceptors = new IInterceptor[]
{
new PageTypePropertyInterceptor()
};
}
public object Generate(IProxyBuilder builder, ProxyGenerationOptions options, IInterceptor[] interceptors, ComponentModel model,
CreationContext context)
{
var targetDelegateType = context.RequestedType;
var type = GetProxyType(builder, targetDelegateType);
var instance = GetProxyInstance(type, interceptors);
var method = GetInvokeDelegate(instance, targetDelegateType);
return method;
}
public void Foo1()
{
ProxyGenerator generator = new ProxyGenerator();
//Castle.DynamicProxy.IInterceptor[] interceptors = { new MyCastleInterceptor() };
var options = new ProxyGenerationOptions(new InterceptorFilter()) { Selector = new InterceptorSelector() };
CastleUserProcessor userProcessor = generator.CreateClassProxy<CastleUserProcessor>(options,new MyCastleInterceptor(), new SimpleLogInterceptor());
User user = new User() { Name = "lee", PassWord = "******" };
userProcessor.RegUser(user);
}
/// <summary>
/// Initializes the elements in the Page Object.
/// </summary>
/// <param name="driver">The driver used to find elements on the page.</param>
/// <param name="page">The Page Object to be populated with elements.</param>
public static void InitElements(ISearchContext driver, object page)
{
const BindingFlags BindingOptions = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static | BindingFlags.FlattenHierarchy;
if (page == null)
{
throw new ArgumentNullException("page", "page cannot be null");
}
var type = page.GetType();
var fields = type.GetFields(BindingOptions);
var properties = type.GetProperties(BindingOptions);
var members = new List<MemberInfo>(fields);
members.AddRange(properties);
foreach (var member in members)
{
var attributes = member.GetCustomAttributes(typeof(FindsByAttribute), true);
foreach (var attribute in attributes)
{
var castedAttribute = (FindsByAttribute)attribute;
var generator = new ProxyGenerator();
var cacheAttributeType = typeof(CacheLookupAttribute);
var cache = member.GetCustomAttributes(cacheAttributeType, true).Length != 0 || member.DeclaringType.GetCustomAttributes(cacheAttributeType, true).Length != 0;
var interceptor = new ProxiedWebElementInterceptor(driver, castedAttribute.Bys, cache);
var options = new ProxyGenerationOptions
{
BaseTypeForInterfaceProxy = typeof(WebElementProxyComparer)
};
var field = member as FieldInfo;
var property = member as PropertyInfo;
if (field != null)
{
var proxyElement = generator.CreateInterfaceProxyWithoutTarget(
typeof(IWrapsElement),
new[] { field.FieldType },
options,
interceptor);
field.SetValue(page, proxyElement);
}
else if (property != null)
{
var proxyElement = generator.CreateInterfaceProxyWithoutTarget(
typeof(IWrapsElement),
new[] { property.PropertyType },
options,
interceptor);
property.SetValue(page, proxyElement, null);
}
}
}
}
public Type CreateClassProxyTypeWithTarget(Type classToProxy, Type[] additionalInterfacesToProxy, ProxyGenerationOptions options)
{
this.AssertValidType(classToProxy);
this.AssertValidTypes(additionalInterfacesToProxy);
ClassProxyWithTargetGenerator generator = new ClassProxyWithTargetGenerator(this.scope, classToProxy, additionalInterfacesToProxy, options)
{
Logger = this.logger
};
return generator.GetGeneratedType();
}
public Type CreateInterfaceProxyTypeWithTarget(Type theInterface, Type[] interfaces, Type targetType,
ProxyGenerationOptions options)
{
AssertValidType(theInterface);
AssertValidTypes(interfaces);
InterfaceProxyWithTargetGenerator generator = new InterfaceProxyWithTargetGenerator(scope, theInterface);
return generator.GenerateCode(targetType, interfaces, options);
}
public Type CreateInterfaceProxyTypeWithTarget(Type interfaceToProxy, Type[] additionalInterfacesToProxy, Type targetType,
ProxyGenerationOptions options)
{
AssertValidType(interfaceToProxy);
AssertValidTypes(additionalInterfacesToProxy);
InterfaceProxyWithTargetGenerator generator = new InterfaceProxyWithTargetGenerator(scope, interfaceToProxy);
return generator.GenerateCode(targetType, additionalInterfacesToProxy, options);
}
protected override ArgumentReference[] GetBaseCtorArguments(Type targetFieldType, ProxyGenerationOptions proxyGenerationOptions, out ConstructorInfo baseConstructor)
{
if (proxyGenerationOptions.Selector == null)
{
baseConstructor = InvocationMethods.CompositionInvocationConstructorNoSelector;
return new ArgumentReference[] { new ArgumentReference(targetFieldType), new ArgumentReference(typeof(object)), new ArgumentReference(typeof(IInterceptor[])), new ArgumentReference(typeof(MethodInfo)), new ArgumentReference(typeof(object[])) };
}
baseConstructor = InvocationMethods.CompositionInvocationConstructorWithSelector;
return new ArgumentReference[] { new ArgumentReference(targetFieldType), new ArgumentReference(typeof(object)), new ArgumentReference(typeof(IInterceptor[])), new ArgumentReference(typeof(MethodInfo)), new ArgumentReference(typeof(object[])), new ArgumentReference(typeof(IInterceptorSelector)), new ArgumentReference(typeof(IInterceptor[]).MakeByRefType()) };
}
public Type CreateInterfaceProxyTypeWithoutTarget(Type theInterface, Type[] interfaces, ProxyGenerationOptions options)
{
AssertValidType(theInterface);
AssertValidTypes(interfaces);
InterfaceProxyWithoutTargetGenerator generatorWithoutTarget =
new InterfaceProxyWithoutTargetGenerator(scope, theInterface);
return generatorWithoutTarget.GenerateCode(typeof(object), interfaces, options);
}
/// <summary>
/// Generates the class defined by the provided class emitter.
/// </summary>
/// <param name="class">
/// The <see cref="Castle.DynamicProxy.Generators.Emitters.ClassEmitter"/>
/// being used to build the target type.
/// </param>
/// <param name="options">The options to use during proxy generation.</param>
/// <exception cref="System.ArgumentNullException">
/// Thrown if <paramref name="class" /> is <see langword="null" />.
/// </exception>
/// <remarks>
/// <para>
/// This overridden version of the method does everything that the base
/// <see cref="Castle.DynamicProxy.Contributors.ProxyInstanceContributor.Generate"/>
/// method does but it skips the part where it checks for non-inherited
/// attributes and copies them over from the proxy target.
/// </para>
/// </remarks>
public override void Generate(ClassEmitter @class, ProxyGenerationOptions options)
{
if (@class == null)
{
throw new ArgumentNullException("class");
}
FieldReference field = @class.GetField("__interceptors");
this.ImplementGetObjectData(@class);
this.ImplementProxyTargetAccessor(@class, field);
}
public object Intercept(object value)
{
ProxyGenerationOptions options = new ProxyGenerationOptions();
var interfaces = value.GetType().GetInterfaces();
Type proxyInterface = interfaces.FirstOrDefault();
Type[] additionalInterfaces = interfaces.Skip(1).ToArray();
var proxy = _generator.CreateInterfaceProxyWithTargetInterface(proxyInterface, additionalInterfaces, value, _interceptors);
return proxy;
}
public void Register(ContainerBuilder builder)
{
Assembly assembly = Assembly.GetExecutingAssembly();
ProxyGenerationOptions ProxyOption = new ProxyGenerationOptions()
{
Selector = new InterceptorSelector()
};
builder.RegisterControllers(assembly);//.EnableClassInterceptors(ProxyOption);
}