private void CreateTypeBuilder()
{
TypeAttributes newAttributes = _typeToIntercept.Attributes;
newAttributes = FilterTypeAttributes(newAttributes);
Type baseClass = GetGenericType(_typeToIntercept);
ModuleBuilder moduleBuilder = InterceptingClassGenerator.GetModuleBuilder();
_typeBuilder = moduleBuilder.DefineType(
"DynamicModule.ns.Wrapped_" + _typeToIntercept.Name + "_" + Guid.NewGuid().ToString("N"),
newAttributes,
baseClass);
_mainTypeMapper = DefineGenericArguments(_typeBuilder, baseClass);
if (_typeToIntercept.IsGenericType)
{
var definition = _typeToIntercept.GetGenericTypeDefinition();
var mappedParameters = definition.GetGenericArguments().Select(t => _mainTypeMapper.Map(t)).ToArray();
_targetType = definition.MakeGenericType(mappedParameters);
}
else
{
_targetType = _typeToIntercept;
}
_proxyInterceptionPipelineField = InterceptingProxyImplementor.ImplementIInterceptingProxy(_typeBuilder);
}
internal MethodOverride(
TypeBuilder typeBuilder,
FieldBuilder proxyInterceptionPipelineField,
MethodInfo methodToOverride,
Type targetType,
GenericParameterMapper targetTypeParameterMapper,
int overrideCount)
{
_typeBuilder = typeBuilder;
_proxyInterceptionPipelineField = proxyInterceptionPipelineField;
_methodToOverride = methodToOverride;
_methodParameters = methodToOverride.GetParameters();
_targetType = targetType;
// if the method is inherited and the declaring type is generic, we need to map
// the parameters of the original declaration to the actual intercepted type type
// E.g. consider given class Type1<T> with virtual method "T Method<U>()", the mappings in
// different scenarios would look like:
// Type2<S> : Type2<S> => S Method<U>()
// Type2<S> : Type2<IEnumerable<S>> => IEnumerable<S> Method<U>()
// Type2 : Type1<IEnumerable<string>> => IEnumerable<string> Method<U>()
var declaringType = methodToOverride.DeclaringType;
_targetTypeParameterMapper =
declaringType.IsGenericType && declaringType != methodToOverride.ReflectedType
? new GenericParameterMapper(declaringType, targetTypeParameterMapper)
: targetTypeParameterMapper;
_overrideCount = overrideCount;
}
public InterfaceImplementation(
TypeBuilder typeBuilder,
Type @interface,
GenericParameterMapper genericParameterMapper,
FieldBuilder proxyInterceptionPipelineField,
bool explicitImplementation,
FieldBuilder targetField)
{
_typeBuilder = typeBuilder;
_interface = @interface;
_genericParameterMapper = genericParameterMapper;
_proxyInterceptionPipelineField = proxyInterceptionPipelineField;
_explicitImplementation = explicitImplementation;
_targetField = targetField;
if (@interface.IsGenericType)
{
// when the @interface is generic we need to get references to its methods though it
// in this case, the targetInterface is a constructed version using the generic type parameters
// from the generated type generate type
var definition = @interface.GetGenericTypeDefinition();
Debug.Assert(definition != null, nameof(definition) + " != null");
var mappedParameters = definition.GetGenericArguments().Select(t => genericParameterMapper.Map(t)).ToArray();
_targetInterface = definition.MakeGenericType(mappedParameters);
}
else
{
_targetInterface = @interface;
}
}
private void CreateTypeBuilder()
{
TypeAttributes newAttributes = TypeAttributes.Public | TypeAttributes.Class;
ModuleBuilder moduleBuilder = InterceptorClassGenerator.CreateModuleBuilder(AssemblyBuilder);
_typeBuilder = moduleBuilder.DefineType(CreateTypeName(), newAttributes);
_mainInterfaceMapper = DefineGenericArguments();
_proxyInterceptionPipelineField = InterceptingProxyImplementor.ImplementIInterceptingProxy(_typeBuilder);
_targetField = _typeBuilder.DefineField("target", _typeToIntercept, FieldAttributes.Private);
_typeToProxyField = _typeBuilder.DefineField("typeToProxy", typeof(Type), FieldAttributes.Private);
}
internal InterfaceMethodOverride(
TypeBuilder typeBuilder,
FieldBuilder proxyInterceptionPipelineField,
FieldBuilder targetField,
MethodInfo methodToOverride,
Type targetInterface,
GenericParameterMapper targetInterfaceParameterMapper,
bool explicitImplementation,
int overrideCount)
{
_typeBuilder = typeBuilder;
_proxyInterceptionPipelineField = proxyInterceptionPipelineField;
_explicitImplementation = explicitImplementation;
_targetField = targetField;
_methodToOverride = methodToOverride;
_targetInterface = targetInterface;
_targetInterfaceParameterMapper = targetInterfaceParameterMapper;
_methodParameters = methodToOverride.GetParameters();
_overrideCount = overrideCount;
}
public void SetupParameters(MethodBuilder methodBuilder, GenericParameterMapper parentMapper)
{
if (_methodToOverride.IsGenericMethod)
{
var genericArguments = _methodToOverride.GetGenericArguments();
var names = genericArguments.Select(t => t.Name).ToArray();
var builders = methodBuilder.DefineGenericParameters(names);
for (int i = 0; i < genericArguments.Length; ++i)
{
builders[i].SetGenericParameterAttributes(genericArguments[i].GenericParameterAttributes);
var constraintTypes =
genericArguments[i]
.GetGenericParameterConstraints()
.Select(ct => parentMapper.Map(ct))
.ToArray();
var interfaceConstraints = constraintTypes.Where(t => t.IsInterface).ToArray();
Type baseConstraint = constraintTypes.Where(t => !t.IsInterface).FirstOrDefault();
if (baseConstraint != null)
{
builders[i].SetBaseTypeConstraint(baseConstraint);
}
if (interfaceConstraints.Length > 0)
{
builders[i].SetInterfaceConstraints(interfaceConstraints);
}
}
_genericParameterMapper =
new GenericParameterMapper(genericArguments, builders.Cast <Type>().ToArray(), parentMapper);
}
else
{
_genericParameterMapper = parentMapper;
}
}
