private static void RunOnce()
{
Writer.StepIn(IonType.List);
for (var i = 0; i < 1000; i++)
{
Writer.StepIn(IonType.Struct);
Writer.SetFieldName("boolean");
Writer.WriteBool(true);
Writer.SetFieldName("string");
Writer.WriteString("this is a string");
Writer.SetFieldName("integer");
Writer.WriteInt(int.MaxValue);
Writer.SetFieldName("float");
Writer.WriteFloat(432.23123f);
Writer.SetFieldName("timestamp");
Writer.WriteTimestamp(new Timestamp(new DateTime(2000, 11, 11)));
Writer.StepOut();
}
byte[] bytes = null;
Writer.StepOut();
Writer.Flush(ref bytes);
Writer.Finish();
}
public override void Serialize(IIonWriter writer, Course item)
{
writer.StepIn(IonType.Struct);
writer.SetFieldName("Sections");
writer.WriteInt(updateCourseSections.RemoveSections(item.Sections));
writer.SetFieldName("MeetingTime");
writer.WriteString(updateCourseSections.ShowNewTime());
writer.StepOut();
}
public override void Serialize(IIonWriter writer, Unicorn item)
{
writer.StepIn(IonType.Struct);
writer.SetFieldName("Status");
writer.WriteString(item.Status);
writer.SetFieldName("Drop");
writer.WriteString(this.drop);
writer.SetFieldName("IsHorned");
writer.WriteBool(item.IsHorned);
writer.StepOut();
}
/// <summary>
/// Serializes an IDictionary into an Ion Struct where the Key is the struct field name
/// and the Value is the struct field value.
/// </summary>
///
/// <param name="writer">The Ion writer to be used for serialization.</param>
/// <param name="item">The dictionary value to serialize.</param>
public override void Serialize(IIonWriter writer, IDictionary item)
{
writer.StepIn(IonType.Struct);
foreach (DictionaryEntry nameValuePair in item)
{
writer.SetFieldName((string)nameValuePair.Key);
this.serializer.Serialize(writer, nameValuePair.Value);
}
writer.StepOut();
}
/// <summary>
/// Just write a bunch of scalar values
/// </summary>
private static List <(string key, object value)> WriteFlat(IIonWriter writer)
{
var kvps = new List <(string key, object value)>();
void writeAndAdd <T>(string fieldName, T value, Action <T> writeAction)
{
writer.SetFieldName(fieldName);
writeAction(value);
kvps.Add((fieldName, value));
}
writeAndAdd("boolean", true, writer.WriteBool);
writeAndAdd("cstring", "somestring", writer.WriteString);
writeAndAdd("int", 123456, i => writer.WriteInt(i));
writeAndAdd("long", long.MaxValue / 10000, writer.WriteInt);
writeAndAdd("datetime", new Timestamp(new DateTime(2000, 11, 11, 11, 11, 11, DateTimeKind.Utc)), writer.WriteTimestamp);
writeAndAdd("decimal", 6.34233242123123123423m, writer.WriteDecimal);
writeAndAdd("float", 231236.321312f, d => writer.WriteFloat(d));
writeAndAdd("double", 231345.325667d * 133.346432d, writer.WriteFloat);
return(kvps);
}
/// <summary>
/// Write object knowing the (intended) type
/// </summary>
private static void WriteObject(IIonWriter writer, object obj, Type type, IScalarWriter scalarWriter)
{
Debug.Assert(obj == null || obj.GetType() == type, $"objType: {obj?.GetType()}, type:{type}");
if (TryWriteScalar(writer, obj, type, scalarWriter))
{
return;
}
if (typeof(IEnumerable).IsAssignableFrom(type))
{
//special case of byte[]
if (TryWriteByteArray(writer, obj, type))
{
return;
}
//is this a null.list?
if (obj == null)
{
writer.WriteNull(IonType.List);
return;
}
//Write everything to list now
var enumerable = (IEnumerable)obj;
writer.StepIn(IonType.List);
foreach (var item in enumerable)
{
WriteObject(writer, item, scalarWriter);
}
writer.StepOut();
return;
}
//not scalar, not list, must be a struct
if (obj == null)
{
writer.WriteNull();
return;
}
writer.StepIn(IonType.Struct);
var properties = GetPublicProperties(type);
foreach (var propertyInfo in properties)
{
if (!propertyInfo.CanRead)
{
continue;
}
//with property, we have to be careful because they have type declaration which might carry intention
//for
writer.SetFieldName(propertyInfo.Name);
WriteObject(writer, propertyInfo.GetValue(obj), propertyInfo.PropertyType, scalarWriter);
}
writer.StepOut();
}
/// <inheritdoc/>
public override void Serialize(IIonWriter writer, object item)
{
this.options.TypeAnnotator.Apply(this.options, writer, this.targetType);
writer.StepIn(IonType.Struct);
var serializedIonFields = new HashSet <string>();
// Serialize the values returned from IonPropertyGetter annotated getter methods.
foreach (var(method, ionPropertyName) in this.GetGetters())
{
var getValue = method.Invoke(item, Array.Empty <object>());
writer.SetFieldName(ionPropertyName);
this.ionSerializer.Serialize(writer, getValue);
serializedIonFields.Add(ionPropertyName);
}
// Serialize any properties that satisfy the options/attributes.
foreach (var property in this.GetValidProperties(true))
{
var ionPropertyName = this.IonFieldNameFromProperty(property);
if (serializedIonFields.Contains(ionPropertyName))
{
// This Ion property name was already serialized.
continue;
}
if (this.options.IgnoreReadOnlyProperties && IsReadOnlyProperty(property))
{
continue;
}
var propertyValue = property.GetValue(item);
if (this.options.IgnoreNulls && propertyValue == null)
{
continue;
}
if (this.options.IgnoreDefaults && propertyValue == default)
{
continue;
}
writer.SetFieldName(ionPropertyName);
var ionAnnotateType = (IonAnnotateTypeAttribute)Attribute.GetCustomAttribute(property, typeof(IonAnnotateTypeAttribute), false);
if (ionAnnotateType != null)
{
if (this.ionSerializer.TryAnnotatedIonSerializer(writer, propertyValue, ionAnnotateType))
{
continue;
}
// Use the actual type of property at runtime to handle dynamic type
var propertyType = propertyValue != null?propertyValue.GetType() : property.PropertyType;
writer.AddTypeAnnotation(this.options.AnnotationConvention.Apply(this.options, ionAnnotateType, propertyType));
}
this.ionSerializer.Serialize(writer, propertyValue);
serializedIonFields.Add(ionPropertyName);
}
// Serialize any fields that satisfy the options/attributes.
foreach (var field in this.Fields())
{
var ionFieldName = GetFieldName(field);
if (serializedIonFields.Contains(ionFieldName))
{
// This Ion field name was already serialized.
continue;
}
if (this.options.IgnoreReadOnlyFields && field.IsInitOnly)
{
continue;
}
var fieldValue = field.GetValue(item);
if (this.options.IgnoreNulls && fieldValue == null)
{
continue;
}
if (this.options.IgnoreDefaults && fieldValue == default)
{
continue;
}
writer.SetFieldName(ionFieldName);
var ionAnnotateType = (IonAnnotateTypeAttribute)Attribute.GetCustomAttribute(field, typeof(IonAnnotateTypeAttribute), false);
if (ionAnnotateType != null && this.ionSerializer.TryAnnotatedIonSerializer(writer, fieldValue, ionAnnotateType))
{
continue;
}
this.ionSerializer.Serialize(writer, fieldValue);
}
writer.StepOut();
}