/// <summary>
/// 注册为代理服务
/// </summary>
/// <param name="setting">配置</param>
/// <returns></returns>
public IProxyRegisterRule AsProxy(InterceptCompileSetting setting)
{
var rule = this.AsProxy();
this.setting = setting;
return(rule);
}
/// <summary>
/// 进行构建
/// </summary>
/// <param name="target">目标对象</param>
/// <param name="setting">配置</param>
/// <param name="interceptors">所实现的拦截器接口</param>
/// <returns></returns>
public Func <Target, IInterceptor[], Target> Build(Target target, InterceptCompileSetting setting, Type[] interceptors)
{
var build = this.BuildNotCepaType(target);
if (build != null)
{
return(build);
}
var newType = default(Type);
/*构建接口，较为容易*/
if (this.TargetType.IsInterface)
{
newType = BuildInterface(this.TargetType, typeof(Target), interceptors, setting);
var interfaceEmit = EasyEmitBuilder <Func <Target, IInterceptor[], Target> > .NewDynamicMethod();
interfaceEmit.LoadArgument(0);
interfaceEmit.LoadArgument(1);
interfaceEmit.NewObject(newType.GetConstructor(new[] { typeof(Target), typeof(IInterceptor[]) }));
interfaceEmit.Return();
return(interfaceEmit.CreateDelegate());
}
newType = BuildClass(target.GetType(), interceptors, setting);
var classEmit = EasyEmitBuilder <Func <Target, IInterceptor[], Target> > .NewDynamicMethod();
//classEmit.LoadArgument(0);
classEmit.LoadArgument(1);
classEmit.NewObject(newType.GetConstructor(new[] { typeof(IInterceptor[]) }));
classEmit.Return();
return(classEmit.CreateDelegate());
}
/// <summary>
/// 注册构建行为
/// </summary>
/// <param name="target">目标对象</param>
/// <param name="setting">配置</param>
/// <param name="interceptors">所实现的拦截器接口</param>
/// <returns></returns>
public static Func <Target, IInterceptor[], Target> Register(Target target, InterceptCompileSetting setting, Type[] interceptors)
{
if (func != null)
{
return(func);
}
return(func = new ProxyMockBuilder <Target>().Build(target, setting, interceptors));
}
/// <summary>
/// 创建代理对象，T为接口是最佳条件，T若为class,只能重写virtual方法
/// </summary>
/// <param name="source">代理对象</param>
/// <param name="setting">配置</param>
/// <param name="interceptors">所实现的拦截器接口</param>
/// <returns></returns>
public virtual T CreateProxy(T source, InterceptCompileSetting setting, IInterceptor[] interceptors)
{
if (interceptors == null)
{
interceptors = new IInterceptor[0];
}
var types = new Type[interceptors.Length];
for (var i = 0; i < interceptors.Length; i++)
{
types[i] = interceptors[i].GetType();
}
return(ProxyMockBuilder <T> .Register(source, setting, types).Invoke(source, interceptors));
}
public Type Build(Type implementationType, Type baseType, Type[] interceptors, InterceptCompileSetting setting)
{
if (interceptors != null && interceptors.Length > 0)
{
foreach (var i in interceptors)
{
if (!typeof(IInterceptor).IsAssignableFrom(i))
{
throw new ArgumentException(string.Format("类型{0}只能从拦截器{1}中派生", i.FullName, typeof(IInterceptor).FullName));
}
}
}
var type = default(Type);
/*构建接口，较为容易*/
if (baseType.IsVisible && baseType.IsInterface)
{
type = this.BuildInterface(baseType, implementationType, interceptors, setting);
return(type);
}
/*构建类*/
type = this.BuildClass(baseType, interceptors, setting);
return(type);
}
/// <summary>
/// 创建代理对象，T为接口是最佳条件，T若为class,只能重写virtual方法
/// </summary>
/// <param name="setting">配置</param>
/// <param name="source">代理对象</param>
/// <returns></returns>
public virtual T CreateProxy(T source, InterceptCompileSetting setting)
{
return(this.CreateProxy(source, setting, new IInterceptor[0]));
}
