public static void InitializeArgumentsByPosition(ArgumentReference[] args, bool isStatic)
{
int offset = isStatic ? 0 : 1;
for(int i = 0; i < args.Length; ++i)
{
args[i].Position = i + offset;
}
}
public ConstructorEmitter CreateConstructor(ArgumentReference[] baseCtorArguments, AbstractTypeEmitter invocation)
{
var arguments = GetArguments(baseCtorArguments);
var constructor = invocation.CreateConstructor(arguments);
var delegateField = invocation.CreateField("delegate", delegateType);
constructor.CodeBuilder.AddStatement(new AssignStatement(delegateField, new ReferenceExpression(arguments[0])));
return constructor;
}
public static ArgumentReference[] ConvertToArgumentReference(Type[] args)
{
ArgumentReference[] arguments = new ArgumentReference[args.Length];
for(int i = 0; i < args.Length; ++i)
{
arguments[i] = new ArgumentReference(args[i]);
}
return arguments;
}
public static Expression[] ConvertArgumentReferenceToExpression(ArgumentReference[] args)
{
var expressions = new Expression[args.Length];
for (var i = 0; i < args.Length; ++i)
{
expressions[i] = args[i].ToExpression();
}
return expressions;
}
public static ArgumentReference[] ConvertToArgumentReference(ParameterInfo[] args)
{
var arguments = new ArgumentReference[args.Length];
for (var i = 0; i < args.Length; ++i)
{
arguments[i] = new ArgumentReference(args[i].ParameterType);
}
return arguments;
}
public static Type[] InitializeAndConvert(ArgumentReference[] args)
{
Type[] types = new Type[args.Length];
for(int i = 0; i < args.Length; ++i)
{
args[i].Position = i + 1;
types[i] = args[i].Type;
}
return types;
}
protected override void CustomizeGetObjectData(AbstractCodeBuilder codebuilder, ArgumentReference serializationInfo, ArgumentReference streamingContext, ClassEmitter emitter)
{
var targetField = emitter.GetField("__target");
codebuilder.AddStatement(new ExpressionStatement(
new MethodInvocationExpression(serializationInfo, SerializationInfoMethods.AddValue_Object,
new ConstReference("__targetFieldType").ToExpression(),
new ConstReference(
targetField.Reference.FieldType.AssemblyQualifiedName).
ToExpression())));
codebuilder.AddStatement(new ExpressionStatement(
new MethodInvocationExpression(serializationInfo, SerializationInfoMethods.AddValue_Object,
new ConstReference("__theInterface").ToExpression(),
new ConstReference(targetType.AssemblyQualifiedName).
ToExpression())));
}
protected override void CustomizeGetObjectData(AbstractCodeBuilder codebuilder, ArgumentReference serializationInfo,
ArgumentReference streamingContext, ClassEmitter emitter)
{
codebuilder.AddStatement(new ExpressionStatement(
new MethodInvocationExpression(
serializationInfo,
SerializationInfoMethods.AddValue_Bool,
new ConstReference("__delegateToBase").ToExpression(),
new ConstReference(delegateToBaseGetObjectData).
ToExpression())));
if (delegateToBaseGetObjectData == false)
{
EmitCustomGetObjectData(codebuilder, serializationInfo);
return;
}
EmitCallToBaseGetObjectData(codebuilder, serializationInfo, streamingContext);
}
protected override void CustomizeGetObjectData(AbstractCodeBuilder codebuilder, ArgumentReference serializationInfo, ArgumentReference streamingContext, ClassEmitter emitter)
{
codebuilder.AddStatement(new ExpressionStatement(
new MethodInvocationExpression(serializationInfo, SerializationInfoMethods.AddValue_Bool,
new ConstReference("__delegateToBase").ToExpression(),
new ConstReference(delegateToBaseGetObjectData ? 1 : 0).
ToExpression())));
if (delegateToBaseGetObjectData)
{
MethodInfo baseGetObjectData = targetType.GetMethod("GetObjectData",
new[] {typeof (SerializationInfo), typeof (StreamingContext)});
codebuilder.AddStatement(new ExpressionStatement(
new MethodInvocationExpression(baseGetObjectData,
serializationInfo.ToExpression(),
streamingContext.ToExpression())));
}
else
{
LocalReference members_ref = codebuilder.DeclareLocal(typeof (MemberInfo[]));
LocalReference data_ref = codebuilder.DeclareLocal(typeof (object[]));
codebuilder.AddStatement(new AssignStatement(members_ref,
new MethodInvocationExpression(null,
FormatterServicesMethods.
GetSerializableMembers,
new TypeTokenExpression(targetType))));
codebuilder.AddStatement(new AssignStatement(data_ref,
new MethodInvocationExpression(null,
FormatterServicesMethods.GetObjectData,
SelfReference.Self.ToExpression(),
members_ref.ToExpression())));
codebuilder.AddStatement(new ExpressionStatement(
new MethodInvocationExpression(serializationInfo, SerializationInfoMethods.AddValue_Object,
new ConstReference("__data").ToExpression(),
data_ref.ToExpression())));
}
}
private ArgumentReference[] GetArguments(ArgumentReference[] baseCtorArguments)
{
var arguments = new ArgumentReference[baseCtorArguments.Length + 1];
arguments[0] = new ArgumentReference(delegateType);
baseCtorArguments.CopyTo(arguments, 1);
return arguments;
}
public AssignArgumentStatement(ArgumentReference argument, Expression expression)
{
this.argument = argument;
this.expression = expression;
}
protected virtual void ImplementGetObjectData(ClassEmitter emitter, FieldReference interceptorsField,
Type[] interfaces)
{
if (interfaces == null)
{
interfaces = new Type[0];
}
Type[] get_type_args = new Type[] {typeof(String), typeof(bool), typeof(bool)};
Type[] key_and_object = new Type[] {typeof(String), typeof(Object)};
MethodInfo addValueMethod = typeof(SerializationInfo).GetMethod("AddValue", key_and_object);
ArgumentReference arg1 = new ArgumentReference(typeof(SerializationInfo));
ArgumentReference arg2 = new ArgumentReference(typeof(StreamingContext));
MethodEmitter getObjectData = emitter.CreateMethod("GetObjectData",
typeof(void), arg1, arg2);
LocalReference typeLocal = getObjectData.CodeBuilder.DeclareLocal(typeof(Type));
getObjectData.CodeBuilder.AddStatement(new AssignStatement(
typeLocal,
new MethodInvocationExpression(null,
typeof(Type).GetMethod("GetType",
get_type_args),
new ConstReference(
typeof(ProxyObjectReference).
AssemblyQualifiedName).ToExpression(),
new ConstReference(1).ToExpression(),
new ConstReference(0).ToExpression())));
getObjectData.CodeBuilder.AddStatement(new ExpressionStatement(
new MethodInvocationExpression(
arg1, typeof(SerializationInfo).GetMethod("SetType"),
typeLocal.ToExpression())));
getObjectData.CodeBuilder.AddStatement(new ExpressionStatement(
new MethodInvocationExpression(arg1, addValueMethod,
new ConstReference("__interceptors").
ToExpression(),
interceptorsField.ToExpression())));
LocalReference interfacesLocal =
getObjectData.CodeBuilder.DeclareLocal(typeof(String[]));
getObjectData.CodeBuilder.AddStatement(
new AssignStatement(interfacesLocal,
new NewArrayExpression(interfaces.Length, typeof(String))));
for(int i = 0; i < interfaces.Length; i++)
{
getObjectData.CodeBuilder.AddStatement(new AssignArrayStatement(
interfacesLocal, i,
new ConstReference(interfaces[i].AssemblyQualifiedName).ToExpression()));
}
getObjectData.CodeBuilder.AddStatement(new ExpressionStatement(
new MethodInvocationExpression(arg1, addValueMethod,
new ConstReference("__interfaces").
ToExpression(),
interfacesLocal.ToExpression())));
getObjectData.CodeBuilder.AddStatement(new ExpressionStatement(
new MethodInvocationExpression(arg1, addValueMethod,
new ConstReference("__baseType").
ToExpression(),
new ConstReference (emitter.BaseType.AssemblyQualifiedName).ToExpression())));
getObjectData.CodeBuilder.AddStatement(new ExpressionStatement(
new MethodInvocationExpression(arg1, addValueMethod,
new ConstReference("__proxyGenerationOptions").
ToExpression(),
proxyGenerationOptionsField.ToExpression())));
CustomizeGetObjectData(getObjectData.CodeBuilder, arg1, arg2);
getObjectData.CodeBuilder.AddStatement(new ReturnStatement());
}
protected virtual void AddAddValueInvocation(ArgumentReference serializationInfo, MethodEmitter getObjectData,
FieldReference field)
{
getObjectData.CodeBuilder.AddStatement(
new ExpressionStatement(
new MethodInvocationExpression(
serializationInfo,
SerializationInfoMethods.AddValue_Object,
new ConstReference(field.Reference.Name).ToExpression(),
field.ToExpression())));
return;
}
protected void GenerateConstructor(ClassEmitter emitter, ConstructorInfo baseConstructor,
params FieldReference[] fields)
{
ArgumentReference[] args;
ParameterInfo[] baseConstructorParams = null;
if (baseConstructor != null)
{
baseConstructorParams = baseConstructor.GetParameters();
}
if (baseConstructorParams != null && baseConstructorParams.Length != 0)
{
args = new ArgumentReference[fields.Length + baseConstructorParams.Length];
var offset = fields.Length;
for (var i = offset; i < offset + baseConstructorParams.Length; i++)
{
var paramInfo = baseConstructorParams[i - offset];
args[i] = new ArgumentReference(paramInfo.ParameterType);
}
}
else
{
args = new ArgumentReference[fields.Length];
}
for (var i = 0; i < fields.Length; i++)
{
args[i] = new ArgumentReference(fields[i].Reference.FieldType);
}
var constructor = emitter.CreateConstructor(args);
if (baseConstructorParams != null && baseConstructorParams.Length != 0)
{
var last = baseConstructorParams.Last();
#if !NETFX_CORE
if (last.ParameterType.IsArray && last.HasAttribute<ParamArrayAttribute>())
#else
if (last.ParameterType.IsArray && ParameterInfoExtender.HasAttribute<ParamArrayAttribute>(last))
#endif
{
var parameter = constructor.ConstructorBuilder.DefineParameter(args.Length, ParameterAttributes.None, last.Name);
var builder = AttributeUtil.CreateBuilder<ParamArrayAttribute>();
parameter.SetCustomAttribute(builder);
}
}
for (var i = 0; i < fields.Length; i++)
{
constructor.CodeBuilder.AddStatement(new AssignStatement(fields[i], args[i].ToExpression()));
}
// Invoke base constructor
if (baseConstructor != null)
{
Debug.Assert(baseConstructorParams != null);
var slice = new ArgumentReference[baseConstructorParams.Length];
Array.Copy(args, fields.Length, slice, 0, baseConstructorParams.Length);
constructor.CodeBuilder.InvokeBaseConstructor(baseConstructor, slice);
}
else
{
constructor.CodeBuilder.InvokeBaseConstructor();
}
constructor.CodeBuilder.AddStatement(new ReturnStatement());
}
protected void GenerateSerializationConstructor(ClassEmitter emitter, FieldReference interceptorField,
bool delegateToBaseGetObjectData)
{
ArgumentReference arg1 = new ArgumentReference(typeof(SerializationInfo));
ArgumentReference arg2 = new ArgumentReference(typeof(StreamingContext));
ConstructorEmitter constr = emitter.CreateConstructor(arg1, arg2);
constr.CodeBuilder.AddStatement(
new ConstructorInvocationStatement(serializationConstructor,
arg1.ToExpression(), arg2.ToExpression()));
Type[] object_arg = new Type[] {typeof(String), typeof(Type)};
MethodInfo getValueMethod = typeof(SerializationInfo).GetMethod("GetValue", object_arg);
MethodInvocationExpression getInterceptorInvocation =
new MethodInvocationExpression(arg1, getValueMethod,
new ConstReference("__interceptors").ToExpression(),
new TypeTokenExpression(typeof(IInterceptor[])));
constr.CodeBuilder.AddStatement(new AssignStatement(
interceptorField,
new ConvertExpression(typeof(IInterceptor[]), typeof(object),
getInterceptorInvocation)));
constr.CodeBuilder.AddStatement(new ReturnStatement());
}
protected override void CustomizeGetObjectData(AbstractCodeBuilder codebuilder,
ArgumentReference arg1, ArgumentReference arg2)
{
Type[] key_and_object = new Type[] {typeof(String), typeof(Object)};
Type[] key_and_bool = new Type[] {typeof(String), typeof(bool)};
MethodInfo addValueMethod = typeof(SerializationInfo).GetMethod("AddValue", key_and_object);
MethodInfo addValueBoolMethod = typeof(SerializationInfo).GetMethod("AddValue", key_and_bool);
codebuilder.AddStatement(new ExpressionStatement(
new MethodInvocationExpression(arg1, addValueBoolMethod,
new ConstReference("__delegateToBase").ToExpression(),
new ConstReference(delegateToBaseGetObjectData ? 1 : 0).
ToExpression())));
if (delegateToBaseGetObjectData)
{
MethodInfo baseGetObjectData = targetType.GetMethod("GetObjectData",
new Type[] {typeof(SerializationInfo), typeof(StreamingContext)});
codebuilder.AddStatement(new ExpressionStatement(
new MethodInvocationExpression(baseGetObjectData,
arg1.ToExpression(), arg2.ToExpression())));
}
else
{
LocalReference members_ref = codebuilder.DeclareLocal(typeof(MemberInfo[]));
LocalReference data_ref = codebuilder.DeclareLocal(typeof(object[]));
MethodInfo getSerMembers = typeof(FormatterServices).GetMethod("GetSerializableMembers",
new Type[] {typeof(Type)});
MethodInfo getObjData = typeof(FormatterServices).GetMethod("GetObjectData",
new Type[] {typeof(object), typeof(MemberInfo[])});
codebuilder.AddStatement(new AssignStatement(members_ref,
new MethodInvocationExpression(null, getSerMembers,
new TypeTokenExpression(targetType))));
codebuilder.AddStatement(new AssignStatement(data_ref,
new MethodInvocationExpression(null, getObjData,
SelfReference.Self.ToExpression(),
members_ref.ToExpression())));
codebuilder.AddStatement(new ExpressionStatement(
new MethodInvocationExpression(arg1, addValueMethod,
new ConstReference("__data").ToExpression(),
data_ref.ToExpression())));
}
}
protected virtual void CustomizeGetObjectData(
AbstractCodeBuilder codebuilder, ArgumentReference arg1,
ArgumentReference arg2)
{
}
private void EmitCustomGetObjectData(AbstractCodeBuilder codebuilder, ArgumentReference serializationInfo)
{
var members = codebuilder.DeclareLocal(typeof(MemberInfo[]));
var data = codebuilder.DeclareLocal(typeof(object[]));
var getSerializableMembers = new MethodInvocationExpression(
null,
FormatterServicesMethods.GetSerializableMembers,
new TypeTokenExpression(targetType));
codebuilder.AddStatement(new AssignStatement(members, getSerializableMembers));
// Sort to keep order on both serialize and deserialize side the same, c.f DYNPROXY-ISSUE-127
var callSort = new MethodInvocationExpression(
null,
TypeUtilMethods.Sort,
members.ToExpression());
codebuilder.AddStatement(new AssignStatement(members, callSort));
var getObjectData = new MethodInvocationExpression(
null,
FormatterServicesMethods.GetObjectData,
SelfReference.Self.ToExpression(),
members.ToExpression());
codebuilder.AddStatement(new AssignStatement(data, getObjectData));
var addValue = new MethodInvocationExpression(
serializationInfo,
SerializationInfoMethods.AddValue_Object,
new ConstReference("__data").ToExpression(),
data.ToExpression());
codebuilder.AddStatement(new ExpressionStatement(addValue));
}
private void GenerateSerializationConstructor(ClassEmitter emitter)
{
var serializationInfo = new ArgumentReference(typeof(SerializationInfo));
var streamingContext = new ArgumentReference(typeof(StreamingContext));
var ctor = emitter.CreateConstructor(serializationInfo, streamingContext);
ctor.CodeBuilder.AddStatement(
new ConstructorInvocationStatement(serializationConstructor,
serializationInfo.ToExpression(),
streamingContext.ToExpression()));
foreach (var field in serializedFields)
{
var getValue = new MethodInvocationExpression(serializationInfo,
SerializationInfoMethods.GetValue,
new ConstReference(field.Reference.Name).ToExpression(),
new TypeTokenExpression(field.Reference.FieldType));
ctor.CodeBuilder.AddStatement(new AssignStatement(
field,
new ConvertExpression(field.Reference.FieldType,
typeof(object),
getValue)));
}
ctor.CodeBuilder.AddStatement(new ReturnStatement());
}
/// <summary>
/// If callbackMethod is null the InvokeOnTarget implementation
/// is just the code to throw an exception
/// </summary>
/// <param name="emitter"></param>
/// <param name="targetType"></param>
/// <param name="targetForInvocation"></param>
/// <param name="methodInfo"></param>
/// <param name="callbackMethod"></param>
/// <param name="version"></param>
/// <param name="allowChangeTarget">If true the invocation will implement the IChangeProxyTarget interface</param>
/// <returns></returns>
protected NestedClassEmitter BuildInvocationNestedType(
ClassEmitter emitter,
Type targetType,
Type targetForInvocation,
MethodInfo methodInfo,
MethodInfo callbackMethod,
ConstructorVersion version,
bool allowChangeTarget)
{
CheckNotGenericTypeDefinition(targetType, "targetType");
CheckNotGenericTypeDefinition(targetForInvocation, "targetForInvocation");
nestedCounter++;
Type[] interfaces = new Type[0];
if (allowChangeTarget)
{
interfaces = new Type[] {typeof(IChangeProxyTarget)};
}
NestedClassEmitter nested =
new NestedClassEmitter(emitter,
"Invocation" + methodInfo.Name + "_" + nestedCounter.ToString(),
typeof(AbstractInvocation),
interfaces);
// invocation only needs to mirror the generic parameters of the MethodInfo
// targetType cannot be a generic type definition
nested.CreateGenericParameters(methodInfo.GetGenericArguments());
// Create the invocation fields
FieldReference targetRef = nested.CreateField("target", targetForInvocation);
// Create constructor
CreateIInvocationConstructor(targetForInvocation, nested, targetRef, version);
if (allowChangeTarget)
{
ArgumentReference argument1 = new ArgumentReference(typeof(object));
MethodEmitter methodEmitter =
nested.CreateMethod("ChangeInvocationTarget", MethodAttributes.Public | MethodAttributes.Virtual,
typeof(void), argument1);
methodEmitter.CodeBuilder.AddStatement(
new AssignStatement(targetRef,
new ConvertExpression(targetType, argument1.ToExpression())
)
);
methodEmitter.CodeBuilder.AddStatement(new ReturnStatement());
}
// InvokeMethodOnTarget implementation
if (callbackMethod != null)
{
ParameterInfo[] parameters = methodInfo.GetParameters();
CreateIInvocationInvokeOnTarget(emitter, nested, parameters, targetRef, callbackMethod);
}
else
{
CreateEmptyIInvocationInvokeOnTarget(nested);
}
nested.DefineCustomAttribute(new SerializableAttribute());
return nested;
}
private void EmitCallToBaseGetObjectData(AbstractCodeBuilder codebuilder, ArgumentReference serializationInfo,
ArgumentReference streamingContext)
{
var baseGetObjectData = targetType.GetMethod("GetObjectData",
new[] { typeof(SerializationInfo), typeof(StreamingContext) });
codebuilder.AddStatement(new ExpressionStatement(
new MethodInvocationExpression(baseGetObjectData,
serializationInfo.ToExpression(),
streamingContext.ToExpression())));
}
public void SetParameters(Type[] paramTypes)
{
builder.SetParameters(paramTypes);
arguments = new ArgumentReference[paramTypes.Length];
for(int i = 0; i < paramTypes.Length; i++)
{
arguments[i] = new ArgumentReference(paramTypes[i]);
}
ArgumentsUtil.InitializeArgumentsByPosition (arguments, MethodBuilder.IsStatic);
}
protected abstract void CustomizeGetObjectData(AbstractCodeBuilder builder, ArgumentReference serializationInfo, ArgumentReference streamingContext, ClassEmitter emitter);
/// <summary>
/// Builds the adapter.
/// </summary>
/// <returns></returns>
public Type Build()
{
//Setup emitter
ClassEmitter classEmitter = new ClassEmitter(ModuleScope,
OriginalObject.Name + "Adapter",
typeof(AdapterBase),
new Type[] { }, TypeAttributes.Class,
true);
//Add a field to hold a reference to the original object that is being adapter.
FieldReference adaptedObjectReference = classEmitter.CreateField("_Original", OriginalObject);
//Add a constructor that accepts a reference to the original object and
//assigns that reference to the field.
ArgumentReference parameter = new ArgumentReference(OriginalObject);
ConstructorEmitter constructor = classEmitter.CreateConstructor(parameter);
constructor.CodeBuilder.AddStatement(
new AssignStatement(adaptedObjectReference, new ReferenceExpression(parameter)));
constructor.CodeBuilder.AddStatement(new ReturnStatement());
//For each method, walk the pipeline
foreach (MethodInfo method in OriginalObject.GetMethods())
{
AdapterBuilderStageContext context =
new AdapterBuilderStageContext(OriginalObject, classEmitter, adaptedObjectReference, method);
WalkPipeline(context);
}
//build the type
return classEmitter.BuildType();
}
protected override void CustomizeGetObjectData(AbstractCodeBuilder codebuilder, ArgumentReference arg1,
ArgumentReference arg2)
{
Type[] key_and_object = new Type[] {typeof(String), typeof(Object)};
Type[] key_and_int = new Type[] {typeof(String), typeof(int)};
Type[] key_and_string = new Type[] {typeof(String), typeof(string)};
MethodInfo addValueMethod = typeof(SerializationInfo).GetMethod("AddValue", key_and_object);
MethodInfo addIntMethod = typeof(SerializationInfo).GetMethod("AddValue", key_and_int);
MethodInfo addStringMethod = typeof(SerializationInfo).GetMethod("AddValue", key_and_string);
codebuilder.AddStatement(new ExpressionStatement(
new MethodInvocationExpression(arg1, addValueMethod,
new ConstReference("__target").ToExpression(),
targetField.ToExpression())));
codebuilder.AddStatement (new ExpressionStatement (
new MethodInvocationExpression (arg1, addValueMethod,
new ConstReference ("__targetFieldType").ToExpression (),
new ConstReference (targetField.Reference.FieldType.AssemblyQualifiedName).ToExpression())));
codebuilder.AddStatement(new ExpressionStatement(
new MethodInvocationExpression(arg1, addIntMethod,
new ConstReference("__interface_generator_type").
ToExpression(),
new ConstReference((int) GeneratorType).ToExpression())));
codebuilder.AddStatement(new ExpressionStatement(
new MethodInvocationExpression(arg1, addStringMethod,
new ConstReference("__theInterface").ToExpression(),
new ConstReference(targetType.AssemblyQualifiedName).
ToExpression())));
}
private bool HasByRefArguments(ArgumentReference[] arguments)
{
for (int i = 0; i < arguments.Length; i++ )
{
if (arguments[i].Type.IsByRef)
{
return true;
}
}
return false;
}
public ConstructorEmitter CreateConstructor(ArgumentReference[] baseCtorArguments, AbstractTypeEmitter invocation)
{
return invocation.CreateConstructor(baseCtorArguments);
}
private void GenerateConstructor(ClassEmitter emitter, ConstructorInfo baseConstructor, params FieldReference[] fields)
{
ArgumentReference[] args;
ParameterInfo[] baseConstructorParams = null;
if (baseConstructor != null)
{
baseConstructorParams = baseConstructor.GetParameters();
}
if (baseConstructorParams != null && baseConstructorParams.Length != 0)
{
args = new ArgumentReference[fields.Length + baseConstructorParams.Length];
int offset = fields.Length;
for (int i = offset; i < offset + baseConstructorParams.Length; i++)
{
ParameterInfo paramInfo = baseConstructorParams[i - offset];
args[i] = new ArgumentReference(paramInfo.ParameterType);
}
}
else
{
args = new ArgumentReference[fields.Length];
}
for (int i = 0; i < fields.Length; i++)
{
args[i] = new ArgumentReference(fields[i].Reference.FieldType);
}
ConstructorEmitter constructor = emitter.CreateConstructor(args);
for (int i = 0; i < fields.Length; i++)
{
constructor.CodeBuilder.AddStatement(new AssignStatement(fields[i], args[i].ToExpression()));
}
// Invoke base constructor
if (baseConstructor != null)
{
Debug.Assert(baseConstructorParams != null);
var slice = new ArgumentReference[baseConstructorParams.Length];
Array.Copy(args, fields.Length, slice, 0, baseConstructorParams.Length);
constructor.CodeBuilder.InvokeBaseConstructor(baseConstructor, slice);
}
else
{
constructor.CodeBuilder.InvokeBaseConstructor();
}
constructor.CodeBuilder.AddStatement(new ReturnStatement());
}
public AssignArgumentStatement(ArgumentReference argument, Expression expression)
{
this.argument = argument;
this.expression = expression;
}
protected override void AddAddValueInvocation(ArgumentReference serializationInfo, MethodEmitter getObjectData,
FieldReference field)
{
serializedFields.Add(field);
base.AddAddValueInvocation(serializationInfo, getObjectData, field);
}
/// <summary>
/// Generates the constructor for the nested class that extends
/// <see cref="AbstractInvocation"/>
/// </summary>
/// <param name="targetFieldType"></param>
/// <param name="nested"></param>
/// <param name="targetField"></param>
/// <param name="version"></param>
protected void CreateIInvocationConstructor(
Type targetFieldType, NestedClassEmitter nested, FieldReference targetField, ConstructorVersion version)
{
ArgumentReference cArg0 = new ArgumentReference(targetFieldType);
ArgumentReference cArg1 = new ArgumentReference(typeof(IInterceptor[]));
ArgumentReference cArg2 = new ArgumentReference(typeof(Type));
ArgumentReference cArg3 = new ArgumentReference(typeof(MethodInfo));
ArgumentReference cArg4 = null;
ArgumentReference cArg6 = new ArgumentReference(typeof(object));
if (version == ConstructorVersion.WithTargetMethod)
{
cArg4 = new ArgumentReference(typeof(MethodInfo));
}
ArgumentReference cArg5 = new ArgumentReference(typeof(object[]));
ConstructorEmitter constructor;
if (cArg4 == null)
{
constructor = nested.CreateConstructor(cArg0, cArg1, cArg2, cArg3, cArg5, cArg6);
}
else
{
constructor = nested.CreateConstructor(cArg0, cArg1, cArg2, cArg3, cArg4, cArg5, cArg6);
}
constructor.CodeBuilder.AddStatement(new AssignStatement(targetField, cArg0.ToExpression()));
if (cArg4 == null)
{
constructor.CodeBuilder.InvokeBaseConstructor(Constants.AbstractInvocationConstructorWithoutTargetMethod,
cArg0,
cArg6,
cArg1,
cArg2,
cArg3,
cArg5);
}
else
{
constructor.CodeBuilder.InvokeBaseConstructor(Constants.AbstractInvocationConstructorWithTargetMethod,
cArg0,
cArg6,
cArg1,
cArg2,
cArg3,
cArg4,
cArg5);
}
constructor.CodeBuilder.AddStatement(new ReturnStatement());
}
