public void Scratch()
{
AnnotateGuidsClass annotateGuidsClass = new AnnotateGuidsClass();
AnnotateNullableGuidsClass annotateNullableGuidsClass = new AnnotateNullableGuidsClass();
MemoryStream stream;
IonSerializer serializer;
serializer = new IonSerializer(new IonSerializationOptions {
AnnotateGuids = true
});
stream = (MemoryStream)serializer.Serialize(annotateGuidsClass);
Console.WriteLine(Utils.PrettyPrint(stream));
// {
// a: 1,
// b: guid128::{{ lkjNEjlW0kmrb2M2lA+jGg== }}
// }
stream = (MemoryStream)serializer.Serialize(annotateNullableGuidsClass);
serializer.Deserialize <AnnotateNullableGuidsClass>(stream);
serializer = new IonSerializer(new IonSerializationOptions {
AnnotateGuids = false
});
stream = (MemoryStream)serializer.Serialize(annotateGuidsClass);
Console.WriteLine(Utils.PrettyPrint(stream));
// {
// a: 1,
// b: {{ lkjNEjlW0kmrb2M2lA+jGg== }}
// }
stream = (MemoryStream)serializer.Serialize(annotateNullableGuidsClass);
serializer.Deserialize <AnnotateNullableGuidsClass>(stream);
}
public void CanDeserializeToDifferentTypeUsingIonConstructor()
{
var cr = new CircleRadius(5);
var stream = defaultSerializer.Serialize(cr);
var cc = defaultSerializer.Deserialize <CircleCircumference>(stream);
Assert.AreEqual(2 * Math.PI * cr.Radius, cc.Circumference);
}
public void Scratch()
{
IonSerializer ionSerializer;
MemoryStream stream;
Supra result;
ionSerializer = new IonSerializer();
stream = (MemoryStream)ionSerializer.Serialize(TestObjects.a90);
Console.WriteLine(Utils.PrettyPrint(stream));
// 'Amazon.IonObjectMapper.Test.Supra'::{
// brand: 'OEM.Manufacturer'::"Toyota"
// }
result = ionSerializer.Deserialize <Supra>(stream);
Console.WriteLine(result);
// <Supra>{ Toyota }
ionSerializer = new IonSerializer(new IonSerializationOptions {
WriterFactory = new JsonIonWriterFactory()
});
stream = (MemoryStream)ionSerializer.Serialize(TestObjects.a90);
Console.WriteLine(Utils.PrettyPrint(stream));
// {
// brand: "Toyota"
// }
result = ionSerializer.Deserialize <Supra>(stream);
Console.WriteLine(result);
// <Supra>{ Toyota }
}
public void RespectPrettyTextSerializationFormat()
{
var serializer =
new IonSerializer(new IonSerializationOptions {
Format = IonSerializationFormat.PRETTY_TEXT
});
MemoryStream testStream = (MemoryStream)serializer.Serialize(TestObjects.John);
string testString = System.Text.Encoding.UTF8.GetString(testStream.ToArray());
IIonValue ionValue = IonLoader.Default.Load(TestObjects.JohnIonText).GetElementAt(0);
StringWriter expectedStringWriter = new StringWriter();
using (var writer =
IonTextWriterBuilder.Build(expectedStringWriter, new IonTextOptions {
PrettyPrint = true
}))
{
ionValue.WriteTo(writer);
writer.Finish();
}
string expectedString = expectedStringWriter.ToString();
Assert.AreEqual(expectedString, testString);
}
public void Scratch()
{
IonSerializer ionSerializer;
MemoryStream stream;
ionSerializer = new IonSerializer(new IonSerializationOptions {
Format = IonSerializationFormat.BINARY
});
stream = (MemoryStream)ionSerializer.Serialize(TestObjects.a90);
Console.WriteLine(BitConverter.ToString(stream.ToArray()));
// E0-01-00-EA-EE-B0...
ionSerializer = new IonSerializer(new IonSerializationOptions {
Format = IonSerializationFormat.TEXT
});
stream = (MemoryStream)ionSerializer.Serialize(TestObjects.a90);
Console.WriteLine(System.Text.Encoding.UTF8.GetString(stream.ToArray()));
// 'Amazon.IonObjectMapper.Test.Supra'::{brand:'OEM.Manufacturer'::"Toyota"}
ionSerializer = new IonSerializer(new IonSerializationOptions {
Format = IonSerializationFormat.PRETTY_TEXT
});
stream = (MemoryStream)ionSerializer.Serialize(TestObjects.a90);
Console.WriteLine(System.Text.Encoding.UTF8.GetString(stream.ToArray()));
// 'Amazon.IonObjectMapper.Test.Supra'::{
// brand: 'OEM.Manufacturer'::"Toyota"
// }
}
/// <summary>
/// Serialize a C# object into a ValueHolder object containing the Ion binary.
/// </summary>
///
/// <param name="o">The C# object to be serialized into ValueHolder.</param>
///
/// <returns>The ValueHolder object containing the Ion binary.</returns>
public ValueHolder Serialize(object o)
{
return(new ValueHolder
{
IonBinary = (MemoryStream)serializer.Serialize(o),
});
}
public void ExceptionOnMultiParameterIonPropertySetterMethods()
{
var serializer = new IonSerializer();
var stream = serializer.Serialize(TestObjects.Chalkboard);
Assert.ThrowsException <InvalidOperationException>(() => serializer.Deserialize <Chalkboard>(stream));
}
public static IIonValue SerializeToIonWithCustomSerializers <T>(
Dictionary <Type, IIonSerializer> ionSerializers, T item)
{
var serializer = new IonSerializer(new IonSerializationOptions {
IonSerializers = ionSerializers
});
var stream = serializer.Serialize(item);
return(StreamToIonValue(stream));
}
public void SerializesObjectsWithIgnoreReadOnlyProperties()
{
var serializer = new IonSerializer(new IonSerializationOptions {
IgnoreReadOnlyProperties = true
});
IIonStruct serialized = StreamToIonValue(serializer.Serialize(TestObjects.JohnGreenwood));
Assert.IsTrue(serialized.ContainsField("firstName"));
Assert.IsTrue(serialized.ContainsField("lastName"));
Assert.IsFalse(serialized.ContainsField("major"));
}
public void RespectTypeAnnotationForProperty()
{
var serializer = new IonSerializer();
var testStream = serializer.Serialize(TestObjects.a90);
var ionValue = StreamToIonValue(Copy(testStream));
Assert.IsTrue(ionValue.GetField("brand").HasAnnotation("OEM.Manufacturer"));
var deserialized = serializer.Deserialize <Supra>(testStream);
Assert.AreEqual(TestObjects.a90.ToString(), deserialized.ToString());
}
public void SerializesObjectsWithIgnoreReadOnlyFields()
{
var serializer = new IonSerializer(new IonSerializationOptions {
IgnoreReadOnlyFields = true, IncludeFields = true
});
IIonStruct serialized = StreamToIonValue(serializer.Serialize(TestObjects.drKyler));
Assert.IsFalse(serialized.ContainsField("firstName"));
Assert.IsFalse(serialized.ContainsField("lastName"));
Assert.IsTrue(serialized.ContainsField("department"));
Assert.IsFalse(serialized.ContainsField("birthDate"));
}
public void SerializesAndDeserializesObjectsWithCaseInsensitiveProperties()
{
var serializer = new IonSerializer(new IonSerializationOptions {
PropertyNameCaseInsensitive = true
});
var stream = serializer.Serialize(TestObjects.Titanic);
var deserialized = serializer.Deserialize <ShipWithVariedCasing>(stream);
Assert.AreEqual(TestObjects.Titanic.Name, deserialized.name);
Assert.AreEqual(TestObjects.Titanic.Weight, deserialized.WEIGHT);
Assert.AreEqual(TestObjects.Titanic.Capacity, deserialized.CaPaCiTy);
}
public void DeserializeBasedOnTypeAnnotations()
{
var item = new List <Vehicle>()
{
new Plane {
MaxCapacity = 64
}, new Boat(), new Helicopter()
};
var serializer = new IonSerializer();
var deserialized = serializer.Deserialize <List <Vehicle> >(serializer.Serialize(item));
Assert.AreEqual(string.Join(",", item), string.Join(",", deserialized));
}
public void SerializesObjectsWithIgnoreDefaults()
{
var serializer = new IonSerializer(new IonSerializationOptions {
IgnoreDefaults = true
});
IIonStruct serialized = StreamToIonValue(serializer.Serialize(new Motorcycle {
canOffroad = true
}));
Assert.IsFalse(serialized.ContainsField("Brand"));
Assert.IsFalse(serialized.ContainsField("color"));
Assert.IsTrue(serialized.ContainsField("canOffroad"));
}
public void Scratch()
{
IonSerializer ionSerializer;
Unicorn result;
MemoryStream stream;
Unicorn unicorn = new Unicorn();
// ionSerializer = new IonSerializer();
// stream = (MemoryStream)ionSerializer.Serialize(unicorn);
// uncommenting the previous two lines will throw a System.ArgumentNullException error
ionSerializer = new IonSerializer(new IonSerializationOptions
{
CustomContext = new Dictionary <string, object>()
{
{ "drop", "Dentine" }
}
});
stream = (MemoryStream)ionSerializer.Serialize(unicorn);
Console.WriteLine(Utils.PrettyPrint(stream));
// {
// Status: "Mythical",
// Drop: "Dentine",
// IsHorned: true
// }
result = ionSerializer.Deserialize <Unicorn>(stream);
Console.WriteLine(result);
// <Unicorn>{ Mythical, Dentine, True }
ionSerializer = new IonSerializer(new IonSerializationOptions
{
CustomContext = new Dictionary <string, object>()
{
{ "father", "Poseidon" }
}
});
stream = (MemoryStream)ionSerializer.Serialize(unicorn);
Console.WriteLine(Utils.PrettyPrint(stream));
// {
// Status: "Mythical",
// Drop: "Alicorn",
// IsHorned: true
// }
result = ionSerializer.Deserialize <Unicorn>(stream);
Console.WriteLine(result);
// <Unicorn>{ Mythical, Alicorn, True }
}
public void SerializesAndDeserializesSubtypesBasedOnTypeAnnotations()
{
var item = new List <Vehicle>()
{
new Plane(), new Boat(), new Helicopter()
};
var serializer = new IonSerializer(new IonSerializationOptions
{
AnnotatedTypeAssemblies = new string[]
{
typeof(Vehicle).Assembly.GetName().Name
}
});
var deserialized = serializer.Deserialize <List <Vehicle> >(serializer.Serialize(item));
Assert.AreEqual(string.Join(",", item), string.Join(",", deserialized));
}
public void RespectBinarySerializationFormat()
{
var serializer = new IonSerializer(new IonSerializationOptions {
Format = IonSerializationFormat.BINARY
});
MemoryStream testStream = (MemoryStream)serializer.Serialize(TestObjects.John);
IIonValue ionValue = IonLoader.Default.Load(TestObjects.JohnIonText).GetElementAt(0);
MemoryStream expectedStream = new MemoryStream();
using (var writer = IonBinaryWriterBuilder.Build(expectedStream))
{
ionValue.WriteTo(writer);
writer.Finish();
}
Assert.IsTrue(expectedStream.ToArray().SequenceEqual(testStream.ToArray()));
}
public void RespectTypeAnnotationForClassAndProperty()
{
var serializer = new IonSerializer();
var testStream = serializer.Serialize(TestObjects.honda);
var ionValue = StreamToIonValue(Copy(testStream));
string[] actualAnnotations = ionValue.GetField("engine").GetTypeAnnotationSymbols()
.Select(symbolToken => symbolToken.Text).ToArray();
string[] expectedAnnotations =
{
"Amazon.IonObjectMapper.Test.my.custom.engine.type",
"Amazon.IonObjectMapper.Test.Engine"
};
Assert.AreEqual(string.Join(",", expectedAnnotations), string.Join(",", actualAnnotations));
var deserialized = serializer.Deserialize <Car>(testStream);
Assert.AreEqual(TestObjects.honda.ToString(), deserialized.ToString());
}
private static void RecordMetrics(IDictionary <string, PerformanceTestObject> dictionary)
{
IonSerializer serializer = new IonSerializer();
GC.Collect();
GC.WaitForPendingFinalizers();
long baseMemoryUsed = GC.GetTotalMemory(true);
Stopwatch timer = new Stopwatch();
timer.Start();
Stream serialized = serializer.Serialize(dictionary);
dictionary = serializer.Deserialize <Dictionary <string, PerformanceTestObject> >(serialized);
timer.Stop();
long memoryUsed = GC.GetTotalMemory(true) - baseMemoryUsed;
suite.AddMetric(dictionary.Count, timer.ElapsedTicks, memoryUsed);
}
public void SerializeObjectsWithCustomContextFactoryAttribute()
{
var customContext = new Dictionary <string, object>()
{
{ "customCourseSerializer", new UpdateCourseSections() }
};
var customSerializer = new IonSerializer(new IonSerializationOptions {
CustomContext = customContext
});
var stream = customSerializer.Serialize(TestObjects.bob);
var serialized = StreamToIonValue(stream);
Assert.IsTrue(serialized.ContainsField("name"));
Assert.IsTrue(serialized.ContainsField("course"));
Assert.IsTrue(serialized.ContainsField("id"));
var course = serialized.GetField("course");
Assert.AreEqual(9, course.GetField("Sections").IntValue);
Assert.AreEqual("2021-10-10T13:15:21Z", course.GetField("MeetingTime").StringValue);
}
public void Scratch()
{
IonSerializer ionSerializer;
List <object> result;
MemoryStream stream;
List <object> testList = new List <object>(new object[] { "test", 5 });
ionSerializer = new IonSerializer();
stream = (MemoryStream)ionSerializer.Serialize(testList);
Console.WriteLine(Utils.PrettyPrint(stream));
// [
// "test",
// 5
// ]
result = ionSerializer.Deserialize <List <object> >(stream);
Console.WriteLine(result[0]);
// test
Console.WriteLine(result[1]);
// 5
ionSerializer = new IonSerializer(new IonSerializationOptions
{
IonSerializers = new Dictionary <Type, IIonSerializer>()
{
{ typeof(string), new BracketStringIonSerializer() }
}
});
stream = (MemoryStream)ionSerializer.Serialize(testList);
Console.WriteLine(Utils.PrettyPrint(stream));
// [
// "<test>",
// 5
// ]
result = ionSerializer.Deserialize <List <object> >(stream);
Console.WriteLine(result[0]);
// test
Console.WriteLine(result[1]);
// 5
}
public void Scratch()
{
IgnoreDefaultsClass ignoreDefaultsObject = new IgnoreDefaultsClass {
A = 1
};
MemoryStream stream;
IonSerializer ionSerializer;
ionSerializer = new IonSerializer(new IonSerializationOptions {
IgnoreDefaults = false
});
stream = (MemoryStream)ionSerializer.Serialize(ignoreDefaultsObject);
Console.WriteLine(Utils.PrettyPrint(stream));
// {
// a: 1,
// b: null
// }
ignoreDefaultsObject = ionSerializer.Deserialize <IgnoreDefaultsClass>(stream);
Console.WriteLine(ignoreDefaultsObject.A);
// 1
Console.WriteLine(ignoreDefaultsObject.B == null);
// True
ionSerializer = new IonSerializer(new IonSerializationOptions {
IgnoreDefaults = true
});
stream = (MemoryStream)ionSerializer.Serialize(ignoreDefaultsObject);
Console.WriteLine(Utils.PrettyPrint(stream));
// {
// a: 1
// }
ignoreDefaultsObject = ionSerializer.Deserialize <IgnoreDefaultsClass>(stream);
Console.WriteLine(ignoreDefaultsObject.A);
// 1
Console.WriteLine(ignoreDefaultsObject.B == null);
// True
}
public void Scratch()
{
IonSerializer ionSerializer;
Trilobyte result;
MemoryStream stream;
Trilobyte trilobyte = new Trilobyte();
ionSerializer = new IonSerializer();
stream = (MemoryStream)ionSerializer.Serialize(trilobyte);
Console.WriteLine(Utils.PrettyPrint(stream));
// {
// group: 'Paleozoic.Cambrian'::"Arthropods",
// isVertebrate: false
// },
result = ionSerializer.Deserialize <Trilobyte>(stream);
Console.WriteLine(result);
// <Trilobyte>{ Arthropods, False }
ionSerializer = new IonSerializer(new IonSerializationOptions
{
AnnotatedIonSerializers = new Dictionary <string, IIonSerializer>()
{
{ "Paleozoic.Cambrian", new CambrianIonSerializer() }
}
});
stream = (MemoryStream)ionSerializer.Serialize(trilobyte);
Console.WriteLine(Utils.PrettyPrint(stream));
// {
// group: 'Paleozoic.Cambrian'::"Springgina",
// isVertebrate: false
// },
result = ionSerializer.Deserialize <Trilobyte>(stream);
Console.WriteLine(result);
// <Trilobyte>{ Springgina, False }
}
public void RespectAnnotationInheritance()
{
var serializer = new IonSerializer(new IonSerializationOptions {
TypeAnnotationPrefix = new FixedTypeAnnotationPrefix("testing")
});
AssertHasNoAnnotations(serializer.Serialize(new House()));
AssertHasAnnotation("testing.Cabin", serializer.Serialize(new Cabin()));
AssertHasNoAnnotations(serializer.Serialize(new LogCabin()));
AssertHasNoAnnotations(serializer.Serialize(new Food()));
AssertHasAnnotation("testing.Meat", serializer.Serialize(new Meat()));
AssertHasNoAnnotations(serializer.Serialize(new Chicken()));
AssertHasNoAnnotations(serializer.Serialize(new Vegetable()));
AssertHasAnnotation("testing.Fruit", serializer.Serialize(new Fruit()));
AssertHasAnnotation("testing.Grape", serializer.Serialize(new Grape()));
AssertHasAnnotation("testing.Plane", serializer.Serialize(new Plane()));
AssertHasNoAnnotations(serializer.Serialize(new Yacht()));
AssertHasAnnotation("testing.Catamaran", serializer.Serialize(new Catamaran()));
AssertHasAnnotation("testing.Jet", serializer.Serialize(new Jet()));
AssertHasAnnotation("testing.Boeing", serializer.Serialize(new Boeing()));
}
public static T Serde <T>(IonSerializer ionSerializer, T item)
{
var stream = ionSerializer.Serialize(item);
return(ionSerializer.Deserialize <T>(stream));
}
public static IIonValue ToIonValue <T>(IonSerializer ionSerializer, T item)
{
var stream = ionSerializer.Serialize(item);
return(StreamToIonValue(stream));
}
