internal static BlockExpression Build(Type type)
{
Type keyType = type.GetGenericArguments()[0];
Type valueType = type.GetGenericArguments()[1];
List <Expression> methodCall = new List <Expression>();
Type keyValuePairType = typeof(KeyValuePair <,>).MakeGenericType(keyType, valueType);
LabelTarget returnValueLable = Expression.Label(keyValuePairType, "returnValue");
ConstructorInfo ctor = keyValuePairType.GetConstructor(new[] { keyType, valueType });
ParameterExpression key = Expression.Variable(keyType, "key");
ParameterExpression value = Expression.Variable(valueType, "value");
/*
* ReadObjLeft()
*/
methodCall.Add(Expression.Call(ExpressionMembers.Reader, JsonReader._ReadObjLeft));
/*
* if(reader.ReadBoolObjRight)
* return new KeyValuePair<,>(default,default);
*/
methodCall.Add(
Expression.IfThen(
Expression.Call(ExpressionMembers.Reader, JsonReader._ReadBoolObjRight),
Expression.Return(returnValueLable, Expression.New(ctor, keyType.IsValueType ? (Expression)Expression.New(keyType) : Expression.Constant(null, keyType), valueType.IsValueType ? (Expression)Expression.New(valueType) : Expression.Constant(null, valueType)))));
/*
* ReadKey()
*/
methodCall.Add(ExpressionMembers.GenerateKeyValuePairByReadKey(keyType, key));
/*
* reader.ReadColon()
*/
methodCall.Add(Expression.Call(ExpressionMembers.Reader, JsonReader._ReadColon));
/*
* value = ResolveProvider<ValueType>.InvokeGet(reader, handler);
*/
methodCall.Add(Expression.Assign(value, ExpressionMembers.GetMethodCall(valueType)));
/*
* reader.ReadObjRight();
*/
methodCall.Add(Expression.Call(ExpressionMembers.Reader, JsonReader._ReadObjRight));
/*
* return new KeyValuePair<,>(key,value);
*/
methodCall.Add(Expression.Return(returnValueLable, Expression.New(ctor, key, value)));
methodCall.Add(Expression.Label(returnValueLable, Expression.New(ctor, key, value)));
return(Expression.Block(new[] { key, value }, methodCall));
}
internal static BlockExpression Build(Type type)
{
LabelTarget returnTarget = Expression.Label(type, "returnLable");
Type elementType = type.GetGenericArguments()[0];
ParameterExpression element = Expression.Variable(elementType, "element");
var ctr = type.GetAppointTypeCtor(typeof(Func <>).MakeGenericType(elementType));
return(Expression.Block(new[] { element },
Expression.IfThenElse(
Expression.Call(ExpressionMembers.Reader, JsonReader._ReadBoolNull),
Expression.Return(returnTarget, Expression.Constant(null, type)),
Expression.Block(
Expression.Assign(element, ExpressionMembers.GetMethodCall(elementType)), //inject = Read<T>(); T-->)
Expression.Return(returnTarget, Expression.New(ctr, Expression.Call(_TransitionFunc.MakeGenericMethod(elementType), element)))
)),
Expression.Label(returnTarget, Expression.Constant(null, type))
));
}
internal static BlockExpression Build(Type type, Type injectType, ConstructorInfo ctr)
{
LabelTarget returnTarget = Expression.Label(type, "returnLable");
ParameterExpression inject = Expression.Variable(injectType, "inject");
if (!type.IsValueType)
{
return(Expression.Block(new[] { inject },
Expression.Assign(inject, ExpressionMembers.GetMethodCall(injectType)),//inject = Read<T>(); T-->
Expression.IfThenElse(
Expression.Equal(inject, Expression.Constant(null, injectType)),
Expression.Return(returnTarget, Expression.Constant(null, type)),
Expression.Return(returnTarget, Expression.Convert(Expression.New(ctr, inject), type))),
Expression.Label(returnTarget, Expression.Constant(null, type))
));
}
return(Expression.Block(new[] { inject },
Expression.Assign(inject, ExpressionMembers.GetMethodCall(injectType)),
Expression.Return(returnTarget, Expression.Convert(Expression.New(ctr, inject), type)),
Expression.Label(returnTarget, Expression.Convert(Expression.New(ctr, inject), type))));
}
private static BlockExpression GenerateValueFormatCode(Expression formatDeclareInstance, MethodInfo callFormat, Expression[] paras, ParameterExpression newModel, MemberExtension member)
{
Expression[] expressions = new Expression[6];
/*
* reader.BeforAnnotation();
* reader.RollBackChar()
*/
expressions[0] = Expression.Call(ExpressionMembers.Reader, JsonReader._BeforAnnotation);
expressions[1] = Expression.Call(ExpressionMembers.Reader, JsonReader._RollbackChar);
/*
* currentIdx= Length - reader.Remaining
*/
expressions[2] = ExpressionMembers.CurrentIdxAssignReming;
/*
* valueLength=reader.Skipobj()
*/
expressions[3] = (ExpressionMembers.ValueLengthAssignSkipObj);
/*
* object formatResult = ValueFormat.ReadValueFormat( reader.Substring(currentIdx,valueLength) ,out isValueFormat);
*/
expressions[4] = (Expression.Assign(ExpressionMembers.FormatResult, Expression.Call(formatDeclareInstance, callFormat, paras)));
/*
* if(isValueFormat==true)
* model.N=(Convert)obj;
* else
* reader.Rollback(valueLength)
* m.N=ReadJson();//string
*/
expressions[5] = (Expression.IfThenElse(ExpressionMembers.IsValueFormatEqualTrue, Expression.Assign(Expression.MakeMemberAccess(newModel, member.MemberInfo), Expression.Convert(ExpressionMembers.FormatResult, member.Type)), Expression.Block(Expression.Call(ExpressionMembers.Reader, JsonReader._Rollback, ExpressionMembers.ValueLength), Expression.Assign(Expression.MakeMemberAccess(newModel, member.MemberInfo), ExpressionMembers.GetMethodCall(member.Type)))));
return(Expression.Block(expressions));
}
private static Expression GenerateKeyValueObjectReadValue(MemberExtension member, ParameterExpression newModel)
{
if (!member.IsProperty || (member.IsProperty && member.PropertyInfo.CanWrite))
{
var valueFormatAttribute = member.MemberInfo.GetCustomAttribute <ValueFormatAttribute>() ?? member.MemberInfo.DeclaringType.GetCustomAttribute <ValueFormatAttribute>();
if (valueFormatAttribute != null)//part
{
return(GenerateValueFormatCode(Expression.Constant(valueFormatAttribute, typeof(ValueFormatAttribute)), ValueFormatAttribute._ReadValueFormat, new[] { ExpressionMembers.JsonRemoveQuoteAndSubstring, Expression.Constant(member.Type, typeof(Type)), ExpressionMembers.JsonDeserializeHandler, ExpressionMembers.IsValueFormat }, newModel, member));
}
else //global
{
/*
* if( jsonDeserializeHandler.jsonDeserializeOption .globalValueFormat!=null)
* {
* }
* else
* model.N=ReadJson();
*/
return(Expression.IfThenElse(ExpressionMembers.GlobalValueFormatNotEqualNull, GenerateValueFormatCode(ExpressionMembers.GlobalValueFormat, JsonDeserializeOption._GlobalValueFormatInvoke, new[] { ExpressionMembers.JsonRemoveQuoteAndSubstring, Expression.Constant(member.Type, typeof(Type)), ExpressionMembers.JsonDeserializeHandler, ExpressionMembers.IsValueFormat }, newModel, member), Expression.Assign(Expression.MakeMemberAccess(newModel, member.MemberInfo), ExpressionMembers.GetMethodCall(member.Type))));
}
}
else
{
/* SkipObj(); */
return(Expression.Call(ExpressionMembers.Reader, JsonReader._SkipObj, ExpressionMembers.JsonDeserializeHandler));
}
}
internal static BlockExpression Build(Type multiType, Type sawtoothType, int rank)
{
LabelTarget returnValueLable = Expression.Label(multiType, "returnValue");
List <ParameterExpression> lambdaVariables = new List <ParameterExpression>();
Expression[] exs = new Expression[3];
ParameterExpression sawtoothAry = Expression.Variable(sawtoothType);
lambdaVariables.Add(sawtoothAry);
/*
* int[][][] sawtoothAry= InvokeGet<int[][][]>();
*/
exs[0] = Expression.Assign(sawtoothAry, ExpressionMembers.GetMethodCall(sawtoothType));
/*
* if(sawtoothAry==null)
* return null;
* else
* ...
*/
exs[1] = Expression.IfThenElse(
Expression.Equal(sawtoothAry, Expression.Constant(null, sawtoothType)),
Expression.Return(returnValueLable, Expression.Constant(null, multiType)),
ReturnFunc <Expression>(() =>
{
List <Expression> expressions = new List <Expression>();
/*
* var index0_Length = sawtoothAry.Length;
* var index1_Length = sawtoothAry[0].Length;
* var index2_Length = sawtoothAry[0][0].Length;
*
* var a = 0;
* var b = 0;
* var c = 0;
*/
ParameterExpression[] arrayLengthVariables = new ParameterExpression[rank];
ParameterExpression[] forVariables = new ParameterExpression[rank];
for (int i = 0; i < arrayLengthVariables.Length; i++)
{
arrayLengthVariables[i] = Expression.Variable(typeof(int));
expressions.Add(Expression.Assign(arrayLengthVariables[i], Expression.MakeMemberAccess(GetIndexAccessBySawtoothAry(sawtoothAry, GetExpressionConstantZero(i).ToArray()), typeof(Array).GetProperty("Length"))));
forVariables[i] = Expression.Variable(typeof(int));
}
lambdaVariables.AddRange(arrayLengthVariables);
/*
* int[,,] multiAry=new multiAry(index0_Length,index1_Length,index2_Length)
*/
ParameterExpression multiAry = Expression.Variable(multiType);
lambdaVariables.Add(multiAry);
expressions.Add(Expression.Assign(multiAry, Expression.New(multiType.GetConstructors()[0], arrayLengthVariables)));
/*
* for (int a = 0; a < index0_Length; a++)
* {
* for (int b = 0; b < index1_Length; b++)
* {
* for (int c = 0; c < index2_Length; c++)
* {
* multiAry[a,b,c] = sawtoothAry[a][b][c];
* }
* }
* }
*/
Expression forMain = null;
for (int i = arrayLengthVariables.Length - 1; i >= 0; i--)
{
Expression content = null;
if (forMain == null)
{
/*
* sawtoothAry[a][b][c];
*/
Expression sawtoothAryAccess = GetIndexAccessBySawtoothAry(sawtoothAry, forVariables);
/*
* multiAry[a,b,c] = sawtoothAry[a][b][c];
*/
content = Expression.Assign(Expression.ArrayAccess(multiAry, forVariables), sawtoothAryAccess);
}
else
{
content = forMain;
}
forMain = ExpressionHelper.For(forVariables[i], Expression.LessThan(forVariables[i], arrayLengthVariables[i]), Expression.PostIncrementAssign(forVariables[i]),
content
);
}
expressions.Add(forMain);
/*
* return multiAry
*/
expressions.Add(Expression.Return(returnValueLable, multiAry));
return(Expression.Block(expressions));
}));
exs[2] = Expression.Label(returnValueLable, Expression.Constant(null, multiType));
return(Expression.Block(lambdaVariables.ToArray(), exs));
}
internal static BlockExpression Build(Type type)
{
List <Expression> methodCall = new List <Expression>();
LabelTarget returnValueLable = Expression.Label(type, "returnValue");
var c = type.GetProperties();
ParameterExpression[] ctorArgs = null;
if (c.Length > 0)
{
ctorArgs = new ParameterExpression[c.Length];
for (int i = 0; i < c.Length; i++)
{
ctorArgs[i] = Expression.Variable(c[i].PropertyType);
if (c[i].PropertyType.IsValueType)
{
methodCall.Add(Expression.Assign(ctorArgs[i], Expression.New(c[i].PropertyType)));
}
else
{
methodCall.Add(Expression.Assign(ctorArgs[i], Expression.Constant(null, c[i].PropertyType)));
}
}
}
methodCall.Add(Expression.IfThen(Expression.Call(ExpressionMembers.Reader, JsonReader._ReadNullOrObjLeft), Expression.Return(returnValueLable, Expression.Constant(null, type))));
methodCall.Add(Expression.IfThen(Expression.Call(ExpressionMembers.Reader, JsonReader._ReadBoolObjRight), Expression.Return(returnValueLable, c.Length == 0 ? Expression.New(type) : Expression.New(type.GetConstructors()[0], ctorArgs))));
/*
* read.ReadLeftOrNull()
* return null
* if(_ReadBoolObjRight)
* reture new (default)
* int a;
* string b;
* i=2
* while(i-->0)
* {
* var s= readString;
* ReadColon()
* switch(s)
* case(s=='Name')
* b=readValue
*
* case(s=='Age')
* a=readValue
* arrig=true
* if(!arrig)
* throw
* if(comma())
* i++;
* }
* readRight();
* return new dynamicModel(a,b)
*/
List <ParameterExpression> args = new List <ParameterExpression>()
{
};
if (c.Length > 0)
{
ParameterExpression str = Expression.Variable(typeof(string), "str");
LabelTarget whileBreak = Expression.Label();
methodCall.Add(ExpressionMembers.MoveNextAssignOne);
LoopExpression loopExpression = Expression.Loop(Expression.IfThenElse(ExpressionMembers.MoveNextDecrement,
ReturnFunc <Expression>(() =>
{
Expression[] expressions = new Expression[5];
expressions[0] = Expression.Assign(str, Expression.Call(ExpressionMembers.Reader, JsonReader._ReadString));
expressions[1] = Expression.Call(ExpressionMembers.Reader, JsonReader._ReadColon);
expressions[2] = Expression.Switch(str,
ReturnFunc(() =>
{
SwitchCase[] switchCases = new SwitchCase[c.Length];
for (int i = 0; i < c.Length; i++)
{
switchCases[i] = Expression.SwitchCase(
Expression.Block(typeof(void),
Expression.Assign(ctorArgs[i], ExpressionMembers.GetMethodCall(c[i].PropertyType)),
ExpressionMembers.IsArriveAssignTrue
)
, Expression.Constant(c[i].Name, typeof(string)));
}
return(switchCases);
})
);
expressions[3] = Expression.IfThen(Expression.Equal(ExpressionMembers.IsArrive, Expression.Constant(false, typeof(bool))), Expression.Throw(Expression.New(JsonDeserializationTypeResolutionException._JsonDeserializationTypeResolutionExceptionMsgCtor, Expression.Constant("An error occurred parsing the dynamically typed key. The key does not match", typeof(string)))));
expressions[4] = ExpressionMembers.IfReadBoolCommaIsTrueSoMoveNextIncrement;
return(Expression.Block(expressions));
}),
Expression.Break(whileBreak)
));
methodCall.Add(loopExpression);
methodCall.Add(Expression.Label(whileBreak));
args.Add(str);
args.AddRange(ctorArgs);
}
methodCall.Add(Expression.Call(ExpressionMembers.Reader, JsonReader._ReadObjRight));
methodCall.Add(Expression.Return(returnValueLable, c.Length == 0 ? Expression.New(type) : Expression.New(type.GetConstructors()[0], ctorArgs)));
methodCall.Add(Expression.Label(returnValueLable, Expression.Constant(null, type)));
args.Add(ExpressionMembers.IsArrive);
args.Add(ExpressionMembers.MoveNext);
return(Expression.Block(args, methodCall));
}
internal static BlockExpression Build(Type defindType, Type instanceType, Type convertType, Type keyType, Type valueType)
{
/*
* defind:ExpandoObject new:ExpandoObject convert:IDictionary<string, object>
* ExpandoObject ss = new ExpandoObject();
* IDictionary<string, object> dic = (IDictionary<string, object>)ss;
*
* hashtable
*/
Expression[] methodDictionaryCall = new Expression[9];
LabelTarget returnTarget = Expression.Label(defindType, "returnLable");
Expression ifReadNullOrObjLeftReturnNull;
if (!defindType.IsValueType)
{
/*
* if (reader.ReadNullOrObjLeft())
* return null;
*/
ifReadNullOrObjLeftReturnNull = Expression.IfThen(Expression.Call(ExpressionMembers.Reader, JsonReader._ReadNullOrObjLeft), Expression.Return(returnTarget, Expression.Constant(null, defindType)));
}
else
{
ifReadNullOrObjLeftReturnNull = Expression.Call(ExpressionMembers.Reader, JsonReader._ReadObjLeft);
}
methodDictionaryCall[0] = ifReadNullOrObjLeftReturnNull;
/*
* Dictionary<> dictionary =new Dictionary<>();
*/
NewExpression dictionaryCtor = Expression.New(instanceType);
ParameterExpression dictionary = Expression.Variable(defindType, "dictionary");
methodDictionaryCall[1] = Expression.Assign(dictionary, dictionaryCtor);
/*
* if(reader.ReadBoolObjRight)
* return dictionary;
*/
methodDictionaryCall[2] = (Expression.IfThen(Expression.Call(ExpressionMembers.Reader, JsonReader._ReadBoolObjRight), Expression.Return(returnTarget, dictionary)));
/*
* IDictionary iDic = dictionary;
* IDictionary<,> iDic = dictionary;
*/
MethodInfo iDicAdd = convertType.GetMethod("Add");
ParameterExpression iDic = Expression.Variable(convertType, "iDic");
methodDictionaryCall[3] = Expression.Assign(iDic, Expression.Convert(dictionary, convertType));
/*
* int moveNext=2;
*/
methodDictionaryCall[4] = ExpressionMembers.MoveNextAssignOne;
ParameterExpression key = Expression.Variable(keyType, "key");
ParameterExpression value = Expression.Variable(valueType, "value");
/*
* while(moveNext-->0)
* {}
*/
LabelTarget loopBreak = Expression.Label("loopBreak");
LoopExpression loopExpression = Expression.Loop(Expression.IfThenElse(ExpressionMembers.MoveNextDecrement,
ReturnFunc <Expression>(() =>
{
Expression[] methodCall = new Expression[5];
/*
* ReadKey()
*/
methodCall[0] = ExpressionMembers.GenerateKeyValuePairByReadKey(keyType, key);
/*
* reader.ReadColon()
*/
methodCall[1] = (Expression.Call(ExpressionMembers.Reader, JsonReader._ReadColon));
/*
* value = ResolveProvider<ValueType>.InvokeGet(reader, handler);
*/
methodCall[2] = (Expression.Assign(value, ExpressionMembers.GetMethodCall(valueType)));
/*
* iDic.Add(key,value);
*/
methodCall[3] = (Expression.Call(iDic, iDicAdd, key, value));
/*
* if(reader.ReadComma()==true)
* moveNext++;
*/
methodCall[4] = (ExpressionMembers.IfReadBoolCommaIsTrueSoMoveNextIncrement);
return(Expression.Block(methodCall));;
})
, Expression.Break(loopBreak)));
methodDictionaryCall[5] = Expression.Block(loopExpression, Expression.Label(loopBreak));
/*
* reader.ReadObjRight();
*/
methodDictionaryCall[6] = Expression.Call(ExpressionMembers.Reader, JsonReader._ReadObjRight);
/*
* return dictionary
*/
GotoExpression returnExpression = Expression.Return(returnTarget, dictionary);
LabelExpression returnLabel = Expression.Label(returnTarget, dictionary);
methodDictionaryCall[7] = returnExpression;
methodDictionaryCall[8] = returnLabel;
return(Expression.Block(new[] { iDic, dictionary, key, value, ExpressionMembers.MoveNext }, methodDictionaryCall));
}
internal static BlockExpression Build(Type type)
{
Type arrayItemType = type.GetElementType();
Expression[] methodListCall = new Expression[11];
LabelTarget returnTarget = Expression.Label(type, "returnLable");
/*
* if (reader.ReadNullOrArrayLeft())
* return null;
*/
Expression ifReadNullOrArrayLeftReturnNull = Expression.IfThen(Expression.Call(ExpressionMembers.Reader, JsonReader._ReadNullOrArrayLeft), Expression.Return(returnTarget, Expression.Constant(null, type)));
methodListCall[0] = ifReadNullOrArrayLeftReturnNull;
/*
* int arrayLength=reader._GetArrayLength;
* T[] array=new [arrayLength];
*/
ParameterExpression arrayLength = Expression.Variable(typeof(int), "arrayLength");
methodListCall[1] = Expression.Assign(arrayLength, Expression.Call(ExpressionMembers.Reader, JsonReader._GetArrayLength, ExpressionMembers.JsonDeserializeHandler));
NewExpression aryCtor = Expression.New(type.GetConstructors()[0], arrayLength);
ParameterExpression array = Expression.Variable(type, "array");
methodListCall[2] = Expression.Assign(array, aryCtor);
/*
* if(arrayLength==0)
* goto ReadArrayRightLabel;
*/
LabelTarget readArrayRightLabel = Expression.Label(typeof(void), "ReadArrayRightLabel");
methodListCall[3] = Expression.IfThen(Expression.Equal(arrayLength, Expression.Constant(0)), Expression.Goto(readArrayRightLabel));
/*
* int moveNext=1;
*/
methodListCall[4] = ExpressionMembers.MoveNextAssignOne;
/*
* int idx=0;
*/
ParameterExpression idx = Expression.Variable(typeof(int), "idx");
methodListCall[5] = Expression.Assign(idx, Expression.Constant(0));
/*
* while(moveNext-->0)
* {}
*/
LabelTarget loopBreak = Expression.Label("loopBreak");
LoopExpression loopExpression = Expression.Loop(Expression.IfThenElse(ExpressionMembers.MoveNextDecrement,
ReturnFunc <Expression>(() =>
{
Expression[] methodCall = new Expression[3];
/*
* ary[idx]=item;
*/
methodCall[0] = Expression.Assign(Expression.ArrayAccess(array, idx), ExpressionMembers.GetMethodCall(arrayItemType));
/*
* if(reader.ReadBoolComma()==true)
* moveNext++;
*/
methodCall[1] = ExpressionMembers.IfReadBoolCommaIsTrueSoMoveNextIncrement;
/*
* idx++;
*/
methodCall[2] = Expression.PostIncrementAssign(idx);
return(Expression.Block(methodCall));;
})
, Expression.Break(loopBreak)));
methodListCall[6] = Expression.Block(loopExpression, Expression.Label(loopBreak));
/*
* ReadArrayRightLabel:
* reader.ReadArrayRight()
*/
methodListCall[7] = Expression.Label(readArrayRightLabel);
methodListCall[8] = Expression.Call(ExpressionMembers.Reader, JsonReader._ReadArrayRight);
/*
* return list;
*/
GotoExpression returnExpression = Expression.Return(returnTarget, array);
LabelExpression returnLabel = Expression.Label(returnTarget, array);
methodListCall[9] = returnExpression;
methodListCall[10] = returnLabel;
return(Expression.Block(new[] { arrayLength, array, idx, ExpressionMembers.MoveNext }, methodListCall));
}
internal static BlockExpression Build(Type defindType, Type instanceType, Type convertType, Type arrayItemType)
{
/*
* //defind:IEnumerable<string> new: List<string> convert: List<string>
* IEnumerable<string> li = new List<string>();
* List<string> list = (List<string>)li;
*
* //defind:ArrayList new:ArrayList convert: IList/ArrayList
* ArrayList v = new ArrayList();
* var df = (IList)v;
*/
Expression[] methodListCall = new Expression[9];
LabelTarget returnTarget = Expression.Label(defindType, "returnLable");
Expression ifReadNullOrArrayLeftReturnNull;
if (!defindType.IsValueType)
{
/*
* if (reader.ReadNullOrArrayLeft())
* return null;
*/
ifReadNullOrArrayLeftReturnNull = Expression.IfThen(Expression.Call(ExpressionMembers.Reader, JsonReader._ReadNullOrArrayLeft), Expression.Return(returnTarget, Expression.Constant(null, defindType)));
}
else
{
ifReadNullOrArrayLeftReturnNull = Expression.Call(ExpressionMembers.Reader, JsonReader._ReadArrayLeft);
}
methodListCall[0] = ifReadNullOrArrayLeftReturnNull;
/*
* List<> list =new List<>();
*/
NewExpression listCtor = Expression.New(instanceType);
ParameterExpression list = Expression.Variable(defindType, "list");
methodListCall[1] = Expression.Assign(list, listCtor);
/*
* if(reader.ReadBoolArrayRight)
* return list;
*/
methodListCall[2] = (Expression.IfThen(Expression.Call(ExpressionMembers.Reader, JsonReader._ReadBoolArrayRight), Expression.Return(returnTarget, list)));
/*
* ICollection<int> iCollec = (ICollection<int>)list;
* iCollec.Add(ReadInt())
*/
MethodInfo iCollecAdd = convertType.GetMethod("Add", BindingFlags.Public | BindingFlags.Instance);
ParameterExpression iCollec = Expression.Variable(convertType, "iDic");
methodListCall[3] = Expression.Assign(iCollec, Expression.Convert(list, convertType));
/*
* int moveNext=1;
*/
methodListCall[4] = ExpressionMembers.MoveNextAssignOne;
/*
* while(moveNext-->0)
* {}
*/
LabelTarget loopBreak = Expression.Label("loopBreak");
LoopExpression loopExpression = Expression.Loop(Expression.IfThenElse(ExpressionMembers.MoveNextDecrement,
ReturnFunc <Expression>(() =>
{
Expression[] methodCall = new Expression[2];
/*
* list.Add(item);
*/
methodCall[0] = Expression.Call(iCollec, iCollecAdd, ExpressionMembers.GetMethodCall(arrayItemType));
/*
* if(reader.ReadBoolComma()==true)
* moveNext++;
*/
methodCall[1] = ExpressionMembers.IfReadBoolCommaIsTrueSoMoveNextIncrement;
return(Expression.Block(methodCall));;
})
, Expression.Break(loopBreak)));
methodListCall[5] = Expression.Block(loopExpression, Expression.Label(loopBreak));
/*
* reader.ReadArrayRight()
*/
methodListCall[6] = Expression.Call(ExpressionMembers.Reader, JsonReader._ReadArrayRight);
/*
* return list;
*/
GotoExpression returnExpression = Expression.Return(returnTarget, list);
LabelExpression returnLabel = Expression.Label(returnTarget, list);
methodListCall[7] = returnExpression;
methodListCall[8] = returnLabel;
return(Expression.Block(new[] { iCollec, list, ExpressionMembers.MoveNext }, methodListCall));
}