public BaseAccessor(TypeAccessor typeAccessor, ParameterExpression par, MemberExpression expr) : base(typeAccessor, expr.Member) { Expression ex = expr; if (ex.Type.IsEnum && ex.Type != typeof(T)) { ex = Expression.Convert(ex, typeof(T)); } Getter = Expression.Lambda <Func <object, T> >(ex, par).Compile(); var mi = expr.Member; HasSetterValue = !(mi is PropertyInfo) || ((PropertyInfo)mi).GetSetMethod(true) != null; if (HasSetterValue) { var dm = new DynamicMethod( "setter_" + mi.Name + "_" + ++_counter, typeof(void), new[] { typeof(object), typeof(T) }, typeAccessor.Type); var emit = new EmitHelper(dm.GetILGenerator()); emit .ldarg_0 .castType(typeAccessor.Type) .ldarg_1 .end(); if (mi is FieldInfo) { emit.stfld((FieldInfo)mi); } else { emit.callvirt(((PropertyInfo)mi).GetSetMethod(true)); } emit.ret(); Setter = (Action <object, T>)dm.CreateDelegate(typeof(Action <object, T>)); } }
public void AddEdge(IEdge edge) { if (dumpInfo.IsExcludedEdgeType(edge.Type)) { return; } String erName = edgeRealizer ?? GetEdgeRealizer(edge.Type); String edgeName = graph.GetElementName(edge); String srcName = graph.GetElementName(edge.Source); String tgtName = graph.GetElementName(edge.Target); ycompStream.Write("addEdge \"e" + edgeName + "\" \"n" + srcName + "\" \"n" + tgtName + "\" \"" + erName + "\" \"" + GetElemLabel(edge) + "\"\n"); foreach (AttributeType attrType in edge.Type.AttributeTypes) { if (attrType.Kind == AttributeKind.SetAttr || attrType.Kind == AttributeKind.MapAttr) { IDictionary setmap = (IDictionary)edge.GetAttribute(attrType.Name); string attrTypeString; string attrValue; EmitHelper.ToString(setmap, out attrTypeString, out attrValue, attrType, graph); ycompStream.Write("changeEdgeAttr \"e" + edgeName + "\" \"" + attrType.OwnerType.Name + "::" + attrType.Name + " : " + attrTypeString + "\" \"" + Encode(attrValue) + "\"\n"); } else if (attrType.Kind == AttributeKind.ArrayAttr) { IList array = (IList)edge.GetAttribute(attrType.Name); string attrTypeString; string attrValue; EmitHelper.ToString(array, out attrTypeString, out attrValue, attrType, graph); ycompStream.Write("changeEdgeAttr \"e" + edgeName + "\" \"" + attrType.OwnerType.Name + "::" + attrType.Name + " : " + attrTypeString + "\" \"" + Encode(attrValue) + "\"\n"); } else { object attr = edge.GetAttribute(attrType.Name); ycompStream.Write("changeEdgeAttr \"e" + edgeName + "\" \"" + attrType.OwnerType.Name + "::" + attrType.Name + " : " + GetKindName(attrType) + "\" \"" + EncodeAttr(attr) + "\"\n"); } } isDirty = true; isLayoutDirty = true; }
public void EmitGet() { if (this.ClassContext is ContextNestedClass) { FieldBuilder fieldBuilder = this.ProcContext.ClassContext.GetZCompilingType() .SearchDeclaredZField(VarName).FieldBuilder; EmitHelper.EmitThis(IL, false); EmitHelper.LoadField(IL, fieldBuilder); base.EmitConv(); } else { //Console.WriteLine(ArgSymbol.EmitIndex); EmitSymbolHelper.EmitLoad(IL, ArgSymbol); base.EmitConv(); } }
private void GeneratePropertySet(EmitHelper emit, int typeCode, MemberInfo memberInfo) { Type propertyType = null; if (memberInfo.MemberType == MemberTypes.Property) { propertyType = memberInfo.DeclaringType.GetProperty(memberInfo.Name).PropertyType; } if (memberInfo is FieldInfo) { propertyType = memberInfo.DeclaringType.GetField(memberInfo.Name).FieldType; } if (propertyType == null) { throw new ArgumentNullException(memberInfo.Name); } emit.ldloc_0.ldarg_0.ldloc_1.callvirt(typeof(AMFReader).GetMethod("ReadAMF3Data", new Type[] { typeof(byte) })).ldtoken(propertyType).call(typeof(Type).GetMethod("GetTypeFromHandle", new Type[] { typeof(RuntimeTypeHandle) })).call(typeof(TypeHelper).GetMethod("ChangeType", new Type[] { typeof(object), typeof(Type) })).CastFromObject(propertyType).GenerateSetMember(memberInfo).end(); }
private void GenerateOneToManyGetPropertyBody(MethodBuilder methodBuilder, FieldInfo fieldInfo, ConstructorInfo hashSetConstructor) { var generator = new EmitHelper(methodBuilder.GetILGenerator()); Label afterInitialization = generator.DefineLabel(); generator.ldarg_0() .ldfld(fieldInfo) .brtrue_s(afterInitialization) .ldarg_0() .newobj(hashSetConstructor) .stfld(fieldInfo) .MarkLabel(afterInitialization) .ldarg_0() .ldfld(fieldInfo) .ret(); }
public override void EmitSet(Exp valueExp) { if (this.ClassContext is ContextNestedClass) { FieldBuilder fieldBuilder = this.ProcContext.ClassContext.GetZCompilingType() .SearchDeclaredZField(VarName).FieldBuilder; EmitHelper.EmitThis(IL, false); EmitValueExp(valueExp); EmitHelper.StormField(IL, fieldBuilder); base.EmitConv(); } else { EmitValueExp(valueExp); EmitSymbolHelper.EmitStorm(IL, ArgSymbol); } }
public override void Build(BuildContext context) { if (context == null) { throw new ArgumentNullException("context"); } ParameterInfo pi = (ParameterInfo)TargetElement; if (pi.ParameterType.IsValueType == false) { EmitHelper emit = context.MethodBuilder.Emitter; Label label = emit.DefineLabel(); string message = _message != null?string.Format(_message, pi.Name) : string.Empty; emit .ldarg(pi) .brtrue_s(label) ; if (string.IsNullOrEmpty(message)) { emit .ldstr(pi.Name) .newobj(typeof(ArgumentNullException), typeof(string)) ; } else { emit .ldnull .ldstr(message) .newobj(typeof(ArgumentNullException), typeof(string), typeof(string)) ; } emit .@throw .MarkLabel(label) ; } }
bool TryGenerate(Type type, out int id) { // 0- try to resolve type var resolvedTypes = new List <Type>(); int nextId = _nextId; if (!TryResolveType(type, ref nextId, resolvedTypes)) { id = -1; return(false); } // 1- generate the actual code for the type EmitHelper.EmitSerializationCode(_emitCtx, resolvedTypes, EmitHelper.EmitDynamicSerializeStub); EmitHelper.EmitDeserializationCode(_emitCtx, resolvedTypes, EmitHelper.EmitDynamicDeserializeStub); // 2- generate delegators and add to list for (int i = 0; i < resolvedTypes.Count; i++) { var resolved = resolvedTypes[i]; var writer = _emitCtx.GetWriteStub(resolved); var serializeDelegator = EmitHelper.EmitDynamicSerializeDelegator(resolved, writer); _serializationDelegates.Add(serializeDelegator); var reader = _emitCtx.GetReadStub(resolved); var deserializeDelegator = EmitHelper.EmitDynamicDeserializeDelegator(resolved, reader); _deserializationDelegates.Add(deserializeDelegator); } if (_onTypeGenerated != null) { for (int i = 0; i < resolvedTypes.Count; i++) { _onTypeGenerated(resolvedTypes[i]); } } // 3- set ids _nextId = nextId; id = GetTypeId(type); return(true); }
private void EmitSet(TypeBuilder classBuilder, string propertyName, Type propertyType, bool isStatic, FieldBuilder field, PropertyBuilder property, MethodAttributes methodAttr) { MethodBuilder methodSet = classBuilder.DefineMethod("set_" + propertyName, methodAttr, typeof(void), new Type[] { propertyType }); ILGenerator ilSet = methodSet.GetILGenerator(); EmitHelper.EmitThis(ilSet, isStatic); if (isStatic) { ilSet.Emit(OpCodes.Ldarg_0); } else { ilSet.Emit(OpCodes.Ldarg_1); } EmitHelper.StormField(ilSet, field); ilSet.Emit(OpCodes.Ret); property.SetSetMethod(methodSet); }
private static Type CreateEntityType( EntityInfo entity, ModuleBuilder entityModule) { string cliTypeName = TypeHelper.NormalizeForCliTypeName(entity.TableName.FullName); TypeBuilder entityTypeBuilder = entityModule.DefineType(cliTypeName, TypeAttributes.Public); foreach (EntityPropertyInfo property in entity.Properties) { EmitHelper.AddProperty(entityTypeBuilder, property.Name, property.ClrType); } #if NETSTANDARD return(entityTypeBuilder.CreateTypeInfo()); #else return(entityTypeBuilder.CreateType()); #endif }
public override void EmitWrite(Type type) { // arg0: stream, arg1: value, arg2: ctx //if (value == null) //{ // WriteInt32(stream, -1); // return; //} //WriteInt32(stream, value.Length); //for(int i = 0; i < value.Length; i++) // Serialize(stream, value[i], ctx); // if (value == null) WriteInt(stream, -1); return; EmitHelper.HandleNullWrite(); // WriteInt(stream, value.Length); var writeInt = Basic.GetWriter <int>(); emit.ldarg_0() .ldarg_1() .ldlen() .call(writeInt); EmitHelper.EmitSerializeRef(); EmitHelper.EmitArrayForLoop(type, null, i => { var elementType = type.GetElementType(); var serialize = ctx.GetWriteMethod(elementType); // Serialize(stream, value[i], ctx) emit.ldarg_0() .ldarg_1() .ldloc_s(i) .ldelem(elementType) .ldarg_2() .call(serialize); }); emit.ret(); }
private void EmitSerialize(FieldInfo field, ref EmitHelper serializerEmit) { var obj = serializerEmit.DeclareLocal(typeof(object)); var propertyNullLabel = serializerEmit.DefineLabel(); var propertyNotNullLabel = serializerEmit.DefineLabel(); var objectExistsLocal = serializerEmit.DefineLabel(); var objectNotExistsLocal = serializerEmit.DefineLabel(); serializerEmit .ldarg_0 .ldfld(field) .stloc(obj) .ldloc(obj) .brtrue(propertyNotNullLabel) .ldarg_1 .ldc_i4_m1 .call(typeof(BinaryWriter).GetMethod("Write", new[] { typeof(int) })) .br(propertyNullLabel) .MarkLabel(propertyNotNullLabel) .ldarg_2 .ldloc(obj) .call(typeof(IDictionary <object, int>).GetMethod("ContainsKey", new[] { typeof(object) })) .brtrue(objectExistsLocal) .ldarg_1 .ldarg_3 .call(typeof(BinaryWriter).GetMethod("Write", new[] { typeof(int) })) .ldloc(obj) .castclass(typeof(ISerializable)) .ldarg_1 .ldarg_2 .ldarg_3 .call(typeof(ISerializable).GetMethod("Serialize")) .br(objectNotExistsLocal) .MarkLabel(objectExistsLocal) .ldarg_1 .ldarg_2 .ldloc(obj) .call(typeof(IDictionary <object, int>).GetMethod("get_Item", new[] { typeof(object) })) .call(typeof(BinaryWriter).GetMethod("Write", new[] { typeof(int) })) .MarkLabel(objectNotExistsLocal) .MarkLabel(propertyNullLabel); }
protected FieldBuilder GetArrayInitializer(Type arrayType) { string fieldName = "_array_of_$_" + arrayType.FullName; FieldBuilder field = Context.GetField(fieldName); if (field == null) { field = Context.CreatePrivateStaticField(fieldName, arrayType); EmitHelper emit = Context.TypeBuilder.TypeInitializer.Emitter; int rank = arrayType.GetArrayRank(); if (rank > 1) { Type[] parameters = new Type[rank]; for (int i = 0; i < parameters.Length; i++) { parameters[i] = typeof(int); emit.ldc_i4_0.end(); } ConstructorInfo ci = TypeHelper.GetConstructor(arrayType, parameters); emit .newobj(ci) .stsfld(field) ; } else { emit .ldc_i4_0 .newarr(arrayType.GetElementType()) .stsfld(field) ; } } return(field); }
protected virtual ReadDataInvoker CreateReadDataMethod(Type type, AMFReader reader, object instance) { bool skipVisibility = SecurityManager.IsGranted(new ReflectionPermission(ReflectionPermissionFlag.MemberAccess)); DynamicMethod method = new DynamicMethod(string.Empty, typeof(object), new Type[] { typeof(AMFReader), typeof(ClassDefinition) }, base.GetType(), skipVisibility); ILGenerator iLGenerator = method.GetILGenerator(); LocalBuilder builder = iLGenerator.DeclareLocal(type); LocalBuilder builder2 = iLGenerator.DeclareLocal(typeof(byte)); LocalBuilder builder3 = iLGenerator.DeclareLocal(typeof(string)); LocalBuilder builder4 = iLGenerator.DeclareLocal(typeof(object)); LocalBuilder builder5 = iLGenerator.DeclareLocal(typeof(int)); LocalBuilder builder6 = iLGenerator.DeclareLocal(typeof(int)); LocalBuilder builder7 = iLGenerator.DeclareLocal(typeof(object)); LocalBuilder builder8 = iLGenerator.DeclareLocal(typeof(Type)); EmitHelper emit = new EmitHelper(iLGenerator); ConstructorInfo constructorInfo = type.GetConstructor(EmitHelper.AnyVisibilityInstance, null, CallingConventions.HasThis, Type.EmptyTypes, null); MethodInfo methodInfo = typeof(AMFReader).GetMethod("AddReference"); MethodInfo info3 = typeof(AMFReader).GetMethod("ReadString"); MethodInfo info4 = typeof(AMFReader).GetMethod("ReadByte"); emit.newobj(constructorInfo).stloc_0.ldarg_0.ldloc_0.callvirt(methodInfo).ldc_i4_0.stloc_1.ldnull.stloc_2.end(); string memberName = reader.ReadString(); for (byte i = reader.ReadByte(); i != 9; i = reader.ReadByte()) { emit.ldarg_0.callvirt(info3).stloc_2.ldarg_0.callvirt(info4).stloc_1.end(); object obj2 = reader.ReadData(i); reader.SetMember(instance, memberName, obj2); MemberInfo[] member = type.GetMember(memberName); if ((member == null) || (member.Length <= 0)) { throw new MissingMemberException(type.FullName, memberName); } this.GeneratePropertySet(emit, i, member[0]); memberName = reader.ReadString(); } Label label = emit.DefineLabel(); ConstructorInfo info5 = typeof(UnexpectedAMF).GetConstructor(EmitHelper.AnyVisibilityInstance, null, CallingConventions.HasThis, Type.EmptyTypes, null); emit.ldarg_0.callvirt(info3).stloc_2.ldarg_0.callvirt(info4).stloc_1.ldloc_1.ldc_i4_s(9).ceq.brtrue_s(label).newobj(info5)[email protected](); emit.MarkLabel(label).ldloc_0.ret(); return((ReadDataInvoker)method.CreateDelegate(typeof(ReadDataInvoker))); }
private void BuildLazyInstanceEnsurer() { string fieldName = GetFieldName(); FieldBuilder field = Context.GetField(fieldName); TypeHelper fieldType = new TypeHelper(field.FieldType); TypeHelper objectType = new TypeHelper(GetObjectType()); MethodBuilderHelper ensurer = Context.TypeBuilder.DefineMethod( string.Format("$EnsureInstance{0}", fieldName), MethodAttributes.Private | MethodAttributes.HideBySig); EmitHelper emit = ensurer.Emitter; Label end = emit.DefineLabel(); emit .ldarg_0 .ldfld(field) .brtrue_s(end) ; object[] parameters = TypeHelper.GetPropertyParameters(Context.CurrentProperty); ConstructorInfo ci = objectType.GetPublicConstructor(typeof(InitContext)); if (ci != null || objectType.IsAbstract) { CreateInitContextLazyInstance(field, fieldType, objectType, emit, parameters); } else if (parameters == null) { CreateDefaultInstance(field, fieldType, objectType, emit); } else { CreateParametrizedInstance(field, fieldType, objectType, emit, parameters); } emit .MarkLabel(end) .ret() ; Context.Items.Add("$BLToolkit.FieldInstanceEnsurer." + fieldName, ensurer); }
public void AddNode(INode node) { if (dumpInfo.IsExcludedNodeType(node.Type)) { return; } String nrName = nodeRealizer ?? GetNodeRealizer(node.Type); String name = graph.GetElementName(node); ycompStream.Write("addNode \"-1\" \"n" + name + "\" \"" + nrName + "\" \"" + GetElemLabel(node) + "\"\n"); foreach (AttributeType attrType in node.Type.AttributeTypes) { if (attrType.Kind == AttributeKind.SetAttr || attrType.Kind == AttributeKind.MapAttr) { IDictionary setmap = (IDictionary)node.GetAttribute(attrType.Name); string attrTypeString; string attrValue; EmitHelper.ToString(setmap, out attrTypeString, out attrValue, attrType, graph); ycompStream.Write("changeNodeAttr \"n" + name + "\" \"" + attrType.OwnerType.Name + "::" + attrType.Name + " : " + attrTypeString + "\" \"" + Encode(attrValue) + "\"\n"); } else if (attrType.Kind == AttributeKind.ArrayAttr) { IList array = (IList)node.GetAttribute(attrType.Name); string attrTypeString; string attrValue; EmitHelper.ToString(array, out attrTypeString, out attrValue, attrType, graph); ycompStream.Write("changeNodeAttr \"n" + name + "\" \"" + attrType.OwnerType.Name + "::" + attrType.Name + " : " + attrTypeString + "\" \"" + Encode(attrValue) + "\"\n"); } else { object attr = node.GetAttribute(attrType.Name); ycompStream.Write("changeNodeAttr \"n" + name + "\" \"" + attrType.OwnerType.Name + "::" + attrType.Name + " : " + GetKindName(attrType) + "\" \"" + EncodeAttr(attr) + "\"\n"); } } isDirty = true; isLayoutDirty = true; }
public List <T> GetAllFromQuery <T>(SqlConnectionType connectionType, string query) where T : ILoadDr { var result = new List <T>(); using (SqlConnection conn = GetSqlConnection(connectionType)) { using (SqlDataReader dr = SqlHelper.ExecuteReader(conn, query, CommandType.Text, null)) { while (dr.Read()) { var model = (T)EmitHelper.GetInstanceCreator(typeof(T)).Invoke(); model.LoadData(dr); result.Add(model); } } } return(result); }
protected FieldBuilder GetTypeAccessorField() { string fieldName = "_" + GetObjectType().FullName + "_$typeAccessor"; FieldBuilder field = Context.GetField(fieldName); if (field == null) { field = Context.CreatePrivateStaticField(fieldName, typeof(TypeAccessor)); EmitHelper emit = Context.TypeBuilder.TypeInitializer.Emitter; emit .LoadType(GetObjectType()) .call(typeof(TypeAccessor), "GetAccessor", typeof(Type)) .stsfld(field) ; } return(field); }
private void CallBaseMethod() { EmitHelper emit = Context.MethodBuilder.Emitter; MethodInfo method = Context.MethodBuilder.OverriddenMethod; ParameterInfo[] ps = method.GetParameters(); emit.ldarg_0.end(); for (int i = 0; i < ps.Length; i++) { emit.ldarg(i + 1); } emit.call(method); if (Context.ReturnValue != null) { emit.stloc(Context.ReturnValue); } }
/// <summary> /// 设置返回值信息。 /// </summary> /// <param name="emitter"></param> /// <param name="returnType"></param> /// <param name="lbRetValNotNull"></param> /// <returns></returns> private static EmitHelper GetReturnValue(this EmitHelper emitter, Type returnType, Label lbRetValNotNull) { return(emitter .ldloc(STACK_CALLINFO_INDEX) .callvirt(InterceptCache.CallInfoGetReturnValue) .Assert(returnType.IsValueType, e1 => e1.brtrue_s(lbRetValNotNull) .ldtoken(returnType) .call(InterceptCache.TypeGetTypeFromHandle) .call(InterceptCache.MethodGetDefaultValue) .Assert(returnType.IsValueType, e => e.unbox_any(returnType)) .ret() .MarkLabel(lbRetValNotNull) .ldloc(STACK_CALLINFO_INDEX) .callvirt(InterceptCache.CallInfoGetReturnValue) .Assert(returnType.IsValueType, e => e.unbox_any(returnType)) .ret(), e1 => e1.ret() )); }
public override void Emit( ) { if (OpToken.Kind == TokenKindSymbol.ADD) { RightExp.Emit(); } else { if (ZTypeUtil.IsFloat(RetType))//(RetType.SharpType == typeof(float)) { IL.Emit(OpCodes.Ldc_R4, 0.0); } else if (ZTypeUtil.IsInt(RetType))//if (RetType.SharpType == typeof(int)) { EmitHelper.LoadInt(IL, 0); } RightExp.Emit(); IL.Emit(OpCodes.Sub); } base.EmitConv(); }
public override void Emit() { var zlistType = TypeExp.RetType.SharpType; var Constructor = zlistType.GetConstructor(new Type[] {});// ConstructorDesc.Constructor; LocalBuilder varLocal = IL.DeclareLocal(zlistType); EmitHelper.NewObj(IL, Constructor); IL.Emit(OpCodes.Stloc, varLocal); MethodInfo addMethod = zlistType.GetMethod(CompileConstant.ZListAddMethodName);//"Add"); ZMethodInfo exAddMethodInfo = new ZMethodInfo(addMethod); foreach (var exp in ArgExp.InneExps) { EmitHelper.LoadVar(IL, varLocal);//il.Emit(OpCodes.Ldloc, varLocal); exp.Emit(); EmitHelper.CallDynamic(IL, exAddMethodInfo.SharpMethod); } EmitHelper.LoadVar(IL, varLocal);//il.Emit(OpCodes.Ldloc, varLocal); base.EmitConv(); }
protected FieldBuilder GetParameterField() { string fieldName = GetFieldName() + "_$parameters"; FieldBuilder field = Context.GetField(fieldName); if (field == null) { field = Context.CreatePrivateStaticField(fieldName, typeof(object[])); FieldBuilder piField = GetPropertyInfoField(); EmitHelper emit = Context.TypeBuilder.TypeInitializer.Emitter; emit .ldsfld(piField) .call(typeof(TypeHelper).GetMethod("GetPropertyParameters")) .stsfld(field) ; } return(field); }
private void EndEmitMethod() { EmitHelper emit = _context.MethodBuilder.Emitter; // Prepare return. // emit.MarkLabel(_context.ReturnLabel); if (_context.ReturnValue != null) { emit.ldloc(_context.ReturnValue); } emit.ret(); // Cleanup the context. // _context.ReturnValue = null; _context.CurrentMethod = null; _context.MethodBuilder = null; }
void generateEveryOne(EmitExpContext context) { ILGenerator il = context.ILout; var True_Label = il.DefineLabel(); var False_Label = il.DefineLabel(); generateList(context, everyoneExp); generateCount(context); genInitIndex(context); generateCondition(context); il.Emit(OpCodes.Brfalse, False_Label); //定义一个标签,表示从下面开始进入循环体 il.MarkLabel(True_Label); genBody(context); EmitHelper.Inc(il, indexSymbol.VarBuilder); generateCondition(context); il.Emit(OpCodes.Brtrue, True_Label); il.MarkLabel(False_Label); }
private void HighlightDictionary(IDictionary value, string name, bool addAnnotation) { Type keyType; Type valueType; ContainerHelper.GetDictionaryTypes(value.GetType(), out keyType, out valueType); if (valueType == typeof(SetValueType)) { foreach (DictionaryEntry entry in value) { if (entry.Key is IGraphElement) { HighlightSingleValue(entry.Key, name, addAnnotation); } } } else { int cnt = 0; foreach (DictionaryEntry entry in value) { if (entry.Key is INode && entry.Value is INode) { HighlightMapping((INode)entry.Key, (INode)entry.Value, name, cnt, addAnnotation); ++cnt; } else { if (entry.Key is IGraphElement) { HighlightSingleValue(entry.Key, name + ".Domain -> " + EmitHelper.ToString(entry.Value, shellProcEnv.ProcEnv.NamedGraph), addAnnotation); } if (entry.Value is IGraphElement) { HighlightSingleValue(entry.Value, EmitHelper.ToString(entry.Key, shellProcEnv.ProcEnv.NamedGraph) + " -> " + name + ".Range", addAnnotation); } } } } }
protected override void BuildAbstractMethod() { EmitHelper emit = Context.MethodBuilder.Emitter; List <ParameterInfo> parameters = new List <ParameterInfo>(); ParameterInfo callback = null; ParameterInfo exceptionHandler = null; foreach (ParameterInfo p in Context.CurrentMethod.GetParameters()) { Type parameterType = p.ParameterType; string paramTypeName = parameterType.Name.Split('`')[0]; if (paramTypeName == "Action") { if (parameterType.IsGenericType && parameterType.GetGenericArguments()[0] == typeof(Exception)) { exceptionHandler = p; } else { callback = p; } } else { parameters.Add(p); } } EmitMethodName(emit); if (callback == null) { EmitSyncCall(parameters, emit); } else { EmitAsyncCall(parameters, emit, callback, exceptionHandler); } }
public override void Emit() { Type toType = ZTypeUtil.GetTypeOrBuilder(TypeExp.RetType); Type argType = ZTypeUtil.GetTypeOrBuilder(ArgExp.RetType); if (toType == typeof(int)) { if (argType == typeof(int)) { ArgExp.Emit(); return; } else if (argType == typeof(float)) { ArgExp.Emit(); IL.Emit(OpCodes.Conv_I); return; } } else if (toType == typeof(float)) { if (argType == typeof(int)) { ArgExp.Emit(); IL.Emit(OpCodes.Conv_R4); return; } else if (argType == typeof(float)) { ArgExp.Emit(); return; } } caseMethod = MakeCastMethod(TypeExp.RetType); ArgExp.RequireType = ZLangBasicTypes.ZOBJECT; ArgExp.Emit(); EmitHelper.CallDynamic(IL, caseMethod); base.EmitConv(); }
/// <summary> /// DataTable转List /// </summary> /// <typeparam name="T">转换类型</typeparam> /// <param name="dt">数据源</param> /// <returns></returns> public static List <T> EmitToList <T>(this DataTable dt) { //确认参数有效 if (dt == null) { return(null); } List <T> list = new List <T>(); var objBuilder = EmitHelper.CreateBuilder(typeof(T)); for (int i = 0; i < dt.Rows.Count; i++) { //创建泛型对象 T _t = (T)objBuilder(); //获取对象所有属性 PropertyInfo[] propertyInfo = _t.GetType().GetProperties(); for (int j = 0; j < dt.Columns.Count; j++) { foreach (PropertyInfo info in propertyInfo) { //属性名称和列名相同时赋值 if (dt.Columns[j].ColumnName.ToUpper().Equals(info.Name.ToUpper())) { if (dt.Rows[i][j] != DBNull.Value) { info.SetValue(_t, dt.Rows[i][j], null); } else { info.SetValue(_t, null, null); } break; } } } list.Add(_t); } return(list); }
public override void Emit() { lambdaExp.Emit(); LocalBuilder lanmbdaLocalBuilder = IL.DeclareLocal(lambdaExp.NestedClassContext.EmitContext.ClassBuilder); IL.Emit(OpCodes.Newobj, lambdaExp.NewBuilder); EmitHelper.StormVar(IL, lanmbdaLocalBuilder); int i = 0; if (this.ExpContext.ClassContext.IsStaticClass == false) { SymbolDefField fieldSymbol = lambdaExp.FieldSymbols[0]; EmitHelper.LoadVar(IL, lanmbdaLocalBuilder); EmitHelper.EmitThis(IL, false); IL.Emit(OpCodes.Stfld, fieldSymbol.Field); i++; } for (; i < this.BodySymbolVars.Count; i++) { SymbolBase thisSymbol = this.BodySymbolVars[i]; SymbolDefField fieldSymbol = lambdaExp.FieldSymbols[i]; EmitHelper.LoadVar(IL, lanmbdaLocalBuilder); //SymbolInfo inMethodSymbol = symbols.Get(field); //EmitHelper.EmitSymbolGet(IL, thisSymbol); if (EmitSymbolHelper.NeedCallThis(thisSymbol)) { EmitHelper.Emit_LoadThis(IL); } EmitSymbolHelper.EmitLoad(IL, thisSymbol); IL.Emit(OpCodes.Stfld, fieldSymbol.Field); } EmitHelper.LoadVar(IL, lanmbdaLocalBuilder); IL.Emit(OpCodes.Ldftn, lambdaExp.ProcBuilder);//.EmitContext.CurrentMethodBuilder); ConstructorInfo[] constructorInfos = lambdaExp.FnRetType.SharpType.GetConstructors(); IL.Emit(OpCodes.Newobj, constructorInfos[0]); base.EmitConv(); }
public static Type Create(Type targetType, JSBindingOptions options, NamingConvention namingConvention) { Initialize(); // create the type TypeBuilder type = module.DefineType( string.Format("{0}.{1}Proxy", namespaceName, targetType.FullName), TypeAttributes.Public | TypeAttributes.Sealed, typeof(JSObjectBase), new Type[] { targetType } ); // TODO: properties // create members foreach (var method in targetType.GetMethods()) { // explicit interface implementation MethodBuilder mb = type.DefineMethod( targetType.Name + "." + method.Name, MethodAttributes.Private | MethodAttributes.HideBySig | MethodAttributes.NewSlot | MethodAttributes.Virtual | MethodAttributes.Final, method.ReturnType, method.GetParameters().Select(_ => _.ParameterType).ToArray() ); type.DefineMethodOverride(mb, method); var emit = new EmitHelper(mb.GetILGenerator()); emit.LdArg(1) .Ret() ; } return type.CreateType(); }
private LocalBuilder GetInitContextBuilder( string initContextName, EmitHelper emit) { var initField = Context.GetItem<LocalBuilder>(initContextName); if (initField == null) { Context.Items.Add(initContextName, initField = emit.DeclareLocal(InitContextType)); emit .newobj (InitContextType.GetPublicDefaultConstructor()) .dup .ldarg_0 .callvirt (InitContextType.GetProperty("Parent").GetSetMethod()) .dup .ldc_i4_1 .callvirt (InitContextType.GetProperty("IsInternal").GetSetMethod()) .stloc (initField) ; Context.Items.Add("$BLToolkit.Default.DirtyParameters", false); } return initField; }
private static void EmitInvoker(EmitHelper emit, MethodInfo method, int? argc, bool setter) { var parameters = method.GetParameters(); var methodArgC = parameters.Length; if (!argc.HasValue) { EmitThrowIfArgumentCountMismatch(emit, methodArgC); argc = methodArgC; } emit.LdArg(retvalArgIndex); // instance method if (!method.IsStatic) { emit.LdArg(objArgIndex); } // prepare arguments for (var i = 0; i < parameters.Length; i++) { var parameter = parameters[i]; if (i < argc.Value) { var changeTypeMethod = CefConvert.GetChangeTypeMethod(typeof(cef_v8value_t*), parameter.ParameterType); EmitLdV8Argument(emit, i); emit.Call(changeTypeMethod); } else { // push default arg if (!parameter.IsOptional) throw new JSBindingException("MethodInvoker compilation error."); EmitLdRawDefaultValue(emit, parameter.RawDefaultValue); } } // call target method if (method.IsStatic) { emit.Call(method); } else { emit.CallVirt(method); } if (method.ReturnType == typeof(void)) { // If method is setter, then it can be called with retval == null from V8Accessor. if (setter) { var returnValueLabel = emit.DefineLabel(); emit.Dup() .BrTrueS(returnValueLabel) .Pop() .Ret() .MarkLabel(returnValueLabel); ; } if (ForceVoidToUndefined) { emit.Call(createUndefinedNativeV8ValueMethod); } else { emit.LdNull(); } } else { // convert return value var retValchangeTypeMethod = CefConvert.GetChangeTypeMethod(method.ReturnType, typeof(cef_v8value_t*)); emit.Call(retValchangeTypeMethod); } // store result at retval emit.StIndI(); // return emit.Ret(); }
private void BuildHolderInstance(EmitHelper emit) { var fieldName = GetFieldName(); var field = Context.GetField(fieldName); var fieldType = new TypeHelper(field.FieldType); var objectType = new TypeHelper(GetObjectType()); var ci = fieldType.GetPublicDefaultConstructor(); if (ci != null) { emit .ldarg_0 .newobj (ci) .stfld (field) ; } else { if (!CheckObjectHolderCtor(fieldType, objectType)) return; emit .ldarg_0 .ldnull .newobj (fieldType, objectType) .stfld (field) ; } }
private void CreateDefaultInstance( FieldBuilder field, TypeHelper fieldType, TypeHelper objectType, EmitHelper emit) { if (!CheckObjectHolderCtor(fieldType, objectType)) return; if (objectType.Type == typeof(string)) { emit .ldarg_0 .LoadInitValue (objectType) ; } else if (objectType.IsArray) { var initializer = GetArrayInitializer(objectType); emit .ldarg_0 .ldsfld (initializer) ; } else { var ci = objectType.GetPublicDefaultConstructor(); if (ci == null) { if (objectType.Type.IsValueType) return; var message = string.Format( Resources.TypeBuilder_PropertyTypeHasNoPublicDefaultCtor, Context.CurrentProperty.Name, Context.Type.FullName, objectType.FullName); emit .ldstr (message) .newobj (typeof(TypeBuilderException), typeof(string)) .@throw .end() ; return; } emit .ldarg_0 .newobj (ci) ; } if (IsObjectHolder) { emit .newobj (fieldType, objectType) ; } emit .stfld (field) ; }
private static void EmitLdRawDefaultValue(EmitHelper emit, object value) { if (value == null) { emit.LdNull(); } else { switch (Type.GetTypeCode(value.GetType())) { case TypeCode.Empty: emit.LdNull(); break; // case TypeCode.Object: // case TypeCode.DBNull: case TypeCode.Boolean: emit.LdConstI4(((bool)value) ? 1 : 0); break; case TypeCode.Char: emit.LdConstI4((int)(char)value); break; case TypeCode.SByte: emit.LdConstI4((int)(sbyte)value); break; case TypeCode.Byte: emit.LdConstI4((int)(byte)value); break; case TypeCode.Int16: emit.LdConstI4((int)(short)value); break; case TypeCode.UInt16: emit.LdConstI4((int)(ushort)value); break; case TypeCode.Int32: emit.LdConstI4((int)value); break; // TODO: support types for opt args // case TypeCode.UInt32: // case TypeCode.Int64: // case TypeCode.UInt64: // case TypeCode.Single: // case TypeCode.Double: // case TypeCode.Decimal: // case TypeCode.DateTime: case TypeCode.String: emit.LdStr((string)value); break; default: throw new JSBindingException(string.Format("Type '{0}' for default values is not supported.", value.GetType().FullName)); } } }
private static void EmitLdV8Argument(EmitHelper emit, int index) { if (index < 0) throw new ArgumentException("index"); emit.LdArg(argumentsArgIndex); if (index > 0) { emit.LdConstI4(index * IntPtr.Size) .Add(); } emit.LdIndI(); }
private static void EmitThrowIfArgumentCountMismatch(EmitHelper emit, int expectedArgumentCount) { var doneLabel = emit.DefineLabel(); emit.LdArg(argumentsCountArgIndex) .LdConstI4(expectedArgumentCount) .BeqS(doneLabel) .Call(throwArgumentCountMismatchMethod) .MarkLabel(doneLabel) ; }
private void CreateInitContextDefaultInstance( string initContextName, FieldBuilder field, TypeHelper fieldType, TypeHelper objectType, EmitHelper emit, object[] parameters) { if (!CheckObjectHolderCtor(fieldType, objectType)) return; var initField = GetInitContextBuilder(initContextName, emit); var memberParams = InitContextType.GetProperty("MemberParameters").GetSetMethod(); if (parameters != null) { emit .ldloc (initField) .ldsfld (GetParameterField()) .callvirt (memberParams) ; } else if ((bool)Context.Items["$BLToolkit.Default.DirtyParameters"]) { emit .ldloc (initField) .ldnull .callvirt (memberParams) ; } Context.Items["$BLToolkit.Default.DirtyParameters"] = parameters != null; if (objectType.IsAbstract) { emit .ldarg_0 .ldsfld (GetTypeAccessorField()) .ldloc (initField) .callvirtNoGenerics (typeof(TypeAccessor), "CreateInstanceEx", _initContextType) .isinst (objectType) ; } else { emit .ldarg_0 .ldloc (initField) .newobj (objectType.GetPublicConstructor(typeof(InitContext))) ; } if (IsObjectHolder) { emit .newobj (fieldType, objectType) ; } emit .stfld (field) ; }
private void CreateAbstractInitContextInstance( FieldBuilder field, TypeHelper fieldType, TypeHelper objectType, EmitHelper emit, object[] parameters) { if (!CheckObjectHolderCtor(fieldType, objectType)) return; var memberParams = InitContextType.GetProperty("MemberParameters").GetSetMethod(); var parentField = Context.GetItem<LocalBuilder>("$BLToolkit.InitContext.Parent"); if (parentField == null) { Context.Items.Add("$BLToolkit.InitContext.Parent", parentField = emit.DeclareLocal(typeof(object))); var label = emit.DefineLabel(); emit .ldarg_1 .brtrue_s (label) .newobj (InitContextType.GetPublicDefaultConstructor()) .starg (1) .ldarg_1 .ldc_i4_1 .callvirt (InitContextType.GetProperty("IsInternal").GetSetMethod()) .MarkLabel (label) .ldarg_1 .callvirt (InitContextType.GetProperty("Parent").GetGetMethod()) .stloc (parentField) ; } emit .ldarg_1 .ldarg_0 .callvirt (InitContextType.GetProperty("Parent").GetSetMethod()) ; var isDirty = Context.GetItem<bool?>("$BLToolkit.InitContext.DirtyParameters"); if (parameters != null) { emit .ldarg_1 .ldsfld (GetParameterField()) .callvirt (memberParams) ; } else if (isDirty != null && (bool)isDirty) { emit .ldarg_1 .ldnull .callvirt (memberParams) ; } if (Context.Items.ContainsKey("$BLToolkit.InitContext.DirtyParameters")) Context.Items["$BLToolkit.InitContext.DirtyParameters"] = (bool?)(parameters != null); else Context.Items.Add("$BLToolkit.InitContext.DirtyParameters", (bool?)(parameters != null)); if (objectType.IsAbstract) { emit .ldarg_0 .ldsfld (GetTypeAccessorField()) .ldarg_1 .callvirtNoGenerics (typeof(TypeAccessor), "CreateInstanceEx", _initContextType) .isinst (objectType) ; } else { emit .ldarg_0 .ldarg_1 .newobj (objectType.GetPublicConstructor(typeof(InitContext))) ; } if (IsObjectHolder) { emit .newobj (fieldType, objectType) ; } emit .stfld (field) ; }
private void CreateParametrizedInstance( FieldBuilder field, TypeHelper fieldType, TypeHelper objectType, EmitHelper emit, object[] parameters) { if (!CheckObjectHolderCtor(fieldType, objectType)) return; Stack<ConstructorInfo> genericNestedConstructors; if (parameters.Length == 1) { var o = parameters[0]; if (o == null) { if (objectType.IsValueType == false) emit .ldarg_0 .ldnull .end() ; if (IsObjectHolder) { emit .newobj (fieldType, objectType) ; } else { if (objectType.Type.IsGenericType) { Type nullableType = null; genericNestedConstructors = GetGenericNestedConstructors( objectType, typeHelper => typeHelper.IsValueType == false || (typeHelper.Type.IsGenericType && typeHelper.Type.GetGenericTypeDefinition() == typeof (Nullable<>)), typeHelper => { nullableType = typeHelper.Type; }, () => nullableType != null); if (nullableType == null) throw new Exception("Cannot find nullable type in generic types chain"); if (nullableType.IsValueType == false) { emit .ldarg_0 .ldnull .end() ; } else { var nullable = emit.DeclareLocal(nullableType); emit .ldloca(nullable) .initobj(nullableType) .ldarg_0 .ldloc(nullable) ; if (genericNestedConstructors != null) { while (genericNestedConstructors.Count != 0) { emit .newobj(genericNestedConstructors.Pop()) ; } } } } } emit .stfld (field) ; return; } if (objectType.Type == o.GetType()) { if (objectType.Type == typeof(string)) { emit .ldarg_0 .ldstr ((string)o) .stfld (field) ; return; } if (objectType.IsValueType) { emit.ldarg_0.end(); if (emit.LoadWellKnownValue(o) == false) { emit .ldsfld (GetParameterField()) .ldc_i4_0 .ldelem_ref .end() ; } emit.stfld(field); return; } } } var types = new Type[parameters.Length]; for (var i = 0; i < parameters.Length; i++) { if (parameters[i] != null) { var t = parameters[i].GetType(); types[i] = (t.IsEnum) ? Enum.GetUnderlyingType(t) : t; } else types[i] = typeof(object); } // Do some heuristics for Nullable<DateTime> and EditableValue<Decimal> // ConstructorInfo objectCtor = null; genericNestedConstructors = GetGenericNestedConstructors( objectType, typeHelper => true, typeHelper => { objectCtor = typeHelper.GetPublicConstructor(types); }, () => objectCtor != null); if (objectCtor == null) { if (objectType.IsValueType) return; throw new TypeBuilderException( string.Format(types.Length == 0? Resources.TypeBuilder_PropertyTypeHasNoPublicDefaultCtor: Resources.TypeBuilder_PropertyTypeHasNoPublicCtor, Context.CurrentProperty.Name, Context.Type.FullName, objectType.FullName)); } var pi = objectCtor.GetParameters(); emit.ldarg_0.end(); for (var i = 0; i < parameters.Length; i++) { var o = parameters[i]; var oType = o.GetType(); if (emit.LoadWellKnownValue(o)) { if (oType.IsValueType) { if (!pi[i].ParameterType.IsValueType) emit.box(oType); else if (Type.GetTypeCode(oType) != Type.GetTypeCode(pi[i].ParameterType)) emit.conv(pi[i].ParameterType); } } else { emit .ldsfld (GetParameterField()) .ldc_i4 (i) .ldelem_ref .CastFromObject (types[i]) ; if (oType.IsValueType && !pi[i].ParameterType.IsValueType) emit.box(oType); } } emit .newobj (objectCtor) ; if (genericNestedConstructors != null) { while (genericNestedConstructors.Count != 0) { emit .newobj(genericNestedConstructors.Pop()) ; } } if (IsObjectHolder) { emit .newobj (fieldType, objectType) ; } emit .stfld (field) ; }
private void CreateInitContextLazyInstance( FieldBuilder field, TypeHelper fieldType, TypeHelper objectType, EmitHelper emit, object[] parameters) { if (!CheckObjectHolderCtor(fieldType, objectType)) return; var initField = emit.DeclareLocal(InitContextType); emit .newobj (InitContextType.GetPublicDefaultConstructor()) .dup .ldarg_0 .callvirt (InitContextType.GetProperty("Parent").GetSetMethod()) .dup .ldc_i4_1 .callvirt (InitContextType.GetProperty("IsInternal").GetSetMethod()) .dup .ldc_i4_1 .callvirt (InitContextType.GetProperty("IsLazyInstance").GetSetMethod()) ; if (parameters != null) { emit .dup .ldsfld (GetParameterField()) .callvirt (InitContextType.GetProperty("MemberParameters").GetSetMethod()) ; } emit .stloc (initField); if (objectType.IsAbstract) { emit .ldarg_0 .ldsfld (GetTypeAccessorField()) .ldloc (initField) .callvirtNoGenerics (typeof(TypeAccessor), "CreateInstanceEx", _initContextType) .isinst (objectType) ; } else { emit .ldarg_0 .ldloc (initField) .newobj (objectType.GetPublicConstructor(typeof(InitContext))) ; } if (IsObjectHolder) { emit .newobj (fieldType, objectType) ; } emit .stfld (field) ; }