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); }
private IEnumerable <IStreamable> ReceiveObjects(IZetboxContext ctx, ZetboxStreamReader sr, out List <IStreamable> auxObjects) { var result = ReceiveObjectList(ctx, sr); auxObjects = ReceiveObjectList(ctx, sr); return(result); }
public IEnumerable <T> FetchRelation <T>(IZetboxContext ctx, Guid relationId, RelationEndRole role, IDataObject parent, out List <IStreamable> auxObjects) where T : class, IRelationEntry { // TODO: could be implemented in generated properties if (parent.ObjectState == DataObjectState.New) { auxObjects = new List <IStreamable>(); return(new List <T>()); } Relation rel = ctx.FindPersistenceObject <Relation>(relationId); IEnumerable <T> result = null; List <IStreamable> tmpAuxObjects = null; var handler = _memoryFactory .GetServerCollectionHandler( _backingStore, _iftFactory(rel.A.Type.GetDataType()), _iftFactory(rel.B.Type.GetDataType()), role); var objects = handler .GetCollectionEntries(ZetboxGeneratedVersionAttribute.Current, _backingStore, relationId, role, parent.ID) .Cast <IStreamable>(); var bytes = SendObjects(objects, true).ToArray(); using (MemoryStream s = new MemoryStream(bytes)) using (var sr = new ZetboxStreamReader(_map, new BinaryReader(s))) { result = ReceiveObjects(ctx, sr, out tmpAuxObjects).Cast <T>(); } auxObjects = tmpAuxObjects; 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 IEnumerable<IPersistenceObject> FromStream(ZetboxStreamReader sr) { var baseResult = base.FromStream(sr); TestInt = sr.ReadInt32(); TestString = sr.ReadString(); return baseResult; }
public override IEnumerable <IPersistenceObject> FromStream(ZetboxStreamReader sr) { var baseResult = base.FromStream(sr); TestProperty = sr.ReadString(); return(baseResult); }
public override IEnumerable <IPersistenceObject> FromStream(ZetboxStreamReader sr) { var baseResult = base.FromStream(sr); sr.ReadConverter(i => _objectState = (DataObjectState)i); return(baseResult); }
public IEnumerable <IPersistenceObject> FromStream(ZetboxStreamReader sr) { sr.Read(out _ID); sr.Read(out _StringProperty); sr.Read(out _IntProperty); sr.Read(out _BoolProperty); return(null); }
public override IEnumerable <IPersistenceObject> FromStream(ZetboxStreamReader sr) { var baseResult = base.FromStream(sr); sr.Read(out this._Value); sr.Read(out this._fk_Parent); return(baseResult); }
public override IEnumerable <IPersistenceObject> FromStream(ZetboxStreamReader sr) { var baseResult = base.FromStream(sr); sr.ReadConverter(i => ClientObjectState = (DataObjectState)i); sr.ReadInt32(); // ignore access permissions return(baseResult); }
private IEnumerable <IStreamable> ReceiveObjects(IZetboxContext ctx, ZetboxStreamReader sr, out List <IStreamable> auxObjects) { var result = ReceiveObjectList(ctx, sr); auxObjects = ReceiveObjectList(ctx, sr); Logging.Facade.DebugFormat("retrieved: {0} objects; {1} auxObjects", result.Count, auxObjects.Count); return(result); }
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 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 override IEnumerable <IPersistenceObject> FromStream(ZetboxStreamReader binStream) { var baseResult = base.FromStream(binStream); binStream.Read(out this._MyIntProperty); binStream.Read(out this._fk_ObjectProp); binStream.Read(out this._StringProp); { int?baseValue; binStream.Read(out baseValue); ((TestObjClass)this).TestEnumProp = (Zetbox.App.Test.TestEnum)baseValue; } return(baseResult); }
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 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 IEnumerable <IPersistenceObject> FromStream(ZetboxStreamReader sr) { var baseResult = base.FromStream(sr); var result = new List <IPersistenceObject>(); this.fk_BaseTestObjClass = sr.ReadNullableInt32() ?? -1; this._StringProp = sr.ReadString(); this._TestEnumProp = (TestEnum)sr.ReadInt32(); sr.ReadCollectionEntries(this, this.TestNamesImpl); result.AddRange(this.TestNamesImpl.Cast <IPersistenceObject>()); return(baseResult == null ? result : result.Concat(baseResult)); }
public Zetbox.App.Base.Blob SetBlobStream(IZetboxContext ctx, Stream stream, string filename, string mimetype) { Zetbox.App.Base.Blob result = null; var handler = _memoryFactory.GetServerDocumentHandler(); var serverBlob = handler.SetBlobStream(ZetboxGeneratedVersionAttribute.Current, _backingStore, stream, filename, mimetype); BlobResponse resp = new BlobResponse(); resp.ID = serverBlob.ID; resp.BlobInstance = SendObjects(new IDataObject[] { serverBlob }, true); using (var sr = new ZetboxStreamReader(_map, new BinaryReader(resp.BlobInstance))) { result = ReceiveObjectList(ctx, sr).Cast <Zetbox.App.Base.Blob>().Single(); } return(result); }
private List <IStreamable> ReceiveObjectList(IZetboxContext ctx, ZetboxStreamReader sr) { List <IStreamable> result = new List <IStreamable>(); var cont = sr.ReadBoolean(); while (cont) { var objType = sr.ReadSerializableType(); IStreamable obj = (IStreamable)ctx.Internals().CreateUnattached(_iftFactory(objType.GetSystemType())); obj.FromStream(sr); result.Add((IStreamable)obj); cont = sr.ReadBoolean(); } return(result); }
public IEnumerable <IDataObject> GetListOf(IZetboxContext ctx, InterfaceType ifType, int ID, string property, out List <IStreamable> auxObjects) { List <IStreamable> tmpAuxObjects = null; IEnumerable <IDataObject> result = null; var handler = _memoryFactory.GetServerObjectHandler(ifType); var objects = handler.GetListOf(ZetboxGeneratedVersionAttribute.Current, _backingStore, ID, property); var bytes = SendObjects(objects, true).ToArray(); using (var sr = new ZetboxStreamReader(_map, new BinaryReader(new MemoryStream(bytes)))) { result = ReceiveObjects(ctx, sr, out tmpAuxObjects).Cast <IDataObject>(); } auxObjects = tmpAuxObjects; return(result); }
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 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 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_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>(); 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 IEnumerable <IDataObject> GetList(IZetboxContext ctx, InterfaceType ifType, int maxListCount, bool eagerLoadLists, IEnumerable <Expression> filter, IEnumerable <OrderBy> orderBy, out List <IStreamable> auxObjects) { List <IStreamable> tmpAuxObjects = null; IEnumerable <IDataObject> result = null; var handler = _memoryFactory.GetServerObjectHandler(ifType); var objects = handler.GetList( ZetboxGeneratedVersionAttribute.Current, _backingStore, maxListCount, filter != null ? filter.ToList() : null, orderBy != null ? orderBy.ToList() : null); var bytes = SendObjects(objects, eagerLoadLists).ToArray(); using (var sr = new ZetboxStreamReader(_map, new BinaryReader(new MemoryStream(bytes)))) { result = ReceiveObjects(ctx, sr, out tmpAuxObjects).Cast <IDataObject>(); } auxObjects = tmpAuxObjects; return(result); }
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); }
private List <IStreamable> ReceiveObjectList(IZetboxContext ctx, ZetboxStreamReader sr) { List <IStreamable> result = new List <IStreamable>(); bool cont = sr.ReadBoolean(); long dbgByteCounter = 0; long dbgObjTypeByteCounter = 0; while (cont) { long dbgCurrentPos = sr.BaseStream.Position; var objType = sr.ReadSerializableType(); dbgObjTypeByteCounter += sr.BaseStream.Position - dbgCurrentPos; IStreamable obj = (IStreamable)ctx.Internals().CreateUnattached(_iftFactory(objType.GetSystemType())); obj.FromStream(sr); result.Add((IStreamable)obj); cont = sr.ReadBoolean(); long dbgSize = sr.BaseStream.Position - dbgCurrentPos; dbgByteCounter += dbgSize; } Logging.Facade.DebugFormat("ReceiveObjectList: {0:n0} objects; {1:n0} bytes total size; {2:n0} bytes avg. size / object; Total ObjType size: {3:n0}; {4:n2}% of total", result.Count, dbgByteCounter, (double)dbgByteCounter / (double)result.Count, dbgObjTypeByteCounter, (double)dbgObjTypeByteCounter / (double)dbgByteCounter * 100.0); return(result); }
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 static void AssertCorrectContents <LOCALINTERFACE, ENUMTYPE>(ZetboxStreamReader sr, InterfaceType.Factory iftFactory) where LOCALINTERFACE : TestObjClass <LOCALINTERFACE, ENUMTYPE> where ENUMTYPE : struct { Assert.That(sr, Is.Not.Null, "no stream to inspect"); var objType = sr.ReadSerializableType(); Assert.That(objType, Is.EqualTo(GetSerializableType <LOCALINTERFACE, ENUMTYPE>(iftFactory)), "wrong interface type found"); var testObjId = sr.ReadInt32(); Assert.That(testObjId, Is.EqualTo(TestObjClassId), "wrong object ID found"); DataObjectState?objectState = null; sr.ReadConverter(i => objectState = (DataObjectState)i); Assert.That(objectState, Is.EqualTo(TestObjectState), "wrong ObjectState found"); int accessRights = sr.ReadInt32(); Assert.That(accessRights, Is.GreaterThan(0), "wrong Access Rights found"); // TestObjClass // BaseTestObjClass Reference int?testObjRefId; sr.Read(out testObjRefId); Assert.That(testObjRefId, Is.EqualTo(TestBaseClassId), "wrong BaseObjClass ID found"); // StringProp string testStringProp; sr.Read(out testStringProp); Assert.That(testStringProp, Is.EqualTo(TestStringPropValue), "wrong StringProp Value found"); //// SubClasses are not serialized, but fetched lazily //foreach (int subClassID in TestSubClassesIds) //{ // bool continuationMarkerForSubClasses = false; // BinarySerializer.FromStream(out continuationMarkerForSubClasses, sr); // Assert.That(continuationMarkerForSubClasses, Is.True, "wrong continuation marker for subClassId {0}", subClassID); // int readSubClassId; // BinarySerializer.FromStream(out readSubClassId, sr); // Assert.That(readSubClassId, Is.EqualTo(readSubClassId), "wrong subClassId read", subClassID); //} //bool continuationMarkerAfterSubClasses = false; //BinarySerializer.FromStream(out continuationMarkerAfterSubClasses, sr); //Assert.That(continuationMarkerAfterSubClasses, Is.False, "wrong continuation marker after subClassIds"); // TestEnumProp var testEnum = (TestEnum)sr.ReadInt32(); Assert.That(testEnum, Is.EqualTo(TestEnum.TestSerializationValue), "wrong enum value found"); // TestNames for (int i = 0; i < TestTestNamesIds.Length; i++) { var continuationMarkerForCes = sr.ReadBoolean(); Assert.That(continuationMarkerForCes, Is.True, "wrong continuation marker for testName #{0}", i); var ceType = sr.ReadSerializableType(); Assert.That(ceType, Is.EqualTo(GetSerializableCollectionEntryType <LOCALINTERFACE, ENUMTYPE>(iftFactory)), "wrong interface type found for collection entry #{0}", i); var readCeId = sr.ReadInt32(); Assert.That(readCeId, Is.EqualTo(TestTestNamesIds[i]), "wrong id read for collection entry #{0}", i); DataObjectState?ceObjectState = null; sr.ReadConverter(read => ceObjectState = (DataObjectState)read); Assert.That(ceObjectState, Is.EqualTo(TestCollectionEntryState), "wrong ObjectState found for collection entry #{0}", i); var readCeAccessRights = sr.ReadInt32(); Assert.That(readCeAccessRights, Is.GreaterThan(0), "wrong access rights for collection entry #{0}", i); var readValue = sr.ReadString(); Assert.That(readValue, Is.EqualTo(TestTestNamesValues[i]), "wrong value read for collection entry #{0}", i); } var continuationMarkerAfterCes = sr.ReadBoolean(); Assert.That(continuationMarkerAfterCes, Is.False, "wrong continuation marker after testNames collection entries"); }
public override IEnumerable<IPersistenceObject> FromStream(ZetboxStreamReader sr) { var baseResult = base.FromStream(sr); sr.ReadConverter(i => ClientObjectState = (DataObjectState)i); sr.ReadInt32(); // ignore access permissions return baseResult; }
public IEnumerable<IPersistenceObject> FromStream(ZetboxStreamReader sr) { sr.Read(out _ID); sr.Read(out _TestName); return null; }
public override IEnumerable<IPersistenceObject> FromStream(ZetboxStreamReader sr) { var baseResult = base.FromStream(sr); sr.ReadConverter(i => _ObjectState = (DataObjectState)i); sr.ReadConverter(i => ApplyRightsFromStream((API.AccessRights)i)); return baseResult; }
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 IEnumerable <IPersistenceObject> FromStream(ZetboxStreamReader sr) { throw new NotImplementedException(); }
public override IEnumerable<IPersistenceObject> FromStream(ZetboxStreamReader sr) { var baseResult = base.FromStream(sr); sr.ReadConverter(i => _objectState = (DataObjectState)i); return baseResult; }
public IEnumerable<IPersistenceObject> FromStream(ZetboxStreamReader sr) { sr.Read(out _ID); sr.Read(out _StringProperty); sr.Read(out _IntProperty); sr.Read(out _BoolProperty); return null; }
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 IEnumerable<IPersistenceObject> FromStream(ZetboxStreamReader binStream) { var baseResult = base.FromStream(binStream); binStream.Read(out this._MyIntProperty); binStream.Read(out this._fk_ObjectProp); binStream.Read(out this._StringProp); { int? baseValue; binStream.Read(out baseValue); ((TestObjClass)this).TestEnumProp = (Zetbox.App.Test.TestEnum)baseValue; } return baseResult; }
public IEnumerable <IPersistenceObject> FromStream(ZetboxStreamReader sr) { sr.Read(out _ID); sr.Read(out _TestName); return(null); }
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 override IEnumerable<IPersistenceObject> FromStream(ZetboxStreamReader sr) { var baseResult = base.FromStream(sr); var result = new List<IPersistenceObject>(); this.fk_BaseTestObjClass = sr.ReadNullableInt32() ?? -1; this._StringProp = sr.ReadString(); this._TestEnumProp = (TestEnum)sr.ReadInt32(); sr.ReadCollectionEntries(this, this.TestNamesImpl); result.AddRange(this.TestNamesImpl.Cast<IPersistenceObject>()); return baseResult == null ? result : result.Concat(baseResult); }
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 IEnumerable<IPersistenceObject> FromStream(ZetboxStreamReader sr) { 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)); }