private static void RunTestForRecord()
{
Schema schema;
using (var stream = new FileStream("./Schemas/Widget.avsc", FileMode.Open))
{
var reader = new JsonSchemaReader();
schema = reader.Read(stream);
}
var serializer = new BinarySerializerBuilder()
.BuildSerializer <Widget>(schema);
var deserializer = new BinaryDeserializerBuilder()
.BuildDeserializer <Widget>(schema);
var widgetIn = new Widget
{
Id = 1010,
Name = "One Thousand Ten",
Cost = 3829.7401m,
Lifetime = TimeSpan.FromMilliseconds(987654321),
GlobalId = new Guid("21d45c13-76b1-459d-8571-ba0ad0fa27de"),
CreatedAt = DateTime.UtcNow,
CreatedAtLocal = DateTimeOffset.Now
};
var bytes = serializer.Serialize(widgetIn);
var widgetOut = deserializer.Deserialize(bytes);
Console.WriteLine();
Console.WriteLine($"Serialized widget to {bytes.Length} bytes.");
Console.WriteLine($"Deserialized widget {widgetOut.Id} (\"{widgetOut.Name}\").");
}
private static void RunTestForDateTimeOffset()
{
/*
* var dtoIn = DateTimeOffset.Now;
* var dtoStr = dtoIn.ToString("O");
* var dtoOut = DateTimeOffset.Parse(dtoStr);
*
* var loc = DateTime.Now;
* var utc = loc.ToUniversalTime();
*
* var dtoFromLocal = new DateTimeOffset(loc);
* var dtoFromUtc = new DateTimeOffset(utc);
*
* Console.WriteLine((dtoFromUtc == dtoFromLocal) ? "==" : "!=");
*/
var schema = new StringSchema();
var serializer = new BinarySerializerBuilder()
.BuildSerializer <DateTimeOffset>(schema);
var deserializer = new BinaryDeserializerBuilder()
.BuildDeserializer <DateTimeOffset>(schema);
var dtoIn = DateTimeOffset.Now;
var bytes = serializer.Serialize(dtoIn);
var dtoOut = deserializer.Deserialize(bytes);
Console.WriteLine();
Console.WriteLine($"Serialized: {dtoIn.ToString("O")}");
Console.WriteLine($"Deserialized: {dtoOut.ToString("O")}");
}
public void SelectedTypes()
{
var schema = new RecordSchema(nameof(EventContainer), new[]
{
new RecordField("event", new UnionSchema(new[]
{
new RecordSchema(nameof(OrderCreatedEvent), new[]
{
new RecordField("timestamp", new StringSchema()),
new RecordField("total", new BytesSchema()
{
LogicalType = new DecimalLogicalType(5, 2)
})
}),
new RecordSchema(nameof(OrderCancelledEvent), new[]
{
new RecordField("timestamp", new StringSchema())
})
}))
});
var codec = new BinaryCodec();
var resolver = new ReflectionResolver();
var deserializer = new BinaryDeserializerBuilder(BinaryDeserializerBuilder.CreateBinaryDeserializerCaseBuilders(codec)
.Prepend(builder => new OrderDeserializerBuilderCase(resolver, codec, builder)))
.BuildDeserializer <EventContainer>(schema);
var serializer = new BinarySerializerBuilder(BinarySerializerBuilder.CreateBinarySerializerCaseBuilders(codec)
.Prepend(builder => new OrderSerializerBuilderCase(resolver, codec, builder)))
.BuildSerializer <EventContainer>(schema);
var creation = new EventContainer
{
Event = new OrderCreatedEvent
{
Timestamp = DateTime.UtcNow,
Total = 40M
}
};
var cancellation = new EventContainer
{
Event = new OrderCancelledEvent
{
Timestamp = DateTime.UtcNow
}
};
Assert.IsType <OrderCreatedEvent>(deserializer.Deserialize(serializer.Serialize(creation)).Event);
Assert.IsType <OrderCancelledEvent>(deserializer.Deserialize(serializer.Serialize(cancellation)).Event);
}
private static IConsumer <OrderKey, OrderEventRecord> CreateConsumer(
ISchemaRegistryClient registryClient)
{
var deserializerBuilder = new BinaryDeserializerBuilder(
BinaryDeserializerBuilder.CreateDefaultCaseBuilders()
.Prepend(builder => new OrderEventUnionDeserializerBuilderCase(builder)));
return(new ConsumerBuilder <OrderKey, OrderEventRecord>(
new ConsumerConfig
{
BootstrapServers = BootstrapServers,
EnableAutoCommit = false,
GroupId = $"union-type-example-{Guid.NewGuid()}",
})
.SetAvroKeyDeserializer(registryClient)
.SetValueDeserializer(new AsyncSchemaRegistryDeserializer <OrderEventRecord>(
registryClient,
deserializerBuilder).AsSyncOverAsync())
.Build());
}
protected override void Run()
{
var type = this.ResolveType();
var task = this.ResolveSchema();
task.Wait();
var reader = new JsonSchemaReader();
var schema = reader.Read(task.Result);
try
{
var builder = new BinaryDeserializerBuilder();
var method = typeof(IBinaryDeserializerBuilder)
.GetMethod(nameof(IBinaryDeserializerBuilder.BuildDeserializer))
.MakeGenericMethod(type);
method.Invoke(builder, new[] { schema });
}
catch (TargetInvocationException exception) when(exception.InnerException is Exception inner)
{
throw new ProgramException(message: $"A deserializer cannot be created for {type}: {inner.Message}", inner: inner);
}
try
{
var builder = new BinarySerializerBuilder();
var method = typeof(IBinarySerializerBuilder)
.GetMethod(nameof(IBinarySerializerBuilder.BuildSerializer))
.MakeGenericMethod(type);
method.Invoke(builder, new[] { schema });
}
catch (TargetInvocationException exception) when(exception.InnerException is Exception inner)
{
throw new ProgramException(message: $"A serializer cannot be created for {type}: {inner.Message}", inner: inner);
}
Console.Error.WriteLine($"{type} is compatible with the schema.");
}
public void SelectedTypes()
{
var schema = new RecordSchema(nameof(EventContainer))
{
Fields = new[]
{
new RecordField(
"event",
new UnionSchema(new[]
{
new RecordSchema(nameof(OrderCreatedEvent))
{
Fields = new[]
{
new RecordField("timestamp", new StringSchema()),
new RecordField(
"total",
new BytesSchema()
{
LogicalType = new DecimalLogicalType(5, 2),
}),
},
},
new RecordSchema(nameof(OrderCancelledEvent))
{
Fields = new[]
{
new RecordField("timestamp", new StringSchema()),
},
},
})),
},
};
var deserialize = new BinaryDeserializerBuilder(BinaryDeserializerBuilder
.CreateDefaultCaseBuilders()
.Prepend(builder => new OrderDeserializerBuilderCase(builder)))
.BuildDelegate <EventContainer>(schema);
var serialize = new BinarySerializerBuilder(BinarySerializerBuilder
.CreateDefaultCaseBuilders()
.Prepend(builder => new OrderSerializerBuilderCase(builder)))
.BuildDelegate <EventContainer>(schema);
var creation = new EventContainer
{
Event = new OrderCreatedEvent
{
Timestamp = DateTime.UtcNow,
Total = 40M,
},
};
var cancellation = new EventContainer
{
Event = new OrderCancelledEvent
{
Timestamp = DateTime.UtcNow,
},
};
using (stream)
{
serialize(creation, new BinaryWriter(stream));
var reader = new BinaryReader(stream.ToArray());
var result = deserialize(ref reader);
Assert.IsType <OrderCreatedEvent>(result.Event);
stream.Position = 0;
serialize(cancellation, new BinaryWriter(stream));
reader = new BinaryReader(stream.ToArray());
result = deserialize(ref reader);
Assert.IsType <OrderCancelledEvent>(result.Event);
}
}
