public void Multistep_Serialization_References_With_MemoryStream() { using (var stream = new MemoryStream()) { { var writer = new ObjectWriter(stream); var primitiveClass1 = new PrimitiveTestClass(); primitiveClass1.Float = 20.5f; primitiveClass1.Integer = 77; writer.Write(primitiveClass1); writer.Write(primitiveClass1); } var reader = new ObjectReader(stream); var readPrimitiveClass1 = reader.Read() as PrimitiveTestClass; Assert.AreEqual(readPrimitiveClass1.Float, 20.5f); Assert.AreEqual(readPrimitiveClass1.Integer, 77); var readPrimitiveClass2 = reader.Read() as PrimitiveTestClass; Assert.AreSame(readPrimitiveClass1, readPrimitiveClass2); } }
public void Multistep_Serialization_References_Static_NonStatic_With_MemoryStream() { using (var stream = new MemoryStream()) { { var myClass = new PrimitiveTestClass(); StaticPrimitiveContainer.TestClass = myClass; StaticPrimitiveContainer.TestClass.Float = 5.7f; StaticPrimitiveContainer.TestClass.Integer = 32; var assembly = Assembly.GetExecutingAssembly(); var writer = new ObjectWriter(stream); writer.WriteStatics(assembly); writer.Write(myClass); } var reader = new ObjectReader(stream); reader.ReadStatics(); Assert.AreEqual(StaticPrimitiveContainer.TestClass.Float, 5.7f); var readClass = reader.Read() as PrimitiveTestClass; Assert.AreSame(readClass, StaticPrimitiveContainer.TestClass); } }
public void Generic_List_With_MemoryStream() { using (var stream = new MemoryStream()) { { var list = new List <int>(); for (var i = 0; i < 5; i++) { list.Add(1 << i); } var writer = new ObjectWriter(stream); writer.Write(list); } var reader = new ObjectReader(stream); var readObject = reader.Read(); Assert.AreSame(readObject.GetType(), typeof(List <int>)); var parsedObject = (List <int>)readObject; Assert.AreEqual(parsedObject.Count, 5); for (var i = 0; i < parsedObject.Count; i++) { Assert.IsTrue((parsedObject[i] & (parsedObject[i] - 1)) == 0); } } }
public void Polymorphism_Array_With_MemoryStream() { using (var stream = new MemoryStream()) { { var animals = new Animal[2]; animals[0] = new Dog(); animals[1] = new Cat(); var writer = new ObjectWriter(stream); writer.Write(animals); } var reader = new ObjectReader(stream); var readObject = reader.Read(); Assert.AreSame(readObject.GetType(), typeof(Animal[])); var animalArray = readObject as Animal[]; Assert.AreEqual(animalArray.Length, 2); Assert.AreEqual(animalArray[0].GetType(), typeof(Dog)); Assert.AreEqual(animalArray[1].GetType(), typeof(Cat)); } }
public void Generic_Dictionary_With_MemoryStream() { using (var stream = new MemoryStream()) { { var dictionary = new Dictionary <string, float>(); dictionary["first"] = 10.7f; dictionary["second"] = 17.5f; var writer = new ObjectWriter(stream); writer.Write(dictionary); } stream.Position = 0; var streamReader = new StreamReader(stream); var readString = streamReader.ReadToEnd(); var reader = new ObjectReader(stream); var readObject = reader.Read(); Assert.AreSame(readObject.GetType(), typeof(Dictionary <string, float>)); var parsedObject = readObject as Dictionary <string, float>; Assert.AreEqual(parsedObject.Count, 2); Assert.IsTrue(parsedObject.ContainsKey("first")); Assert.IsTrue(parsedObject.ContainsKey("second")); Assert.AreEqual(parsedObject["first"], 10.7f); Assert.AreEqual(parsedObject["second"], 17.5f); } }
private ObjectSet <T> GetObjectSet <T>(ObjectReader reader) { ObjectSet <T> objectSet = null; try { objectSet = new ObjectSet <T>(reader.PageIndex, reader.PageCount, reader.TotalCount); while (reader.Read()) { T entityObject = (T)reader.Current(); object keyValue = reader.ObjectKey(); objectSet.Add(keyValue, entityObject); } } catch (ORMapperException) { throw; } catch (Exception exception) { throw new ORMapperException("GetObjectSet<T> failed for " + reader.ObjectType.ToString(), exception); } finally { if (reader != null) { reader.Close(); } } return(objectSet); }
public object GetObject(Type objectType, object objectKey, bool firstLevel) { if (objectKey == null) { return(null); } object entityObject = null; EntityKey entityKey = new EntityKey(objectType, objectKey); if (this.instances.Contains(entityKey)) { EntityMap map = this.Mappings[objectType]; if (map.AutoTrack) { Instance instance = (Instance)this.instances[entityKey]; entityObject = instance.EntityObject; } } if (entityObject == null) { Commands commands = this.Mappings.Commands(objectType); using (ObjectReader reader = this.GetObjectReader(commands.KeyQuery(objectType, objectKey), firstLevel)) { if (reader.Read()) { entityObject = reader.Current(); } } } return(entityObject); }
public void Primitives_With_MemoryStream() { using (var stream = new MemoryStream()) { { var testObject = new PrimitiveTestClass(); testObject.Integer = 75; testObject.Float = 13.37f; var writer = new ObjectWriter(stream); writer.Write(testObject); } var reader = new ObjectReader(stream); var readObject = reader.Read(); Assert.AreSame(readObject.GetType(), typeof(PrimitiveTestClass)); var parsedObject = (PrimitiveTestClass)readObject; Assert.AreEqual(parsedObject.Integer, 75); Assert.AreEqual(parsedObject.Float, 13.37f); } }
void Check <T>(T value, Action <T, T> assertTEqual = null) { var wrap = new SimpleClass <T>(); wrap.Set(value); var sb = new StringBuilder(); var writer = new ObjectWriter(new PrimitiveTextWriter(new StringWriter(sb))); writer.Write(wrap); var text = sb.ToString(); var reader = new ObjectReader(new PrimitiveTextReader(new StringReader(text))); var clone = reader.Read(); Assert.IsType <SimpleClass <T> >(clone); var tclone = (SimpleClass <T>)clone; tclone.AssertClonningSuccess(value, assertTEqual); // this is a tad different, it uses BinaryWriter and an internal flag that write less TypeSurrogate info var clone2 = Serializer.Clone(wrap); clone2.AssertClonningSuccess(value, assertTEqual); }
private static void ReadMeExample2() { byte[] bytes = { 25, 26, 27, 28, 29, 30, 31 }; var reader = new ObjectReader <Foo>(bytes); var frame = new Foo(); reader.Read(frame); }
// Jeff Lanning ([email protected]): Added for OPath support. public object GetObject(CompiledQuery query, bool firstLevel, object[] parameters) { //NOTE: Longhorn 4074 throws an exception if more than one record is returned. // Decided it was better (and faster) not to do the same. using (ObjectReader reader = this.GetObjectReader(query, true, parameters)) { return((reader.Read()) ? reader.Current() : null); } }
public void Generic_Dictionary_With_Key_References_MemoryStream() { using (var stream = new MemoryStream()) { { var dictionary = new Dictionary <PrimitiveTestClass, int>(); var firstPrimitive = new PrimitiveTestClass(); firstPrimitive.Float = 70.5f; dictionary[firstPrimitive] = 1; var secondPrimitive = new PrimitiveTestClass(); secondPrimitive.Float = 85.7f; dictionary[secondPrimitive] = 0; var writer = new ObjectWriter(stream); writer.Write(dictionary); writer.Write(firstPrimitive); writer.Write(secondPrimitive); } var reader = new ObjectReader(stream); var readDictionary = reader.Read() as Dictionary <PrimitiveTestClass, int>; var firstReadPrimitive = reader.Read() as PrimitiveTestClass; var secondReadPrimitive = reader.Read() as PrimitiveTestClass; var keyEnumerator = readDictionary.Keys.GetEnumerator(); keyEnumerator.MoveNext(); Assert.AreSame(keyEnumerator.Current, firstReadPrimitive); keyEnumerator.MoveNext(); Assert.AreSame(keyEnumerator.Current, secondReadPrimitive); Assert.True(readDictionary.ContainsKey(firstReadPrimitive)); Assert.True(readDictionary.ContainsKey(secondReadPrimitive)); Assert.AreEqual(readDictionary[firstReadPrimitive], 1); Assert.AreEqual(readDictionary[secondReadPrimitive], 0); } }
private static void ObjectReaderSample() { byte[] bytes = { 255, 0, 255, 5, 13, 170 }; var frame = new FooFrame(); var reader = new ObjectReader <FooFrame>(bytes); reader.Read(frame); Console.WriteLine(frame.Foo); //-65281 Console.WriteLine(frame.Spam); //3333 Console.WriteLine(frame.Bar); //42 Console.WriteLine(frame.Eggs); //-2 }
public void CreateSimpleObject() { using (Stream stream = new MemoryStream()) using (ObjectWriter wr = new ObjectWriter(new BinaryWriter(stream))) using (BinaryReader br = new BinaryReader(stream)) { wr.Write(new SampleClass()); stream.Seek(0, SeekOrigin.Begin); ObjectReader target = new ObjectReader(br); var result = target.Read <SampleClass>(); Assert.IsInstanceOfType(result, typeof(SampleClass)); } }
public void AssemblyLoad() { using (var stream = new MemoryStream()) { { var myAssembly = AppDomain.CurrentDomain.GetAssemblies()[1]; var writer = new ObjectWriter(stream); writer.Write(myAssembly); } var reader = new ObjectReader(stream); var readAssembly = reader.Read() as Assembly; } }
public void Delegate_Null_Target_With_MemoryStream() { using (var stream = new MemoryStream()) { { var handler = new Action(EmptyFunction); handler += () => MyFunction(); var writer = new ObjectWriter(stream); writer.Write(handler); } var reader = new ObjectReader(stream); var readHolder = reader.Read() as Action; } }
public void PropertyDefaultValue() { using (var stream = new MemoryStream()) { { var myClass = new PropertyHolder(); var writer = new ObjectWriter(stream); writer.Write(myClass); } var reader = new ObjectReader(stream); var readClass = reader.Read() as PropertyHolder; Assert.AreEqual(readClass.Float, 800.0); } }
public void IntPtr_With_MemoryStream() { using (var stream = new MemoryStream()) { { var ptr = new IntPtr(0xDEDEDE); var writer = new ObjectWriter(stream); writer.Write(ptr); } var reader = new ObjectReader(stream); var readValue = (IntPtr)reader.Read(); Assert.AreEqual(readValue.ToInt64(), 0xDEDEDE); } }
public void Generic_Member_Instance_With_MemoryStream() { using (var stream = new MemoryStream()) { { var genericInstance = new GenericInstance <PrimitiveTestClass>(); var writer = new ObjectWriter(stream); writer.Write(genericInstance); } var reader = new ObjectReader(stream); var readValue = reader.Read() as GenericInstance <PrimitiveTestClass>; Assert.AreSame(readValue.GetType(), typeof(GenericInstance <PrimitiveTestClass>)); } }
private System.Collections.ObjectModel.Collection <T> GetCollection <T>(ObjectReader reader) { System.Collections.ObjectModel.Collection <T> collection = new System.Collections.ObjectModel.Collection <T>(); try { while (reader.Read()) { collection.Add((T)reader.Current()); } } finally { if (reader != null) { reader.Close(); } } return(collection); }
public void ReadOnlySerialization_With_MemoryStream() { using (var stream = new MemoryStream()) { { var myClass = new ReadOnlyOwnerClass(); var writer = new ObjectWriter(stream); writer.Write(myClass); } var reader = new ObjectReader(stream); var readClass = reader.Read() as ReadOnlyOwnerClass; Assert.AreEqual(readClass.test.Float, 5); } }
public void CreateSimpleObjectWithIntMember() { using (Stream stream = new MemoryStream()) using (ObjectWriter wr = new ObjectWriter(new BinaryWriter(stream))) using (BinaryReader br = new BinaryReader(stream)) { const int five = 5; var simpleObject = new SampleClass { simpleMember = five }; wr.Write(simpleObject); stream.Seek(0, SeekOrigin.Begin); ObjectReader target = new ObjectReader(br); var result = target.Read <SampleClass>(); Assert.AreEqual(five, result.simpleMember); } }
public void Primitive_With_MemoryStream() { using (var stream = new MemoryStream()) { { int myInt = 1337; var writer = new ObjectWriter(stream); writer.Write(myInt); } var reader = new ObjectReader(stream); var readInteger = (int)reader.Read(); Assert.AreSame(readInteger.GetType(), typeof(int)); Assert.AreEqual(readInteger, 1337); } }
public void ObjectReaderParsesNullableStructs_Test() { using (var ms = new MemoryStream(new byte[] { (byte)ObjectType.Instance, 5, 0, 0, 0 })) { var v = ObjectReader.Read <int?>(ms); Assert.NotNull(v); Assert.Equal(5, v !.Value); } using (var ms = new MemoryStream(new byte[] { (byte)ObjectType.Default })) { var v = ObjectReader.Read <int?>(ms); Assert.NotNull(v); Assert.Equal(0, v !.Value); } using (var ms = new MemoryStream(new byte[] { (byte)ObjectType.Null })) { Assert.Null(ObjectReader.Read <int?>(ms)); } }
public void Lambda_Action_With_MemoryStream() { using (var stream = new MemoryStream()) { { var actionHolder = new LambdaActionHolder(); var actionOwner = new LambdaActionOwner(); actionHolder.method = () => actionOwner.MyFunction(); var writer = new ObjectWriter(stream); writer.Write(actionHolder); } var reader = new ObjectReader(stream); var readHolder = reader.Read() as LambdaActionHolder; //Assert.AreEqual(readHolder.method.Target.GetType(), typeof(LambaActionOwner)); } }
public void ObjectReference_Test_With_MemoryStream() { using (var stream = new MemoryStream()) { { var value = new MyReferenceClass(); value.testClassCopy = value.testClass; Assert.AreSame(value.testClass, value.testClassCopy); var writer = new ObjectWriter(stream); writer.Write(value); } var reader = new ObjectReader(stream); var readValue = reader.Read() as MyReferenceClass; Assert.AreSame(readValue.testClass, readValue.testClassCopy); } }
public void Enum_With_MemoryStream() { using (var stream = new MemoryStream()) { { var myEnum = TestEnumeration.Second; var writer = new ObjectWriter(stream); writer.Write(myEnum); } var reader = new ObjectReader(stream); var readObject = reader.Read(); Assert.AreSame(readObject.GetType(), typeof(TestEnumeration)); var enumObject = (TestEnumeration)readObject; Assert.AreEqual(enumObject, TestEnumeration.Second); } }
public void ObjectReaderParsesArray_Test() { using (var ms = new MemoryStream(new byte[] { 3, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0 })) { Assert.Equal(new int[] { 1, 2, 3 }, ObjectReader.Read <int[]>(ms)); } using (var ms = new MemoryStream(new byte[] { 0, 0, 0, 0 })) { Assert.Equal(Array.Empty <int>(), ObjectReader.Read <int[]>(ms)); } using (var ms = new MemoryStream(new byte[] { 255, 255, 255, 255 })) { Assert.Null(ObjectReader.Read <int[]>(ms)); } }
private IList GetCollection(Type collectionType, ObjectReader reader) { IList collection = null; if (collectionType == typeof(ObjectSet)) { collection = new ObjectSet(reader.ObjectType, reader.PageIndex, reader.PageCount, reader.TotalCount); } else if (collectionType == typeof(ObjectList)) { ObjectSet objectSet = new ObjectSet(reader.ObjectType, reader.PageIndex, reader.PageCount, reader.TotalCount); collection = new ObjectList(this, objectSet); } else { collection = (IList)Activator.CreateInstance(collectionType, true); } try { while (reader.Read()) { if (collectionType == typeof(IObjectSet)) { ((IObjectSet)collection).Add(reader.ObjectKey(), reader.Current()); } else { collection.Add(reader.Current()); } } } finally { if (reader != null) { reader.Close(); } } return(collection); }
public void String_With_MemoryStream() { using (var stream = new MemoryStream()) { { StringTestClass testObject = new StringTestClass(); testObject.String = "This string was brought to you by Crytek"; var writer = new ObjectWriter(stream); writer.Write(testObject); } var reader = new ObjectReader(stream); var readObject = reader.Read(); Assert.AreSame(readObject.GetType(), typeof(StringTestClass)); var parsedObject = (StringTestClass)readObject; Assert.AreEqual(parsedObject.String, "This string was brought to you by Crytek"); } }
public void Test_ObjectReader_NotObject() { var raw = "%Comment"; var stream = new MemoryStream(Encoding.ASCII.GetBytes(raw)); var reader = new ObjectReader(stream, null); var obj = reader.Read(); Assert.IsNull(obj); Assert.AreEqual(0, stream.Position); stream.Dispose(); raw = "0 0 obj\r\n5\r\nendobj"; stream = new MemoryStream(Encoding.ASCII.GetBytes(raw)); reader = new ObjectReader(stream, null); obj = reader.Read(); Assert.IsNull(obj); Assert.AreEqual(0, stream.Position); stream.Dispose(); raw = "2 -5 obj\r\n5\r\nendobj"; stream = new MemoryStream(Encoding.ASCII.GetBytes(raw)); reader = new ObjectReader(stream, null); obj = reader.Read(); Assert.IsNull(obj); Assert.AreEqual(0, stream.Position); stream.Dispose(); }
public void Test_ObjectReader_UnknownType() { const string raw = "1 0 obj\r\nsomething unknown\r\nendobj"; var stream = new MemoryStream(Encoding.ASCII.GetBytes(raw)); var reader = new ObjectReader(stream, null); try { reader.Read(); } finally { stream.Dispose(); } }
public void Test_ObjectReader_UnexpectedEndOfObject() { const string raw = "1 0 obj\r\n0\r\n5"; var stream = new MemoryStream(Encoding.ASCII.GetBytes(raw)); var reader = new ObjectReader(stream, null); try { reader.Read(); } finally { stream.Dispose(); } }
public void Test_ObjectReader_Regular() { const string raw = "1 0 obj\r\n200\r\nendobj\r\n2 3 obj\r\n-12.5\r\nendobj"; var stream = new MemoryStream(Encoding.ASCII.GetBytes(raw)); var reader = new ObjectReader(stream, null); var obj = reader.Read(); Assert.IsNotNull(obj); Assert.AreEqual(200, ((IntegerObject) obj).Value); Assert.AreEqual(1u, obj.Number); Assert.AreEqual(0u, obj.Generation); obj = reader.Read(); Assert.IsNotNull(obj); Assert.AreEqual(-12.5f, ((RealObject) obj).Value); Assert.AreEqual(2u, obj.Number); Assert.AreEqual(3u, obj.Generation); stream.Dispose(); }