internal void AddSupply(PropertyInfo info, PassageCallback passage)
{
long passageId = _NotifierPassage.RegisterSupply(passage);
PackageNotifierEvent package = new PackageNotifierEvent();
package.Entity = _Ghost.GetID();
package.Property = _Protocol.GetMemberMap().GetProperty(info);
package.Passage = passageId;
_Requester.Request(ClientToServerOpCode.AddNotifierSupply, package.ToBuffer(_Protocol.GetSerialize()));
}
internal void Add(System.Reflection.EventInfo info, long handler)
{
MemberMap map = _Protocol.GetMemberMap();
Serialization.ISerializer serialize = _Protocol.GetSerialize();
PackageAddEvent package = new PackageAddEvent();
package.Entity = _Ghost.GetID();
package.Event = map.GetEvent(info);
package.Handler = handler;
_Requester.Request(ClientToServerOpCode.AddEvent, package.ToBuffer(serialize));
}
private void _InvokeMethod(Guid entity_id, int method_id, Guid return_id, byte[][] args)
{
var soulInfo = (from soul in _Souls
where soul.ID == entity_id
select new
{
soul.MethodInfos,
soul.ObjectInstance
}).FirstOrDefault();
if (soulInfo == null)
{
return;
}
var info = _Protocol.GetMemberMap().GetMethod(method_id);
var methodInfo =
(from m in soulInfo.MethodInfos
where
m == _Protocol.GetMemberMap().GetMethod(method_id) &&
m.GetParameters().Length == args.Length
select m)
.FirstOrDefault();
if (methodInfo == null)
{
return;
}
try
{
var argObjects = args.Select(arg => _Serialize.Deserialize(arg));
var returnValue = methodInfo.Invoke(soulInfo.ObjectInstance, argObjects.ToArray()) as IValue;
if (returnValue != null)
{
_ReturnValue(return_id, returnValue);
}
}
catch (Exception e)
{
throw new Exception($"call method {methodInfo.Name}:{methodInfo.DeclaringType?.FullName ?? "no type" }", e);
}
}
private void _UpdateProperty(int property, Guid entity_id, byte[] arg)
{
var ghost = _FindGhost(entity_id);
if (ghost != null)
{
var map = _Protocol.GetMemberMap();
var info = map.GetProperty(property);
var value = _Serializer.Deserialize(arg);
var instance = ghost.GetInstance();
var type = _GhostInterfaceProvider.Find(info.DeclaringType);
var field = type.GetField("_" + info.Name, BindingFlags.Instance | BindingFlags.NonPublic);
if (field != null)
{
field.SetValue(instance, value);
}
}
}
private void _InvokeMethod(Guid entity_id, int method_id, Guid returnId, byte[][] args)
{
var soulInfo = (from soul in _Souls.UpdateSet()
where soul.ID == entity_id
select new
{
soul.MethodInfos,
soul.ObjectInstance
}).FirstOrDefault();
if (soulInfo != null)
{
var info = _Protocol.GetMemberMap().GetMethod(method_id);
var methodInfo =
(from m in soulInfo.MethodInfos where m == info && m.GetParameters().Count() == args.Count() select m)
.FirstOrDefault();
if (methodInfo != null)
{
try
{
var argObjects = args.Select(arg => _Serializer.Deserialize(arg));
var returnValue = methodInfo.Invoke(soulInfo.ObjectInstance, argObjects.ToArray());
if (returnValue != null)
{
_ReturnValue(returnId, returnValue as IValue);
}
}
catch (DeserializeException deserialize_exception)
{
var message = deserialize_exception.Base.ToString();
_ErrorDeserialize(method_id.ToString(), returnId, message);
}
catch (Exception e)
{
Log.Instance.WriteDebug(e.ToString());
_ErrorDeserialize(method_id.ToString(), returnId, e.Message);
}
}
}
}
public static IProtocol CreateProtocol(ISerializer serializer)
{
IProtocol protocol = NSubstitute.Substitute.For <IProtocol>();
var types = new System.Collections.Generic.Dictionary <System.Type, System.Type>();
types.Add(typeof(IGpiA), typeof(GhostIGpiA));
InterfaceProvider interfaceProvider = new InterfaceProvider(types);
protocol.GetInterfaceProvider().Returns(interfaceProvider);
protocol.GetSerialize().Returns(serializer);
System.Func <IProvider> gpiaProviderProvider = () => new TProvider <IGpiA>();
System.Tuple <System.Type, System.Func <IProvider> >[] typeProviderProvider = new System.Tuple <System.Type, System.Func <IProvider> >[] { new System.Tuple <System.Type, System.Func <IProvider> >(typeof(IGpiA), gpiaProviderProvider) };
protocol.GetMemberMap().Returns(new MemberMap(new System.Reflection.MethodInfo[0], new System.Reflection.EventInfo[0], new System.Reflection.PropertyInfo[0], typeProviderProvider));
return(protocol);
}
private void _LoadProperty(Soul new_soul)
{
PropertyInfo[] propertys = new_soul.ObjectType.GetProperties(BindingFlags.GetProperty | BindingFlags.Instance | BindingFlags.Public);
MemberMap map = _Protocol.GetMemberMap();
for (int i = 0; i < propertys.Length; ++i)
{
PropertyInfo property = propertys[i];
int id = map.GetProperty(property);
if (property.PropertyType.GetInterfaces().Any(t => t == typeof(IDirtyable)))
{
object propertyValue = property.GetValue(new_soul.ObjectInstance);
IAccessable accessable = propertyValue as IAccessable;
_LoadProperty(new_soul.Id, id, accessable.Get());
}
}
}
public void Run(MethodInfo info, object[] args, IValue return_value)
{
var map = _Protocol.GetMemberMap();
var serialize = _Protocol.GetSerialize();
var method = map.GetMethod(info);
var package = new PackageCallMethod();
package.EntityId = _Ghost.GetID();
package.MethodId = method;
package.MethodParams = args.Select(arg => serialize.Serialize(arg)).ToArray();
if (return_value != null)
{
package.ReturnId = _ReturnValueQueue.PushReturnValue(return_value);
}
_Requester.Request(ClientToServerOpCode.CallMethod, package.ToBuffer(serialize));
}
private void _LoadSoulCompile(int type_id, Guid entity_id, Guid return_id)
{
var map = _Protocol.GetMemberMap();
var type = map.GetInterface(type_id);
var provider = _QueryProvider(type);
if (provider != null)
{
var ghost = provider.Ready(entity_id);
_SetReturnValue(return_id, ghost);
}
}
private void _LoadProperty(SoulProxy new_soul)
{
IEnumerable <PropertyInfo> propertys = new_soul.PropertyInfos;
MemberMap map = _Protocol.GetMemberMap();
foreach (PropertyInfo property in propertys)
{
int id = map.GetProperty(property);
if (property.PropertyType.GetInterfaces().Any(t => t == typeof(IDirtyable)))
{
object propertyValue = property.GetValue(new_soul.ObjectInstance);
IAccessable accessable = propertyValue as IAccessable;
_LoadProperty(new_soul.Id, id, accessable.Get());
}
}
}
private void _LoadSoulCompile(int type_id, long entity_id, long return_id)
{
MemberMap map = _Protocol.GetMemberMap();
Type type = map.GetInterface(type_id);
IProvider provider = _QueryProvider(type);
IGhost ghost = provider.Ready(entity_id);
if (return_id != 0)
{
_ReturnValue(return_id, ghost);
}
}
private void _LoadSoulCompile(int type_id, long entity_id, long return_id, long passage_id)
{
MemberMap map = _Protocol.GetMemberMap();
Type type = map.GetInterface(type_id);
IProvider provider = _QueryProvider(type);
if (provider != null)
{
IGhost ghost = provider.Ready(entity_id);
_NotifierPassage.Supply(ghost, passage_id);
_SetReturnValue(return_id, ghost);
}
else
{
}
}