本文整理汇总了C#中System.Reflection.Emit.CodeGenerator.Ldarg方法的典型用法代码示例。如果您正苦于以下问题:C# CodeGenerator.Ldarg方法的具体用法?C# CodeGenerator.Ldarg怎么用?C# CodeGenerator.Ldarg使用的例子?那么, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类System.Reflection.Emit.CodeGenerator
的用法示例。
在下文中一共展示了CodeGenerator.Ldarg方法的14个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C#代码示例。
示例1: SetMemberValue
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) }));
}
示例2: EndSetMembers
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();
}
示例3: GetMemberValue
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();
}
}
示例4: SetMemberValue
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"));
}
示例5: SetMemberValue
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();
}
示例6: GetMemberValue
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();
}
}
示例7: GetConvertHandler
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();
}
示例8: GetMemberValue
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();
}
示例9: GetMemberValue
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);
}
示例10: LoadParameters
private static void LoadParameters(CodeGenerator gen, ParameterInfo[] pis, bool isMethodStatic)
{
Check.Require(gen, "gen");
if (pis != null)
{
for (int i = 0; i < pis.Length; ++i)
{
if (isMethodStatic)
{
gen.Ldarg(0);
}
else
{
gen.Ldarg(1);
}
gen.Ldc(i);
Type srcType = pis[i].ParameterType;
string str = srcType.ToString();
if (str.EndsWith("&"))
{
srcType = CommonUtils.GetType(str.Substring(0, str.Length - 1));
}
if (str.EndsWith("&")) //ref or out param
{
if (srcType.IsValueType && (pis[i].Attributes & ParameterAttributes.Out) != ParameterAttributes.Out) //ref value param
{
gen.Ldelem(typeof(object));
gen.Unbox(srcType);
}
else
{
if (srcType.IsValueType && srcType != typeof(object)) //out value param
{
gen.LoadDefaultValue(srcType);
gen.Box(srcType);
gen.Stelem(typeof(object));
if (isMethodStatic)
{
gen.Ldarg(0);
}
else
{
gen.Ldarg(1);
}
gen.Ldc(i);
gen.Ldelem(typeof(object));
gen.Unbox(srcType);
}
else //ref or out class param
{
gen.Ldelema(typeof(object));
}
}
}
else
{
gen.Ldelem(typeof(object));
if (srcType.IsValueType)
{
gen.UnboxAny(srcType);
}
else if (srcType != typeof(object))
{
gen.Castclass(srcType);
}
}
}
}
}
示例11: DoGetStaticFieldSetDelegate
/// <summary>
/// Do Get Static Field Set Delegate
/// </summary>
/// <param name="targetModule"></param>
/// <param name="fieldInfo"></param>
/// <returns></returns>
protected static StaticDynamicMethodProxyHandler DoGetStaticFieldSetDelegate(
Module targetModule,
FieldInfo fieldInfo
)
{
Check.Require(targetModule, "targetModule");
Check.Require(fieldInfo, "fieldInfo");
Check.Require(fieldInfo.IsStatic, "fieldInfo MUST be static here.");
CodeGenerator gen = new CodeGenerator(targetModule);
gen.BeginMethod("dm" + Guid.NewGuid().ToString("N"), typeof(StaticDynamicMethodProxyHandler));
gen.Ldarg(0);
gen.Ldc(0);
gen.Ldelem(typeof(object));
if (fieldInfo.FieldType.IsValueType)
gen.UnboxAny(fieldInfo.FieldType);
gen.StoreMember(fieldInfo);
gen.Load(null);
return (StaticDynamicMethodProxyHandler)gen.EndMethod();
}
示例12: DoGetMethodDelegate
/// <summary>
/// Do GetMethodDelegate
/// </summary>
/// <param name="targetModule"></param>
/// <param name="genericMethodInfo"></param>
/// <param name="genericParameterTypes"></param>
/// <returns></returns>
protected static DynamicMethodProxyHandler DoGetMethodDelegate(
Module targetModule,
MethodInfo genericMethodInfo,
params Type[] genericParameterTypes)
{
#region Check preconditions
Check.Require(targetModule, "targetModule");
Check.Require(genericMethodInfo, "genericMethodInfo");
Check.Require((genericParameterTypes == null && genericMethodInfo.GetGenericArguments().Length == 0) ||
genericParameterTypes.Length == genericMethodInfo.GetGenericArguments().Length,
"The number of generic type parameter of genericMethodInfo and the input types must equal!");
Check.Require(!genericMethodInfo.IsStatic, "genericMethodInfo must not be static here!");
#endregion
//Create a dynamic method proxy delegate used to call the specified methodinfo
CodeGenerator gen = new CodeGenerator(targetModule);
gen.BeginMethod("dm" + Guid.NewGuid().ToString("N"), typeof(DynamicMethodProxyHandler));
MethodInfo makeGenericMethodInfo = MakeMethodGeneric(genericMethodInfo, genericParameterTypes);
gen.Ldarg(0);
LoadParameters(gen, makeGenericMethodInfo.GetParameters(), false);
gen.Call(makeGenericMethodInfo);
CastValueToObject(gen, makeGenericMethodInfo.ReturnType);
return (DynamicMethodProxyHandler)gen.EndMethod();
}
示例13: DoGetFieldGetDelegate
/// <summary>
/// Do Get Field Get Delegate
/// </summary>
/// <param name="targetModule"></param>
/// <param name="fieldInfo"></param>
/// <returns></returns>
protected static DynamicMethodProxyHandler DoGetFieldGetDelegate(
Module targetModule,
FieldInfo fieldInfo
)
{
Check.Require(targetModule, "targetModule");
Check.Require(fieldInfo, "fieldInfo");
Check.Require(!fieldInfo.IsStatic, "fieldInfo could not be static.");
CodeGenerator gen = new CodeGenerator(targetModule);
gen.BeginMethod("dm" + Guid.NewGuid().ToString("N"), typeof(DynamicMethodProxyHandler));
gen.Ldarg(0);
gen.LoadMember(fieldInfo);
CastValueToObject(gen, fieldInfo.FieldType);
return (DynamicMethodProxyHandler)gen.EndMethod();
}
示例14: SetMemberValue
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);
}
}