private static void checkAlternateDeserializers <S>(S expected, Stream input, long startPos, Schema ws, Schema rs) where S : class, ISpecificRecord
{
input.Position = startPos;
var reader = new SpecificDatumReader <S>(ws, rs);
Decoder d = new BinaryDecoder(input);
S output = reader.Read(null, d);
Assert.AreEqual(input.Length, input.Position); // Ensure we have read everything.
AssertSpecificRecordEqual(expected, output);
}
private IList <T> AvroToSpecificRecords <T>(byte[] avro, RecordSchema schema) where T : ISpecificRecord
{
using (MemoryStream inputStream = new MemoryStream(avro))
{
SpecificDatumReader <T> reader = new SpecificDatumReader <T>(schema, schema);
BinaryDecoder decoder = new BinaryDecoder(inputStream);
List <T> records = new List <T>();
for (int i = 0; i < _numberOfRecordsInAvro; i++)
{
T record = reader.Read(default, decoder);;
public void LogicalTimeStamp()
{
SpecificDatumReader <MessageTimestampKind> reader;
SpecificDatumWriter <MessageTimestampKind> writer;
var simple = typeof(MessageTimestampKind).GetSchema();
_output.WriteLine(simple);
var schema = (RecordSchema)Schema.Parse(simple);
reader = new SpecificDatumReader <MessageTimestampKind>(schema, schema);
writer = new SpecificDatumWriter <MessageTimestampKind>(schema);
var msgBytes = Write(new MessageTimestampKind {
Schema = schema, StampMicros = DateTime.Now, StampMillis = DateTime.Now.AddDays(20)
}, writer);
using var stream = new MemoryStream((byte[])(object) msgBytes);
var msg = Read(stream, reader);
Assert.NotNull(msg);
}
public void LogicalTime()
{
SpecificDatumReader <MessageTimeKind> reader;
SpecificDatumWriter <MessageTimeKind> writer;
var simple = typeof(MessageTimeKind).GetSchema();
_output.WriteLine(simple);
var schema = (RecordSchema)Schema.Parse(simple);
reader = new SpecificDatumReader <MessageTimeKind>(schema, schema);
writer = new SpecificDatumWriter <MessageTimeKind>(schema);
var msgBytes = Write(new MessageTimeKind {
Schema = schema, TimeMicros = TimeSpan.FromSeconds(60), TimeMillis = TimeSpan.FromSeconds(300)
}, writer);
using var stream = new MemoryStream((byte[])(object) msgBytes);
var msg = Read(stream, reader);
Assert.NotNull(msg);
}
public void LogicalDate()
{
SpecificDatumReader <MessageDateKind> reader;
SpecificDatumWriter <MessageDateKind> writer;
var simple = typeof(MessageDateKind).GetSchema();
_output.WriteLine(simple);
var schema = (RecordSchema)Schema.Parse(simple);
reader = new SpecificDatumReader <MessageDateKind>(schema, schema);
writer = new SpecificDatumWriter <MessageDateKind>(schema);
var msgBytes = Write(new MessageDateKind {
Schema = schema, CreatedTime = DateTime.Now, DayOfWeek = "Saturday", Size = new AvroDecimal(102.65M)
}, writer);
using var stream = new MemoryStream((byte[])(object) msgBytes);
var msg = Read(stream, reader);
Assert.NotNull(msg);
Assert.True(msg.Size == 102.65M);
}
public object Deserialize(byte[] bytes)
{
if (bytes != null)
{
try
{
int function = BitConverter.ToInt32(bytes, 0);
ObjectType type = (ObjectType)function;
Schema schema = staticMap[type];
reader = new SpecificDatumReader <ISpecificRecord>(schema, schema);
using (MemoryStream ms = new MemoryStream(bytes, 4, bytes.Length - 4, false))
{
BinaryDecoder decoder = new BinaryDecoder(ms);
return(reader.Read(null, decoder));
}
}
catch (Exception)
{
}
}
return(null);
}
public static void test ()
{
//Schema schema = Schema.Parse ("schema json");
SpecificDatumWriter<User> w = new SpecificDatumWriter<User> (User._SCHEMA);
User input = new User ();
input.name = "mm";
input.favorite_color = "red";
input.favorite_number = 11;
MemoryStream stream = new MemoryStream ();
w.Write (input, new BinaryEncoder (stream));
stream.Seek (0, SeekOrigin.Begin);
SpecificDatumReader<User> r = new SpecificDatumReader<User> (User._SCHEMA, User._SCHEMA);
User output = r.Read (null, new BinaryDecoder (stream));
Console.WriteLine (output.name);
}
protected override object DoDecode(byte[] raw, Type type)
{
using (MemoryStream stream = new MemoryStream(raw))
{
byte magicByte = (byte)stream.ReadByte();
if (magicByte != MAGIC_BYTE)
{
throw new InvalidDataException("Unknown magic byte!");
}
byte[] schemaIdBytes = new byte[4];
stream.Read(schemaIdBytes, 0, 4);
if (BitConverter.IsLittleEndian)
{
Array.Reverse(schemaIdBytes);
}
int schemaId = BitConverter.ToInt32(schemaIdBytes, 0);
Schema schema = Schema.Parse(schemaCache.GetSchemaString(schemaId));
SpecificDatumReader<object> r = new SpecificDatumReader<object>(schema, schema);
return r.Read(null, new BinaryDecoder(stream));
}
}
public T Read <T>(Stream stream, SpecificDatumReader <T> reader)
{
stream.Seek(0, SeekOrigin.Begin);
return(reader.Read(default, new BinaryDecoder(stream)));
