/// <summary>
/// Generates a parameters constructor that initializes the proxy
/// state with <see cref="StandardInterceptor"/> just to make it non-null.
/// <para>
/// This constructor is important to allow proxies to be XML serializable
/// </para>
/// </summary>
protected void GenerateParameterlessConstructor(ClassEmitter emitter, Type baseClass, FieldReference interceptorField)
{
// Check if the type actually has a default constructor
ConstructorInfo defaultConstructor = baseClass.GetConstructor(BindingFlags.Public | BindingFlags.Instance, null, Type.EmptyTypes, null);
if (defaultConstructor == null)
{
defaultConstructor = baseClass.GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, null, Type.EmptyTypes, null);
if (defaultConstructor == null || defaultConstructor.IsPrivate)
{
return;
}
}
ConstructorEmitter constructor = emitter.CreateConstructor();
// initialize fields with an empty interceptor
constructor.CodeBuilder.AddStatement(new AssignStatement(interceptorField,
new NewArrayExpression(1, typeof(IInterceptor))));
constructor.CodeBuilder.AddStatement(
new AssignArrayStatement(interceptorField, 0, new NewInstanceExpression(typeof(StandardInterceptor), new Type[0])));
// Invoke base constructor
constructor.CodeBuilder.InvokeBaseConstructor(defaultConstructor);
constructor.CodeBuilder.AddStatement(new ReturnStatement());
}
/// <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());
}
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());
}
private ConstructorEmitter GetStaticConstructor()
{
if (staticConstructor == null)
{
staticConstructor = new ConstructorEmitter(this, true);
}
return(staticConstructor);
}
private ConstructorEmitter GetInstanceConstructor()
{
if (instanceConstructor == null)
{
instanceConstructor = new ConstructorEmitter(this, false);
}
return(instanceConstructor);
}
private void AddBuilder(Type contract,
Type concrete,
ServiceLifetime lifeCycle,
Func <Container, dynamic> initializer,
dynamic instance)
{
var ctor = _profiler.GetOptimalConstructor(concrete);
var parameters = _profiler.GetParameters(ctor);
var constructor = ConstructorEmitter.Emit(concrete, ctor, parameters);
var profile = new Profile(contract, lifeCycle, parameters, constructor, initializer, instance);
var builder = _profiler.GetTypeBuilder(profile, lifeCycle);
_builders.TryAdd(contract, builder);
}
public void CreateConstructorCreateField()
{
var classEmitter = new CustomClassEmitter(Scope, "CreateConstructorCreateField", typeof(object));
FieldReference field = classEmitter.CreateField("_test", typeof(string));
ConstructorEmitter constructor = classEmitter.CreateConstructor(new[] { typeof(string), typeof(int) });
constructor.CodeBuilder.InvokeBaseConstructor();
constructor.CodeBuilder
.AddStatement(new AssignStatement(field, new ArgumentReference(typeof(string), 1).ToExpression()))
.AddStatement(new ReturnStatement());
object instance = Activator.CreateInstance(classEmitter.BuildType(), "bla", 0);
Assert.That(instance.GetType().GetField("_test").GetValue(instance), Is.EqualTo("bla"));
}
private void ReplicateBaseTypeConstructor(ConstructorInfo constructor, Action <ConstructorEmitter> preStatementsAdder, Action <ConstructorEmitter> postStatementsAdder)
{
ArgumentUtility.CheckNotNull("constructor", constructor);
ArgumentUtility.CheckNotNull("preStatementsAdder", preStatementsAdder);
ArgumentUtility.CheckNotNull("postStatementsAdder", postStatementsAdder);
ArgumentReference[] arguments = ArgumentsUtil.ConvertToArgumentReference(constructor.GetParameters());
ConstructorEmitter newConstructor = InnerEmitter.CreateConstructor(arguments);
preStatementsAdder(newConstructor);
Expression[] argumentExpressions = ArgumentsUtil.ConvertArgumentReferenceToExpression(arguments);
newConstructor.CodeBuilder.AddStatement(new ConstructorInvocationStatement(constructor, argumentExpressions));
postStatementsAdder(newConstructor);
newConstructor.CodeBuilder.AddStatement(new ReturnStatement());
}
internal ConstructorEmitterVisitor(ConstructorDeclaration constructorDeclaration, IOpCodeIndexer instructionsIndexer)
{
_instructionsIndexer = instructionsIndexer;
_constructorEmitter = new ConstructorEmitter(this, instructionsIndexer, _locals);
_root = constructorDeclaration;
}
