public void JsonSchemaBuilder_ClassOfGuidWriterSchema()
{
var settings = new AvroSerializerSettings { Resolver = new AvroDataContractResolver(false) };
IAvroSerializer<ClassOfGuid> serializer = AvroSerializer.Create<ClassOfGuid>(settings);
string writerSchema = serializer.WriterSchema.ToString();
AvroSerializer.CreateDeserializerOnly<ClassOfGuid>(writerSchema, settings);
}
public void TestSerializeDeserializeObject()
{
//CreateDeserializerOnly a new AvroSerializer instance and specify a custom serialization strategy AvroDataContractResolver
//for serializing only properties attributed with DataContract/DateMember
var settings = new AvroSerializerSettings();
var avroSerializer = AvroSerializer.Create<SensorData>(settings);
//CreateDeserializerOnly a new buffer
using (var buffer = new MemoryStream())
{
//CreateDeserializerOnly sample data
var expected = new SensorData { Value = new byte[] { 1, 2, 3, 4, 5 }, Position = new Location { Room = 243, Floor = 1 } };
//Serialize the data to the specified stream
avroSerializer.Serialize(buffer, expected);
//Prepare the stream for deserializing the data
buffer.Seek(0, SeekOrigin.Begin);
//Derserialize data from the stream and cast it to the same type used for serialization
var actual = avroSerializer.Deserialize(buffer);
//Finally, verify that deserialized data matches the original ones
Assert.IsTrue(this.Equal(expected, actual));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ReflectionSchemaBuilder" /> class.
/// </summary>
/// <param name="settings">The settings.</param>
public ReflectionSchemaBuilder(AvroSerializerSettings settings)
{
if (settings == null)
{
throw new ArgumentNullException("settings");
}
this.settings = settings;
this.knownTypes = new HashSet<Type>(this.settings.KnownTypes);
}
public void TestSerializeDeserializeUsingSequentialContainers()
{
//CreateDeserializerOnly a new AvroSerializer instance and specify a custom serialization strategy AvroDataContractResolver
//for handling only properties attributed with DataContract/DateMember.
var settings = new AvroSerializerSettings();
//CreateDeserializerOnly a new buffer
using (var buffer = new MemoryStream())
{
//CreateDeserializerOnly sample data
var testData = new List<SensorData>
{
new SensorData { Value = new byte[] { 1, 2, 3, 4, 5 }, Position = new Location { Room = 243, Floor = 1 } },
new SensorData { Value = new byte[] { 6, 7, 8, 9 }, Position = new Location { Room = 244, Floor = 1 } }
};
//CreateDeserializerOnly a SequentialWriter instance for type SensorData which can serialize a sequence of SensorData objects to stream
using (var w = AvroContainer.CreateWriter<SensorData>(buffer, settings, Codec.Null))
{
using (var writer = new SequentialWriter<SensorData>(w, 24))
{
// Serialize the data to stream using the sequential writer
testData.ForEach(writer.Write);
}
}
//Prepare the stream for deserializing the data
buffer.Seek(0, SeekOrigin.Begin);
//CreateDeserializerOnly a SequentialReader for type SensorData which will derserialize all serialized objects from the given stream
//It allows iterating over the deserialized objects because it implements IEnumerable<T> interface
using (var reader = new SequentialReader<SensorData>(
AvroContainer.CreateReader<SensorData>(buffer, true, settings, new CodecFactory())))
{
var results = reader.Objects;
//Finally, verify that deserialized data matches the original ones
var pairs = testData.Zip(results, (serialized, deserialized) => new { expected = serialized, actual = deserialized });
foreach (var pair in pairs)
{
Assert.IsTrue(this.Equal(pair.expected, pair.actual));
}
}
}
}
public void SchemaEvolution_RecordWithMemberOrderChanged()
{
var settings = new AvroSerializerSettings() { Resolver = new AvroDataContractResolver(true, true) };
var serializer = AvroSerializer.Create<Rectangle>(settings);
var deserializer = AvroSerializer.Create<AnotherRectangle>(settings);
using (var stream = new MemoryStream())
{
Rectangle expected = Rectangle.Create();
serializer.Serialize(stream, expected);
stream.Seek(0, SeekOrigin.Begin);
AnotherRectangle actual = deserializer.Deserialize(stream);
Assert.AreEqual(expected.Width, actual.Width);
Assert.AreEqual(expected.Height, actual.Height);
}
}
public void TestSetup()
{
this.dataContractSettings = new AvroSerializerSettings();
}
//Serializes and deserializes sample data set using Reflection and Avro Object Container Files
//Serialized data is compressed with the Custom compression codec (Deflate of .NET Framework 4.5)
//
//This sample uses Memory Stream for all operations related to serialization, deserialization and
//Object Container manipulation, though File Stream could be easily used.
public void SerializeDeserializeUsingObjectContainersReflectionCustomCodec()
{
Console.WriteLine("SERIALIZATION USING REFLECTION, AVRO OBJECT CONTAINER FILES AND CUSTOM CODEC\n");
//Path for Avro Object Container File
string path = "AvroSampleReflectionDeflate45.avro";
//Create a data set using sample Class and struct
var testData = new List<SensorData>
{
new SensorData { Value = new byte[] { 1, 2, 3, 4, 5 }, Position = new Location { Room = 243, Floor = 1 } },
new SensorData { Value = new byte[] { 6, 7, 8, 9 }, Position = new Location { Room = 244, Floor = 1 } }
};
//Serializing and saving data to file
//Creating a Memory Stream buffer
using (var buffer = new MemoryStream())
{
Console.WriteLine("Serializing Sample Data Set...");
//Create a SequentialWriter instance for type SensorData which can serialize a sequence of SensorData objects to stream
//Here the custom Codec is introduced. For convenience the next commented code line shows how to use built-in Deflate.
//Note, that because the sample deals with different IMPLEMENTATIONS of Deflate, built-in and custom codecs are interchangeable
//in read-write operations
//using (var w = AvroContainer.CreateWriter<SensorData>(buffer, Codec.Deflate))
using (var w = AvroContainer.CreateWriter<SensorData>(buffer, new DeflateCodec45()))
{
using (var writer = new SequentialWriter<SensorData>(w, 24))
{
// Serialize the data to stream using the sequential writer
testData.ForEach(writer.Write);
}
}
//Save stream to file
Console.WriteLine("Saving serialized data to file...");
if (!WriteFile(buffer, path))
{
Console.WriteLine("Error during file operation. Quitting method");
return;
}
}
//Reading and deserializing data
//Creating a Memory Stream buffer
using (var buffer = new MemoryStream())
{
Console.WriteLine("Reading data from file...");
//Reading data from Object Container File
if (!ReadFile(buffer, path))
{
Console.WriteLine("Error during file operation. Quitting method");
return;
}
Console.WriteLine("Deserializing Sample Data Set...");
//Prepare the stream for deserializing the data
buffer.Seek(0, SeekOrigin.Begin);
//Because of SequentialReader<T> constructor signature an AvroSerializerSettings instance is required
//when Codec Factory is explicitly specified
//You may comment the line below if you want to use built-in Deflate (see next comment)
AvroSerializerSettings settings = new AvroSerializerSettings();
//Create a SequentialReader for type SensorData which will derserialize all serialized objects from the given stream
//It allows iterating over the deserialized objects because it implements IEnumerable<T> interface
//Here the custom Codec Factory is introduced.
//For convenience the next commented code line shows how to use built-in Deflate
//(no explicit Codec Factory parameter is required in this case).
//Note, that because the sample deals with different IMPLEMENTATIONS of Deflate, built-in and custom codecs are interchangeable
//in read-write operations
//using (var reader = new SequentialReader<SensorData>(AvroContainer.CreateReader<SensorData>(buffer, true)))
using (var reader = new SequentialReader<SensorData>(
AvroContainer.CreateReader<SensorData>(buffer, true, settings, new CodecFactoryDeflate45())))
{
var results = reader.Objects;
//Finally, verify that deserialized data matches the original one
Console.WriteLine("Comparing Initial and Deserialized Data Sets...");
bool isEqual;
int count = 1;
var pairs = testData.Zip(results, (serialized, deserialized) => new { expected = serialized, actual = deserialized });
foreach (var pair in pairs)
{
isEqual = this.Equal(pair.expected, pair.actual);
Console.WriteLine("For Pair {0} result of Data Set Identity Comparison is {1}", count, isEqual.ToString());
count++;
}
}
}
//Delete the file
RemoveFile(path);
}
public SerializerAssigningVisitor(AvroSerializerSettings settings)
{
this.visited = new HashSet<Schema>();
this.settings = settings;
}
public void TestSetup()
{
this.dataContractSettings = new AvroSerializerSettings { Resolver = new AvroDataContractResolver(true) };
}
public void ReflectionSchemaBuilder_BuildSchemaForSchemaNullableUsingDataContractResolverWithNoNulls()
{
var nullableSettings = new AvroSerializerSettings { Resolver = new AvroDataContractResolver(false) };
RoundTripTestNullableSchema(nullableSettings, false, true, false, true, false, true, false);
}
private static void RoundTripTestNullableSchema(
AvroSerializerSettings settings,
bool rootSchemaIsUnion,
bool nullableValueSchemaNullableIsUnion,
bool nullableValueSchemaNotNullableIsUnion,
bool valueSchemaNullableIsUnion,
bool valueSchemaNotNullableIsUnion,
bool referenceSchemaNullableIsUnion,
bool referenceSchemaNotNullableIsUnion)
{
var builder = new ReflectionSchemaBuilder(settings);
var schema = builder.BuildSchema(typeof(ClassWithSchemaNullableField));
RecordSchema recordSchema = null;
if (rootSchemaIsUnion)
{
var asUnion = schema as UnionSchema;
Assert.IsNotNull(asUnion);
var innerNullSchema = asUnion.Schemas[0] is NullSchema
? asUnion.Schemas[0]
: asUnion.Schemas[1];
recordSchema = asUnion.Schemas.Single(s => s != innerNullSchema) as RecordSchema;
Assert.IsNotNull(recordSchema);
}
else
{
recordSchema = schema as RecordSchema;
Assert.IsNotNull(recordSchema);
}
Assert.AreEqual(typeof(ClassWithSchemaNullableField).GetAllFields().Count(), recordSchema.Fields.Count);
var nullableValueSchemaNullable = recordSchema.Fields.Single(f => f.Name == "NullableValueNullableSchema");
ValidateSchema(nullableValueSchemaNullable.TypeSchema, nullableValueSchemaNullableIsUnion, typeof(IntSchema));
var nullableValueSchemaNotNullable = recordSchema.Fields.Single(f => f.Name == "NullableValueNotNullableSchema");
ValidateSchema(nullableValueSchemaNotNullable.TypeSchema, nullableValueSchemaNotNullableIsUnion, typeof(IntSchema));
var valueSchemaNullable = recordSchema.Fields.Single(f => f.Name == "NotNullableValueNullableSchema");
ValidateSchema(valueSchemaNullable.TypeSchema, valueSchemaNullableIsUnion, typeof(IntSchema));
var valueSchemaNotNullable = recordSchema.Fields.Single(f => f.Name == "NotNullableValueNotNullableSchema");
ValidateSchema(valueSchemaNotNullable.TypeSchema, valueSchemaNotNullableIsUnion, typeof(IntSchema));
var referenceSchemaNullable = recordSchema.Fields.Single(f => f.Name == "ReferenceFieldNullableSchema");
ValidateSchema(referenceSchemaNullable.TypeSchema, referenceSchemaNullableIsUnion, typeof(RecordSchema));
var referenceSchemaNotNullable = recordSchema.Fields.Single(f => f.Name == "ReferenceFieldNotNullableSchema");
ValidateSchema(referenceSchemaNotNullable.TypeSchema, referenceSchemaNotNullableIsUnion, typeof(RecordSchema));
}
public void ReflectionSchemaBuilder_BuildSchemaForSchemaNullableUsingPublicMembersResolverWithCSharpNulls()
{
var nullableSettings = new AvroSerializerSettings { Resolver = new AvroPublicMemberContractResolver(true) };
RoundTripTestNullableSchema(nullableSettings, true, true, true, true, false, true, true);
}
