public override ValueTask <Stream?> SerializeAsync(
object?message,
MessageHeaderCollection messageHeaders,
MessageSerializationContext context)
{
Check.NotNull(messageHeaders, nameof(messageHeaders));
if (message == null)
{
return(ValueTaskFactory.FromResult <Stream?>(null));
}
if (message is Stream inputStream)
{
return(ValueTaskFactory.FromResult <Stream?>(inputStream));
}
if (message is byte[] inputBytes)
{
return(ValueTaskFactory.FromResult <Stream?>(new MemoryStream(inputBytes)));
}
var type = message.GetType();
messageHeaders.AddOrReplace(DefaultMessageHeaders.MessageType, type.AssemblyQualifiedName);
var bytes = JsonSerializer.SerializeToUtf8Bytes(message, type, Options);
return(ValueTaskFactory.FromResult <Stream?>(new MemoryStream(bytes)));
}
private async ValueTask <byte[]?> SerializeAsync <TValue>(
object?message,
MessageComponentType componentType,
MessageSerializationContext context)
{
if (message == null)
{
return(null);
}
if (message is Stream inputStream)
{
return(await inputStream.ReadAllAsync().ConfigureAwait(false));
}
if (message is byte[] inputBytes)
{
return(inputBytes);
}
return(await new AvroSerializer <TValue>(
SchemaRegistryClientFactory.GetClient(SchemaRegistryConfig),
AvroSerializerConfig)
.SerializeAsync(
(TValue)message,
GetConfluentSerializationContext(componentType, context))
.ConfigureAwait(false));
}
/// <inheritdoc cref="IMessageSerializer.DeserializeAsync" />
public override async ValueTask <(object?, Type)> DeserializeAsync(
Stream?messageStream,
MessageHeaderCollection messageHeaders,
MessageSerializationContext context)
{
Check.NotNull(messageHeaders, nameof(messageHeaders));
var type = SerializationHelper.GetTypeFromHeaders(messageHeaders) ??
throw new InvalidOperationException("Message type is null.");
if (messageStream == null)
{
return(null, type);
}
if (messageStream.CanSeek && messageStream.Length == 0)
{
return(null, type);
}
var deserializedObject = await JsonSerializer.DeserializeAsync(messageStream, type, Options)
.ConfigureAwait(false) ??
throw new MessageSerializerException("The deserialization returned null.");
return(deserializedObject, type);
}
public override ValueTask <Stream?> SerializeAsync(
object?message,
MessageHeaderCollection messageHeaders,
MessageSerializationContext context)
{
Check.NotNull(messageHeaders, nameof(messageHeaders));
if (message == null)
{
return(ValueTaskFactory.FromResult <Stream?>(null));
}
if (message is Stream inputStream)
{
return(ValueTaskFactory.FromResult <Stream?>(inputStream));
}
if (message is byte[] inputBytes)
{
return(ValueTaskFactory.FromResult <Stream?>(new MemoryStream(inputBytes)));
}
var type = message.GetType();
var jsonString = JsonConvert.SerializeObject(message, type, Settings);
messageHeaders.AddOrReplace(DefaultMessageHeaders.MessageType, type.AssemblyQualifiedName);
return(ValueTaskFactory.FromResult <Stream?>(new MemoryStream(GetSystemEncoding().GetBytes(jsonString))));
}
/// <inheritdoc cref="IKafkaMessageSerializer.DeserializeKey" />
public override string DeserializeKey(
byte[] key,
IReadOnlyCollection <MessageHeader>?messageHeaders,
MessageSerializationContext context)
{
Check.NotNull(key, nameof(key));
return(AsyncHelper.RunSynchronously(
() => DeserializeAsync <string>(key, MessageComponentType.Key, context)) !);
}
/// <inheritdoc cref="IMessageSerializer.SerializeAsync" />
public override async ValueTask <Stream?> SerializeAsync(
object?message,
MessageHeaderCollection messageHeaders,
MessageSerializationContext context)
{
var buffer = await SerializeAsync <TMessage>(message, MessageComponentType.Value, context)
.ConfigureAwait(false);
return(buffer == null ? null : new MemoryStream(buffer));
}
/// <inheritdoc cref="IKafkaMessageSerializer.SerializeKey" />
public override byte[] SerializeKey(
string key,
IReadOnlyCollection <MessageHeader>?messageHeaders,
MessageSerializationContext context)
{
Check.NotEmpty(key, nameof(key));
byte[]? serializedKey = AsyncHelper.RunValueTaskSynchronously(
() => SerializeAsync <string>(key, MessageComponentType.Key, context));
return(serializedKey ?? Array.Empty <byte>());
}
/// <inheritdoc cref="IMessageSerializer.DeserializeAsync" />
public override async ValueTask <(object?Message, Type MessageType)> DeserializeAsync(
Stream?messageStream,
MessageHeaderCollection messageHeaders,
MessageSerializationContext context)
{
var buffer = await messageStream.ReadAllAsync().ConfigureAwait(false);
var deserialized = await DeserializeAsync <TMessage>(buffer, MessageComponentType.Value, context)
.ConfigureAwait(false);
var type = deserialized?.GetType() ?? typeof(TMessage);
return(deserialized, type);
}
/// <inheritdoc cref="IMessageSerializer.DeserializeAsync" />
public override async ValueTask <(object?, Type)> DeserializeAsync(
Stream?messageStream,
MessageHeaderCollection messageHeaders,
MessageSerializationContext context)
{
if (messageStream == null)
{
return(null, _type);
}
var buffer = await messageStream.ReadAllAsync().ConfigureAwait(false);
var jsonString = GetSystemEncoding().GetString(buffer !);
var deserializedObject = JsonConvert.DeserializeObject(jsonString, _type, Settings);
return(deserializedObject, _type);
}
/// <inheritdoc cref="IMessageSerializer.DeserializeAsync" />
public override async ValueTask <(object?, Type)> DeserializeAsync(
Stream?messageStream,
MessageHeaderCollection messageHeaders,
MessageSerializationContext context)
{
if (messageStream == null)
{
return(null, _type);
}
if (messageStream.CanSeek && messageStream.Length == 0)
{
return(null, _type);
}
var deserializedObject = await JsonSerializer.DeserializeAsync(messageStream, _type, Options)
.ConfigureAwait(false) ??
throw new MessageSerializerException("The deserialization returned null.");
return(deserializedObject, _type);
}
private async Task <TValue?> DeserializeAsync <TValue>(
byte[]?message,
MessageComponentType componentType,
MessageSerializationContext context)
where TValue : class
{
if (message == null)
{
return(null);
}
var avroDeserializer = new AvroDeserializer <TValue>(
SchemaRegistryClientFactory.GetClient(SchemaRegistryConfig),
AvroSerializerConfig);
var confluentSerializationContext = GetConfluentSerializationContext(componentType, context);
return(await avroDeserializer.DeserializeAsync(
new ReadOnlyMemory <byte>(message),
false,
confluentSerializationContext)
.ConfigureAwait(false));
}
/// <inheritdoc cref="IMessageSerializer.DeserializeAsync" />
public override async ValueTask <(object?, Type)> DeserializeAsync(
Stream?messageStream,
MessageHeaderCollection messageHeaders,
MessageSerializationContext context)
{
Check.NotNull(messageHeaders, nameof(messageHeaders));
var type = SerializationHelper.GetTypeFromHeaders(messageHeaders) ??
throw new InvalidOperationException("Message type is null.");
if (messageStream == null)
{
return(null, type);
}
var buffer = await messageStream.ReadAllAsync().ConfigureAwait(false);
var jsonString = GetSystemEncoding().GetString(buffer !);
var deserializedObject = JsonConvert.DeserializeObject(jsonString, type, Settings);
return(deserializedObject, type);
}
public override ValueTask <Stream?> SerializeAsync(
object?message,
MessageHeaderCollection messageHeaders,
MessageSerializationContext context)
{
if (message == null)
{
return(ValueTaskFactory.FromResult <Stream?>(null));
}
if (message is Stream inputStream)
{
return(ValueTaskFactory.FromResult <Stream?>(inputStream));
}
if (message is byte[] inputBytes)
{
return(ValueTaskFactory.FromResult <Stream?>(new MemoryStream(inputBytes)));
}
var bytes = JsonSerializer.SerializeToUtf8Bytes(message, _type, Options);
return(ValueTaskFactory.FromResult <Stream?>(new MemoryStream(bytes)));
}
public override ValueTask <Stream?> SerializeAsync(
object?message,
MessageHeaderCollection messageHeaders,
MessageSerializationContext context)
{
if (message == null)
{
return(ValueTaskFactory.FromResult <Stream?>(null));
}
if (message is Stream inputStream)
{
return(ValueTaskFactory.FromResult <Stream?>(inputStream));
}
if (message is byte[] inputBytes)
{
return(ValueTaskFactory.FromResult <Stream?>(new MemoryStream(inputBytes)));
}
var jsonString = JsonConvert.SerializeObject(message, _type, Settings);
return(ValueTaskFactory.FromResult <Stream?>(new MemoryStream(GetSystemEncoding().GetBytes(jsonString))));
}
public abstract ValueTask <(object?, Type)> DeserializeAsync(
Stream?messageStream,
MessageHeaderCollection messageHeaders,
MessageSerializationContext context);
/// <inheritdoc cref="IKafkaMessageSerializer.DeserializeKey" />
public string DeserializeKey(
byte[] key,
IReadOnlyCollection <MessageHeader> messageHeaders,
MessageSerializationContext context) =>
Encoding.UTF8.GetString(key);
/// <inheritdoc cref="IKafkaMessageSerializer.SerializeKey" />
public byte[] SerializeKey(
string key,
IReadOnlyCollection <MessageHeader> messageHeaders,
MessageSerializationContext context) =>
Encoding.UTF8.GetBytes(key);
/// <inheritdoc cref="IMessageSerializer.DeserializeAsync" />
public ValueTask <(object?Message, Type MessageType)> DeserializeAsync(
Stream?messageStream,
MessageHeaderCollection messageHeaders,
MessageSerializationContext context) =>
private static SerializationContext GetConfluentSerializationContext(
MessageComponentType componentType,
MessageSerializationContext context) =>
new SerializationContext(componentType, context.ActualEndpointName);
public abstract ValueTask <Stream?> SerializeAsync(
object?message,
MessageHeaderCollection messageHeaders,
MessageSerializationContext context);
private static SerializationContext GetConfluentSerializationContext(
MessageComponentType componentType,
MessageSerializationContext context) =>
/// <inheritdoc cref="IMessageSerializer.SerializeAsync" />
public ValueTask <Stream?> SerializeAsync(
object?message,
MessageHeaderCollection messageHeaders,
MessageSerializationContext context) =>
_serializer.SerializeAsync(message, messageHeaders, context);
