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