public byte[] InvokeServerMethod(Guid version, SerializableType type, int ID, string method, SerializableType[] parameterTypes, byte[] parameterArray, byte[] changedObjectsArray, ObjectNotificationRequest[] notificationRequests, out byte[] retChangedObjects)
{
using (Logging.Facade.DebugTraceMethodCallFormat("InvokeServerMethod:" + method, "method={0}, ID={1}", method, ID))
{
if (type == null)
{
throw new ArgumentNullException("type");
}
if (string.IsNullOrEmpty(method))
{
throw new ArgumentNullException("method");
}
if (parameterTypes == null)
{
throw new ArgumentNullException("parameterTypes");
}
if (parameterArray == null)
{
throw new ArgumentNullException("parameterArray");
}
if (changedObjectsArray == null)
{
throw new ArgumentNullException("changedObjectsArray");
}
_perfCounter.IncrementServerMethodInvocation();
retChangedObjects = null;
try
{
DebugLogIdentity();
using (IZetboxContext ctx = _ctxFactory())
{
var parameter = new MemoryStream(parameterArray);
parameter.Seek(0, SeekOrigin.Begin);
List <object> parameterList = new List <object>();
var parameterReader = _readerFactory(new BinaryReader(parameter));
foreach (var t in parameterTypes)
{
object val;
parameterReader.Read(out val,
t.GetSystemType().IsIStreamable()
? ctx.ToImplementationType(ctx.GetInterfaceType(t.GetSystemType())).Type
: t.GetSystemType());
parameterList.Add(val);
}
var changedObjects = new MemoryStream(changedObjectsArray);
changedObjects.Seek(0, SeekOrigin.Begin);
IEnumerable <IPersistenceObject> changedObjectsList;
var result = _sohFactory
.GetServerObjectHandler(_iftFactory(type.GetSystemType()))
.InvokeServerMethod(version, ctx, ID, method,
parameterTypes.Select(t => t.GetSystemType()),
parameterList,
ReadObjects(changedObjects, ctx),
notificationRequests ?? new ObjectNotificationRequest[0],
out changedObjectsList);
retChangedObjects = SendObjects(changedObjectsList.Cast <IStreamable>(), true).ToArray();
if (Logging.Facade.IsDebugEnabled && result != null)
{
Logging.Facade.DebugFormat("Serializing method result type is '{0}'", result.GetType().FullName);
}
if (result != null && result.GetType() == typeof(string))
{
Logging.Facade.Debug("Serializing method result as string");
// string is also a IEnumerable, but FindElementTypes returns nothing
MemoryStream resultStream = new MemoryStream();
new BinaryFormatter().Serialize(resultStream, result);
return(resultStream.ToArray());
}
else if (result != null && result.GetType().IsIStreamable())
{
Logging.Facade.Debug("Serializing method result as IStreamable");
IStreamable resultObj = (IStreamable)result;
return(SendObjects(new IStreamable[] { resultObj }, true).ToArray());
}
else if (result != null && result.GetType().IsIEnumerable() && result.GetType().FindElementTypes().Any(t => t.IsIStreamable()))
{
Logging.Facade.Debug("Serializing method result as IEnumerable<IStreamable>");
var lst = ((IEnumerable)result).AsQueryable().Cast <IStreamable>().Take(Zetbox.API.Helper.MAXLISTCOUNT);
return(SendObjects(lst, true).ToArray());
}
else if (result != null)
{
Logging.Facade.Debug("Serializing method result as object with BinaryFormatter");
MemoryStream resultStream = new MemoryStream();
new BinaryFormatter().Serialize(resultStream, result);
return(resultStream.ToArray());
}
else
{
Logging.Facade.Debug("Serializing empty method");
return(new byte[] { });
}
}
}
catch (Exception ex)
{
Helper.ThrowFaultException(ex);
// Never called, Handle errors throws an Exception
return(null);
}
}
}
public object InvokeServerMethod(IZetboxContext ctx, InterfaceType ifType, int ID, string method, Type retValType, IEnumerable <Type> parameterTypes, IEnumerable <object> parameter, IEnumerable <IPersistenceObject> objects, IEnumerable <ObjectNotificationRequest> notificationRequests, out IEnumerable <IPersistenceObject> changedObjects, out List <IStreamable> auxObjects)
{
_perfCounter.IncrementServerMethodInvocation();
object result = null;
auxObjects = null;
byte[] retChangedObjectsArray = null;
byte[] bytes = null;
using (var parameterStream = new MemoryStream())
using (var parameterWriter = _writerFactory(new BinaryWriter(parameterStream)))
{
foreach (var paramVal in parameter)
{
parameterWriter.Write(paramVal);
}
using (var changedObjectsStream = new MemoryStream())
using (var sw = _writerFactory(new BinaryWriter(changedObjectsStream)))
{
SendObjects(objects, sw);
var _ifType = ifType.ToSerializableType();
var _parameterTypes = parameterTypes.Select(t => _iftFactory(t).ToSerializableType()).ToArray();
var _parameterStream = parameterStream.ToArray();
var _changedObjStream = changedObjectsStream.ToArray();
var _nReq = notificationRequests.ToArray();
MakeRequest(() =>
{
bytes = _service.InvokeServerMethod(
out retChangedObjectsArray,
ZetboxGeneratedVersionAttribute.Current,
_ifType,
ID,
method,
_parameterTypes,
_parameterStream,
_changedObjStream,
_nReq);
});
}
}
IEnumerable <IPersistenceObject> tmpChangedObjects = null;
using (var resultStream = new MemoryStream(bytes))
{
using (var retChangedObjects = new MemoryStream(retChangedObjectsArray))
using (var br = _readerFactory(new BinaryReader(retChangedObjects)))
{
tmpChangedObjects = ReceiveObjectList(ctx, br).Cast <IPersistenceObject>();
}
resultStream.Seek(0, SeekOrigin.Begin);
if (retValType.IsIStreamable())
{
var br = _readerFactory(new BinaryReader(resultStream));
result = ReceiveObjects(ctx, br, out auxObjects).Cast <IPersistenceObject>().FirstOrDefault();
}
else if (retValType.IsIEnumerable() && retValType.FindElementTypes().Any(t => t.IsIPersistenceObject()))
{
var br = _readerFactory(new BinaryReader(resultStream));
IList lst = (IList)Activator.CreateInstance(typeof(List <>).MakeGenericType(retValType.FindElementTypes().Single(t => t.IsIPersistenceObject())));
foreach (object resultObj in ReceiveObjects(ctx, br, out auxObjects))
{
lst.Add(resultObj);
}
result = lst;
}
else if (resultStream.Length > 0)
{
result = new BinaryFormatter().Deserialize(resultStream);
}
else
{
result = null;
}
changedObjects = tmpChangedObjects;
return(result);
}
}
