private async ValueTask <object> DeserializeInternalAsync(
Stream stream,
Type returnType,
bool async,
CancellationToken cancellationToken)
{
Argument.AssertNotNull(stream, nameof(stream));
Argument.AssertNotNull(returnType, nameof(returnType));
SupportedType supportedType = GetSupportedTypeOrThrow(returnType);
ReadOnlyMemory <byte> message = CopyToReadOnlyMemory(stream);
ValidateRecordFormatIdentifier(message);
byte[] schemaIdBytes = message.Slice(RecordFormatIndicatorLength, SchemaIdLength).ToArray();
string schemaId = Utf8Encoding.GetString(schemaIdBytes);
Schema schema;
if (async)
{
schema = await GetSchemaByIdAsync(schemaId, true, cancellationToken).ConfigureAwait(false);
}
else
{
schema = GetSchemaByIdAsync(schemaId, false, cancellationToken).EnsureCompleted();
}
using var valueStream = new MemoryStream(message.Slice(PayloadStartPosition, message.Length - PayloadStartPosition).ToArray());
var binaryDecoder = new BinaryDecoder(valueStream);
DatumReader <object> reader = GetReader(schema, supportedType);
return(reader.Read(reuse: null, binaryDecoder));
}
public void RecordTestWithOverlap()
{
var expectedValue = new TestRecordWithDefault()
{
Name = "Test"
};
var writeValue = new TestRecordWithExtraField()
{
Name = "Test", Desc = "Description"
};
var writer = new DatumWriter <TestRecordWithExtraField>(writeValue.Schema);
var reader = new DatumReader <TestRecordWithDefault>(expectedValue.Schema, writeValue.Schema);
using (var stream = new MemoryStream())
using (var encoder = new BinaryEncoder(stream))
using (var decoder = new BinaryDecoder(stream))
{
writer.Write(encoder, writeValue);
stream.Seek(0, SeekOrigin.Begin);
var actualValue = reader.Read(decoder);
for (int i = 0; i < expectedValue.FieldCount; i++)
{
Assert.AreEqual(expectedValue.Get(i), actualValue.Get(i));
}
}
}
public void RecordTest()
{
var expectedValue = new TestRecord()
{
FieldA = 123, FieldB = "Test", FieldC = new TestSubRecord()
{
FieldD = false
}, FieldX = TestEnum.B, TestFixed = new TestFixed()
};
var writer = new DatumWriter <TestRecord>(expectedValue.Schema);
var reader = new DatumReader <TestRecord>(expectedValue.Schema, expectedValue.Schema);
using (var stream = new MemoryStream())
using (var encoder = new BinaryEncoder(stream))
using (var decoder = new BinaryDecoder(stream))
{
writer.Write(encoder, expectedValue);
stream.Seek(0, SeekOrigin.Begin);
var actualValue = reader.Read(decoder);
for (int i = 0; i < expectedValue.FieldCount; i++)
{
Assert.AreEqual(expectedValue.Get(i), actualValue.Get(i));
}
}
}
public Promoted(TWriter writeValue, TReader readValue, object writeInstance, object readInstance)
{
_writeValue = writeValue;
_readValue = readValue;
_writeSchema = writeInstance as SWriter;
_readSchema = readInstance as SReader;
_specificWriter = new DatumWriter <TWriter>(_writeSchema);
_specificReader = new DatumReader <TReader>(_readSchema, _writeSchema);
}
public UnionUpscaleTest(TWriter writeValue, object readValue)
{
_writeValue = writeValue;
_readValue = readValue;
_writeSchema = new SWriter();
_readSchema = new UnionSchema(new WUnionSchemaOne(), new WUnionSchemaTwo());
_specificWriter = new DatumWriter <TWriter>(_writeSchema);
_specificReader = new DatumReader <object>(_readSchema, _writeSchema);
}
public AvroReader(Avro.Schema writeSchema, Avro.Schema readSchema)
{
var type = typeof(T);
if (typeof(ISpecificRecord).IsAssignableFrom(type))
{
_reader = new SpecificDatumReader <T>(writeSchema, readSchema);
}
else
{
_reader = new ReflectReader <T>(writeSchema, readSchema);
}
}
public AvroReader(Avro.Schema avroSchema)
{
_schema = avroSchema;
var type = typeof(T);
if (typeof(ISpecificRecord).IsAssignableFrom(type))
{
_reader = new SpecificDatumReader <T>(avroSchema, avroSchema);
}
else
{
_reader = new ReflectReader <T>(_schema, _schema);
}
}
/// <summary>Create a new Event Reader</summary>
/// <param name="in"/>
/// <exception cref="System.IO.IOException"/>
public EventReader(DataInputStream @in)
{
this.@in = @in;
this.version = @in.ReadLine();
if (!EventWriter.Version.Equals(version))
{
throw new IOException("Incompatible event log version: " + version);
}
Schema myschema = new SpecificData(typeof(Event).GetClassLoader()).GetSchema(typeof(
Event));
this.schema = Schema.Parse(@in.ReadLine());
this.reader = new SpecificDatumReader(schema, myschema);
this.decoder = DecoderFactory.Get().JsonDecoder(schema, @in);
}
private static DatumReader <T> CreateDefaultReader(Schema writerSchema, Schema readerSchema)
{
DatumReader <T> reader = null;
Type type = typeof(T);
if (typeof(ISpecificRecord).GetTypeInfo().IsAssignableFrom(type))
{
reader = new SpecificReader <T>(writerSchema, readerSchema);
}
else // generic
{
reader = new GenericReader <T>(writerSchema, readerSchema);
}
return(reader);
}
private DatumReader <T> GetReaderFromSchema()
{
DatumReader <T> reader = null;
Type type = typeof(T);
if (typeof(ISpecificRecord).IsAssignableFrom(type))
{
reader = new SpecificReader <T>(_header.Schema, _readerSchema ?? _header.Schema);
}
else // generic
{
reader = new GenericReader <T>(_header.Schema, _readerSchema ?? _header.Schema);
}
return(reader);
}
private void Init(Stream stream)
{
_stream = stream;
_header = new Header();
_decoder = new BinaryDecoder(stream);
_syncBuffer = new byte[DataFileConstants.SyncSize];
// read magic
byte[] firstBytes = new byte[DataFileConstants.AvroHeader.Length];
try
{
_decoder.ReadFixed(firstBytes);
}
catch (Exception e)
{
throw new AvroRuntimeException("Not a valid data file!", e);
}
if (!firstBytes.SequenceEqual(DataFileConstants.AvroHeader))
{
throw new AvroRuntimeException("Not a valid data file!");
}
// read meta data
long len = _decoder.ReadMapStart();
if (len > 0)
{
do
{
for (long i = 0; i < len; i++)
{
string key = _decoder.ReadString();
byte[] val = _decoder.ReadBytes();
_header.MetaData.Add(key, val);
}
} while ((len = _decoder.ReadMapNext()) != 0);
}
// read in sync data
_decoder.ReadFixed(_header.SyncData);
// parse schema and set codec
_header.Schema = Schema.Parse(GetMetaString(DataFileConstants.MetaDataSchema));
_reader = _datumReaderFactory(_header.Schema, _readerSchema ?? _header.Schema);
_codec = ResolveCodec();
}
public void UnionToUnionMixedTest()
{
var writerSchema = new UnionSchema(new BooleanSchema(), new LongSchema(), new DoubleSchema(), new StringSchema());
var readerSchema = new UnionSchema(new NullSchema(), new IntSchema(), new FloatSchema(), new BytesSchema());
var writer = new DatumWriter <object>(writerSchema);
var reader = new DatumReader <object>(readerSchema, writerSchema);
var expectedValue = 56723234L;
using (var stream = new MemoryStream())
using (var encoder = new BinaryEncoder(stream))
using (var decoder = new BinaryDecoder(stream))
{
writer.Write(encoder, expectedValue);
stream.Seek(0, SeekOrigin.Begin);
Assert.AreEqual(expectedValue, reader.Read(decoder));
}
}
public void NonUnionValueToUnionTest()
{
var writerSchema = new FloatSchema();
var readerSchema = new UnionSchema(new FloatSchema(), new StringSchema(), new BytesSchema());
var writer = new DatumWriter <float>(writerSchema);
var reader = new DatumReader <object>(readerSchema, writerSchema);
var expectedValue = 123.456F;
using (var stream = new MemoryStream())
using (var encoder = new BinaryEncoder(stream))
using (var decoder = new BinaryDecoder(stream))
{
writer.Write(encoder, expectedValue);
stream.Seek(0, SeekOrigin.Begin);
Assert.AreEqual(expectedValue, reader.Read(decoder));
}
}
public void EnumTest()
{
var enumSchema = new EnumSchema(nameof(TestEnum), typeof(TestEnum).Namespace, Enum.GetNames(typeof(TestEnum)));
var writer = new DatumWriter <TestEnum>(enumSchema);
var reader = new DatumReader <TestEnum>(enumSchema, enumSchema);
var expectedValue = TestEnum.A;
using (var stream = new MemoryStream())
using (var encoder = new BinaryEncoder(stream))
using (var decoder = new BinaryDecoder(stream))
{
writer.Write(encoder, expectedValue);
stream.Seek(0, SeekOrigin.Begin);
var actualValue = reader.Read(decoder);
Assert.AreEqual(expectedValue, actualValue);
}
}
public void NullableNotNullWriterTest()
{
var writerSchema = new IntSchema();
var readerSchema = new UnionSchema(new NullSchema(), new IntSchema());
var writer = new DatumWriter <int>(writerSchema);
var reader = new DatumReader <int?>(readerSchema, writerSchema);
var expectedValueNotNull = 123;
using (var stream = new MemoryStream())
using (var encoder = new BinaryEncoder(stream))
using (var decoder = new BinaryDecoder(stream))
{
writer.Write(encoder, expectedValueNotNull);
stream.Seek(0, SeekOrigin.Begin);
Assert.AreEqual(expectedValueNotNull, reader.Read(decoder));
stream.Seek(0, SeekOrigin.Begin);
}
}
public void ArrayTest()
{
var writerSchema = new ArraySchema(new IntSchema());
var readerSchema = new ArraySchema(new LongSchema());
var writer = new DatumWriter <IList <int> >(writerSchema);
var reader = new DatumReader <IList <long> >(readerSchema, writerSchema);
var expectedArray = new List <int> {
10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0
};
using (var stream = new MemoryStream())
using (var encoder = new BinaryEncoder(stream))
using (var decoder = new BinaryDecoder(stream))
{
stream.Seek(0, SeekOrigin.Begin);
writer.Write(encoder, expectedArray);
stream.Seek(0, SeekOrigin.Begin);
Assert.AreEqual(expectedArray, reader.Read(decoder));
}
}
public void MapTest()
{
var writerSchema = new MapSchema(new FloatSchema());
var readerSchema = new MapSchema(new DoubleSchema());
var writer = new DatumWriter <IDictionary <string, float> >(writerSchema);
var reader = new DatumReader <IDictionary <string, double> >(readerSchema, writerSchema);
var expectedMap = new Dictionary <string, float> {
{ "Key1", 1.1F }, { "Key2", 2.2F }, { "Key3", 3.3F }, { "Key4", 4.4F }, { "Key5", 5.5F }
};
using (var stream = new MemoryStream())
using (var encoder = new BinaryEncoder(stream))
using (var decoder = new BinaryDecoder(stream))
{
stream.Seek(0, SeekOrigin.Begin);
writer.Write(encoder, expectedMap);
stream.Seek(0, SeekOrigin.Begin);
Assert.AreEqual(expectedMap, reader.Read(decoder));
}
}
/// <summary>
/// Deserialize an object of type <see cref="T"/> from a byte array.
/// </summary>
/// <param name="topic">
/// The topic associated with the data (ignored by this deserializer).
/// </param>
/// <param name="array">
/// A byte array containing the object serialized in the format produced
/// by <see cref="AvroSerializer" />.
/// </param>
/// <returns>
/// The deserialized <see cref="T"/> value.
/// </returns>
public T Deserialize(string topic, byte[] array)
{
// Note: topic is not necessary for deserialization (or knowing if it's a key
// or value) only the schema id is needed.
using (var stream = new MemoryStream(array))
using (var reader = new BinaryReader(stream))
{
var magicByte = reader.ReadByte();
if (magicByte != Constants.MagicByte)
{
// may change in the future.
throw new InvalidDataException($"magic byte should be 0, not {magicByte}");
}
var writerIdBigEndian = reader.ReadInt32();
var writerId = IPAddress.NetworkToHostOrder(writerIdBigEndian);
DatumReader <T> datumReader = null;
lock (datumReaderLock)
{
datumReaderBySchemaId.TryGetValue(writerId, out datumReader);
if (datumReader == null)
{
// it's a good idea to retain the lock over this blocking call since there
// may be concurrent deserialize calls for the same T, and in that case it's
// best not to hit Schema Registry more than once for the same information.
var writerSchemaJson = SchemaRegistryClient.GetSchemaAsync(writerId).Result;
var writerSchema = Avro.Schema.Parse(writerSchemaJson);
datumReader = new SpecificReader <T>(writerSchema, ReaderSchema);
datumReaderBySchemaId[writerId] = datumReader;
}
}
return(datumReader.Read(default(T), new BinaryDecoder(stream)));
}
}
public void NullableArbitraryUnionTest()
{
var writerSchema = new UnionSchema(new StringSchema(), new DoubleSchema(), new UuidSchema(), new NullSchema());
var readerSchema = new UnionSchema(new StringSchema(), new NullSchema());
var writer = new DatumWriter <object>(writerSchema);
var reader = new DatumReader <string>(readerSchema, writerSchema);
var expectedValueNotNull = "Some String";
var expectedValueNull = null as string;
using (var stream = new MemoryStream())
using (var encoder = new BinaryEncoder(stream))
using (var decoder = new BinaryDecoder(stream))
{
writer.Write(encoder, expectedValueNotNull);
stream.Seek(0, SeekOrigin.Begin);
Assert.AreEqual(expectedValueNotNull, reader.Read(decoder));
stream.Seek(0, SeekOrigin.Begin);
writer.Write(encoder, expectedValueNull);
stream.Seek(0, SeekOrigin.Begin);
Assert.AreEqual(expectedValueNull, reader.Read(decoder));
}
}
public void RecordGenericTest()
{
var enumSchema = AvroParser.ReadSchema <EnumSchema>(@"{""name"":""Avro.Test.Generic.TestEnum"",""type"":""enum"",""symbols"":[""A"",""B"",""C""]}");
var fixedSchema = AvroParser.ReadSchema <FixedSchema>(@"{""name"":""Avro.Test.Generic.TestFixed"",""type"":""fixed"",""size"":40}");
var subRecordSchema = AvroParser.ReadSchema <RecordSchema>(@"{""name"":""Avro.Test.Generic.TestSubRecord"",""type"":""record"",""fields"":[{""name"":""FieldD"",""type"":""boolean""}]}");
var recordSchema = AvroParser.ReadSchema <RecordSchema>(@"{""name"":""Avro.Test.Generic.TestRecord"",""type"":""record"",""fields"":[{""name"":""FieldA"",""type"":""int""},{""name"":""FieldB"",""type"":""string""},{""name"":""FieldC"",""type"":{""name"":""Avro.Test.Generic.TestSubRecord"",""type"":""record"",""fields"":[{""name"":""FieldD"",""type"":""boolean""}]}},{""name"":""FieldX"",""type"":{""name"":""Avro.Test.Generic.TestEnum"",""type"":""enum"",""symbols"":[""A"",""B"",""C""]}},{""name"":""TestFixed"",""type"":{""name"":""Avro.Test.Generic.TestFixed"",""type"":""fixed"",""size"":40}}]}");
var subRecordInstance = new GenericRecord(subRecordSchema);
var fixedInstance = new GenericFixed(fixedSchema);
var enumInstance = new GenericEnum(enumSchema, "B");
subRecordInstance["FieldD"] = false;
var expectedValue = new GenericRecord(recordSchema);
expectedValue["FieldA"] = 123;
expectedValue["FieldB"] = "Test";
expectedValue["FieldC"] = subRecordInstance;
expectedValue["FieldX"] = enumInstance;
expectedValue["TestFixed"] = fixedInstance;
var writer = new DatumWriter <GenericRecord>(recordSchema);
var reader = new DatumReader <GenericRecord>(recordSchema, recordSchema);
using (var stream = new MemoryStream())
using (var encoder = new BinaryEncoder(stream))
using (var decoder = new BinaryDecoder(stream))
{
writer.Write(encoder, expectedValue);
stream.Seek(0, SeekOrigin.Begin);
var actualValue = reader.Read(decoder);
for (int i = 0; i < expectedValue.FieldCount; i++)
{
Assert.AreEqual(expectedValue[i], actualValue[i]);
}
}
}
public void FixedTest()
{
var expectedValue = new TestFixed();
expectedValue[1] = 1;
for (int i = 2; i < expectedValue.Size; i++)
{
expectedValue[i] = (byte)((expectedValue[i - 2] + expectedValue[i - 1]) % byte.MaxValue);
}
var writer = new DatumWriter <TestFixed>(expectedValue.Schema);
var reader = new DatumReader <TestFixed>(expectedValue.Schema, expectedValue.Schema);
using (var stream = new MemoryStream())
using (var encoder = new BinaryEncoder(stream))
using (var decoder = new BinaryDecoder(stream))
{
writer.Write(encoder, expectedValue);
stream.Seek(0, SeekOrigin.Begin);
var actualValue = reader.Read(decoder);
Assert.AreEqual(expectedValue, actualValue);
}
}
public void EnumGenericTest()
{
var enumSchema = AvroParser.ReadSchema <EnumSchema>(@"{""name"":""Avro.Test.Generic.TestEnum"",""type"":""enum"",""symbols"":[""A"",""B"",""C""]}");
var writer = new DatumWriter <GenericEnum>(enumSchema);
var reader = new DatumReader <GenericEnum>(enumSchema, enumSchema);
var expectedValue = new GenericEnum(enumSchema, "B");
using (var stream = new MemoryStream())
using (var encoder = new BinaryEncoder(stream))
using (var decoder = new BinaryDecoder(stream))
{
writer.Write(encoder, expectedValue);
stream.Seek(0, SeekOrigin.Begin);
var actualValue = reader.Read(decoder);
Assert.AreEqual(expectedValue, actualValue);
var expectedPosition = stream.Position;
stream.Seek(0, SeekOrigin.Begin);
reader.Skip(decoder);
Assert.AreEqual(expectedPosition, stream.Position);
}
}
private static void checkDefault(String schemaJson, String defaultJson,
Object defaultValue)
{
//throw new NotImplementedException();
String recordJson =
"{\"type\":\"record\", \"name\":\"Foo\", \"fields\":[{\"name\":\"f\", "
+ "\"type\":" + schemaJson + ", "
+ "\"default\":" + defaultJson + "}]}";
Schema expected = Schema.Parse(recordJson);
DatumReader input = new DatumReader(ACTUAL, expected);
//Record record = (GenericData.Record)
// input.Read(null, BinaryDecoder.CreateBinaryDecoder(
// new byte[0], null));
//Assert.AreEqual(defaultValue, record.get("f"), "Wrong default.");
//Assert.AreEqual(expected, Schema.Parse(expected.ToString()), "Wrong toString");
}
private static void checkJson(Schema schema, Object datum,
DatumWriter writer,
DatumReader reader)
{
throw new NotImplementedException();
//IPC.ByteBufferOutputStream iostr = new Avro.IPC.ByteBufferOutputStream();
//Encoder encoder = new JsonEncoder(schema, iostr);
//writer.Schema = schema;
//writer.write(datum, encoder);
////writer.write(datum, encoder);
//encoder.Flush();
//byte[] data = iostr.ToArray();
//System.IO.File.WriteAllBytes("C:\\temp\\test.js", data);
//reader.Schema = schema;
//Decoder decoder = new JsonDecoder(schema, new MemoryStream(data));
//Object decoded = reader.Read(null, decoder);
//Assert.AreEqual(datum, decoded, "Decoded data does not match.");
//decoded = reader.Read(decoded, decoder);
//Assert.AreEqual(datum, decoded, "Decoded data does not match.");
}
private static void checkBinary(Schema schema, Object datum,
DatumWriter writer,
DatumReader reader)
{
throw new NotImplementedException();
//Avro.IPC.ByteBufferOutputStream iostr = new Avro.IPC.ByteBufferOutputStream();
//writer.Schema = schema;
//writer.write(datum, new BinaryEncoder(iostr));
//byte[] data = iostr.ToArray();
//reader.Schema = schema;
//BinaryDecoder decoder = BinaryDecoder.CreateBinaryDecoder(data, null);
//Assert.IsNotNull(decoder, "decoder is null");
//Object decoded = reader.Read(null, decoder);
//Assert.AreEqual(datum, decoded, "Decoded data does not match.");
}
public void testNoDefaultField()
{
Schema expected = Schema.Parse("{\"type\":\"record\", \"name\":\"Foo\", \"fields\":" +
"[{\"name\":\"f\", \"type\": \"string\"}]}");
DatumReader input = new DatumReader(ACTUAL, expected);
//throw new NotSupportedException();
//input.Read(null, BinaryDecoder.CreateBinaryDecoder(
// new byte[0], null));
}
private GenericProtocolPair(AvroProtocol local, AvroProtocol remote)
{
LocalHash = local.MD5;
RemoteHash = remote.MD5;
var requestReaders = new Dictionary <string, IAvroReader <IAvroRecord> >();
var requestWriters = new Dictionary <string, IAvroWriter <IAvroRecord> >();
var responseReaders = new Dictionary <string, IAvroReader <object> >();
var responseWriters = new Dictionary <string, IAvroWriter <object> >();
var errorReaders = new Dictionary <string, IAvroReader <object> >();
var errorWriters = new Dictionary <string, IAvroWriter <object> >();
var messagePairs =
from lm in local.Messages
join rm in remote.Messages on lm.Name equals rm.Name
select new
{
MessageName = lm.Name,
LocalMessage = lm,
RemoteMessage = rm
};
foreach (var messagePair in messagePairs)
{
var localRequestParameters =
from p in messagePair.LocalMessage.RequestParameters
join t in local.Types on p.Type.FullName equals t.FullName
select new RecordSchema.Field(p.Name, t)
;
var remoteRequestParameters =
from p in messagePair.RemoteMessage.RequestParameters
join t in remote.Types on p.Type.FullName equals t.FullName
select new RecordSchema.Field(p.Name, t)
;
var localRequest = new RecordSchema($"{local.FullName}.messages.{messagePair.MessageName}", localRequestParameters);
var remoteRequest = new RecordSchema($"{remote.FullName}.messages.{messagePair.MessageName}", remoteRequestParameters);
var requestReader = new DatumReader <IAvroRecord>(localRequest, remoteRequest);
var requestWriter = new DatumWriter <IAvroRecord>(localRequest);
requestReaders.Add(messagePair.MessageName, requestReader);
requestWriters.Add(messagePair.MessageName, requestWriter);
var responseReader = new DatumReader <object>(messagePair.LocalMessage.Response, messagePair.RemoteMessage.Response);
var responseWriter = new DatumWriter <object>(messagePair.LocalMessage.Response);
responseReaders.Add(messagePair.MessageName, responseReader);
responseWriters.Add(messagePair.MessageName, responseWriter);
var errorReader = new DatumReader <object>(messagePair.LocalMessage.Error, messagePair.RemoteMessage.Error);
var errorWriter = new DatumWriter <object>(messagePair.LocalMessage.Error);
errorReaders.Add(messagePair.MessageName, errorReader);
errorWriters.Add(messagePair.MessageName, errorWriter);
}
RequestReaders = requestReaders;
RequestWriters = requestWriters;
ResponseReaders = responseReaders;
ResponseWriters = responseWriters;
ErrorReaders = errorReaders;
ErrorWriters = errorWriters;
}
private static S Read <S>(DatumReader <S> reader, Decoder d)
{
S reuse = default(S);
return(reader.Read(reuse, d));
}
internal AvroDeserializer(AvroSerialization <T> _enclosing, Type clazz)
{
this._enclosing = _enclosing;
this.reader = this._enclosing.GetReader(clazz);
}
public void TestSimple()
{
var schema = AvroParser.ReadSchema(@"{
""name"":""Test.Foobar.Record.Thing"",
""type"":""record"",
""fields"":[
{""name"":""ID"",""type"":""int""},
{""name"":""Name"",""type"":""string""},
{""name"":""Nuller"",""type"":""null""},
{""name"":""family"",""type"":{
""type"":""map"",""values"":""string""
}},
{""name"":""stuff"",""type"":{
""name"":""stuffs"",
""type"":""record"",
""fields"":[
{""name"":""key"",""type"":""bytes""},
{""name"":""keytype"",""type"":{
""name"":""keyenum"",
""type"":""enum"",
""symbols"":[""ANALOG"",""DIGITAL""]
}}
]
}},
{""name"":""NullableThing"",""type"":[""null"",""string""]},
{""name"":""Tags"",""type"":{
""type"":""array"",""items"":""string""
}}
]
}") as RecordSchema;
var stuffSchema = schema.First(r => r.Name == "stuff").Type as RecordSchema;
var enumSchema = stuffSchema.First(r => r.Name == "keytype").Type as EnumSchema;
var genericRecord = new GenericRecord(schema);
var reader = new DatumReader <GenericRecord>(schema);
var writer = new DatumWriter <GenericRecord>(schema);
var delimiter = Environment.NewLine;
var stringBuilder = new StringBuilder();
using (var stream = new StringWriter(stringBuilder))
using (var encoder = new JsonEncoder(stream, schema, delimiter))
{
for (int i = 0; i < 10; i++)
{
var record = new GenericRecord(genericRecord);
record[0] = i;
record[1] = $"foo{i}";
record[2] = null;
record[3] = new Dictionary <string, string>()
{
{ "Brother", "John" }
};
var stuffRecord = new GenericRecord(stuffSchema);
var keyEnum = new GenericEnum(enumSchema, i % enumSchema.Symbols.Count);
stuffRecord[0] = Guid.NewGuid().ToByteArray();
stuffRecord[1] = keyEnum;
record[4] = stuffRecord;
record[5] = (i % 2) == 0 ? "ToNullOrNotToNull" : null;
record[6] = new List <string> {
};
writer.Write(encoder, record);
var singleJson = stringBuilder.ToString();
}
}
var allJson = stringBuilder.ToString();
using (var stream = new StringReader(allJson))
using (var decoder = new JsonDecoder(stream, schema, delimiter))
{
for (int i = 0; i < 10; i++)
{
var record = reader.Read(decoder);
Debug.WriteLine(record.ToString());
}
}
}
