public IEnumerable <IPersistenceObject> SetObjects(IZetboxContext ctx, IEnumerable <IPersistenceObject> objects, IEnumerable <ObjectNotificationRequest> notficationRequests) { IEnumerable <IPersistenceObject> result = null; // Serialize using (var ms = new MemoryStream()) using (var sw = new ZetboxStreamWriter(_map, new BinaryWriter(ms))) { SendObjects(objects, sw); var handler = _memoryFactory.GetServerObjectSetHandler(); var changedObjects = handler .SetObjects(ZetboxGeneratedVersionAttribute.Current, _backingStore, objects, notficationRequests ?? new ObjectNotificationRequest[0]) .Cast <IStreamable>(); var bytes = SendObjects(changedObjects, true).ToArray(); using (var sr = new ZetboxStreamReader(_map, new BinaryReader(new MemoryStream(bytes)))) { // merge auxiliary objects into primary set objects result List <IStreamable> auxObjects; var receivedObjects = ReceiveObjects(ctx, sr, out auxObjects); result = receivedObjects.Concat(auxObjects).Cast <IPersistenceObject>(); } } return(result); }
/// <summary> /// Serializes a list of objects onto a <see cref="MemoryStream"/>. /// </summary> /// <param name="lst">the list of objects to send</param> /// <param name="eagerLoadLists">True if Lists should be eager loaded</param> /// <returns>a memory stream containing all objects and all eagerly loaded auxiliary objects</returns> private MemoryStream SendObjects(IEnumerable <IStreamable> lst, bool eagerLoadLists) { HashSet <IStreamable> sentObjects = new HashSet <IStreamable>(); HashSet <IStreamable> auxObjects = new HashSet <IStreamable>(); MemoryStream result = new MemoryStream(); ZetboxStreamWriter sw = new ZetboxStreamWriter(_map, new BinaryWriter(result)); foreach (IStreamable obj in lst) { sw.Write(true); // don't check sentObjects here, because a list might contain items twice obj.ToStream(sw, auxObjects, eagerLoadLists); sentObjects.Add(obj); } sw.Write(false); SendAuxiliaryObjects(sw, auxObjects, sentObjects, eagerLoadLists); // https://connect.microsoft.com/VisualStudio/feedback/details/541494/wcf-streaming-issue sw.Write(false); sw.Write(false); sw.Write(false); result.Seek(0, SeekOrigin.Begin); return(result); }
public void Stream() { var typeMap = scope.Resolve <TypeMap>(); using (var ms = new MemoryStream()) using (var sw = new ZetboxStreamWriter(typeMap, new BinaryWriter(ms))) using (var sr = new ZetboxStreamReader(typeMap, new BinaryReader(ms))) { var ctx = GetContext(); ctx.Attach(obj); obj.ToStream(sw, null, false); Assert.That(ms.Length, Is.GreaterThan(0)); ms.Seek(0, SeekOrigin.Begin); var t = sr.ReadSerializableType(); Assert.That(t.GetSystemType().IsAssignableFrom(typeof(ANewObjectClass)), string.Format("{0} not assignable to {1}", typeof(ANewObjectClass), t)); BaseClientDataObjectMockImpl result = new BaseClientDataObjectMockImpl(null); result.FromStream(sr); Assert.That(result.GetType(), Is.EqualTo(obj.GetType())); Assert.That(result.ID, Is.EqualTo(obj.ID)); Assert.That(result.ObjectState, Is.EqualTo(obj.ObjectState)); } }
public override void ToStream(ZetboxStreamWriter binStream, HashSet <IStreamable> auxObjects, bool eagerLoadLists) { base.ToStream(binStream, auxObjects, eagerLoadLists); binStream.Write(this._MyIntProperty); binStream.Write(this._fk_ObjectProp); binStream.Write(this._StringProp); binStream.Write((int?)((TestObjClass)this).TestEnumProp); }
public void ToStream(ZetboxStreamWriter sw, HashSet <IStreamable> auxObjects, bool eagerLoadLists) { sw.Write(ReadOnlyContext.GetInterfaceType(this).ToSerializableType()); sw.Write(ID); sw.Write(StringProperty); sw.Write(IntProperty); sw.Write(BoolProperty); }
private static void SendObjects(IEnumerable <IPersistenceObject> objects, ZetboxStreamWriter sw) { foreach (var obj in objects) { sw.Write(true); obj.ToStream(sw, new HashSet <IStreamable>(), false); } sw.Write(false); }
public override void ToStream(ZetboxStreamWriter sw, HashSet <IStreamable> auxObjects, bool eagerLoadLists) { base.ToStream(sw, auxObjects, eagerLoadLists); int?id = this.BaseTestObjClass == null ? (int?)null : this.BaseTestObjClass.ID; sw.Write(id); sw.Write(this._StringProp); sw.Write((int)this.TestEnumProp); sw.WriteCollectionEntries(this.TestNamesImpl); }
public override void SetUp() { base.SetUp(); readerFactory = scope.Resolve<ZetboxStreamReader.Factory>(); writerFactory = scope.Resolve<ZetboxStreamWriter.Factory>(); stream = new MemoryStream(); reader = readerFactory.Invoke(new BinaryReader(stream)); writer = writerFactory.Invoke(new BinaryWriter(stream)); }
public override void SetUp() { base.SetUp(); readerFactory = scope.Resolve <ZetboxStreamReader.Factory>(); writerFactory = scope.Resolve <ZetboxStreamWriter.Factory>(); stream = new MemoryStream(); reader = readerFactory.Invoke(new BinaryReader(stream)); writer = writerFactory.Invoke(new BinaryWriter(stream)); }
public ZetboxService(IServerObjectHandlerFactory sohFactory, Func<IZetboxContext> ctxFactory, InterfaceType.Factory iftFactory, IPerfCounter perfCounter, ZetboxStreamReader.Factory readerFactory, ZetboxStreamWriter.Factory writerFactory) { if (readerFactory == null) throw new ArgumentNullException("readerFactory"); if (writerFactory == null) throw new ArgumentNullException("writerFactory"); Logging.Facade.Debug("Creating new ZetboxService instance"); _sohFactory = sohFactory; _ctxFactory = ctxFactory; _iftFactory = iftFactory; _perfCounter = perfCounter; _readerFactory = readerFactory; _writerFactory = writerFactory; }
public void should_use_interfacetype_on_the_stream() { var typeMap = scope.Resolve <TypeMap>(); var ms = new MemoryStream(); var sw = new ZetboxStreamWriter(typeMap, new BinaryWriter(ms)); var sr = new ZetboxStreamReader(typeMap, new BinaryReader(ms)); obj.ToStream(sw, null, false); ms.Seek(0, SeekOrigin.Begin); var t = sr.ReadSerializableType(); Assert.That(t, Is.EqualTo(_iftFactory(typeof(TestObjClass)).ToSerializableType())); }
public void ToStream_creates_correct_Stream() { var typeMap = scope.Resolve <TypeMap>(); var ms = new MemoryStream(); var sw = new ZetboxStreamWriter(typeMap, new BinaryWriter(ms)); var sr = new ZetboxStreamReader(typeMap, new BinaryReader(ms)); InitialiseObject(obj); obj.ToStream(sw, null, false); Assert.That(ms.Length, Is.GreaterThan(0)); ms.Seek(0, SeekOrigin.Begin); TestObjClassSerializationMock.AssertCorrectContents <TestObjClass, TestEnum>(sr, _iftFactory); }
/// <summary> /// Serializes a test TestObjClass to the stream sw. /// </summary> /// <param name="sw"></param> public static void ToStream <LOCALINTERFACE, ENUMTYPE>(ZetboxStreamWriter sw, InterfaceType.Factory iftFactory) where LOCALINTERFACE : TestObjClass <LOCALINTERFACE, ENUMTYPE> where ENUMTYPE : struct { // BaseServerPersistenceObject sw.Write(GetSerializableType <LOCALINTERFACE, ENUMTYPE>(iftFactory)); sw.Write(TestObjClassId); sw.Write((int)TestObjectState); sw.Write((int)AccessRights.Full); // TestObjClass // BaseTestObjClass Reference sw.Write(TestBaseClassId); // StringProp sw.Write(TestStringPropValue); //// SubClasses are not serialized, but fetched lazily //foreach (int subClassID in TestSubClassesIds) //{ // BinarySerializer.ToStream(true, sw); // BinarySerializer.ToStream(subClassID, sw); //} //BinarySerializer.ToStream(false, sw); // TestEnumProp sw.Write((int)TestEnum.TestSerializationValue); // TestNames var ceType = GetSerializableCollectionEntryType <LOCALINTERFACE, ENUMTYPE>(iftFactory); for (int i = 0; i < TestTestNamesIds.Length; i++) { sw.Write(true); sw.Write(ceType); sw.Write(TestTestNamesIds[i]); sw.Write((int)TestCollectionEntryState); sw.Write((int)AccessRights.Full); sw.Write(TestTestNamesValues[i]); } sw.Write(false); }
public HttpServiceClient(ICredentialsResolver credentialsResolver, ZetboxStreamReader.Factory readerFactory, ZetboxStreamWriter.Factory writerFactory) { if (credentialsResolver == null) throw new ArgumentNullException("credentialsResolver"); if (readerFactory == null) throw new ArgumentNullException("readerFactory"); if (writerFactory == null) throw new ArgumentNullException("writerFactory"); SetObjectsUri = new Uri(ConfigurationManager.AppSettings["serviceUri"] + "/SetObjects"); GetObjectsUri = new Uri(ConfigurationManager.AppSettings["serviceUri"] + "/GetObjects"); GetListOfUri = new Uri(ConfigurationManager.AppSettings["serviceUri"] + "/GetListOf"); FetchRelationUri = new Uri(ConfigurationManager.AppSettings["serviceUri"] + "/FetchRelation"); GetBlobStreamUri = new Uri(ConfigurationManager.AppSettings["serviceUri"] + "/GetBlobStream"); SetBlobStreamUri = new Uri(ConfigurationManager.AppSettings["serviceUri"] + "/SetBlobStream"); InvokeServerMethodUri = new Uri(ConfigurationManager.AppSettings["serviceUri"] + "/InvokeServerMethod"); _credentialsResolver = credentialsResolver; _readerFactory = readerFactory; _writerFactory = writerFactory; }
public void ToStream_creates_correct_Stream() { var typeMap = scope.Resolve <TypeMap>(); using (var ms = new MemoryStream()) using (var sw = new ZetboxStreamWriter(typeMap, new BinaryWriter(ms))) using (var sr = new ZetboxStreamReader(typeMap, new BinaryReader(ms))) { InitialiseObject(ctx, obj); obj.ToStream(sw, null, false); Assert.That(ms.Length, Is.GreaterThan(0)); ms.Seek(0, SeekOrigin.Begin); Assert.Ignore("need to implement mocked serialization for ObjectClass"); //TestObjClassSerializationMock.AssertCorrectContents<TestObjClass, int>(sr); } }
public void FromStream_Attached() { var typeMap = scope.Resolve<TypeMap>(); var ms = new MemoryStream(); var sw = new ZetboxStreamWriter(typeMap, new BinaryWriter(ms)); var sr = new ZetboxStreamReader(typeMap, new BinaryReader(ms)); obj.ToStream(sw, null, false); Assert.That(ms.Length, Is.GreaterThan(0)); ms.Seek(0, SeekOrigin.Begin); var ctxMock = GetContext(); TestObjClass result = ctxMock.Create<TestObjClass>(); Assert.That(result.IsAttached, Is.True); Assert.That(() => result.FromStream(sr), Throws.InstanceOf<InvalidOperationException>()); }
public void FromStream_Attached() { var typeMap = scope.Resolve <TypeMap>(); var ms = new MemoryStream(); var sw = new ZetboxStreamWriter(typeMap, new BinaryWriter(ms)); var sr = new ZetboxStreamReader(typeMap, new BinaryReader(ms)); obj.ToStream(sw, null, false); Assert.That(ms.Length, Is.GreaterThan(0)); ms.Seek(0, SeekOrigin.Begin); var ctxMock = GetContext(); TestObjClass result = ctxMock.Create <TestObjClass>(); Assert.That(result.IsAttached, Is.True); Assert.That(() => result.FromStream(sr), Throws.InstanceOf <InvalidOperationException>()); }
public void Stream() { var typeMap = scope.Resolve <TypeMap>(); var ms = new MemoryStream(); var sw = new ZetboxStreamWriter(typeMap, new BinaryWriter(ms)); var sr = new ZetboxStreamReader(typeMap, new BinaryReader(ms)); obj.ToStream(sw, null, false); Assert.That(ms.Length, Is.GreaterThan(0)); ms.Seek(0, SeekOrigin.Begin); TestCompoundObject result = new TestCompoundObject(); result.FromStream(sr); Assert.That(result.TestInt, Is.EqualTo(obj.TestInt)); Assert.That(result.TestString, Is.EqualTo(obj.TestString)); }
public void FromStream_creates_correct_Object() { var typeMap = scope.Resolve <TypeMap>(); using (var ms = new MemoryStream()) using (var sw = new ZetboxStreamWriter(typeMap, new BinaryWriter(ms))) using (var sr = new ZetboxStreamReader(typeMap, new BinaryReader(ms))) { Assert.Ignore("need to implement mocked serialization for ObjectClass"); //TestObjClassSerializationMock.ToStream<TestObjClass, int>(sw); sw.Flush(); Assert.That(ms.Length, Is.GreaterThan(0)); ms.Seek(0, SeekOrigin.Begin); obj.FromStream(sr); //TestObjClassSerializationMock.AssertCorrectContentsInt<TestObjClass>(objImpl); } }
public void FromStream_Attached_fails() { var typeMap = scope.Resolve <TypeMap>(); using (var ms = new MemoryStream()) using (var sw = new ZetboxStreamWriter(typeMap, new BinaryWriter(ms))) using (var sr = new ZetboxStreamReader(typeMap, new BinaryReader(ms))) { obj.ToStream(sw, null, false); Assert.That(ms.Length, Is.GreaterThan(0)); ms.Seek(0, SeekOrigin.Begin); using (var ctx = GetContext()) { var result = ctx.Create <ObjectClass>(); result.FromStream(sr); } } }
public void FromStream_creates_correct_Object() { var typeMap = scope.Resolve<TypeMap>(); var ms = new MemoryStream(); var sw = new ZetboxStreamWriter(typeMap, new BinaryWriter(ms)); var sr = new ZetboxStreamReader(typeMap, new BinaryReader(ms)); TestObjClassSerializationMock.ToStream<TestObjClass, TestEnum>(sw, _iftFactory); sw.Flush(); Assert.That(ms.Length, Is.GreaterThan(0)); ms.Seek(0, SeekOrigin.Begin); var t = sr.ReadSerializableType(); Assert.That(t.GetSystemType().IsAssignableFrom(typeof(TestObjClass)), string.Format("{0} not assignable to {1}", typeof(TestObjClass), t)); var obj = new TestObjClassImpl(); obj.FromStream(sr); ctx.Attach(obj); TestObjClassSerializationMock.AssertCorrectContentsEnum<TestObjClass>(obj); }
/// <summary> /// Sends a list of auxiliary objects to the specified ZetboxStreamWriter while avoiding to send objects twice. /// </summary> /// <param name="sw">the stream to write to</param> /// <param name="auxObjects">a set of objects to send; will not be modified by this call</param> /// <param name="sentObjects">a set objects already sent; receives all newly sent objects too</param> /// <param name="eagerLoadLists">True if Lists should be eager loaded</param> private static void SendAuxiliaryObjects(ZetboxStreamWriter sw, HashSet <IStreamable> auxObjects, HashSet <IStreamable> sentObjects, bool eagerLoadLists) { // clone auxObjects to avoid modification auxObjects = new HashSet <IStreamable>(auxObjects); auxObjects.ExceptWith(sentObjects); // send all eagerly loaded objects while (auxObjects.Count > 0) { HashSet <IStreamable> secondTierAuxObjects = new HashSet <IStreamable>(); foreach (var aux in auxObjects.Where(o => o != null)) { sw.Write(true); aux.ToStream(sw, secondTierAuxObjects, eagerLoadLists); sentObjects.Add(aux); } // check whether new objects where eagerly loaded secondTierAuxObjects.ExceptWith(sentObjects); auxObjects = secondTierAuxObjects; } // finish list sw.Write(false); }
public void FromStream_creates_correct_Object() { var typeMap = scope.Resolve <TypeMap>(); var ms = new MemoryStream(); var sw = new ZetboxStreamWriter(typeMap, new BinaryWriter(ms)); var sr = new ZetboxStreamReader(typeMap, new BinaryReader(ms)); TestObjClassSerializationMock.ToStream <TestObjClass, TestEnum>(sw, _iftFactory); sw.Flush(); Assert.That(ms.Length, Is.GreaterThan(0)); ms.Seek(0, SeekOrigin.Begin); var t = sr.ReadSerializableType(); Assert.That(t.GetSystemType().IsAssignableFrom(typeof(TestObjClass)), string.Format("{0} not assignable to {1}", typeof(TestObjClass), t)); var obj = new TestObjClassImpl(); obj.FromStream(sr); ctx.Attach(obj); TestObjClassSerializationMock.AssertCorrectContentsEnum <TestObjClass>(obj); }
public override void ToStream(ZetboxStreamWriter sw, HashSet <IStreamable> auxObjects, bool eagerLoadLists) { base.ToStream(sw, auxObjects, eagerLoadLists); sw.Write(TestInt); sw.Write(TestString); }
public void ToStream(ZetboxStreamWriter sw, HashSet <IStreamable> auxObjects, bool eagerLoadLists) { }
private void InitStreams() { ms = new MemoryStream(); sw = scope.Resolve <ZetboxStreamWriter.Factory>().Invoke(new BinaryWriter(ms)); sr = scope.Resolve <ZetboxStreamReader.Factory>().Invoke(new BinaryReader(ms)); }
public override void ToStream(ZetboxStreamWriter sw, HashSet<IStreamable> auxObjects, bool eagerLoadLists) { base.ToStream(sw, auxObjects, eagerLoadLists); int? id = this.BaseTestObjClass == null ? (int?)null : this.BaseTestObjClass.ID; sw.Write(id); sw.Write(this._StringProp); sw.Write((int)this.TestEnumProp); sw.WriteCollectionEntries(this.TestNamesImpl); }
public override void ToStream(ZetboxStreamWriter binStream, HashSet<IStreamable> auxObjects, bool eagerLoadLists) { base.ToStream(binStream, auxObjects, eagerLoadLists); binStream.Write(this._MyIntProperty); binStream.Write(this._fk_ObjectProp); binStream.Write(this._StringProp); binStream.Write((int?)((TestObjClass)this).TestEnumProp); }
/// <summary> /// Sends a list of auxiliary objects to the specified ZetboxStreamWriter while avoiding to send objects twice. /// </summary> /// <param name="sw">the stream to write to</param> /// <param name="auxObjects">a set of objects to send; will not be modified by this call</param> /// <param name="sentObjects">a set objects already sent; receives all newly sent objects too</param> /// <param name="eagerLoadLists">True if Lists should be eager loaded</param> private static void SendAuxiliaryObjects(ZetboxStreamWriter sw, HashSet<IStreamable> auxObjects, HashSet<IStreamable> sentObjects, bool eagerLoadLists) { // clone auxObjects to avoid modification auxObjects = new HashSet<IStreamable>(auxObjects); auxObjects.ExceptWith(sentObjects); // send all eagerly loaded objects while (auxObjects.Count > 0) { HashSet<IStreamable> secondTierAuxObjects = new HashSet<IStreamable>(); foreach (var aux in auxObjects.Where(o => o != null)) { sw.Write(true); aux.ToStream(sw, secondTierAuxObjects, eagerLoadLists); sentObjects.Add(aux); } // check whether new objects where eagerly loaded secondTierAuxObjects.ExceptWith(sentObjects); auxObjects = secondTierAuxObjects; } // finish list sw.Write(false); }
public override void ToStream(ZetboxStreamWriter sw, HashSet <IStreamable> auxObjects, bool eagerLoadLists) { base.ToStream(sw, auxObjects, eagerLoadLists); sw.Write((int)ObjectState); sw.Write((int)CurrentAccessRights); }
public override void ToStream(ZetboxStreamWriter sw, HashSet<IStreamable> auxObjects, bool eagerLoadLists) { base.ToStream(sw, auxObjects, eagerLoadLists); sw.Write((int)ObjectState); sw.Write((int)CurrentAccessRights); }
public void ToStream(ZetboxStreamWriter sw, HashSet <IStreamable> auxObjects, bool eagerLoadLists) { throw new NotImplementedException(); }
public void Stream() { var typeMap = scope.Resolve<TypeMap>(); using (var ms = new MemoryStream()) using (var sw = new ZetboxStreamWriter(typeMap, new BinaryWriter(ms))) using (var sr = new ZetboxStreamReader(typeMap, new BinaryReader(ms))) { var ctx = GetContext(); ctx.Attach(obj); obj.ToStream(sw, null, false); Assert.That(ms.Length, Is.GreaterThan(0)); ms.Seek(0, SeekOrigin.Begin); var t = sr.ReadSerializableType(); Assert.That(t.GetSystemType().IsAssignableFrom(typeof(ANewObjectClass)), string.Format("{0} not assignable to {1}", typeof(ANewObjectClass), t)); BaseClientDataObjectMockImpl result = new BaseClientDataObjectMockImpl(null); result.FromStream(sr); Assert.That(result.GetType(), Is.EqualTo(obj.GetType())); Assert.That(result.ID, Is.EqualTo(obj.ID)); Assert.That(result.ObjectState, Is.EqualTo(obj.ObjectState)); } }
public void ToStream(ZetboxStreamWriter sw, HashSet<IStreamable> auxObjects, bool eagerLoadLists) { sw.Write(ReadOnlyContext.GetInterfaceType(this).ToSerializableType()); sw.Write(ID); sw.Write(StringProperty); sw.Write(IntProperty); sw.Write(BoolProperty); }
public void should_use_interfacetype_on_the_stream() { var typeMap = scope.Resolve<TypeMap>(); var ms = new MemoryStream(); var sw = new ZetboxStreamWriter(typeMap, new BinaryWriter(ms)); var sr = new ZetboxStreamReader(typeMap, new BinaryReader(ms)); obj.ToStream(sw, null, false); ms.Seek(0, SeekOrigin.Begin); var t = sr.ReadSerializableType(); Assert.That(t, Is.EqualTo(_iftFactory(typeof(TestObjClass)).ToSerializableType())); }
public void ToStream_creates_correct_Stream() { var typeMap = scope.Resolve<TypeMap>(); var ms = new MemoryStream(); var sw = new ZetboxStreamWriter(typeMap, new BinaryWriter(ms)); var sr = new ZetboxStreamReader(typeMap, new BinaryReader(ms)); InitialiseObject(obj); obj.ToStream(sw, null, false); Assert.That(ms.Length, Is.GreaterThan(0)); ms.Seek(0, SeekOrigin.Begin); TestObjClassSerializationMock.AssertCorrectContents<TestObjClass, TestEnum>(sr, _iftFactory); }
public override void ToStream(ZetboxStreamWriter sw, HashSet<IStreamable> auxObjects, bool eagerLoadLists) { base.ToStream(sw, auxObjects, eagerLoadLists); sw.Write(TestProperty); }
public override void ToStream(ZetboxStreamWriter sw, HashSet <IStreamable> auxObjects, bool eagerLoadLists) { base.ToStream(sw, auxObjects, eagerLoadLists); sw.Write(this.Value); sw.Write(this.fk_Parent); }
public void ToStream(ZetboxStreamWriter sw, HashSet<IStreamable> auxObjects, bool eagerLoadLists) { throw new NotImplementedException(); }
public void Stream() { var typeMap = scope.Resolve<TypeMap>(); var ms = new MemoryStream(); var sw = new ZetboxStreamWriter(typeMap, new BinaryWriter(ms)); var sr = new ZetboxStreamReader(typeMap, new BinaryReader(ms)); obj.ToStream(sw, null, false); Assert.That(ms.Length, Is.GreaterThan(0)); ms.Seek(0, SeekOrigin.Begin); TestCompoundObject result = new TestCompoundObject(); result.FromStream(sr); Assert.That(result.TestInt, Is.EqualTo(obj.TestInt)); Assert.That(result.TestString, Is.EqualTo(obj.TestString)); }