public ProxyScope(ModuleScope moduleScope, TypeBuilder typeBuilder, ProxyTypeDefinition typeDefinition)
{
if (moduleScope is null)
{
throw new ArgumentNullException(nameof(moduleScope));
}
if (typeBuilder is null)
{
throw new ArgumentNullException(nameof(typeBuilder));
}
if (typeDefinition is null)
{
throw new ArgumentNullException(nameof(typeDefinition));
}
this.fields = new List <FieldBuilder>();
this.properties = new List <PropertyBuilder>();
this.methods = new List <MethodBuilder>();
this.events = new List <EventBuilder>();
this.propertyMappings = new List <PropertyMapping>();
this.methodMappings = new List <MethodMapping>();
this.eventMappings = new List <EventMapping>();
this.moduleScope = moduleScope;
this.typeBuilder = typeBuilder;
this.typeDefinition = typeDefinition;
interceptableMethodBuilder = typeDefinition.Options?.InterceptableMethodBuilder;
if (interceptableMethodBuilder == null)
{
interceptableMethodBuilder = new InterceptableMethodBuilder();
}
}
public Type CreateProxyType(ProxyTypeDefinition typeDefinition, object target)
{
Type proxyType = moduleScope.GetOrCreateProxyType(typeDefinition);
OnProxyTypeCreated(typeDefinition.Type, target, proxyType);
return(proxyType);
}
protected object ProtectedCreateClassProxy(Type type, object target, ProxyGeneratorOptions options, IInterceptor[] interceptors)
{
if (type is null)
{
throw new ArgumentNullException(nameof(type));
}
if (type.IsInterface)
{
throw new InvalidOperationException($"Unexpected interface for '{type.Name}'");
}
if (target != null && !type.IsAssignableFrom(target.GetType()))
{
throw new InvalidOperationException($"The target '{target.GetType().Name}' is not assignable from '{type.Name}'");
}
ProxyTypeDefinition typeDefinition = GetTypeDefinition(type, target, options);
return(CreateProxy(typeDefinition, interceptors, target));
}
protected object[] GetArguments(ProxyTypeDefinition typeDefinition, IInterceptor[] interceptors, object target, Type proxyType)
{
List <object> args = new List <object>();
// interceptors
args.Add(interceptors);
// target
if (target != null)
{
args.Add(target);
}
// interceptorSelector
ProxyGeneratorOptions options = typeDefinition.Options;
IInterceptorSelector interceptorSelector = options?.InterceptorSelector;
if (interceptorSelector != null)
{
args.Add(interceptorSelector);
}
// mixins
if (options != null && options.MixinInstances.Count > 0)
{
args.AddRange(options.MixinInstances);
}
// base ctor dependencies
ConstructorInfo constructor = proxyType.GetConstructors()[0];
var parameters = constructor.GetParameters();
int length = parameters.Length;
if (length > args.Count)
{
for (int i = args.Count; i < length; i++)
{
args.Add(ConstructorInjectionResolver.Resolve(parameters[i]));
}
}
return(args.ToArray());
}
internal Type GetOrCreateProxyType(ProxyTypeDefinition typeDefinition)
{
if (typeDefinition is null)
{
throw new ArgumentNullException(nameof(typeDefinition));
}
string name = typeDefinition.Name;
Type type = proxyTypes.FirstOrDefault(p => p.Name == name);
if (type == null)
{
TypeBuilder typeBuilder = Module.DefineType(typeDefinition.FullName, typeDefinition.TypeAttributes);
ProxyScope proxyScope = new ProxyScope(this, typeBuilder, typeDefinition);
proxyScope.DefineTypeAndMembers();
type = typeBuilder.BuildType();
proxyTypes.Add(type);
}
return(type);
}
protected object CreateProxy(ProxyTypeDefinition typeDefinition, IInterceptor[] interceptors, object target)
{
if (typeDefinition is null)
{
throw new ArgumentNullException(nameof(typeDefinition));
}
if (interceptors is null)
{
throw new ArgumentNullException(nameof(interceptors));
}
Type proxyType = CreateProxyType(typeDefinition, target);
object[] args = GetArguments(typeDefinition, interceptors, target, proxyType);
//#if NET45 || NET472
// moduleScope.Save();
//#endif
return(CreateProxyInstance(proxyType, args));
}
