internal void ProcessPacket(IMessage message)
{
/*if(message.GetType() == typeof(MsgRequest))
* {
* MsgRequest req = message as MsgRequest;
* object ret = null;
*
* switch (packetId)
* {
* case PacketId.Shared_GetClass:
* ret = new R_GetSharedClass().onRequest(this, pr);
* break;
* case PacketId.Shared_ExecuteMethod:
* ret = new R_SharedMethodInvoke().onRequest(this, pr);
* break;
* }
*
* if (SendResultBack)
* {
* Connection.SendMessage(new MsgRequestResult(RequestId, ret));
* }
* }*/
if (message.GetType() == typeof(MsgGetSharedClass))
{
MsgGetSharedClass req = message as MsgGetSharedClass;
object ret = new R_GetSharedClass().onRequest(this, req);
Connection.SendMessage(new MsgGetSharedClassResponse(req.RequestId, ret as ReturnResult));
}
else if (message.GetType() == typeof(MsgGetSharedClassResponse))
{
MsgGetSharedClassResponse response = message as MsgGetSharedClassResponse;
lock (GetSharedClassRequests)
{
if (GetSharedClassRequests.ContainsKey(response.RequestId))
{
GetSharedClassRequests[response.RequestId].Value = response.Result;
GetSharedClassRequests[response.RequestId].Pulse();
}
}
}
else if (message.GetType() == typeof(MsgExecuteMethod))
{
MsgExecuteMethod req = message as MsgExecuteMethod;
object ret = new R_SharedMethodInvoke().onRequest(this, new PayloadReader(req.Data));
if (req.RequireResultBack)
{
Connection.SendMessage(new MsgExecuteMethodResponse(req.RequestId, ret as ReturnResult));
//Connection.SendMessage(new MsgRequestResult(RequestId, ret));
}
}
else if (message.GetType() == typeof(MsgExecuteMethodResponse))
{
lock (MethodRequests)
{
MsgExecuteMethodResponse response = message as MsgExecuteMethodResponse;
if (MethodRequests.ContainsKey(response.RequestId))
{
MethodRequests[response.RequestId].Value = response.result;
MethodRequests[response.RequestId].Pulse();
MethodRequests.Remove(response.RequestId);
}
}
}
/*else if (message.GetType() == typeof(MsgRequestResult))
* {
* lock (BeginRequestLock)
* {
* MsgRequestResult result = message as MsgRequestResult;
* if (Requests.ContainsKey(result.RequestId))
* {
* Request req = Requests[result.RequestId];
* req.syncObject.Value = result.ReturnObject;
* req.syncObject.Pulse();
*
* if (req.Async)
* req.Callback(req.syncObject.Value);
* Requests.Remove(result.RequestId);
* }
* }
* }*/
else if (message.GetType() == typeof(MsgReleaseLock))
{
lock (NetworkLocks)
{
MsgReleaseLock releaseLock = message as MsgReleaseLock;
uint LockId = releaseLock.LockId;
if (NetworkLocks.ContainsKey(LockId))
{
NetworkLocks[LockId].Pulse();
NetworkLocks.Remove(LockId);
}
else
{
NetworkLocks.Add(LockId, new SyncObject(this.Connection.Connection));
NetworkLocks[LockId].Pulse();
}
}
}
}
public object onRequest(AClient connection, MsgGetSharedClass request)
{
ReturnResult result = new ReturnResult(null, false);
lock (connection.SharingClasses)
{
try
{
if (connection.SharingClasses.ContainsKey(request.ClassName))
{
SharedClass localSharedClass = connection.SharingClasses[request.ClassName];
if (localSharedClass.RemoteInitialize)
{
bool FoundConstructor = false;
if (request.ArgObjects.Length > 0)
{
//lets check if there is a constructor with these arguments
for (int i = 0; i < localSharedClass.ConstructorTypes.Count; i++)
{
if (localSharedClass.ConstructorTypes[i].Length == request.ArgObjects.Length)
{
bool CorrectArgs = true;
for (int j = 0; j < request.ArgObjects.Length; j++)
{
if (localSharedClass.ConstructorTypes[i][j] != request.ArgObjects[j].GetType() &&
localSharedClass.ConstructorTypes[i][j] != request.ArgObjects[j].GetType().BaseType)
{
CorrectArgs = false;
break;
}
}
if (CorrectArgs)
{
FoundConstructor = true;
break;
}
}
}
if (!FoundConstructor)
{
return(null);
}
}
}
SharedClass sClass = new SharedClass(localSharedClass.BaseClassType, connection, localSharedClass.RemoteInitialize, localSharedClass.BaseClassTypeArgs);
sClass.InitializedClass = Activator.CreateInstance(sClass.BaseClassType, localSharedClass.RemoteInitialize ? request.ArgObjects : sClass.BaseClassTypeArgs);
Random rnd = new Random(DateTime.Now.Millisecond);
int RandomId = rnd.Next();
while (connection.RemoteSharedClasses.ContainsKey(RandomId))
{
RandomId = rnd.Next();
}
sClass.SharedId = RandomId;
connection.RemoteSharedClasses.Add(RandomId, sClass);
result.ReturnValue = sClass;
return(result);
}
} catch (Exception ex)
{
result.ExceptionOccured = true;
result.exceptionMessage = ex.InnerException != null ? ex.InnerException.Message : ex.Message;
}
}
return(result);
}
