public LiteClient(string HostIp, ushort HostPort, ProxySettings proxy = null, Action <LiteClient> BeforeConnect = null)
: base(HostIp, HostPort, typeof(ClientChannel), new object[0], EncryptionType.None, CompressionType.None, true, proxy)
{
this.aClient = new AClient();
if (BeforeConnect != null)
{
BeforeConnect(this);
}
aClient.Connection = this;
//aClient.Connection.MultiThreadProcessing = true;
aClient.ShareClass(typeof(Lite_Static_Cursor));
aClient.ShareClass(typeof(Lite_Socket), true);
aClient.ShareClass(typeof(Lite_Graphics), true);
aClient.ShareClass(typeof(Lite_Process), true);
aClient.ShareClass(typeof(Lite_FileStream), true);
aClient.Lock("InitConnect"); //just wait till server side completed his part
}
public object onRequest(AClient connection, PayloadReader pr)
{
ReturnResult result = new ReturnResult(null, false);
bool isDelegate = false;
bool ReadFullHeader = false;
try
{
int SharedClassId = pr.ReadInteger();
int MethodId = pr.ReadInteger();
isDelegate = pr.ReadByte() == 1;
int DelegateId = isDelegate ? pr.ReadInteger() : 0;
int DelegateClassId = isDelegate ? pr.ReadInteger() : 0;
ReadFullHeader = true;
if (connection.RemoteSharedClasses.ContainsKey(SharedClassId) ||
(isDelegate && connection.LocalSharedClasses.ContainsKey(DelegateClassId)))
{
SharedClass sClass = isDelegate ? connection.LocalSharedClasses[SharedClassId] : connection.RemoteSharedClasses[SharedClassId];
SharedMethod sharedMethod = sClass.GetMethod(MethodId);
if (sharedMethod != null)
{
List <object> args = new List <object>();
List <Type> types = new List <Type>();
SortedList <int, SharedDelegate> SharedDelegates = new SortedList <int, SharedDelegate>();
SmartSerializer serializer = new SmartSerializer();
lock (sharedMethod.Delegates)
{
if (sharedMethod.Delegates.ContainsKey(DelegateId))
{
for (int i = 0; i < sharedMethod.Delegates[DelegateId].sharedMethod.ArgumentTypes.Length; i++)
{
args.Add(serializer.Deserialize(pr.ReadBytes(pr.ReadInteger())));
}
}
else
{
for (int i = 0; i < sharedMethod.ArgumentTypes.Length; i++)
{
args.Add(serializer.Deserialize(pr.ReadBytes(pr.ReadInteger())));
}
}
}
if (!isDelegate) //atm no support yet for delegate inside another delegate
{
for (int i = 0; i < sharedMethod.DelegateIndex.Count; i++)
{
if (pr.ReadByte() == 1)
{
SharedDelegate del = pr.ReadObject <SharedDelegate>();
del.sharedMethod.sharedClass = sClass;
args[sharedMethod.DelegateIndex.Keys[i]] = DynamicDelegateCreator.CreateDelegate(del);
SharedDelegates.Add(del.sharedMethod.DelegateId, del);
}
}
}
if (isDelegate)
{
//only show the result and not the actual ReturnResult type
return(sharedMethod.Delegates[DelegateId].Delegate.DynamicInvoke(args.ToArray()));
}
else
{
MethodInfo m = sClass.InitializedClass.GetType().GetMethod(sharedMethod.Name, sharedMethod.ArgumentTypes);
if (m.GetCustomAttributes(typeof(RemoteExecutionAttribute), false).Length == 0 &&
m.GetCustomAttributes(typeof(UncheckedRemoteExecutionAttribute), false).Length == 0)
{
return(null);
}
result.ReturnValue = m.Invoke(sClass.InitializedClass, args.ToArray());
}
}
}
} catch (Exception ex)
{
if (isDelegate && ReadFullHeader)
{
throw ex;
}
result.exceptionMessage = ex.InnerException != null ? ex.InnerException.Message : ex.Message;
result.ExceptionOccured = true;
}
return(result);
}
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);
}
