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)));
}
