internal static ReturnInfo Execute(Action <Action> invokeCore, VarPool varManager, TypeFinder typeFinder, ProtocolInfo info) { IAsyncInvoke invoke = new AsyncExecute(invokeCore); if (info.ProtocolType == ProtocolType.Operation) { invoke = new SyncExecute(invokeCore); var executeCheck = varManager.Add(false); var args = new List <object>(info.Arguments); args.Insert(0, executeCheck); info = new ProtocolInfo(info.ProtocolType, info.OperationTypeInfo, info.VarAddress, info.TypeFullName, info.Operation, args.ToArray()); try { return(Execute(invoke, varManager, typeFinder, info)); } finally { varManager.Remove(executeCheck); } } else { return(Execute(invoke, varManager, typeFinder, info)); } }
static ReturnInfo ExecuteField(IAsyncInvoke async, VarPool varManager, ProtocolInfo info, object obj, object[] args, FieldInfo field) { if (args.Length == 0) { VarAddress getVar = varManager.Add(null); KeepAlive(varManager, info.Arguments, getVar); async.Execute(delegate { ReturnInfo retInfo = new ReturnInfo(); try { varManager.SetObject(getVar, field.GetValue(obj)); } catch (Exception e) { retInfo = new ReturnInfo(new ExceptionInfo(e)); } varManager.SetObject((VarAddress)info.Arguments[0], retInfo); FreeKeepAlive(varManager, info.Arguments, getVar); }); return(new ReturnInfo(getVar)); } else if (args.Length == 1) { KeepAlive(varManager, info.Arguments, null); async.Execute(delegate { ReturnInfo retInfo = new ReturnInfo(); try { field.SetValue(obj, args[0]); } catch (Exception e) { retInfo = new ReturnInfo(new ExceptionInfo(e)); } varManager.SetObject((VarAddress)info.Arguments[0], retInfo); FreeKeepAlive(varManager, info.Arguments, null); }); return(new ReturnInfo()); } throw new InternalException(); }
static ReturnInfo VarInitialize(VarPool varManager, ProtocolInfo info) { //arguments count is 1. if (info.Arguments.Length != 1) { throw new InternalException(); } object[] args; ResolveArgs(varManager, info.Arguments, out args); //entry variable. return(new ReturnInfo(varManager.Add(args[0]))); }
static ReturnInfo GetElements(VarPool varManager, ProtocolInfo info) { object obj = varManager.GetVarAndType(info.VarAddress).Core; IEnumerable enumerable = obj as IEnumerable; if (enumerable == null) { throw new InformationException(ResourcesLocal.Instance.HasNotEnumerable); } List <VarAddress> list = new List <VarAddress>(); foreach (object element in enumerable) { list.Add(varManager.Add(element)); } return(new ReturnInfo(list.ToArray())); }
static ReturnInfo ExecuteMethodOrProperty(IAsyncInvoke async, VarPool varManager, ProtocolInfo info, object obj, object[] args, MethodInfo method) { VarAddress handle = null; if (method.ReturnParameter.ParameterType != typeof(void)) { handle = varManager.Add(null); } KeepAlive(varManager, info.Arguments, handle); async.Execute(delegate { ReturnInfo retInfo = new ReturnInfo(); try { object retObj = method.Invoke(obj, args); if (method.ReturnParameter.ParameterType != typeof(void)) { varManager.SetObject(handle, retObj); } List <object> retArgsTmp = new List <object>(); retArgsTmp.Add(null); retArgsTmp.AddRange(args); ReflectArgsAfterInvoke(varManager, info.Arguments, retArgsTmp.ToArray()); } catch (Exception e) { retInfo = new ReturnInfo(new ExceptionInfo(e)); } varManager.SetObject((VarAddress)info.Arguments[0], retInfo); FreeKeepAlive(varManager, info.Arguments, handle); }); return(new ReturnInfo(handle)); }
/// <summary> /// create object. /// </summary> static ReturnInfo VarNew(IAsyncInvoke async, VarPool varManager, TypeFinder typeFinder, ProtocolInfo info) { Type type = typeFinder.GetType(info.TypeFullName); if (type == null) { throw new InformationException(string.Format(CultureInfo.CurrentCulture, ResourcesLocal.Instance.UnknownTypeInfoFormat, info.TypeFullName)); } object[] args; Type[] argTypesOri; ResolveArgs(varManager, info.Arguments, out args, out argTypesOri); Type[] argTypes = GetArgTypes(typeFinder, info.OperationTypeInfo, argTypesOri); //value type. if (argTypes.Length == 0 && type.IsValueType()) { return(new ReturnInfo(varManager.Add(Activator.CreateInstance(type)))); } //resolve overload. ConstructorInfo[] constructorInfos = type.GetConstructors(); List <ConstructorInfo> constructorList = new List <ConstructorInfo>(); bool isObjectArrayArg = false; for (int i = 0; i < constructorInfos.Length; i++) { ParameterInfo[] paramInfos = constructorInfos[i].GetParameters(); bool isPerfect; bool isObjectArrayArgTmp; if (IsMatchParameter(info.OperationTypeInfo != null, argTypes, paramInfos, out isPerfect, out isObjectArrayArgTmp)) { if (isPerfect) { constructorList.Clear(); constructorList.Add(constructorInfos[i]); break; } constructorList.Add(constructorInfos[i]); } if (isObjectArrayArgTmp) { isObjectArrayArg = true; } } //not found. if (constructorList.Count == 0) { if (isObjectArrayArg) { throw new InformationException(string.Format(CultureInfo.CurrentCulture, ResourcesLocal.Instance.ErrorNotFoundConstractorFormatForObjectArray, type.Name, MakeErrorInvokeArgInfo(argTypes))); } else { throw new InformationException(string.Format(CultureInfo.CurrentCulture, ResourcesLocal.Instance.ErrorNotFoundConstractorFormat, type.Name, MakeErrorInvokeArgInfo(argTypes))); } } if (constructorList.Count != 1) { //can't resolve overload. throw new InformationException(string.Format(CultureInfo.CurrentCulture, ResourcesLocal.Instance.ErrorManyFoundConstractorFormat, type.Name, MakeErrorInvokeArgInfo(argTypes))); } //create. bool isCreated = false;//TODO object instance = null; async.Execute(() => { instance = constructorList[0].Invoke(args); isCreated = true; }); while (!isCreated) { Thread.Sleep(0); } //resolve ref, out. ReflectArgsAfterInvoke(varManager, info.Arguments, args); //entry object. return(new ReturnInfo(varManager.Add(instance))); }