|
public AddTrueStatement ( |
||
| stmt | ||
| return | void | |
protected virtual void ImplementCacheInvocationCache()
{
MethodInfo get_ItemMethod = typeof(HybridDictionary).GetMethod("get_Item", new Type[] {typeof(object)});
MethodInfo set_ItemMethod = typeof(HybridDictionary).GetMethod("Add", new Type[] {typeof(object), typeof(object)});
Type[] args = new Type[] {typeof(ICallable), typeof(MethodInfo)};
Type[] invocation_const_args = new Type[] {typeof(ICallable), typeof(object), typeof(MethodInfo), typeof(object)};
ArgumentReference arg1 = new ArgumentReference(typeof(ICallable));
ArgumentReference arg2 = new ArgumentReference(typeof(MethodInfo));
ArgumentReference arg3 = new ArgumentReference(typeof(object));
_method2Invocation = MainTypeBuilder.CreateMethod("_Method2Invocation",
new ReturnReferenceExpression(Context.Invocation),
MethodAttributes.Family | MethodAttributes.HideBySig, arg1, arg2,
arg3);
LocalReference invocation_local =
_method2Invocation.CodeBuilder.DeclareLocal(Context.Invocation);
LockBlockExpression block = new LockBlockExpression(SelfReference.Self);
block.AddStatement(new AssignStatement(invocation_local,
new ConvertExpression(Context.Invocation,
new VirtualMethodInvocationExpression(CacheField,
get_ItemMethod,
arg2.ToExpression()))));
ConditionExpression cond1 = new ConditionExpression(OpCodes.Brfalse_S,
invocation_local.ToExpression());
cond1.AddTrueStatement(new AssignStatement(
invocation_local,
new NewInstanceExpression(InvocationType.GetConstructor(invocation_const_args),
arg1.ToExpression(), SelfReference.Self.ToExpression(),
arg2.ToExpression(), arg3.ToExpression())));
cond1.AddTrueStatement(new ExpressionStatement(
new VirtualMethodInvocationExpression(CacheField,
set_ItemMethod, arg2.ToExpression(),
invocation_local.ToExpression())));
block.AddStatement(new ExpressionStatement(cond1));
_method2Invocation.CodeBuilder.AddStatement(new ExpressionStatement(block));
_method2Invocation.CodeBuilder.AddStatement(new ReturnStatement(invocation_local));
}
public void Conditionals()
{
EasyType typebuilder = new EasyType( module, "mytype" );
FieldReference cachefield = typebuilder.CreateField( "cache", typeof(IDictionary) );
ArgumentReference arg = new ArgumentReference( typeof(bool) );
EasyConstructor constructor = typebuilder.CreateConstructor( arg );
constructor.CodeBuilder.InvokeBaseConstructor();
ConditionExpression exp = new ConditionExpression(OpCodes.Brtrue_S, arg.ToExpression());
exp.AddTrueStatement( new AssignStatement(cachefield,
new NewInstanceExpression( typeof(HybridDictionary), new Type[0] ) ) );
exp.AddFalseStatement( new AssignStatement(cachefield,
new NewInstanceExpression( typeof(Hashtable), new Type[0] ) ) );
constructor.CodeBuilder.AddStatement( new ExpressionStatement(exp) );
constructor.CodeBuilder.AddStatement( new ReturnStatement() );
ReturnReferenceExpression ret = new ReturnReferenceExpression(typeof(IDictionary));
EasyMethod getCache = typebuilder.CreateMethod( "GetCache", ret );
getCache.CodeBuilder.AddStatement( new ReturnStatement( cachefield ) );
Type newType = typebuilder.BuildType();
object instance = Activator.CreateInstance( newType, new object[] { true } );
MethodInfo method = instance.GetType().GetMethod("GetCache");
object dic = method.Invoke( instance, new object[0] );
Assert.IsTrue( dic is HybridDictionary );
instance = Activator.CreateInstance( newType, new object[] { false } );
dic = method.Invoke( instance, new object[0] );
Assert.IsTrue( dic is Hashtable );
RunPEVerify();
}