public void TestConstructorResolutionWith2IntParamWhenOneIsNull() { MethodCache cache = new MethodCache(); var obj = cache.CreateInstance <Sample1>(BindingFlags.NonPublic | BindingFlags.Instance, 1, null); obj.Prop.Should().Be(1); }
public void TestConstructorResolutionWith2IntParam() { MethodCache cache = new MethodCache(); var obj1 = cache.CreateInstance <Sample1>(BindingFlags.NonPublic | BindingFlags.Instance, 1, 2); obj1.Prop.Should().Be(3); }
public void TestConstructorResolutionWith1StringWrongParam() { MethodCache cache = new MethodCache(); Assert.Throws <FormatException>(() => cache.CreateInstance <Sample1>("a")); }
public void TestConstructorResolutionWith1StringParam() { MethodCache cache = new MethodCache(); var obj1 = cache.CreateInstance <Sample1>("1"); obj1.Prop.Should().Be(1); }
public void TestConstructorThatDoesntExist() { MethodCache cache = new MethodCache(); Assert.Throws <MissingMethodException>(() => cache.CreateInstance <Sample1>("asd", null, 1)); }
public void TestConstructorResolutionWith2IntParam() { MethodCache cache = new MethodCache(); var obj1 = cache.CreateInstance<Sample1>(BindingFlags.NonPublic | BindingFlags.Instance, 1, 2); obj1.Prop.Should().Be(3); }
public CompilationCache(string pNamespace) { Namespace = pNamespace; _types = new SmallTypeCache(); _methods = new MethodCache(); _references = new Dictionary <string, CompilationModule>(); }
public void TestConstructorResolutionWithNoParams() { MethodCache cache = new MethodCache(); var obj1 = cache.CreateInstance <Sample1>(); obj1.Prop.Should().Be(0); }
public void ConvertNewToOverrides(ModuleDefinition module) { foreach (var type in module.GetTypes()) { if (type.IsInterface) { continue; } if (type.IsEnum) { continue; } var baseTypes = GetBaseTypes(type).ToList(); var baseMethods = MethodCache.Where(x => baseTypes.Contains(x.DeclaringType)).ToList(); if (baseMethods.Count == 0) { continue; } foreach (var methodDefinition in type.Methods) { Replace(methodDefinition, baseMethods); } foreach (var propertyDefinition in type.Properties) { Replace(propertyDefinition.GetMethod, baseMethods); Replace(propertyDefinition.SetMethod, baseMethods); } } }
public void TestConstructorResolutionWithNoParams() { MethodCache cache = new MethodCache(); var obj1 = cache.CreateInstance<Sample1>(); obj1.Prop.Should().Be(0); }
/// <summary> /// 创建委托 /// </summary> /// <param name="service">继承NarutoWebSocketService的服务</param> /// <param name="action">执行的方法</param> /// <param name="parameterEntity">方法的参数</param> /// <param name="parameterType">参数类型</param> /// <param name="isParamter">是否为有参数的</param> /// <returns></returns> private static Task Create(object service, string action, bool isParamter, object parameterEntity, Type parameterType) { //定义输入参数 var p1 = Expression.Parameter(service.GetType(), "service"); //方法的参数对象 var methodParameter = Expression.Parameter(isParamter ? parameterType : typeof(object), "methodParameter"); //动态执行方法 var methodCacheInfo = MethodCache.Get(service.GetType(), action); //调用指定的方法 MethodCallExpression actionCall = null; //验证是否方法是否 有参数 if (methodCacheInfo.ParameterInfos.Count() == 0) { //执行无参方法 actionCall = Expression.Call(p1, methodCacheInfo.Method); } else { //执行有参的方法 actionCall = Expression.Call(p1, methodCacheInfo.Method, methodParameter); } //生成lambda var lambda = Expression.Lambda(actionCall, new ParameterExpression[] { p1, methodParameter }); //获取key var key = service.GetType().Name + action; //存储 exec.TryAdd(key, lambda.Compile()); return(exec[key].DynamicInvoke(service, parameterEntity) as Task); }
public void TestConstructorResolutionWith1StringParam() { MethodCache cache = new MethodCache(); var obj1 = cache.CreateInstance<Sample1>("1"); obj1.Prop.Should().Be(1); }
private static MethodInfoCollection GetMethodCollection(MethodCache cache, Type type, string name) { MethodInfoCollection info; if (!cache.TryGetValue(name, out info)) { return(null); } return(info); }
public void Execute(Runner my) { var prop = typeof(TestClass).GetProperty("TestProperty"); var obj = new TestClass(); my.Execute("raw", i => { obj.TestProperty = "asd"; }); var stdDel = (Action <TestClass, string>)Delegate.CreateDelegate(typeof(Action <TestClass, string>), prop.GetSetMethod()); my.Execute("stddel", i => { stdDel(obj, "asd"); }); var genDel = new MethodCache().GetSetter(prop); my.Execute("gendel", i => { genDel(obj, "asd"); }); var cache = new MethodCache(); var method = prop.GetSetMethod(); cache.GetInvoker(method); my.Execute("gendelc", i => { cache.GetInvoker(method)(obj, "asd"); }); my.Execute("gendelc2", i => { cache.GetSetter(prop)(obj, "asd"); }); my.Execute("invoke", i => { method.Invoke(obj, new[] { "asd" }); }); my.Execute("setvalue", i => { prop.SetValue(obj, "asd", null); }); var settable = prop.ToSettable(); my.Execute("settable", i => { settable.Set(obj, "asd"); }); }
MethodCache GetMethod(int opcode) { if (methods.ContainsKey(opcode)) { return(methods[opcode]); } else { string method = Enum.GetName(opcodeType, opcode); if (string.IsNullOrEmpty(method) == false) { var m = commandType.GetMethod(method); if (m != null) { var mc = new MethodCache(); methods[opcode] = mc; mc.Method = m; var ps = m.GetParameters(); if (ps.Length == 1) { var po = Activator.CreateInstance(ps[0].ParameterType); mc.ParameterType = ps[0].ParameterType; var rm = ps[0].ParameterType.GetMethod("ReadFrom", new Type[] { typeof(byte[]), typeof(int), typeof(int) }); if (rm != null) { mc.ReadMethod = rm; } else { Debug.LogError("Command" + method + " 参数" + ps[0].ParameterType.FullName + "没有ReadFrom函数,无法执行"); } } else if (ps.Length >= 1) { Debug.LogError("Command" + method + " 参数个数大于1,无法执行"); } return(mc); } else { Debug.LogError("CommandHandle: " + method + " not found"); return(null); } } else { Debug.LogWarning(string.Format("收到未定义的ClientMethod opcode: {0}", opcode)); return(null); } } }
/// <inheritdoc /> protected internal override object Invoke(MethodInvocation invocation) { var targetMethod = MethodCache.GetMethodMap(TargetType, invocation.Method); var signature = new InvocationSignature( invocation.Method, targetMethod, DeclaringType, TargetType, invocation.Method.GetInvocationType()); return(Interceptor.Intercept( signature, invocation.MethodCall, invocation.Arguments, Target, invocation.TransparentProxy)); }
public static Subroutine OldEvalPopSubroutine <Local, Parameter, Type, Method, Field, Property, Attribute, Assembly>( MethodCache <Local, Parameter, Type, Method, Field, Property, Attribute, Assembly> methodCache, Subroutine oldEval ) { Debug.Assert(oldEval.StackDelta == 1); var sub = new SimpleILCodeProvider <Local, Parameter, Type, Method, Field, Property, Attribute, Assembly>( new Instruction[] { Instruction.Pop }, 0).GetSubroutine(methodCache); sub.AddEdgeSubroutine(sub.Entry, sub.EntryAfterRequires, oldEval, "oldmanifest"); return(sub); }
public void Execute(Runner my) { var prop = typeof(TestClass).GetProperty("TestProperty"); var obj = new TestClass(); my.Execute("raw", i => { obj.TestProperty = "asd"; }); var stdDel = (Action<TestClass, string>)Delegate.CreateDelegate(typeof(Action<TestClass, string>), prop.GetSetMethod()); my.Execute("stddel", i => { stdDel(obj, "asd"); }); var genDel = new MethodCache().GetSetter(prop); my.Execute("gendel", i => { genDel(obj, "asd"); }); var cache = new MethodCache(); var method = prop.GetSetMethod(); cache.GetInvoker(method); my.Execute("gendelc", i => { cache.GetInvoker(method)(obj, "asd"); }); my.Execute("gendelc2", i => { cache.GetSetter(prop)(obj, "asd"); }); my.Execute("invoke", i => { method.Invoke(obj, new[] { "asd" }); }); my.Execute("setvalue", i => { prop.SetValue(obj, "asd", null); }); var settable = prop.ToSettable(); my.Execute("settable", i => { settable.Set(obj, "asd"); }); }
public ServiceMethod Resolve(InvocationTarget target) { if (target == null) { throw new ArgumentNullException(nameof(target), "An invocation target must be specified."); } if (target.IsWeaklyTyped) { ServiceMethod[] methods; if (string.IsNullOrEmpty(target.TypeName)) { SimpleMethodCache.TryGetValue(target.MethodName, out methods); } else { TypedMethodCache.TryGetValue(GetTypedMethodKey(target.TypeName, target.MethodName), out methods); } if (methods == null) { throw new MissingMethodException("The specified request contains an unrecognized interface name, method name."); } if (methods.Length > 1) { throw new ProgrammaticException("Weakly-typed requests cannot be used for methods with more than one overload (including methods that are only differentiated by letter case)", unencrypted: new Tags { { "method", target.MethodName }, { "type", target.TypeName } }); } return(methods.Single()); } else { if (string.IsNullOrEmpty(target.TypeName) || string.IsNullOrEmpty(target.MethodName) || target.ParameterTypes == null) { throw new ArgumentException("The specified invocation target is invalid.", nameof(target)); } MethodCache.TryGetValue(target, out ServiceMethod method); if (method == null) { throw new MissingMethodException("The specified request contains an unrecognized interface name, method name or method overload."); } return(method); } }
public void TestMethodCachedResult() { Type t = typeof(Sample1); MethodCache cache = new MethodCache(); MethodInfo m1 = t.GetMethod("Method"); InvocationDelegate d1 = cache.GetInvoker(m1); MethodInfo m2 = t.GetMethod("Method"); InvocationDelegate d2 = cache.GetInvoker(m2); Assert.AreSame(m1, m2); Assert.AreSame(d1, d2); }
public void TestPropertySetCachedResult() { Type t = typeof(Sample1); MethodCache cache = new MethodCache(); PropertyInfo p1 = t.GetProperty("Prop"); InvocationDelegate d1 = cache.GetSetter(p1); PropertyInfo p2 = t.GetProperty("Prop"); InvocationDelegate d2 = cache.GetSetter(p2); Assert.AreSame(p1, p2); Assert.AreSame(d1, d2); }
public void TestMethodCachedResult() { Type t = typeof(Sample1); MethodCache cache = new MethodCache(); MethodInfo m1 = t.GetMethod("Method"); InvocationDelegate d1 = cache.GetInvoker(m1); MethodInfo m2 = t.GetMethod("Method"); InvocationDelegate d2 = cache.GetInvoker(m2); Assert.AreSame(m1, m2); Assert.AreSame(d1, d2); }
public virtual ActionResult PurgeCache() { try { MethodCache.ExpireAll(); QueryCacheManager.ExpireAll(); SuccessNotification(_localizationService.GetResource("OperationCompletedSuccessfully")); } catch (Exception e) { ErrorNotification(e); } return(RedirectToAction("Index", "Administration")); }
/// <summary> /// 执行接收的外部消息 /// </summary> /// <param name="service"></param> /// <param name="currentServiceType">当前上下文的类型</param> /// <param name="messageModel">消息模型</param> /// <returns></returns> private async Task EexecReciveMessage(object service, Type currentServiceType, WebSocketMessageModel messageModel) { //获取方法 var methodCacheInfo = MethodCache.Get(currentServiceType, messageModel.action); //获取方法的参数 var parameters = methodCacheInfo.ParameterInfos; //是否含有参数 var isParamater = parameters.Count() > 0; //参数信息 var parameterEntity = parameters.Count() > 0 ?await messageModel.message?.ToString().ToDeserializeAsync(parameters[0].ParameterType) : null; //执行操作 await NarutoWebSocketServiceExpression.ExecAsync(service, messageModel.action, isParamter : isParamater, parameterEntity : parameterEntity, parameterType : isParamater?parameters[0].ParameterType : default).ConfigureAwait(false); }
public virtual async Task UpdateAsync(T record) { var oldRecord = await FindByIdAsync(record.Id); _dbContext.Set <T>().AddOrUpdate(record); await _dbContext.SaveChangesAsync(); //Set Post Tags & Categories await UpdatePostTagsAsync(record.Id, record.Tags?.Select(p => p.Tag).ToList()); await UpdatePostCategoriesAsync(record.Id, record.Categories?.Select(p => p.Id).ToList()); QueryCacheManager.ExpireTag(_cacheKey); MethodCache.ExpireTag(_cacheKey); _eventPublisher.EntityUpdated(record, oldRecord); }
protected override void Activities(Fiber fiber) { manager = (IServicesManager)Managers.Find($"{serviceName}ServicesManager"); if (manager == default) { Debug.LogError(Error = $"No service manager '{serviceName}ServicesManager' in a Managers game object"); } else { fiber.OnError(exit: true, actor: message => Error = message).Do(Reset) .Begin .WaitFor(_ => MethodCache.Call(serviceAdapter, "Call", this) as Emitter) .Until(_ => (Error == null) || ((serviceAdapter = manager.Next()) == null)) .If(_ => serviceAdapter == null).Error($"No Server '{serviceName} {entryPointName}' can Respond").End .Finish(); } }
private static MethodCache GetMethodCache(Type type) { MethodCache result; if (!_tpyeCache.TryGetValue(type, out result)) { lock (_tpyeCache) { if (!_tpyeCache.TryGetValue(type, out result)) { result = new MethodCache(); _tpyeCache[type] = result; } } } return(result); }
private static MethodInfoCollection GetMethodCollectionAndCache(InvokeContextBase context, Type type) { MethodCache cache = GetMethodCache(type); MethodInfoCollection infos = GetMethodCollection(cache, type, context.MethodName); if (infos == null) { lock (_syncMethodObject) { infos = GetMethodCollection(cache, type, context.MethodName); if (infos == null) { infos = new MethodInfoCollection(); MemberInfo[] methods = type.GetMembers(_defaultBinding); int index = 0; if (methods != null && methods.Length > 0) { foreach (MemberInfo info in methods) { index++; if (index < 0) { break; } if (info.MemberType == MemberTypes.Method) { MethodInfo method = (MethodInfo)info; MethodAttribute attr = GetMethodAttribute(method); if (attr != null && string.Compare(attr.MethodName, context.MethodName, true) == 0) { infos.Add(method); } else if (string.Compare(info.Name, context.MethodName, true) == 0) { infos.Add(method); } } } } cache[context.MethodName] = infos; } } } return(infos); }
private static MethodInfo TryFindInterfaceMethodMatching( Type interfaceType, string methodName, Type returnType, Type[] parameterTypes) { lock (MethodCache) { PopulateMethodCacheIfNecessaryFor(interfaceType); return(MethodCache.TryGetValue(Tuple.Create( interfaceType, methodName, returnType, parameterTypes), out var result) ? result : null); } }
public BasicAnalysisDriver( IDecodeMetaData <Local, Parameter, Method, Field, Property, Event, Type, Attribute, Assembly> mdDecoder, IDecodeContracts <Local, Parameter, Method, Field, Type> contractDecoder, IOutput output, LogOptions options ) { Contract.Requires(mdDecoder != null); Contract.Requires(contractDecoder != null); Contract.Requires(output != null); Contract.Requires(options != null); this.methodCache = new MethodCache <Local, Parameter, Type, Method, Field, Property, Event, Attribute, Assembly>(mdDecoder, contractDecoder, output.WriteLine); this.mdDecoder = mdDecoder; this.contractDecoder = contractDecoder; this.output = output; this.options = options; }
private void InitializeInterface(TypeInfo interfaceType) { var members = interfaceType.DeclaredMembers; //check that we only have methods and no properties if (interfaceType.DeclaredMembers.Any(x => !(x is MethodInfo))) { throw new ArgumentException("The interface must only provide methods.", nameof(interfaceType)); } //an interface without any methods is pointless var methods = members.Cast <MethodInfo>().ToList(); if (methods.Count == 0) { throw new ArgumentException("The interface must at least provide one method.", nameof(interfaceType)); } var dictionary = new Dictionary <MethodInfo, MethodCache>(); foreach (var methodInfo in methods) { Type actualReturnType; if (methodInfo.ReturnType == typeof(Task)) { actualReturnType = null; } else if (methodInfo.ReturnType.GetTypeInfo().IsGenericType&& methodInfo.ReturnType.GetGenericTypeDefinition() == typeof(Task <>)) { actualReturnType = methodInfo.ReturnType.GenericTypeArguments[0]; } else { throw new ArgumentException("Only tasks are supported as return type.", methodInfo.ToString()); } var methodCache = new MethodCache(methodInfo.GetMethodId(), actualReturnType, methodInfo.GetParameters().Select(x => x.ParameterType).ToArray()); dictionary.Add(methodInfo, methodCache); } _methods = dictionary; }
public virtual async Task DeleteAsync(int id) { var record = await FindByIdAsync(id); await _userLikesService.DeletePostLikesAsync(id); await _userWishlistService.DeletePostFromWishlistAsync(id); await _dbContext.PostComments.Where(p => p.PostId == id).DeleteAsync(); var post = await FindByIdAsync(id); _dbContext.Set <T>().Remove(post); await _dbContext.SaveChangesAsync(); await _localizedEntityService.DeleteEntityAllLocalizedStringsAsync(typeof(T).Name, id); QueryCacheManager.ExpireTag(_cacheKey); MethodCache.ExpireTag(_cacheKey); _eventPublisher.EntityDeleted(record); }
public virtual async Task <int> AddAsync(T record) { var postTags = record.Tags?.Select(p => p.Tag).ToList(); var postCategories = record.Categories?.Select(p => p.Id).ToList(); record.Tags = null; record.Categories = null; _dbContext.Set <T>().Add(record); await _dbContext.SaveChangesAsync(); //Set Post Tags & Categories await UpdatePostTagsAsync(record.Id, postTags); await UpdatePostCategoriesAsync(record.Id, postCategories); QueryCacheManager.ExpireTag(_cacheKey); MethodCache.ExpireTag(_cacheKey); _eventPublisher.EntityInserted(record); return(record.Id); }
public void TestConstructorResolutionWith2IntParamWhenOneIsNull() { MethodCache cache = new MethodCache(); var obj = cache.CreateInstance<Sample1>(BindingFlags.NonPublic | BindingFlags.Instance, 1, null); obj.Prop.Should().Be(1); }
private async Task <object> SendMethodCall(MethodCache methodCache, object[] parameters) { if (methodCache == null) { throw new ArgumentException("The parameter cannot be null.", nameof(methodCache)); } if (methodCache == null) { throw new ArgumentException("The parameter cannot be null.", nameof(parameters)); } //PROTOCOL //CALL: //HEAD - 4 bytes - Identifier, ASCII (NTC1) //HEAD - integer - callback identifier //HEAD - uinteger - The method identifier //HEAD - integer * parameters - the length of each parameter //-------------------------------------------------------------------------- //DATA - length of the parameters - serialized parameters var callbackId = (uint)Interlocked.Increment(ref _callIdCounter); var buffer = new byte[CustomOffset /* user offset */ + 4 /* Header */ + 4 /* Callback id */ + 4 /* method id */ + parameters.Length * 4 /* parameter meta */ + EstimatedDataPerParameter * parameters.Length /* parameter data */]; var bufferOffset = CustomOffset + 12 + parameters.Length * 4; for (var i = 0; i < parameters.Length; i++) { var metaOffset = CustomOffset + 12 + i * 4; var parameterLength = _serializer.Serialize(methodCache.ParameterTypes[i], ref buffer, bufferOffset, parameters[i]); Buffer.BlockCopy(BitConverter.GetBytes(parameterLength), 0, buffer, metaOffset, 4); bufferOffset += parameterLength; } //write header buffer[CustomOffset] = CallProtocolInfo.Header1; buffer[CustomOffset + 1] = CallProtocolInfo.Header2; buffer[CustomOffset + 2] = CallProtocolInfo.Header3Call; buffer[CustomOffset + 3] = CallProtocolInfo.Header4; //write callback id Buffer.BlockCopy(BitConverter.GetBytes(callbackId), 0, buffer, CustomOffset + 4, 4); //method identifier Buffer.BlockCopy(BitConverter.GetBytes(methodCache.MethodId), 0, buffer, CustomOffset + 8, 4); var callback = new ResultCallback(); var callbackWait = callback.Wait(WaitTimeout); _callbacks.TryAdd(callbackId, callback); //impossible that this goes wrong OnSendData(new ArraySegment <byte>(buffer, 0, bufferOffset)).Forget(); //no need to await that using (callback) { if (!await callbackWait.ConfigureAwait(false)) { _callbacks.TryRemove(callbackId, out var _); throw new TimeoutException("The method call timed out, no response received."); } switch (callback.ResponseType) { case CallTransmissionResponseType.MethodExecuted: return(null); case CallTransmissionResponseType.ResultReturned: return(_serializer.Deserialize(methodCache.ReturnType, callback.Data, callback.Offset)); case CallTransmissionResponseType.Exception: var up = _serializer.DeserializeException(callback.Data, callback.Offset); throw up; case CallTransmissionResponseType.MethodNotImplemented: throw new NotImplementedException("The remote method is not implemented."); default: throw new ArgumentOutOfRangeException(); } } }
/* * Matches a method against its arguments in the Lua stack. Returns * if the match was succesful. It it was also returns the information * necessary to invoke the method. */ internal bool matchParameters(LuaCore.lua_State luaState, MethodBase method, ref MethodCache methodCache) { ExtractValue extractValue; bool isMethod = true; var paramInfo = method.GetParameters(); int currentLuaParam = 1; int nLuaParams = LuaLib.lua_gettop(luaState); var paramList = new ArrayList(); var outList = new List<int>(); var argTypes = new List<MethodArgs>(); foreach(var currentNetParam in paramInfo) { if(!currentNetParam.IsIn && currentNetParam.IsOut) // Skips out params outList.Add(paramList.Add(null)); else if(currentLuaParam > nLuaParams) // Adds optional parameters { if(currentNetParam.IsOptional) paramList.Add(currentNetParam.DefaultValue); else { isMethod = false; break; } } else if(_IsTypeCorrect(luaState, currentLuaParam, currentNetParam, out extractValue)) // Type checking { int index = paramList.Add(extractValue(luaState, currentLuaParam)); var methodArg = new MethodArgs(); methodArg.index = index; methodArg.extractValue = extractValue; argTypes.Add(methodArg); if(currentNetParam.ParameterType.IsByRef) outList.Add(index); currentLuaParam++; } // Type does not match, ignore if the parameter is optional else if(_IsParamsArray(luaState, currentLuaParam, currentNetParam, out extractValue)) { object luaParamValue = extractValue(luaState, currentLuaParam); var paramArrayType = currentNetParam.ParameterType.GetElementType(); Array paramArray; if(luaParamValue is LuaTable) { var table = (LuaTable)luaParamValue; var tableEnumerator = table.GetEnumerator(); paramArray = Array.CreateInstance(paramArrayType, table.Values.Count); tableEnumerator.Reset(); int paramArrayIndex = 0; while(tableEnumerator.MoveNext()) { paramArray.SetValue(Convert.ChangeType(tableEnumerator.Value, currentNetParam.ParameterType.GetElementType()), paramArrayIndex); paramArrayIndex++; } } else { paramArray = Array.CreateInstance(paramArrayType, 1); paramArray.SetValue(luaParamValue, 0); } int index = paramList.Add(paramArray); var methodArg = new MethodArgs(); methodArg.index = index; methodArg.extractValue = extractValue; methodArg.isParamsArray = true; methodArg.paramsArrayType = paramArrayType; argTypes.Add(methodArg); currentLuaParam++; } else if(currentNetParam.IsOptional) paramList.Add(currentNetParam.DefaultValue); else // No match { isMethod = false; break; } } if(currentLuaParam != nLuaParams + 1) // Number of parameters does not match isMethod = false; if(isMethod) { methodCache.args = paramList.ToArray(); methodCache.cachedMethod = method; methodCache.outList = outList.ToArray(); methodCache.argTypes = argTypes.ToArray(); } return isMethod; }
/* * __call metafunction of type references. Searches for and calls * a constructor for the type. Returns nil if the constructor is not * found or if the arguments are invalid. Throws an error if the constructor * generates an exception. */ private int callConstructor(LuaCore.lua_State luaState) { var validConstructor = new MethodCache(); IReflect klass; object obj = translator.getRawNetObject(luaState, 1); if(obj.IsNull() || !(obj is IReflect)) { translator.throwError(luaState, "trying to call constructor on an invalid type reference"); LuaLib.lua_pushnil(luaState); return 1; } else klass = (IReflect)obj; LuaLib.lua_remove(luaState, 1); var constructors = klass.UnderlyingSystemType.GetConstructors(); foreach(var constructor in constructors) { bool isConstructor = matchParameters(luaState, constructor, ref validConstructor); if(isConstructor) { try { translator.push(luaState, constructor.Invoke(validConstructor.args)); } catch(TargetInvocationException e) { ThrowError(luaState, e); LuaLib.lua_pushnil(luaState); } catch { LuaLib.lua_pushnil(luaState); } return 1; } } string constructorName = (constructors.Length == 0) ? "unknown" : constructors[0].Name; translator.throwError(luaState, String.Format("{0} does not contain constructor({1}) argument match", klass.UnderlyingSystemType, constructorName)); LuaLib.lua_pushnil(luaState); return 1; }
public Subroutine GetSubroutine(MethodCache <Local, Parameter, Type, Method, Field, Property, Event, Attribute, Assembly> methodCache) { Contract.Requires(methodCache != null); // F: Added as of Clousot suggestion return(methodCache.BuildSubroutine(stackDelta, this, 0)); }
/// <summary> /// Initializes a new instance of the CachingHandler class. /// </summary> /// <param name="container">The Unity Container.</param> public CachingHandler(IUnityContainer container) { this.cache = container.Resolve<MethodCache>(); }
public void TestConstructorThatDoesntExist() { MethodCache cache = new MethodCache(); Assert.Throws<MissingMethodException>(()=> cache.CreateInstance<Sample1>("asd", null, 1)); }
/* * Checks if the method matches the arguments in the Lua stack, getting * the arguments if it does. */ internal bool matchParameters(LuaCore.lua_State luaState, MethodBase method, ref MethodCache methodCache) { return metaFunctions.matchParameters(luaState, method, ref methodCache); }
public void TestConstructorResolutionWith1StringWrongParam() { MethodCache cache = new MethodCache(); Assert.Throws<FormatException>(() => cache.CreateInstance<Sample1>("a")); }
public void TestPropertyGetCachedResult() { Type t = typeof(Sample1); MethodCache cache = new MethodCache(); PropertyInfo p1 = t.GetProperty("Prop"); InvocationDelegate d1 = cache.GetGetter(p1); PropertyInfo p2 = t.GetProperty("Prop"); InvocationDelegate d2 = cache.GetGetter(p2); Assert.AreSame(p1, p2); Assert.AreSame(d1, d2); }