protected async Task DeregisterMethod <TParam, TResult>(MethodProvider <TParam, TResult> method) { await CallControlMethod <Deregister, Empty>("method.deregister", new Deregister() { EndPoint = method.Endpoint.ToString() }); }
/// <summary>Any types derived from a type with a custom initializer must itself have a custom initialzier.</summary> public static void CheckForDerivedCustomInitializers(MethodProvider initializerMethods, HashSet <Type> referenceTypes, StreamWriter errors) { foreach (var type in referenceTypes) { Debug.Assert(!type.IsValueType); Debug.Assert(!type.IsInterface); if (initializerMethods.GetMethodForType(type) != null) { continue; // Type has a custom initializer } var baseType = type.BaseType; while (baseType != null && baseType != typeof(object)) { if (initializerMethods.GetMethodForType(baseType) != null) { errors.WriteLine("ERROR: Type " + type + " is drived from type " + baseType + " with a custom initializer!"); errors.WriteLine(" Add a [CustomInitializer] for " + type); errors.WriteLine(); goto nextType; } baseType = baseType.BaseType; // <- walk up inheritance hierarchy } nextType :; } }
public ILGenContext(Direction direction, MethodProvider fieldSerializeMethods, MethodProvider referenceTypeSerializeMethods) { this.direction = direction; fieldSerializationMethods = fieldSerializeMethods; referenceTypeSerializationMethods = referenceTypeSerializeMethods; }
private static Expression CreateAnyAllExpression( Expression left, Expression right, ParameterExpression sourceParameter, IEnumerable <ParameterExpression> lambdaParameters, MethodInfo anyAllMethod) { var genericFunc = typeof(Func <,>) .MakeGenericType( MethodProvider.GetIEnumerableImpl(left.Type).GetGenericArguments()[0], typeof(bool)); var filteredParameters = new ParameterVisitor() .GetParameters(right) .Where(p => p.Name != sourceParameter.Name) .ToArray(); if (!filteredParameters.Any()) { filteredParameters = lambdaParameters.ToArray(); } return(Expression.Call( anyAllMethod, left, Expression.Lambda(genericFunc, right, filteredParameters))); }
public void TestInitialize() { ExpressionEqualityComparer = new ExpressionEqualityComparer(); var methods = typeof(SqlFunctions).GetMethods().Where(x => x.Name == "StringConvert").ToArray(); MethodProvider.UserFunctions.Clear(); MethodProvider.RegisterFunction("StringConvert", methods); }
public ActionResult IndexAll([Bind(Include = "yacimiento,campo, yacimientos,campos,procesados,metodo")] PozosView datamodel, int page = 0, int checkpozoid = 0, int metodo = 0, int?flow = 0) { int pageindex = page; var pagesize = 12; if (flow == 5) { if (datamodel.metodo == 1) { return(RedirectToAction("SorGraph2", "Pozos", datamodel)); } else { return(RedirectToAction("SorGraph", "Pozos", datamodel)); } } datamodel.procesados = true; var campos_Qry = db.cat_campo.ToList().OrderBy(o => o.campo); datamodel.campos = new SelectList(campos_Qry, "id_campo", "campo", datamodel.campo); if (datamodel.campo == 0) { datamodel.campo = campos_Qry.FirstOrDefault().id_campo; } if (datamodel.yacimiento == 0) { datamodel.yacimiento = db.cat_yacimiento.Where(y => y.id_campo == datamodel.campo).FirstOrDefault().id_yacimiento; } var yacimientos_Qry = db.cat_yacimiento.Where(w => w.id_campo == datamodel.campo).ToList().OrderBy(o => o.yacimiento); if (yacimientos_Qry.Where(y => y.id_yacimiento == datamodel.yacimiento).Count() == 0) { datamodel.yacimiento = yacimientos_Qry.FirstOrDefault().id_yacimiento; } datamodel.yacimientos = new SelectList(yacimientos_Qry, "id_yacimiento", "yacimiento", datamodel.yacimiento); var detalles = new List <PozosViewDetail>(); Services.Set(MethodProvider.Get(datamodel.metodo)); detalles = GetDetalles(datamodel.campo, datamodel.yacimiento, datamodel.procesados).ToList(); if (pageindex == 0) { pageindex = 1; } if ((datamodel.yacimiento != (int?)Session["yacimiento"]) || (datamodel.procesados != (bool?)Session["procesado"])) { pageindex = 1; } datamodel.Preguntas = Preguntas.Where(w => w.Metodo == metodo).ToList(); datamodel.Detalle = detalles.ToPagedList(pageindex, pagesize); ViewBag.SubTitle = "Inferencia del Método"; return(View(datamodel)); }
private Expression GetAnyAllFunctionExpression <T>(string filter, ParameterExpression sourceParameter, ICollection <ParameterExpression> lambdaParameters, IFormatProvider formatProvider) { if (filter == null) { throw new ArgumentNullException("filter"); } if (sourceParameter == null) { throw new ArgumentNullException("sourceParameter"); } if (lambdaParameters == null) { throw new ArgumentNullException("lambdaParameters"); } var functionTokens = filter.GetAnyAllFunctionTokens(); if (functionTokens == null) { return(null); } var propertyExpression = GetPropertyExpression <T>(functionTokens.Left, sourceParameter, lambdaParameters); var leftType = propertyExpression.Type; var left = CreateExpression <T>( functionTokens.Left, sourceParameter, lambdaParameters, leftType, formatProvider); // Create a new ParameterExpression from the lambda parameter and add to a collection to pass around var parameterName = functionTokens.Right.Substring(0, functionTokens.Right.IndexOf(":", System.StringComparison.Ordinal)).Trim(); var lambdaParameter = Expression.Parameter(MethodProvider.GetIEnumerableImpl(leftType).GetGenericArguments()[0], parameterName); lambdaParameters.Add(lambdaParameter); var lambdaFilter = functionTokens.Right.Substring(functionTokens.Right.IndexOf(":", System.StringComparison.Ordinal) + 1).Trim(); var lambdaType = GetFunctionParameterType(functionTokens.Operation) ?? left.Type; var isLambdaAnyAllFunction = lambdaFilter.GetAnyAllFunctionTokens() != null; var right = isLambdaAnyAllFunction ? GetAnyAllFunctionExpression <T>(lambdaFilter, lambdaParameter, lambdaParameters, formatProvider) : CreateExpression <T>(lambdaFilter, sourceParameter, lambdaParameters, lambdaType, formatProvider); return(left == null ? null : GetFunction(functionTokens.Operation, left, right, sourceParameter, lambdaParameters)); }
public override Expression Output(OneToManyQueryDetailWalkInfo walkInfo) { var expression = BuildWhereExpression(walkInfo); expression = BuildOrderExpression(expression, walkInfo); expression = BuildSelectExpression(expression, walkInfo); var toListMethod = MethodProvider.MakeGenericMethod(typeof(Enumerable), "ToList", new Type[] { typeof(IEnumerable <>) }, new Type[] { walkInfo.Type }); return(Expression.Call(toListMethod, expression)); }
private Expression BuildSelectExpression(Expression expression, OneToManyQueryDetailWalkInfo walkInfo) { var memberInitializationExpression = Expression.Lambda( typeof(Func <,>).MakeGenericType(walkInfo.Type, walkInfo.Type), BuildMemberInitExpression(), walkInfo.Member as ParameterExpression); var selectMethod = MethodProvider.MakeGenericMethod(typeof(Enumerable), "Select", new Type[] { typeof(IEnumerable <>), typeof(Func <,>) }, new Type[] { walkInfo.Type, walkInfo.Type }); return(Expression.Call( selectMethod, expression ?? walkInfo.DetailMember, memberInitializationExpression)); }
public SerializationMethodProviders( MethodProvider valueTypeSerializeMethods, MethodProvider valueTypeDeserializeMethods, MethodProvider referenceTypeSerializeMethods, MethodProvider referenceTypeDeserializeMethods, MethodProvider referenceFieldSerializeMethods, MethodProvider referenceFieldDeserializeMethods, MethodProvider referenceTypeInitializeMethods) { ValueTypeSerializeMethods = valueTypeSerializeMethods; ValueTypeDeserializeMethods = valueTypeDeserializeMethods; ReferenceTypeSerializeMethods = referenceTypeSerializeMethods; ReferenceTypeDeserializeMethods = referenceTypeDeserializeMethods; ReferenceFieldSerializeMethods = referenceFieldSerializeMethods; ReferenceFieldDeserializeMethods = referenceFieldDeserializeMethods; ReferenceTypeInitializeMethods = referenceTypeInitializeMethods; }
private Expression BuildWhereExpression(OneToManyQueryDetailWalkInfo walkInfo) { var filterExpression = BuildFilterExpression(walkInfo); if (filterExpression != null) { var whereMethod = MethodProvider.MakeGenericMethod(typeof(Enumerable), "Where", new Type[] { typeof(IEnumerable <>), typeof(Func <,>) }, new Type[] { walkInfo.Type }); return(Expression.Call( whereMethod, walkInfo.DetailMember, filterExpression)); } return(null); }
private void updateRecord(int?metodo, ResultadoCuestionario newrecord, action actionUpd) { decimal sor = MethodProvider.Get(metodo.Value).getSor(newrecord.IdPozo); newrecord.GetType().GetProperty("sor" + (metodo).ToString()).SetValue(newrecord, sor); if (actionUpd == action.Add) { newrecord.included = true; db.ResultadoCuestionarios.Add(newrecord); } if (actionUpd == action.Update) { db.ResultadoCuestionarios.Attach(newrecord); db.Entry(newrecord).State = System.Data.Entity.EntityState.Modified; } db.SaveChanges(); }
private Expression GetAnyAllFunctionExpression <T>(string filter, ParameterExpression sourceParameter, ICollection <ParameterExpression> lambdaParameters, IFormatProvider formatProvider) { CustomContract.Requires(filter != null); CustomContract.Requires(sourceParameter != null); CustomContract.Requires(lambdaParameters != null); var functionTokens = filter.GetAnyAllFunctionTokens(); if (functionTokens == null) { return(null); } var propertyExpression = GetPropertyExpression <T>(functionTokens.Left, sourceParameter, lambdaParameters); var leftType = propertyExpression.Type; var left = CreateExpression <T>( functionTokens.Left, sourceParameter, lambdaParameters, leftType, formatProvider); // Create a new ParameterExpression from the lambda parameter and add to a collection to pass around var parameterName = functionTokens.Right.Substring(0, functionTokens.Right.IndexOf(":", StringComparison.CurrentCultureIgnoreCase)).Trim(); var lambdaParameter = Expression.Parameter(MethodProvider.GetIEnumerableImpl(leftType).GetGenericArguments()[0], parameterName); lambdaParameters.Add(lambdaParameter); var lambdaFilter = functionTokens.Right.Substring(functionTokens.Right.IndexOf(":", StringComparison.CurrentCultureIgnoreCase) + 1).Trim(); var lambdaType = GetFunctionParameterType(functionTokens.Operation) ?? (left != null ? left.Type : null); var isLambdaAnyAllFunction = lambdaFilter.GetAnyAllFunctionTokens() != null; var right = isLambdaAnyAllFunction ? GetAnyAllFunctionExpression <T>(lambdaFilter, lambdaParameter, lambdaParameters, formatProvider) : CreateExpression <T>(lambdaFilter, sourceParameter, lambdaParameters, lambdaType, formatProvider); return(left == null ? null : GetFunction(functionTokens.Operation, left, right, sourceParameter, lambdaParameters)); }
private static Expression CreateAnyAllExpression( Expression left, Expression right, ParameterExpression sourceParameter, IEnumerable <ParameterExpression> lambdaParameters, MethodInfo anyAllMethod) { if (left == null) { throw new ArgumentNullException("left"); } if (right == null) { throw new ArgumentNullException("right"); } var genericFunc = typeof(Func <,>) .MakeGenericType( MethodProvider.GetIEnumerableImpl(left.Type).GetGenericArguments()[0], typeof(bool)); var filteredParameters = new ParameterVisitor() .GetParameters(right) .Where(p => p.Name != sourceParameter.Name) .ToArray(); if (filteredParameters.Length > 0) { return(Expression.Call( anyAllMethod, left, Expression.Lambda(genericFunc, right, filteredParameters))); } return(Expression.Call( MethodProvider.GetAnyAllMethod("All", left.Type), left, Expression.Lambda(genericFunc, right, lambdaParameters))); }
private static Expression GetFunction(string function, Expression left, Expression right, ParameterExpression sourceParameter, IEnumerable <ParameterExpression> lambdaParameters) { if (function == null) { throw new ArgumentNullException("function"); } if (left == null) { throw new ArgumentNullException("left"); } switch (function.ToLowerInvariant()) { case "substringof": return(Expression.Call(right, MethodProvider.ContainsMethod, new[] { left })); case "endswith": return(Expression.Call(left, MethodProvider.EndsWithMethod, new[] { right, MethodProvider.IgnoreCaseExpression })); case "startswith": return(Expression.Call(left, MethodProvider.StartsWithMethod, new[] { right, MethodProvider.IgnoreCaseExpression })); case "length": return(Expression.Property(left, MethodProvider.LengthProperty)); case "indexof": return(Expression.Call(left, MethodProvider.IndexOfMethod, new[] { right, MethodProvider.IgnoreCaseExpression })); case "substring": return(Expression.Call(left, MethodProvider.SubstringMethod, new[] { right })); case "tolower": return(Expression.Call(left, MethodProvider.ToLowerMethod)); case "toupper": return(Expression.Call(left, MethodProvider.ToUpperMethod)); case "trim": return(Expression.Call(left, MethodProvider.TrimMethod)); case "hour": return(Expression.Property(left, MethodProvider.HourProperty)); case "minute": return(Expression.Property(left, MethodProvider.MinuteProperty)); case "second": return(Expression.Property(left, MethodProvider.SecondProperty)); case "day": return(Expression.Property(left, MethodProvider.DayProperty)); case "month": return(Expression.Property(left, MethodProvider.MonthProperty)); case "year": return(Expression.Property(left, MethodProvider.YearProperty)); case "round": return (Expression.Call( left.Type == typeof(double) ? MethodProvider.DoubleRoundMethod : MethodProvider.DecimalRoundMethod, left)); case "floor": return (Expression.Call( left.Type == typeof(double) ? MethodProvider.DoubleFloorMethod : MethodProvider.DecimalFloorMethod, left)); case "ceiling": return (Expression.Call( left.Type == typeof(double) ? MethodProvider.DoubleCeilingMethod : MethodProvider.DecimalCeilingMethod, left)); case "any": case "all": { return(CreateAnyAllExpression( left, right, sourceParameter, lambdaParameters, MethodProvider.GetAnyAllMethod(function.Capitalize(), left.Type))); } default: return(null); } }
private static Expression GetFunction(string function, Expression left, Expression right, ParameterExpression sourceParameter, ICollection <ParameterExpression> lambdaParameters) { CustomContract.Requires(function != null); CustomContract.Requires(left != null); switch (function.ToLowerInvariant()) { case "substringof": return(Expression.Call(right, MethodProvider.ContainsMethod, new[] { left })); case "endswith": return(Expression.Call(left, MethodProvider.EndsWithMethod, new[] { right })); case "startswith": return(Expression.Call(left, MethodProvider.StartsWithMethod, new[] { right })); case "length": return(Expression.Property(left, MethodProvider.LengthProperty)); case "indexof": return(Expression.Call(left, MethodProvider.IndexOfMethod, new[] { right })); case "substring": return(Expression.Call(left, MethodProvider.SubstringMethod, new[] { right })); case "tolower": return(Expression.Call(left, MethodProvider.ToLowerMethod)); case "toupper": return(Expression.Call(left, MethodProvider.ToUpperMethod)); case "trim": return(Expression.Call(left, MethodProvider.TrimMethod)); case "hour": return(Expression.Property(left, MethodProvider.HourProperty)); case "minute": return(Expression.Property(left, MethodProvider.MinuteProperty)); case "second": return(Expression.Property(left, MethodProvider.SecondProperty)); case "day": return(Expression.Property(left, MethodProvider.DayProperty)); case "month": return(Expression.Property(left, MethodProvider.MonthProperty)); case "year": return(Expression.Property(left, MethodProvider.YearProperty)); case "round": return(Expression.Call(left.Type == typeof(double) ? MethodProvider.DoubleRoundMethod : MethodProvider.DecimalRoundMethod, left)); case "floor": return(Expression.Call(left.Type == typeof(double) ? MethodProvider.DoubleFloorMethod : MethodProvider.DecimalFloorMethod, left)); case "ceiling": return(Expression.Call(left.Type == typeof(double) ? MethodProvider.DoubleCeilingMethod : MethodProvider.DecimalCeilingMethod, left)); case "any": case "all": { CustomContract.Assume(right != null); CustomContract.Assume(!string.IsNullOrEmpty(function)); return(CreateAnyAllExpression( left, right, sourceParameter, lambdaParameters, MethodProvider.GetAnyAllMethod(function.Capitalize(), left.Type))); } default: return(null); } }
public static string GetMethodName(int metodo) { Services.Set(MethodProvider.Get(metodo)); return(db.Cuestionarios.Where(m => m.Metodo == metodo).SingleOrDefault().Cuestionario_name); }
public virtual void runTest() { MethodProvider mp = new MethodProvider(); try { // Test boolean primitive. System.Object[] booleanParams = new System.Object[] { true }; type = "boolean"; method = RuntimeSingleton.Introspector.getMethod(typeof(MethodProvider), type + "Method", booleanParams); result = (System.String)method.Invoke(mp, (System.Object[])booleanParams); if (!result.Equals(type)) { failures.add(type + "Method could not be found!"); } // Test byte primitive. System.Object[] byteParams = new System.Object[] { System.Byte.Parse("1") }; type = "byte"; method = RuntimeSingleton.Introspector.getMethod(typeof(MethodProvider), type + "Method", byteParams); result = (System.String)method.Invoke(mp, (System.Object[])byteParams); if (!result.Equals(type)) { failures.add(type + "Method could not be found!"); } // Test char primitive. System.Object[] characterParams = new System.Object[] { 'a' }; type = "character"; method = RuntimeSingleton.Introspector.getMethod(typeof(MethodProvider), type + "Method", characterParams); result = (System.String)method.Invoke(mp, (System.Object[])characterParams); if (!result.Equals(type)) { failures.add(type + "Method could not be found!"); } // Test double primitive. System.Object[] doubleParams = new System.Object[] { (double)1 }; type = "double"; method = RuntimeSingleton.Introspector.getMethod(typeof(MethodProvider), type + "Method", doubleParams); result = (System.String)method.Invoke(mp, (System.Object[])doubleParams); if (!result.Equals(type)) { failures.add(type + "Method could not be found!"); } // Test float primitive. System.Object[] floatParams = new System.Object[] { (float)1 }; type = "float"; method = RuntimeSingleton.Introspector.getMethod(typeof(MethodProvider), type + "Method", floatParams); result = (System.String)method.Invoke(mp, (System.Object[])floatParams); if (!result.Equals(type)) { failures.add(type + "Method could not be found!"); } // Test integer primitive. System.Object[] integerParams = new System.Object[] { (int)1 }; type = "integer"; method = RuntimeSingleton.Introspector.getMethod(typeof(MethodProvider), type + "Method", integerParams); result = (System.String)method.Invoke(mp, (System.Object[])integerParams); if (!result.Equals(type)) { failures.add(type + "Method could not be found!"); } // Test long primitive. System.Object[] longParams = new System.Object[] { (long)1 }; type = "long"; method = RuntimeSingleton.Introspector.getMethod(typeof(MethodProvider), type + "Method", longParams); result = (System.String)method.Invoke(mp, (System.Object[])longParams); if (!result.Equals(type)) { failures.add(type + "Method could not be found!"); } // Test short primitive. System.Object[] shortParams = new System.Object[] { (short)1 }; type = "short"; method = RuntimeSingleton.Introspector.getMethod(typeof(MethodProvider), type + "Method", shortParams); result = (System.String)method.Invoke(mp, (System.Object[])shortParams); if (!result.Equals(type)) { failures.add(type + "Method could not be found!"); } // Test untouchable System.Object[] params_Renamed = new System.Object[] {}; method = RuntimeSingleton.Introspector.getMethod(typeof(MethodProvider), "untouchable", params_Renamed); if (method != null) { failures.add(type + "able to access a private-access method."); } // Test really untouchable method = RuntimeSingleton.Introspector.getMethod(typeof(MethodProvider), "reallyuntouchable", params_Renamed); if (method != null) { failures.add(type + "able to access a default-access method."); } // There were any failures then show all the // errors that occured. int totalFailures = failures.size(); if (totalFailures > 0) { System.Text.StringBuilder sb = new System.Text.StringBuilder("\nIntrospection Errors:\n"); for (int i = 0; i < totalFailures; i++) { sb.Append((System.String)failures.get(i)).Append("\n"); } fail(sb.ToString()); } } catch (System.Exception e) { fail(e.ToString()); } }
public WeakDelegateBase() { provider = new MethodProvider <T>(); }
public GeneratorResult Generate(MethodCreatorCreator methodCreatorCreator) { #region Declare Value Type Serializer Methods var valueTypeSerializerType = methodCreatorCreator.Create("ValueTypeSerializer"); var valueTypeDeserializerType = methodCreatorCreator.Create("ValueTypeDeserializer"); var generatedValueTypeSerializeMethods = new Dictionary <Type, MethodInfo>(); var generatedValueTypeDeserializeMethods = new Dictionary <Type, MethodInfo>(); foreach (var valueType in typeClassifier.ValueTypes) { if (customMethods.HasTypeSerializer(valueType)) { continue; // Don't generate serializers where custom methods exist } var serializeMethod = valueTypeSerializerType.CreateMethod(valueType, "ValueTypeSerialize", typeof(void), new[] { typeof(SerializeContext), typeof(BinaryWriter), valueType.MakeByRefType() }); generatedValueTypeSerializeMethods.Add(valueType, serializeMethod); var deserializeMethod = valueTypeDeserializerType.CreateMethod(valueType, "ValueTypeDeserialize", typeof(void), new[] { typeof(DeserializeContext), typeof(BinaryReader), valueType.MakeByRefType() }); generatedValueTypeDeserializeMethods.Add(valueType, deserializeMethod); } #endregion #region Declare Reference Type Serializer Methods // Note: These methods have no type check/dispatch - fields that could reference derived types must go through the field methods instead of these! var referenceTypeSerializerType = methodCreatorCreator.Create("ReferenceTypeSerializer"); var referenceTypeDeserializerType = methodCreatorCreator.Create("ReferenceTypeDeserializer"); var generatedReferenceTypeSerializeMethods = new Dictionary <Type, MethodInfo>(); var generatedReferenceTypeDeserializeMethods = new Dictionary <Type, MethodInfo>(); foreach (var referenceType in typeClassifier.ReferenceTypes) { Debug.Assert(!referenceType.IsArray); if (customMethods.HasTypeSerializer(referenceType)) { continue; // Don't generate serializers where custom methods exist } var serializeMethod = referenceTypeSerializerType.CreateMethod(referenceType, "ReferenceTypeSerialize", typeof(void), new[] { typeof(SerializeContext), typeof(BinaryWriter), referenceType }); generatedReferenceTypeSerializeMethods.Add(referenceType, serializeMethod); var deserializeMethod = referenceTypeDeserializerType.CreateMethod(referenceType, "ReferenceTypeDeserialize", typeof(void), new[] { typeof(DeserializeContext), typeof(BinaryReader), referenceType }); generatedReferenceTypeDeserializeMethods.Add(referenceType, deserializeMethod); } #endregion #region Declare Field Serializer Methods var fieldSerializerType = methodCreatorCreator.Create("FieldSerializer"); var fieldDeserializerType = methodCreatorCreator.Create("FieldDeserializer"); var generatedReferenceFieldSerializeMethods = new Dictionary <Type, MethodInfo>(); var generatedReferenceFieldDeserializeMethods = new Dictionary <Type, MethodInfo>(); foreach (var fieldType in typeClassifier.fieldSerializerDispatchLookup.Keys) { if (customMethods.HasFieldSerializer(fieldType)) { continue; // Don't create field serializers where custom ones exist } var serializeMethod = fieldSerializerType.CreateMethod(fieldType, "FieldSerialize", typeof(void), new[] { typeof(SerializeContext), typeof(BinaryWriter), fieldType }); generatedReferenceFieldSerializeMethods.Add(fieldType, serializeMethod); var deserializeMethod = fieldDeserializerType.CreateMethod(fieldType, "FieldDeserialize", typeof(void), new[] { typeof(DeserializeContext), typeof(BinaryReader), fieldType.MakeByRefType() }); generatedReferenceFieldDeserializeMethods.Add(fieldType, deserializeMethod); } #endregion #region Declare Dispatch Methods var serializerDispatchType = methodCreatorCreator.Create("SerializerDispatch"); var deserializerDispatchType = methodCreatorCreator.Create("DeserializerDispatch"); // These are dispatched by ID#, so this is a lookup by that ID# var dynamicDispatchMethods = new List <SerializationMethods>(typeClassifier.dispatchableTypes.Count); // Dispatch to types that require actual dispatch (from type classification) as well as any suplemental types // (Suplemental types come from delegates, at the moment, a few of which require dynamic dispatch (see DelegateSerialization.SerializeDelegate) // and I haven't written a direct-dispatch path yet) HashSet <Type> dispatchTypes; if (suplementalDispatchTypes == null) { dispatchTypes = typeClassifier.dispatchableTypes; } else { dispatchTypes = new HashSet <Type>(typeClassifier.dispatchableTypes.Concat(suplementalDispatchTypes)); } foreach (var type in dispatchTypes.NetworkOrder(t => t.Module.Name + t.FullName)) { var idString = dynamicDispatchMethods.Count.ToString("0000"); SerializationMethods sm; sm.type = type; sm.serializer = serializerDispatchType.CreateMethod(type, "SerializeWithId_" + idString, typeof(void), new[] { typeof(SerializeContext), typeof(BinaryWriter), typeof(object) }); sm.deserializer = deserializerDispatchType.CreateMethod(type, "DeserializeFromId_" + idString, type, new[] { typeof(DeserializeContext), typeof(BinaryReader) }); dynamicDispatchMethods.Add(sm); // Defines the ID# } // Deserialization dispatch method (this could reasonably use a table like serialization, but it was original a giant switch statement - so let's keep it that way) deserializationDispatcherMethod = deserializerDispatchType.CreateMethod(null, "DeserializationDispatcher", typeof(object), new[] { typeof(DeserializeContext), typeof(BinaryReader) }); #endregion #region Lookup Hookup // These are all used to do lookup during IL generation (should probably be switched to a SerializationMethodProviders) fieldSerializeMethods = FallbackMethodProvider.Combine(customMethods.ValueTypeSerializeMethods, customMethods.ReferenceFieldSerializeMethods, new LookupMethodProvider(generatedValueTypeSerializeMethods), new LookupMethodProvider(generatedReferenceFieldSerializeMethods)); fieldDeserializeMethods = FallbackMethodProvider.Combine( customMethods.ValueTypeDeserializeMethods, customMethods.ReferenceFieldDeserializeMethods, new LookupMethodProvider(generatedValueTypeDeserializeMethods), new LookupMethodProvider(generatedReferenceFieldDeserializeMethods)); referenceTypeSerializeMethods = FallbackMethodProvider.Combine( customMethods.ReferenceTypeSerializeMethods, new LookupMethodProvider(generatedReferenceTypeSerializeMethods)); referenceTypeDeserializeMethods = FallbackMethodProvider.Combine( customMethods.ReferenceTypeDeserializeMethods, new LookupMethodProvider(generatedReferenceTypeDeserializeMethods)); var serializeContext = new ILGenContext(Direction.Serialize, fieldSerializeMethods, referenceTypeSerializeMethods); var deserializeContext = new ILGenContext(Direction.Deserialize, fieldDeserializeMethods, referenceTypeDeserializeMethods); #endregion #region Generate Dynamic Dispatch Method IL for (var i = 0; i < dynamicDispatchMethods.Count; i++) { // SerializeWithId Method: #region Generate IL { var il = dynamicDispatchMethods[i].serializer.GetILGenerator(); // br.Write('i'); il.Emit(OpCodes.Ldarg_1); il.Emit(OpCodes.Ldc_I4, i); il.Emit(OpCodes.Callvirt, Methods.BinaryWriter_WriteInt32); // ReferenceTypeSerializer.Serialize(context, bw, (Class)obj); il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Ldarg_1); il.Emit(OpCodes.Ldarg_2); il.Emit(OpCodes.Castclass, dynamicDispatchMethods[i].type); il.Emit(OpCodes.Call, referenceTypeSerializeMethods[dynamicDispatchMethods[i].type]); il.Emit(OpCodes.Ret); } #endregion // DeserializeFromId Method: #region Generate IL { var il = dynamicDispatchMethods[i].deserializer.GetILGenerator(); il.DeclareLocal(dynamicDispatchMethods[i].type); // Class obj // Class obj = /* create object */ GenerateTypeCreation(il, dynamicDispatchMethods[i].type); il.Emit(OpCodes.Stloc_0); // ReferenceTypeDeserializer.Deserialize(context, br, (Class)obj); il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Ldarg_1); il.Emit(OpCodes.Ldloc_0); il.Emit(OpCodes.Call, referenceTypeDeserializeMethods[dynamicDispatchMethods[i].type]); // return obj; il.Emit(OpCodes.Ldloc_0); il.Emit(OpCodes.Ret); } #endregion } #endregion #region Generate Reference Field Serializer Method IL foreach (var fieldDispatch in typeClassifier.fieldSerializerDispatchLookup) { var fieldType = fieldDispatch.Key; var dispatchToTypes = fieldDispatch.Value; var serializeMethod = generatedReferenceFieldSerializeMethods[fieldType]; var deserializeMethod = generatedReferenceFieldDeserializeMethods[fieldType]; GenerateReferenceFieldSerializer(serializeMethod.GetILGenerator(), fieldType, dispatchToTypes); GenerateReferenceFieldDeserializer(deserializeMethod.GetILGenerator(), fieldType, dispatchToTypes); } #endregion #region Generate Reference and Value Type Serializers foreach (var sm in generatedValueTypeSerializeMethods) { TypeSerializeILGeneration.GenerateValueTypeSerializationMethod(sm.Key, sm.Value.GetILGenerator(), serializeContext); } foreach (var sm in generatedValueTypeDeserializeMethods) { TypeSerializeILGeneration.GenerateValueTypeSerializationMethod(sm.Key, sm.Value.GetILGenerator(), deserializeContext); } foreach (var sm in generatedReferenceTypeSerializeMethods) { TypeSerializeILGeneration.GenerateReferenceTypeSerializationMethod(sm.Key, sm.Value.GetILGenerator(), serializeContext); } foreach (var sm in generatedReferenceTypeDeserializeMethods) { TypeSerializeILGeneration.GenerateReferenceTypeSerializationMethod(sm.Key, sm.Value.GetILGenerator(), deserializeContext); } #endregion #region Generate Deserialization Dispatcher (IL) { var il = deserializationDispatcherMethod.GetILGenerator(); var dispatchLabels = new Label[dynamicDispatchMethods.Count]; for (var i = 0; i < dispatchLabels.Length; i++) { dispatchLabels[i] = il.DefineLabel(); } var failLabel = il.DefineLabel(); // br.ReadInt32() il.Emit(OpCodes.Ldarg_1); il.Emit(OpCodes.Callvirt, typeof(BinaryReader) .GetMethod("ReadInt32")); // NOTE: C# compiler loads this into two locals for no reason // switch(...) il.Emit(OpCodes.Switch, dispatchLabels); il.Emit(OpCodes.Br, failLabel); // default case // NOTE: C# compiler emits br.s, but I bet it's not short with our huge table! for (var i = 0; i < dynamicDispatchMethods.Count; i++) { // case 'i': il.MarkLabel(dispatchLabels[i]); il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Ldarg_1); il.Emit(OpCodes.Call, dynamicDispatchMethods[i].deserializer); il.Emit(OpCodes.Ret); } // throw new Exception("..."); il.MarkLabel(failLabel); il.Emit(OpCodes.Ldstr, "Unknown Type"); il.Emit(OpCodes.Newobj, typeof(Exception).GetConstructor(new[] { typeof(string) })); il.Emit(OpCodes.Throw); } #endregion #region Fill Serialization Dispatch Table // We used to generate a table with IL in the serializer assembly (fancy). Now we can just do it directly. // (But we do have to do it last, so the methods are actually ready to convert to delegates) var dispatchTable = new Dictionary <Type, SerializeDispatchDelegate>(); // Only dynamic methods can be converted to delegates (because the dynamic assembly we create in assembly-generating mode is save-only) if (methodCreatorCreator is DynamicMethodCreatorCreator) { for (var i = 0; i < dynamicDispatchMethods.Count; i++) { var serializerMethod = dynamicDispatchMethods[i].serializer as DynamicMethod; Debug.Assert(serializerMethod != null); var serializerDelegate = (SerializeDispatchDelegate)serializerMethod.CreateDelegate(typeof(SerializeDispatchDelegate)); dispatchTable.Add(dynamicDispatchMethods[i].type, serializerDelegate); } } #endregion #region Return var generatedMethodProviders = new SerializationMethodProviders( new LookupMethodProvider(generatedValueTypeSerializeMethods), new LookupMethodProvider(generatedValueTypeDeserializeMethods), new LookupMethodProvider(generatedReferenceTypeSerializeMethods), new LookupMethodProvider(generatedReferenceTypeDeserializeMethods), new LookupMethodProvider(generatedReferenceFieldSerializeMethods), new LookupMethodProvider(generatedReferenceFieldDeserializeMethods), new EmptyMethodProvider()); // Note: custom methods come before generated methods: var combinedMethodProviders = SerializationMethodProviders .Combine(customMethods, generatedMethodProviders); DeserializeDispatchDelegate deserializeDispatchDelegate = null; if (methodCreatorCreator is DynamicMethodCreatorCreator ) // Only dynamic methods can be converted to delegates (our dynamic assembly is save-only) { deserializeDispatchDelegate = (DeserializeDispatchDelegate)(deserializationDispatcherMethod as DynamicMethod).CreateDelegate( typeof(DeserializeDispatchDelegate)); } return(new GeneratorResult(combinedMethodProviders, dispatchTable, deserializeDispatchDelegate, null)); // module table gets filled later #endregion }
public virtual void runTest() { MethodProvider mp = new MethodProvider(); try { // Test boolean primitive. System.Object[] booleanParams = new System.Object[]{true}; type = "boolean"; method = RuntimeSingleton.Introspector.getMethod(typeof(MethodProvider), type + "Method", booleanParams); result = (System.String) method.Invoke(mp, (System.Object[]) booleanParams); if (!result.Equals(type)) failures.add(type + "Method could not be found!"); // Test byte primitive. System.Object[] byteParams = new System.Object[]{System.Byte.Parse("1")}; type = "byte"; method = RuntimeSingleton.Introspector.getMethod(typeof(MethodProvider), type + "Method", byteParams); result = (System.String) method.Invoke(mp, (System.Object[]) byteParams); if (!result.Equals(type)) failures.add(type + "Method could not be found!"); // Test char primitive. System.Object[] characterParams = new System.Object[]{'a'}; type = "character"; method = RuntimeSingleton.Introspector.getMethod(typeof(MethodProvider), type + "Method", characterParams); result = (System.String) method.Invoke(mp, (System.Object[]) characterParams); if (!result.Equals(type)) failures.add(type + "Method could not be found!"); // Test double primitive. System.Object[] doubleParams = new System.Object[]{(double) 1}; type = "double"; method = RuntimeSingleton.Introspector.getMethod(typeof(MethodProvider), type + "Method", doubleParams); result = (System.String) method.Invoke(mp, (System.Object[]) doubleParams); if (!result.Equals(type)) failures.add(type + "Method could not be found!"); // Test float primitive. System.Object[] floatParams = new System.Object[]{(float) 1}; type = "float"; method = RuntimeSingleton.Introspector.getMethod(typeof(MethodProvider), type + "Method", floatParams); result = (System.String) method.Invoke(mp, (System.Object[]) floatParams); if (!result.Equals(type)) failures.add(type + "Method could not be found!"); // Test integer primitive. System.Object[] integerParams = new System.Object[]{(int) 1}; type = "integer"; method = RuntimeSingleton.Introspector.getMethod(typeof(MethodProvider), type + "Method", integerParams); result = (System.String) method.Invoke(mp, (System.Object[]) integerParams); if (!result.Equals(type)) failures.add(type + "Method could not be found!"); // Test long primitive. System.Object[] longParams = new System.Object[]{(long) 1}; type = "long"; method = RuntimeSingleton.Introspector.getMethod(typeof(MethodProvider), type + "Method", longParams); result = (System.String) method.Invoke(mp, (System.Object[]) longParams); if (!result.Equals(type)) failures.add(type + "Method could not be found!"); // Test short primitive. System.Object[] shortParams = new System.Object[]{(short) 1}; type = "short"; method = RuntimeSingleton.Introspector.getMethod(typeof(MethodProvider), type + "Method", shortParams); result = (System.String) method.Invoke(mp, (System.Object[]) shortParams); if (!result.Equals(type)) failures.add(type + "Method could not be found!"); // Test untouchable System.Object[] params_Renamed = new System.Object[]{}; method = RuntimeSingleton.Introspector.getMethod(typeof(MethodProvider), "untouchable", params_Renamed); if (method != null) failures.add(type + "able to access a private-access method."); // Test really untouchable method = RuntimeSingleton.Introspector.getMethod(typeof(MethodProvider), "reallyuntouchable", params_Renamed); if (method != null) failures.add(type + "able to access a default-access method."); // There were any failures then show all the // errors that occured. int totalFailures = failures.size(); if (totalFailures > 0) { System.Text.StringBuilder sb = new System.Text.StringBuilder("\nIntrospection Errors:\n"); for (int i = 0; i < totalFailures; i++) sb.Append((System.String) failures.get(i)).Append("\n"); fail(sb.ToString()); } } catch (System.Exception e) { fail(e.ToString()); } }
/// <summary> /// Method used to convert value to target type. Should be used for any conversion during script execution. /// /// This method should be used by derived class for performance instead of ConvertTo /// </summary> /// <param name="value">value to convert or null</param> /// <param name="targetType">target type</param> /// <returns>Converted value or NoResult constant if conversion impossible</returns> protected static object ConvertToStatic(object value, Type targetType) { //TODO: Cache conversion method if (value == null) { return(value); } if (targetType == typeof(object)) { return(value); } Type valueType = value.GetType(); //Interface if (targetType.IsInterface) { if (valueType .GetInterfaces() .Where(i => i.FullName == targetType.FullName) .Count() != 0) { return(value); } //return new ExplicitInterface(value, targetType); } //Type Match if (targetType.IsAssignableFrom(valueType)) { return(value); } //Conversion operators var mi = MethodProvider.GetConversionMethod(valueType, targetType); if (mi != null) { return(mi.Invoke(value, new[] { value })); } //NOTE: ref, out if (targetType.IsByRef) { return(targetType.GetElementType() == valueType ? value : ConvertToStatic(value, targetType.GetElementType())); } //Convertible if (value is IConvertible) { try { return(Convert.ChangeType(value, targetType, System.Globalization.CultureInfo.CurrentCulture)); } catch (InvalidCastException) { return(NoResult); } } //TODO: Improve Scripting.SSharp.Parser.Ast.ScriptFunctionDefinition f = value as Scripting.SSharp.Parser.Ast.ScriptFunctionDefinition; if (f != null) { try { return(f.AsDelegate(targetType)); } catch (InvalidCastException) { return(NoResult); } } return(NoResult); }