public void SetMemberValue(CodeGenerator generator, ArgBuilder targetObject, string memberName, LocalBuilder memberValue)
{
generator.Ldarg(targetObject);
generator.Load(memberName);
generator.Ldloc(memberValue);
// Type originalType = memberValue.LocalType.IsEnum ? typeof(int) : memberValue.LocalType;
if (memberValue.LocalType.IsValueType)
{
generator.Box(memberValue.LocalType.IsEnum ? typeof(int) : memberValue.LocalType);
}
//���ֵΪ�գ����ܵ���ToString
generator.Load(null);
generator.If(Cmp.NotEqualTo);
generator.Ldloc(memberValue);
// Type originalType = memberValue.LocalType.IsEnum ? typeof(int) : memberValue.LocalType;
if (memberValue.LocalType.IsValueType)
{
generator.Box(memberValue.LocalType.IsEnum ? typeof(int) : memberValue.LocalType);
}
generator.Call(typeof(object).GetMethod("ToString", Type.EmptyTypes));
generator.Else();
generator.LoadDefaultValue(memberValue.LocalType);
if (memberValue.LocalType.IsValueType)
{
generator.Box(memberValue.LocalType.IsEnum ? typeof(int) : memberValue.LocalType);
}
generator.EndIf();
generator.Call(typeof(NameValueCollection).GetMethod("Add", new Type[] { typeof(string), typeof(string) }));
}
public override ConvertHandler GetConvertHandler(Type inputType, Type outputType, object inputObject, object outputObject, Dictionary<string, string> mappingNames, List<string> ignoreList, Dictionary<int, string> mappingOrders, bool mappingSpecifiedOnly)
{
Dictionary<string, string> distToSrc = new Dictionary<string, string>();
Dictionary<string, MemberInfo> members = new Dictionary<string, MemberInfo>();
foreach (string sourceName in mappingNames.Keys)
{
MemberInfo sourceMember = ConvertorGeneratorHelper.GetMemberInfo(inputType, sourceName);
Check.Require(sourceMember != null, string.Format("member named {0} could not be found in {1}", sourceName, outputType.FullName));
distToSrc.Add(mappingNames[sourceName], sourceName);
members.Add(mappingNames[sourceName], sourceMember);
}
if (!mappingSpecifiedOnly)
{
Dictionary<string, MemberInfo> sourceMembers = ConvertorGeneratorHelper.GetMembers(inputType);
foreach (string sourceName in sourceMembers.Keys)
{
if (!ignoreList.Contains(sourceName) && !distToSrc.ContainsKey(sourceName))
{
distToSrc.Add(sourceName, sourceName);
members.Add(sourceName, sourceMembers[sourceName]);
}
}
}
CodeGenerator gen = new CodeGenerator();
gen.BeginMethod("m" + Guid.NewGuid().ToString("N"), typeof(ConvertHandler));
ArgBuilder inputObjectArg = new ArgBuilder(0, inputType);
ArgBuilder outputObjectArg = new ArgBuilder(1, outputType);
int currentCount = 0;
int memberCount = members.Count;
string[] keys = new string[memberCount];
distToSrc.Keys.CopyTo(keys, 0);
List<string> keyList = new List<string>(keys);
MemberSetterGenerator.BeginSetMembers(gen, outputObjectArg);
while (currentCount < memberCount)
{
currentCount++;
string targetName = ConvertorGeneratorHelper.GetCurrentKey(mappingOrders, currentCount, keyList).Replace("_", "");
if (string.IsNullOrEmpty(targetName))
{
continue;
}
string sourceName = distToSrc[targetName].Replace("_","");
if (MemberGetterGenerator.ContainsMember(sourceName, inputType, inputObject) && MemberSetterGenerator.ContainsMember(targetName, outputType, outputObject))
{
Type targetType = ConvertorGeneratorHelper.GetMemberType(members[targetName]);
LocalBuilder memberValue = gen.DeclareLocal(targetType, "memberValue");
MemberGetterGenerator.GetMemberValue(gen, inputObjectArg, sourceName, ref memberValue);
MemberSetterGenerator.SetMemberValue(gen, outputObjectArg, targetName, memberValue);
}
}
gen.Ldarg(outputObjectArg);
MemberSetterGenerator.EndSetMembers(gen, outputObjectArg);
return (ConvertHandler)gen.EndMethod();
}
public void EndSetMembers(CodeGenerator generator, ArgBuilder targetObject)
{
generator.Ldarg(targetObject);
generator.Load(null);
generator.If(Cmp.EqualTo);
generator.Pop();
LocalBuilder dataRow = generator.DeclareLocal(typeof(DataRow));
generator.Ldloc(locDataTable);
generator.Call(typeof(DataTable).GetMethod("NewRow"));
generator.Stloc(dataRow);
LocalBuilder locCurrent = generator.DeclareLocal(typeof(string));
LocalBuilder locEnumerator = generator.DeclareLocal(typeof(Dictionary<string, object>.KeyCollection.Enumerator));
generator.Ldloc(locMemberValues);
generator.Call(typeof(Dictionary<string, object>).GetMethod("get_Keys"));
generator.Call(typeof(Dictionary<string, object>.KeyCollection).GetMethod("GetEnumerator"));
generator.Stloc(locEnumerator);
MethodInfo getCurrentMethod = typeof(Dictionary<string, object>.KeyCollection.Enumerator).GetMethod("get_Current");
MethodInfo moveNextMethod = typeof(Dictionary<string, object>.KeyCollection.Enumerator).GetMethod("MoveNext");
generator.ForEach(locCurrent, typeof(string), typeof(Dictionary<string, object>.KeyCollection.Enumerator), locEnumerator, getCurrentMethod);
generator.Ldloc(dataRow);
generator.Ldloc(locCurrent);
generator.Ldloc(locMemberValues);
generator.Ldloc(locCurrent);
generator.Call(typeof(Dictionary<string, object>).GetMethod("get_Item"));
generator.Call(typeof(DataRow).GetMethod("set_Item", new Type[] { typeof(string), typeof(object) }));
generator.EndForEach(moveNextMethod);
generator.Ldloc(dataRow);
generator.EndIf();
}
public void BeginSetMembers(CodeGenerator generator, ArgBuilder targetObject)
{
locMemberValues = generator.DeclareLocal(typeof(Dictionary<string, object>), "memberValues");
locDataTable = generator.DeclareLocal(typeof(DataTable), "dataTable");
generator.New(typeof(Dictionary<string, object>).GetConstructor(Type.EmptyTypes));
generator.Stloc(locMemberValues);
generator.New(typeof(DataTable).GetConstructor(Type.EmptyTypes));
generator.Stloc(locDataTable);
}
public void GetMemberValue(CodeGenerator generator, ArgBuilder targetObject, string memberName, ref LocalBuilder memberValue)
{
LocalBuilder locValue = generator.DeclareLocal(typeof(string));
Type targetType = memberValue.LocalType;
Type originalType = ConvertorGeneratorHelper.GetOriginalType(targetType);
generator.Ldarg(targetObject);
generator.Load(memberName);
generator.Call(typeof(NameValueCollection).GetMethod("get_Item", new Type[] { typeof(string) }));
generator.Stloc(locValue);
if (targetType.IsAssignableFrom(typeof(string)))
{
generator.Ldloc(locValue);
generator.Stloc(memberValue);
return;
}
else
{
generator.Ldloc(locValue);
generator.Call(typeof(string).GetMethod("IsNullOrEmpty"));
generator.Load(true);
generator.If(Cmp.NotEqualTo);
if (targetType == typeof(Guid))
{
generator.Ldloc(locValue);
generator.New(typeof(Guid).GetConstructor(new Type[] { typeof(string) }));
generator.Stloc(memberValue);
}
else
{
MethodInfo parseMethod = targetType.GetMethod("Parse", new Type[] { typeof(string) });
if (parseMethod != null)
{
generator.Ldloc(locValue);
generator.Call(parseMethod);
generator.Stloc(memberValue);
}
else
{
generator.Ldloc(locValue);
generator.Load(originalType);
generator.Call(typeof(Convert).GetMethod("ChangeType", new Type[] { typeof(object), typeof(Type) }));
if (targetType.IsValueType)
{
generator.UnboxAny(targetType);
}
generator.Stloc(memberValue);
}
}
generator.Else();
generator.LoadDefaultValue(targetType);
generator.Stloc(memberValue);
generator.EndIf();
}
}
public void SetMemberValue(CodeGenerator generator, ArgBuilder targetObject, string memberName, LocalBuilder memberValue)
{
generator.Ldarg(targetObject);
generator.Load(memberName);
generator.Ldloc(memberValue);
if (memberValue.LocalType.IsValueType)
{
generator.Box(memberValue.LocalType.IsEnum ? typeof(int) : memberValue.LocalType);
}
generator.Call(typeof(IDictionary).GetMethod("Add"));
}
public void SetMemberValue(CodeGenerator generator, ArgBuilder targetObject, string memberName, LocalBuilder memberValue)
{
generator.Ldarg(targetObject);
if (memberValue.LocalType.FullName.StartsWith("System.Nullable`1["))
{
generator.Ldloc(memberValue);
generator.Load(null);
generator.If(Cmp.EqualTo);
generator.LoadMember(typeof(DBNull).GetField("Value"));
generator.Stloc(memberValue);
generator.EndIf();
}
generator.Load(null);
generator.If(Cmp.EqualTo);
PropertyInfo columns = typeof(DataTable).GetProperty("Columns");
generator.Ldloc(locDataTable);
generator.LoadMember(columns);
generator.Load(memberName);
generator.Ldtoken(CommonUtils.GetOriginalTypeOfNullableType(memberValue.LocalType.IsEnum ? typeof(int) : memberValue.LocalType));
generator.Call(typeof(Type).GetMethod("GetTypeFromHandle", new Type[] { typeof(RuntimeTypeHandle) }));
generator.Call(typeof(DataColumnCollection).GetMethod("Add", new Type[] { typeof(string), typeof(Type) }));
generator.Pop();
generator.Ldloc(locMemberValues);
generator.Load(memberName);
generator.Ldloc(memberValue);
if (memberValue.LocalType.IsValueType)
{
generator.Box(memberValue.LocalType.IsEnum ? typeof(int) : memberValue.LocalType);
}
generator.Call(typeof(Dictionary<string, object>).GetMethod("Add"));
generator.Else();
generator.Ldarg(targetObject);
generator.Load(memberName);
generator.Ldloc(memberValue);
if (memberValue.LocalType.IsValueType)
{
generator.Box(memberValue.LocalType);
}
generator.Call(typeof(DataRow).GetMethod("set_Item", new Type[] { typeof(string), typeof(object) }));
generator.EndIf();
}
internal JsonFormatClassWriterDelegate GenerateClassWriter(ClassDataContract classContract)
{
_ilg = new CodeGenerator();
bool memberAccessFlag = classContract.RequiresMemberAccessForWrite(null, JsonGlobals.JsonSerializationPatterns);
try
{
BeginMethod(_ilg, "Write" + DataContract.SanitizeTypeName(classContract.StableName.Name) + "ToJson", typeof(JsonFormatClassWriterDelegate), memberAccessFlag);
}
catch (SecurityException securityException)
{
if (memberAccessFlag)
{
classContract.RequiresMemberAccessForWrite(securityException, JsonGlobals.JsonSerializationPatterns);
}
else
{
throw;
}
}
InitArgs(classContract.UnderlyingType);
_memberNamesArg = _ilg.GetArg(4);
WriteClass(classContract);
return (JsonFormatClassWriterDelegate)_ilg.EndMethod();
}
private void InitArgs(Type objType)
{
_xmlWriterArg = _ilg.GetArg(0);
_contextArg = _ilg.GetArg(2);
_dataContractArg = _ilg.GetArg(3);
_objectLocal = _ilg.DeclareLocal(objType, "objSerialized");
ArgBuilder objectArg = _ilg.GetArg(1);
_ilg.Load(objectArg);
// Copy the data from the DataTimeOffset object passed in to the DateTimeOffsetAdapter.
// DateTimeOffsetAdapter is used here for serialization purposes to bypass the ISerializable implementation
// on DateTimeOffset; which does not work in partial trust.
if (objType == Globals.TypeOfDateTimeOffsetAdapter)
{
_ilg.ConvertValue(objectArg.ArgType, Globals.TypeOfDateTimeOffset);
_ilg.Call(XmlFormatGeneratorStatics.GetDateTimeOffsetAdapterMethod);
}
//Copy the KeyValuePair<K,T> to a KeyValuePairAdapter<K,T>.
else if (objType.GetTypeInfo().IsGenericType && objType.GetGenericTypeDefinition() == Globals.TypeOfKeyValuePairAdapter)
{
ClassDataContract dc = (ClassDataContract)DataContract.GetDataContract(objType);
_ilg.ConvertValue(objectArg.ArgType, Globals.TypeOfKeyValuePair.MakeGenericType(dc.KeyValuePairGenericArguments));
_ilg.New(dc.KeyValuePairAdapterConstructorInfo);
}
else
{
_ilg.ConvertValue(objectArg.ArgType, objType);
}
_ilg.Stloc(_objectLocal);
}
private CodeGenerator GenerateCollectionReaderHelper(CollectionDataContract collectionContract, bool isGetOnlyCollection)
{
_ilg = new CodeGenerator();
bool memberAccessFlag = collectionContract.RequiresMemberAccessForRead(null);
try
{
if (isGetOnlyCollection)
{
BeginMethod(_ilg, "Read" + DataContract.SanitizeTypeName(collectionContract.StableName.Name) + "FromJson" + "IsGetOnly", typeof(JsonFormatGetOnlyCollectionReaderDelegate), memberAccessFlag);
}
else
{
BeginMethod(_ilg, "Read" + DataContract.SanitizeTypeName(collectionContract.StableName.Name) + "FromJson", typeof(JsonFormatCollectionReaderDelegate), memberAccessFlag);
}
}
catch (SecurityException securityException)
{
if (memberAccessFlag)
{
collectionContract.RequiresMemberAccessForRead(securityException);
}
else
{
throw;
}
}
InitArgs();
_collectionContractArg = _ilg.GetArg(4);
return _ilg;
}
public void SetMemberValue(CodeGenerator generator, ArgBuilder targetObject, string memberName, LocalBuilder memberValue)
{
MemberInfo memberInfo = ConvertorGeneratorHelper.GetMemberInfo(targetObject.ArgType, memberName);
if (memberInfo != null)
{
generator.Ldarg(targetObject);
generator.Ldloc(memberValue);
generator.StoreMember(memberInfo);
}
}
public void GetMemberValue(CodeGenerator generator, ArgBuilder targetObject, string memberName, ref LocalBuilder memberValue)
{
Type inputType = targetObject.ArgType;
MemberInfo memberInfo = ConvertorGeneratorHelper.GetMemberInfo(inputType, memberName);
if (memberInfo == null)
{
return;
}
Type srcMemberType = ConvertorGeneratorHelper.GetMemberType(memberInfo);
Type destMemberType = memberValue.LocalType;
if (memberValue.LocalType.IsAssignableFrom(srcMemberType))
{
generator.Ldarg(targetObject);
generator.LoadMember(memberInfo);
generator.Stloc(memberValue);
return;
}
Type converTargetType = ConvertorGeneratorHelper.GetOriginalType(destMemberType);
Type convertSourceType = ConvertorGeneratorHelper.GetOriginalType(srcMemberType);
//ת������
if (typeof(IConvertible).IsAssignableFrom(convertSourceType))
{
generator.Ldarg(targetObject);
generator.LoadMember(memberInfo);
if (convertSourceType.IsValueType)
{
generator.Box(srcMemberType);
}
//�Ƿ�Ϊ��
generator.Load(null);
generator.If(Cmp.NotEqualTo);
//�����Ϊ�գ���������ת��
generator.Ldarg(targetObject);
generator.LoadMember(memberInfo);
if (convertSourceType.IsValueType)
{
generator.Box(srcMemberType);
}
generator.Load(converTargetType);
generator.Call(typeof(Convert).GetMethod("ChangeType", new Type[] { typeof(object), typeof(Type) }));
if (destMemberType.IsValueType)
{
generator.UnboxAny(destMemberType);
}
generator.Stloc(memberValue);
//���Ϊ�գ������Ĭ��ֵ
generator.Else();
generator.LoadDefaultValue(destMemberType);
generator.Stloc(memberValue);
generator.EndIf();
}
}
CodeGenerator GenerateCollectionReaderHelper(CollectionDataContract collectionContract, bool isGetOnlyCollection)
{
ilg = new CodeGenerator();
bool memberAccessFlag = collectionContract.RequiresMemberAccessForRead(null);
try
{
if (isGetOnlyCollection)
{
BeginMethod(ilg, "Read" + collectionContract.StableName.Name + "FromJson" + "IsGetOnly", typeof(JsonFormatGetOnlyCollectionReaderDelegate), memberAccessFlag);
}
else
{
BeginMethod(ilg, "Read" + collectionContract.StableName.Name + "FromJson", typeof(JsonFormatCollectionReaderDelegate), memberAccessFlag);
}
}
catch (SecurityException securityException)
{
if (memberAccessFlag && securityException.PermissionType.Equals(typeof(ReflectionPermission)))
{
collectionContract.RequiresMemberAccessForRead(securityException);
}
else
{
throw;
}
}
InitArgs();
DemandMemberAccessPermission(memberAccessFlag);
collectionContractArg = ilg.GetArg(4);
return ilg;
}
void InitArgs()
{
xmlReaderArg = ilg.GetArg(0);
contextArg = ilg.GetArg(1);
emptyDictionaryStringArg = ilg.GetArg(2);
memberNamesArg = ilg.GetArg(3);
}
public void GetMemberValue(CodeGenerator generator, ArgBuilder targetObject, string memberName, ref LocalBuilder memberValue)
{
MethodInfo getMethod;
bool mustBeUnBox = false;
switch (Type.GetTypeCode(memberValue.LocalType))
{
case TypeCode.Boolean:
getMethod = typeof(IDataRecord).GetMethod("GetBoolean");
break;
case TypeCode.Byte:
getMethod = typeof(IDataRecord).GetMethod("GetByte");
break;
case TypeCode.Char:
getMethod = typeof(IDataRecord).GetMethod("GetChar");
break;
case TypeCode.DateTime:
getMethod = typeof(IDataRecord).GetMethod("GetDateTime");
break;
case TypeCode.Decimal:
getMethod = typeof(IDataRecord).GetMethod("GetDecimal");
break;
//Teddy 2008-2-2: commented the lines below, because for some database, return data type of float or real could always be System.Single or System.Double
//case TypeCode.Double:
// getMethod = typeof(IDataRecord).GetMethod("GetDouble");
// break;
//case TypeCode.Single:
// getMethod = typeof(IDataRecord).GetMethod("GetFloat");
// break;
case TypeCode.Int16:
getMethod = typeof(IDataRecord).GetMethod("GetInt16");
break;
case TypeCode.Int32:
getMethod = typeof(IDataRecord).GetMethod("GetInt32");
break;
case TypeCode.Int64:
getMethod = typeof(IDataRecord).GetMethod("GetInt64");
break;
case TypeCode.String:
getMethod = typeof(IDataRecord).GetMethod("GetString");
break;
default:
getMethod = typeof(IDataRecord).GetMethod("GetValue");
mustBeUnBox = true;
break;
}
if (memberValue.LocalType == typeof(Guid))
{
getMethod = typeof(IDataRecord).GetMethod("GetGuid");
mustBeUnBox = false;
}
if (memberValue.LocalType.IsEnum)
{
getMethod = typeof(IDataRecord).GetMethod("GetValue");
mustBeUnBox = true;
}
generator.Ldarg(targetObject);
generator.Load(memberName);
generator.Call(typeof(IDataRecord).GetMethod("GetOrdinal"));
LocalBuilder fieldOrdinalLoc = generator.DeclareLocal(typeof(int));
generator.Stloc(fieldOrdinalLoc);
generator.Ldarg(targetObject);
generator.Ldloc(fieldOrdinalLoc);
generator.Call(typeof(IDataRecord).GetMethod("IsDBNull"));
generator.IfNot();
generator.Ldarg(targetObject);
generator.Ldloc(fieldOrdinalLoc);
generator.Call(getMethod);
//Teddy 2008-2-2: added the code section below to convert the object to the memberValue.LocalType
if (!memberValue.LocalType.IsEnum && getMethod == typeof(IDataRecord).GetMethod("GetValue"))
{
generator.Load(Type.GetTypeCode(memberValue.LocalType));
generator.Call(typeof(Convert).GetMethod("ChangeType", BindingFlags.Instance | BindingFlags.Public | BindingFlags.Static, null, new Type[] { typeof(object), typeof(TypeCode) }, null));
}
if (memberValue.LocalType.IsValueType && mustBeUnBox)
{
generator.UnboxAny(memberValue.LocalType);
}
generator.Else();
generator.LoadDefaultValue(memberValue.LocalType);
generator.EndIf();
generator.Stloc(memberValue);
}
void IsStartElement(ArgBuilder nameArg, ArgBuilder nsArg)
{
ilg.Call(xmlReaderArg, JsonFormatGeneratorStatics.IsStartElementMethod2, nameArg, nsArg);
}
public void EndSetMembers(CodeGenerator generator, ArgBuilder targetObject)
{
}
private static MethodTarget MakeByRefReducedMethodTarget(MethodTracker method, List<Parameter> parameters, ArgBuilder instanceBuilder, List<ArgBuilder> argBuilders)
{
List<Parameter> newParameters = new List<Parameter>();
foreach (Parameter param in parameters) {
ByRefParameter p = param as ByRefParameter;
if (p != null) {
if (!p.IsOutOnly) {
newParameters.Add(p.MakeInParameter());
}
} else {
newParameters.Add(param);
}
}
List<int> returnArgs = new List<int>();
if (CompilerHelpers.GetReturnType(method.Method) != typeof(void)) {
returnArgs.Add(-1);
}
int index = 0;
int outParams = 0;
List<ArgBuilder> newArgBuilders = new List<ArgBuilder>();
foreach (ArgBuilder ab in argBuilders) {
ReferenceArgBuilder rab = ab as ReferenceArgBuilder;
if (rab != null) {
returnArgs.Add(index);
if (((ByRefParameter)rab.parameter).IsOutOnly) {
newArgBuilders.Add(new NullArgBuilder());
outParams++;
} else {
newArgBuilders.Add(new SimpleArgBuilder(rab.index - outParams, ((ByRefParameter)rab.parameter).MakeInParameter()));
}
} else {
SimpleArgBuilder asb = ab as SimpleArgBuilder;
if (asb != null) {
newArgBuilders.Add(new SimpleArgBuilder(asb.index - outParams, asb.parameter));
} else {
newArgBuilders.Add(ab);
}
}
index++;
}
return new MethodTarget(method, newParameters, instanceBuilder, newArgBuilders,
new ByRefReturnBuilder(CompilerHelpers.GetReturnType(method.Method), returnArgs));
}
void InitArgs(Type objType)
{
xmlWriterArg = ilg.GetArg(0);
contextArg = ilg.GetArg(2);
dataContractArg = ilg.GetArg(3);
objectLocal = ilg.DeclareLocal(objType, "objSerialized");
ArgBuilder objectArg = ilg.GetArg(1);
ilg.Load(objectArg);
// Copy the data from the DataTimeOffset object passed in to the DateTimeOffsetAdapter.
// DateTimeOffsetAdapter is used here for serialization purposes to bypass the ISerializable implementation
// on DateTimeOffset; which does not work in partial trust.
if (objType == Globals.TypeOfDateTimeOffsetAdapter)
{
ilg.ConvertValue(objectArg.ArgType, Globals.TypeOfDateTimeOffset);
ilg.Call(XmlFormatGeneratorStatics.GetDateTimeOffsetAdapterMethod);
}
else
{
ilg.ConvertValue(objectArg.ArgType, objType);
}
ilg.Stloc(objectLocal);
}
public void GetMemberValue(CodeGenerator generator, ArgBuilder targetObject, string memberName, ref LocalBuilder memberValue)
{
LocalBuilder tempLocal = generator.DeclareLocal(typeof(object), "dataColumn");
Type targetType = memberValue.LocalType;
Type originalType = ConvertorGeneratorHelper.GetOriginalType(targetType);
generator.Ldarg(targetObject);
generator.Load(memberName);
generator.Call(typeof(DataRow).GetMethod("get_Item", new Type[] { typeof(string) }));
generator.Stloc(tempLocal);
generator.Ldloc(tempLocal);
generator.LoadMember(typeof(DBNull).GetField("Value", BindingFlags.Static | BindingFlags.Public));
generator.If(Cmp.EqualTo);
generator.LoadDefaultValue(targetType);
generator.Stloc(memberValue);
generator.Else();
generator.Ldloc(tempLocal);
generator.InternalILGenerator.Emit(OpCodes.Isinst, targetType);
generator.InternalILGenerator.Emit(OpCodes.Ldnull);
generator.InternalILGenerator.Emit(OpCodes.Cgt_Un);
generator.Load(true);
generator.If(Cmp.EqualTo);
generator.Ldloc(tempLocal);
if (targetType.IsValueType)
{
generator.UnboxAny(targetType);
}
generator.Stloc(memberValue);
generator.Else();
if (targetType == typeof(Guid))
{
generator.Ldloc(tempLocal);
generator.InternalILGenerator.Emit(OpCodes.Isinst, typeof(string));
generator.InternalILGenerator.Emit(OpCodes.Ldnull);
generator.InternalILGenerator.Emit(OpCodes.Cgt_Un);
generator.Load(true);
generator.If(Cmp.EqualTo);
generator.Ldloc(tempLocal);
generator.New(typeof(Guid).GetConstructor(new Type[] { typeof(string) }));
generator.Stloc(memberValue);
}
else
{
generator.Ldloc(tempLocal);
generator.InternalILGenerator.Emit(OpCodes.Isinst, typeof(IConvertible));
generator.InternalILGenerator.Emit(OpCodes.Ldnull);
generator.InternalILGenerator.Emit(OpCodes.Cgt_Un);
generator.Load(true);
generator.If(Cmp.EqualTo);
generator.Ldloc(tempLocal);
generator.Load(originalType);
generator.Call(typeof(Convert).GetMethod("ChangeType", new Type[] { typeof(object), typeof(Type) }));
if (targetType.IsValueType)
{
generator.UnboxAny(targetType);
}
generator.Stloc(memberValue);
}
generator.Else();
generator.LoadDefaultValue(targetType);
generator.Stloc(memberValue);
generator.EndIf();
generator.EndIf();
generator.EndIf();
}
public MethodTarget(MethodTracker method, List<Parameter> parameters, ArgBuilder instanceBuilder, List<ArgBuilder> argBuilders, ReturnBuilder returnBuilder)
{
this.method = method;
this.parameters = parameters;
this.instanceBuilder = instanceBuilder;
this.argBuilders = argBuilders;
this.returnBuilder = returnBuilder;
parameters.TrimExcess();
argBuilders.TrimExcess();
}
internal JsonFormatClassWriterDelegate GenerateClassWriter(ClassDataContract classContract)
{
ilg = new CodeGenerator();
bool memberAccessFlag = classContract.RequiresMemberAccessForWrite(null);
try
{
BeginMethod(ilg, "Write" + classContract.StableName.Name + "ToJson", typeof(JsonFormatClassWriterDelegate), memberAccessFlag);
}
catch (SecurityException securityException)
{
if (memberAccessFlag && securityException.PermissionType.Equals(typeof(ReflectionPermission)))
{
classContract.RequiresMemberAccessForWrite(securityException);
}
else
{
throw;
}
}
InitArgs(classContract.UnderlyingType);
memberNamesArg = ilg.GetArg(4);
DemandSerializationFormatterPermission(classContract);
DemandMemberAccessPermission(memberAccessFlag);
if (classContract.IsReadOnlyContract)
{
ThrowIfCannotSerializeReadOnlyTypes(classContract);
}
WriteClass(classContract);
return (JsonFormatClassWriterDelegate)ilg.EndMethod();
}
private void InitArgs()
{
_xmlReaderArg = _ilg.GetArg(0);
_contextArg = _ilg.GetArg(1);
_emptyDictionaryStringArg = _ilg.GetArg(2);
_memberNamesArg = _ilg.GetArg(3);
}