/// <summary>
/// Creates a serializer.
/// </summary>
/// <param name="registryClient">
/// The client to use for Schema Registry operations. (The client will not be disposed.)
/// </param>
/// <param name="registerAutomatically">
/// When to automatically register schemas that match the type being serialized.
/// </param>
/// <param name="schemaBuilder">
/// The schema builder to use to create a schema for a C# type when registering automatically.
/// If none is provided, the default schema builder will be used.
/// </param>
/// <param name="schemaReader">
/// The JSON schema reader to use to convert schemas received from the registry into abstract
/// representations. If none is provided, the default schema reader will be used.
/// </param>
/// <param name="schemaWriter">
/// The JSON schema writer to use to convert abstract schema representations when registering
/// automatically. If none is provided, the default schema writer will be used.
/// </param>
/// <param name="serializerBuilder">
/// The deserializer builder to use to build serialization functions for C# types. If none
/// is provided, the default serializer builder will be used.
/// </param>
/// <param name="subjectNameBuilder">
/// A function that determines the subject name given the topic name and a component type
/// (key or value). If none is provided, the default "{topic name}-{component}" naming
/// convention will be used.
/// </param>
/// <param name="tombstoneBehavior">
/// The behavior of the serializer on tombstone records.
/// </param>
/// <exception cref="ArgumentNullException">
/// Thrown when the registry client is null.
/// </exception>
public AsyncSchemaRegistrySerializer(
ISchemaRegistryClient registryClient,
AutomaticRegistrationBehavior registerAutomatically = AutomaticRegistrationBehavior.Never,
Abstract.ISchemaBuilder schemaBuilder = null,
IJsonSchemaReader schemaReader = null,
IJsonSchemaWriter schemaWriter = null,
IBinarySerializerBuilder serializerBuilder = null,
Func <SerializationContext, string> subjectNameBuilder = null,
TombstoneBehavior tombstoneBehavior = TombstoneBehavior.None
)
{
if (registryClient == null)
{
throw new ArgumentNullException(nameof(registryClient));
}
if (tombstoneBehavior != TombstoneBehavior.None && default(T) != null)
{
throw new UnsupportedTypeException(typeof(T), $"{typeof(T)} cannot represent tombstone values.");
}
RegisterAutomatically = registerAutomatically;
SchemaBuilder = schemaBuilder ?? new Abstract.SchemaBuilder();
SchemaReader = schemaReader ?? new JsonSchemaReader();
SchemaWriter = schemaWriter ?? new JsonSchemaWriter();
SerializerBuilder = serializerBuilder ?? new BinarySerializerBuilder();
SubjectNameBuilder = subjectNameBuilder ??
(c => $"{c.Topic}-{(c.Component == MessageComponentType.Key ? "key" : "value")}");
TombstoneBehavior = tombstoneBehavior;
_cache = new Dictionary <string, Task <Func <T, byte[]> > >();
_register = (subject, json) => registryClient.RegisterSchemaAsync(subject, json);
_resolve = subject => registryClient.GetLatestSchemaAsync(subject);
}
/// <summary>
/// Creates a serializer.
/// </summary>
/// <param name="registryClient">
/// A client to use for Schema Registry operations. (The client will not be disposed.)
/// </param>
/// <param name="registerAutomatically">
/// Whether to automatically register schemas that match the type being serialized.
/// </param>
/// <param name="schemaBuilder">
/// A schema builder (used to build a schema for a C# type when registering automatically).
/// If none is provided, the default schema builder will be used.
/// </param>
/// <param name="schemaReader">
/// A JSON schema reader (used to convert schemas received from the registry into abstract
/// representations). If none is provided, the default schema reader will be used.
/// </param>
/// <param name="schemaWriter">
/// A JSON schema writer (used to convert abstract schema representations when registering
/// automatically). If none is provided, the default schema writer will be used.
/// </param>
/// <param name="serializerBuilder">
/// A deserializer builder (used to build serialization functions for C# types). If none is
/// provided, the default serializer builder will be used.
/// </param>
/// <param name="subjectNameBuilder">
/// A function that determines the subject name given the topic name and a component type
/// (key or value). If none is provided, the default "{topic name}-{component}" naming
/// convention will be used.
/// </param>
/// <exception cref="ArgumentNullException">
/// Thrown when the registry client is null.
/// </exception>
public AsyncSchemaRegistrySerializer(
ISchemaRegistryClient registryClient,
bool registerAutomatically = false,
Abstract.ISchemaBuilder schemaBuilder = null,
IJsonSchemaReader schemaReader = null,
IJsonSchemaWriter schemaWriter = null,
IBinarySerializerBuilder serializerBuilder = null,
Func <SerializationContext, string> subjectNameBuilder = null
) : this(
registerAutomatically,
schemaBuilder,
schemaReader,
schemaWriter,
serializerBuilder,
subjectNameBuilder
)
{
if (registryClient == null)
{
throw new ArgumentNullException(nameof(registryClient));
}
_register = (subject, json) => registryClient.RegisterSchemaAsync(subject, json);
_resolve = subject => registryClient.GetLatestSchemaAsync(subject);
}
/// <summary>
/// Creates a deserializer.
/// </summary>
/// <param name="registryConfiguration">
/// Schema Registry configuration. Using the <see cref="SchemaRegistryConfig" /> class is
/// highly recommended.
/// </param>
/// <param name="deserializerBuilder">
/// The deserializer builder to use to to generate deserialization functions for C# types.
/// If none is provided, the default deserializer builder will be used.
/// </param>
/// <param name="schemaReader">
/// The JSON schema reader to use to convert schemas received from the registry into abstract
/// representations. If none is provided, the default schema reader will be used.
/// </param>
/// <param name="tombstoneBehavior">
/// The behavior of the deserializer on tombstone records.
/// </param>
/// <exception cref="ArgumentNullException">
/// Thrown when the registry configuration is null.
/// </exception>
public AsyncSchemaRegistryDeserializer(
IEnumerable <KeyValuePair <string, string> > registryConfiguration,
IBinaryDeserializerBuilder deserializerBuilder = null,
IJsonSchemaReader schemaReader = null,
TombstoneBehavior tombstoneBehavior = TombstoneBehavior.None
)
{
if (registryConfiguration == null)
{
throw new ArgumentNullException(nameof(registryConfiguration));
}
if (tombstoneBehavior != TombstoneBehavior.None && default(T) != null)
{
throw new UnsupportedTypeException(typeof(T), $"{typeof(T)} cannot represent tombstone values.");
}
DeserializerBuilder = deserializerBuilder ?? new BinaryDeserializerBuilder();
RegistryClient = new CachedSchemaRegistryClient(registryConfiguration);
SchemaReader = schemaReader ?? new JsonSchemaReader();
TombstoneBehavior = tombstoneBehavior;
_cache = new Dictionary <int, Task <Func <Stream, T> > >();
_disposeRegistryClient = true;
}
/// <summary>
/// Creates a deserializer.
/// </summary>
/// <param name="registryClient">
/// The client to use for Schema Registry operations. (The client will not be disposed.)
/// </param>
/// <param name="deserializerBuilder">
/// The deserializer builder used to generate deserialization functions for C# types. If
/// none is provided, the default deserializer builder will be used.
/// </param>
/// <param name="schemaReader">
/// The JSON schema reader used to convert schemas received from the registry into abstract
/// representations. If none is provided, the default schema reader will be used.
/// </param>
/// <param name="tombstoneBehavior">
/// The behavior of the deserializer on tombstone records.
/// </param>
/// <exception cref="ArgumentNullException">
/// Thrown when the registry client is null.
/// </exception>
public AsyncSchemaRegistryDeserializer(
ISchemaRegistryClient registryClient,
IBinaryDeserializerBuilder deserializerBuilder = null,
IJsonSchemaReader schemaReader = null,
TombstoneBehavior tombstoneBehavior = TombstoneBehavior.None
)
{
if (registryClient == null)
{
throw new ArgumentNullException(nameof(registryClient));
}
if (tombstoneBehavior != TombstoneBehavior.None && default(T) != null)
{
throw new UnsupportedTypeException(typeof(T), $"{typeof(T)} cannot represent tombstone values.");
}
DeserializerBuilder = deserializerBuilder ?? new BinaryDeserializerBuilder();
RegistryClient = registryClient;
SchemaReader = schemaReader ?? new JsonSchemaReader();
TombstoneBehavior = tombstoneBehavior;
_cache = new Dictionary <int, Task <Func <Stream, T> > >();
_disposeRegistryClient = false;
}
/// <summary>
/// Initializes a new instance of the <see cref="AsyncSchemaRegistrySerializer{T}" />
/// class with a Schema Registry configuration.
/// </summary>
/// <param name="registryConfiguration">
/// A Schema Registry configuration. Using the <see cref="SchemaRegistryConfig" /> class is
/// highly recommended.
/// </param>
/// <param name="registerAutomatically">
/// Whether the serializer should automatically register schemas that match the type being
/// serialized.
/// </param>
/// <param name="schemaBuilder">
/// A schema builder instance that should be used to create schemas for .NET <see cref="Type" />s
/// when registering automatically. If none is provided, the default <see cref="SchemaBuilder" />
/// will be used.
/// </param>
/// <param name="schemaReader">
/// A schema reader instance that should be used to convert schemas received from the
/// Registry into abstract representations. If none is provided, the default
/// <see cref="JsonSchemaReader" /> will be used.
/// </param>
/// <param name="schemaWriter">
/// A schema writer instance that should be used to convert abstract schema representations
/// when registering automatically. If none is provided, the default <see cref="JsonSchemaWriter" />
/// will be used.
/// </param>
/// <param name="serializerBuilder">
/// A serializer builder instance that should be used to generate serialization functions
/// for .NET <see cref="Type" />s. If none is provided, the default <see cref="BinarySerializerBuilder" />
/// will be used.
/// </param>
/// <param name="subjectNameBuilder">
/// A function that determines a subject name given the topic name and a component type
/// (key or value). If none is provided, the default <c>{topic name}-{component}</c> naming
/// convention will be used.
/// </param>
/// <param name="tombstoneBehavior">
/// How the serializer should handle tombstone records.
/// </param>
/// <exception cref="ArgumentNullException">
/// Thrown when <paramref name="registryConfiguration" /> is <c>null</c>.
/// </exception>
/// <exception cref="UnsupportedTypeException">
/// Thrown when <paramref name="tombstoneBehavior" /> is incompatible with
/// <typeparamref name="T" />.
/// </exception>
public AsyncSchemaRegistrySerializer(
IEnumerable <KeyValuePair <string, string> > registryConfiguration,
AutomaticRegistrationBehavior registerAutomatically = AutomaticRegistrationBehavior.Never,
Abstract.ISchemaBuilder schemaBuilder = null,
IJsonSchemaReader schemaReader = null,
IJsonSchemaWriter schemaWriter = null,
IBinarySerializerBuilder serializerBuilder = null,
Func <SerializationContext, string> subjectNameBuilder = null,
TombstoneBehavior tombstoneBehavior = TombstoneBehavior.None)
{
if (registryConfiguration == null)
{
throw new ArgumentNullException(nameof(registryConfiguration));
}
if (tombstoneBehavior != TombstoneBehavior.None && default(T) != null)
{
throw new UnsupportedTypeException(typeof(T), $"{typeof(T)} cannot represent tombstone values.");
}
RegisterAutomatically = registerAutomatically;
RegistryClient = new CachedSchemaRegistryClient(registryConfiguration);
SchemaBuilder = schemaBuilder ?? new Abstract.SchemaBuilder();
SchemaReader = schemaReader ?? new JsonSchemaReader();
SchemaWriter = schemaWriter ?? new JsonSchemaWriter();
SerializerBuilder = serializerBuilder ?? new BinarySerializerBuilder();
SubjectNameBuilder = subjectNameBuilder ??
(c => $"{c.Topic}-{(c.Component == MessageComponentType.Key ? "key" : "value")}");
TombstoneBehavior = tombstoneBehavior;
cache = new Dictionary <string, Task <Func <T, byte[]> > >();
disposeRegistryClient = true;
}
private AsyncSchemaRegistryDeserializer(
IBinaryDeserializerBuilder deserializerBuilder = null,
IJsonSchemaReader schemaReader = null
)
{
_cache = new ConcurrentDictionary <int, Task <Func <Stream, T> > >();
_deserializerBuilder = deserializerBuilder ?? new BinaryDeserializerBuilder();
_schemaReader = schemaReader ?? new JsonSchemaReader();
}
/// <summary>
/// Creates a serializer.
/// </summary>
/// <param name="registryConfiguration">
/// Schema Registry configuration. Using the <see cref="SchemaRegistryConfig" /> class is
/// highly recommended.
/// </param>
/// <param name="registerAutomatically">
/// When to automatically register schemas that match the type being serialized.
/// </param>
/// <param name="schemaBuilder">
/// The schema builder to use to create a schema for a C# type when registering automatically.
/// If none is provided, the default schema builder will be used.
/// </param>
/// <param name="schemaReader">
/// The JSON schema reader to use to convert schemas received from the registry into abstract
/// representations. If none is provided, the default schema reader will be used.
/// </param>
/// <param name="schemaWriter">
/// The JSON schema writer to use to convert abstract schema representations when registering
/// automatically. If none is provided, the default schema writer will be used.
/// </param>
/// <param name="serializerBuilder">
/// The deserializer builder to use to build serialization functions for C# types. If none
/// is provided, the default serializer builder will be used.
/// </param>
/// <param name="subjectNameBuilder">
/// A function that determines the subject name given the topic name and a component type
/// (key or value). If none is provided, the default "{topic name}-{component}" naming
/// convention will be used.
/// </param>
/// <param name="tombstoneBehavior">
/// The behavior of the serializer on tombstone records.
/// </param>
/// <exception cref="ArgumentNullException">
/// Thrown when the registry configuration is null.
/// </exception>
public AsyncSchemaRegistrySerializer(
IEnumerable <KeyValuePair <string, string> > registryConfiguration,
AutomaticRegistrationBehavior registerAutomatically = AutomaticRegistrationBehavior.Never,
Abstract.ISchemaBuilder schemaBuilder = null,
IJsonSchemaReader schemaReader = null,
IJsonSchemaWriter schemaWriter = null,
IBinarySerializerBuilder serializerBuilder = null,
Func <SerializationContext, string> subjectNameBuilder = null,
TombstoneBehavior tombstoneBehavior = TombstoneBehavior.None
)
{
if (registryConfiguration == null)
{
throw new ArgumentNullException(nameof(registryConfiguration));
}
if (tombstoneBehavior != TombstoneBehavior.None && default(T) != null)
{
throw new UnsupportedTypeException(typeof(T), $"{typeof(T)} cannot represent tombstone values.");
}
RegisterAutomatically = registerAutomatically;
SchemaBuilder = schemaBuilder ?? new Abstract.SchemaBuilder();
SchemaReader = schemaReader ?? new JsonSchemaReader();
SchemaWriter = schemaWriter ?? new JsonSchemaWriter();
SerializerBuilder = serializerBuilder ?? new BinarySerializerBuilder();
SubjectNameBuilder = subjectNameBuilder ??
(c => $"{c.Topic}-{(c.Component == MessageComponentType.Key ? "key" : "value")}");
TombstoneBehavior = tombstoneBehavior;
_cache = new Dictionary <string, Task <Func <T, byte[]> > >();
_register = async(subject, json) =>
{
using (var registry = new CachedSchemaRegistryClient(registryConfiguration))
{
return(await registry.RegisterSchemaAsync(subject, new Schema(json, SchemaType.Avro)).ConfigureAwait(false));
}
};
_resolve = async subject =>
{
using (var registry = new CachedSchemaRegistryClient(registryConfiguration))
{
var schema = await registry.GetLatestSchemaAsync(subject).ConfigureAwait(false);
if (schema.SchemaType != SchemaType.Avro)
{
throw new UnsupportedSchemaException(null, $"The latest schema with subject {subject} is not an Avro schema.");
}
return(schema);
}
};
}
/// <summary>
/// Initializes a new instance of the <see cref="SchemaRegistryDeserializerBuilder" />
/// class with a Schema Registry instance.
/// </summary>
/// <param name="registryClient">
/// A Schema Registry client to use for Registry operations. (The client will not be
/// disposed.)
/// </param>
/// <param name="deserializerBuilder">
/// A deserializer builder instance that should be used to generate deserialization
/// functions for .NET <see cref="Type" />s. If none is provided, the default
/// <see cref="BinaryDeserializerBuilder" /> will be used.
/// </param>
/// <param name="schemaReader">
/// A schema reader instance that should be used to convert schemas received from the
/// Registry into abstract representations. If none is provided, the default
/// <see cref="JsonSchemaReader" /> will be used.
/// </param>
/// <exception cref="ArgumentNullException">
/// Thrown when <paramref name="registryClient" /> is <c>null</c>.
/// </exception>
public SchemaRegistryDeserializerBuilder(
ISchemaRegistryClient registryClient,
IBinaryDeserializerBuilder deserializerBuilder = null,
IJsonSchemaReader schemaReader = null)
{
disposeRegistryClient = false;
DeserializerBuilder = deserializerBuilder ?? new BinaryDeserializerBuilder();
RegistryClient = registryClient ?? throw new ArgumentNullException(nameof(registryClient));
SchemaReader = schemaReader ?? new JsonSchemaReader();
}
/// <summary>
/// Initializes a new instance of the <see cref="SchemaRegistryDeserializerBuilder" />
/// class with a Schema Registry configuration.
/// </summary>
/// <param name="registryConfiguration">
/// A Schema Registry configuration. Using the <see cref="SchemaRegistryConfig" /> class is
/// highly recommended.
/// </param>
/// <param name="deserializerBuilder">
/// A deserializer builder instance that should be used to generate deserialization
/// functions for .NET <see cref="Type" />s. If none is provided, the default
/// <see cref="BinaryDeserializerBuilder" /> will be used.
/// </param>
/// <param name="schemaReader">
/// A schema reader instance that should be used to convert schemas received from the
/// Registry into abstract representations. If none is provided, the default
/// <see cref="JsonSchemaReader" /> will be used.
/// </param>
public SchemaRegistryDeserializerBuilder(
IEnumerable <KeyValuePair <string, string> > registryConfiguration,
IBinaryDeserializerBuilder deserializerBuilder = null,
IJsonSchemaReader schemaReader = null)
: this(
new CachedSchemaRegistryClient(registryConfiguration),
deserializerBuilder,
schemaReader)
{
disposeRegistryClient = true;
}
/// <summary>
/// Initializes a new instance of the <see cref="SchemaRegistrySerializerBuilder" />
/// class with a Schema Registry client.
/// </summary>
/// <param name="registryClient">
/// A Schema Registry client to use for Registry operations. (The client will not be
/// disposed.)
/// </param>
/// <param name="schemaBuilder">
/// A schema builder instance that should be used to create a schemas when registering
/// automatically. If none is provided, the default <see cref="SchemaBuilder" /> will be
/// used.
/// </param>
/// <param name="schemaReader">
/// A schema reader instance that should be used to convert schemas received from the
/// Registry into abstract representations. If none is provided, the default
/// <see cref="JsonSchemaReader" /> will be used.
/// </param>
/// <param name="schemaWriter">
/// A schema writer instance that should be used to convert abstract schema representations
/// when registering automatically. If none is provided, the default <see cref="JsonSchemaWriter" />
/// will be used.
/// </param>
/// <param name="serializerBuilder">
/// A serializer builder instance that should be used to generate serialization functions
/// for .NET <see cref="Type" />s. If none is provided, the default <see cref="BinarySerializerBuilder" />
/// will be used.
/// </param>
/// <exception cref="ArgumentNullException">
/// Thrown when <paramref name="registryClient" /> is <c>null</c>.
/// </exception>
public SchemaRegistrySerializerBuilder(
ISchemaRegistryClient registryClient,
Abstract.ISchemaBuilder schemaBuilder = null,
IJsonSchemaReader schemaReader = null,
IJsonSchemaWriter schemaWriter = null,
IBinarySerializerBuilder serializerBuilder = null)
{
disposeRegistryClient = false;
RegistryClient = registryClient ?? throw new ArgumentNullException(nameof(registryClient));
SchemaBuilder = schemaBuilder ?? new Abstract.SchemaBuilder();
SchemaReader = schemaReader ?? new JsonSchemaReader();
SchemaWriter = schemaWriter ?? new JsonSchemaWriter();
SerializerBuilder = serializerBuilder ?? new BinarySerializerBuilder();
}
/// <summary>
/// Creates a deserializer.
/// </summary>
/// <param name="registryClient">
/// A client to use for Schema Registry operations. (The client will not be disposed.)
/// </param>
/// <param name="deserializerBuilder">
/// A deserializer builder (used to build deserialization functions for C# types). If none
/// is provided, the default deserializer builder will be used.
/// </param>
/// <param name="schemaReader">
/// A JSON schema reader (used to convert schemas received from the registry into abstract
/// representations). If none is provided, the default schema reader will be used.
/// </param>
/// <exception cref="ArgumentNullException">
/// Thrown when the registry client is null.
/// </exception>
public AsyncSchemaRegistryDeserializer(
ISchemaRegistryClient registryClient,
IBinaryDeserializerBuilder deserializerBuilder = null,
IJsonSchemaReader schemaReader = null
) : this(
deserializerBuilder,
schemaReader
)
{
if (registryClient == null)
{
throw new ArgumentNullException(nameof(registryClient));
}
_resolve = id => registryClient.GetSchemaAsync(id);
}
/// <summary>
/// Creates a serializer builder.
/// </summary>
/// <param name="registryConfiguration">
/// Schema Registry configuration. Using the <see cref="SchemaRegistryConfig" /> class is
/// highly recommended.
/// </param>
/// <param name="schemaBuilder">
/// The schema builder to use to create a schema for a C# type when registering automatically.
/// If none is provided, the default schema builder will be used.
/// </param>
/// <param name="schemaReader">
/// The JSON schema reader to use to convert schemas received from the registry into abstract
/// representations. If none is provided, the default schema reader will be used.
/// </param>
/// <param name="schemaWriter">
/// The JSON schema writer to use to convert abstract schema representations when registering
/// automatically. If none is provided, the default schema writer will be used.
/// </param>
/// <param name="serializerBuilder">
/// The deserializer builder to use to build serialization functions for C# types. If none
/// is provided, the default serializer builder will be used.
/// </param>
public SchemaRegistrySerializerBuilder(
IEnumerable <KeyValuePair <string, string> > registryConfiguration,
Abstract.ISchemaBuilder schemaBuilder = null,
IJsonSchemaReader schemaReader = null,
IJsonSchemaWriter schemaWriter = null,
Serialization.IBinarySerializerBuilder serializerBuilder = null
) : this(
new CachedSchemaRegistryClient(registryConfiguration),
schemaBuilder,
schemaReader,
schemaWriter,
serializerBuilder
)
{
_disposeRegistryClient = true;
}
/// <summary>
/// Creates a deserializer.
/// </summary>
/// <param name="registryClient">
/// The client to use for Schema Registry operations. (The client will not be disposed.)
/// </param>
/// <param name="deserializerBuilder">
/// The deserializer builder used to generate deserialization functions for C# types. If
/// none is provided, the default deserializer builder will be used.
/// </param>
/// <param name="schemaReader">
/// The JSON schema reader used to convert schemas received from the registry into abstract
/// representations. If none is provided, the default schema reader will be used.
/// </param>
/// <exception cref="ArgumentNullException">
/// Thrown when the registry client is null.
/// </exception>
public AsyncSchemaRegistryDeserializer(
ISchemaRegistryClient registryClient,
IBinaryDeserializerBuilder deserializerBuilder = null,
IJsonSchemaReader schemaReader = null
) : this(
deserializerBuilder,
schemaReader
)
{
if (registryClient == null)
{
throw new ArgumentNullException(nameof(registryClient));
}
RegistryClient = registryClient;
_disposeRegistryClient = false;
}
/// <summary>
/// Creates a deserializer.
/// </summary>
/// <param name="registryConfiguration">
/// Schema Registry configuration. Using the <see cref="SchemaRegistryConfig" /> class is
/// highly recommended.
/// </param>
/// <param name="deserializerBuilder">
/// The deserializer builder to use to to generate deserialization functions for C# types.
/// If none is provided, the default deserializer builder will be used.
/// </param>
/// <param name="schemaReader">
/// The JSON schema reader to use to convert schemas received from the registry into abstract
/// representations. If none is provided, the default schema reader will be used.
/// </param>
/// <exception cref="ArgumentNullException">
/// Thrown when the registry configuration is null.
/// </exception>
public AsyncSchemaRegistryDeserializer(
IEnumerable <KeyValuePair <string, string> > registryConfiguration,
IBinaryDeserializerBuilder deserializerBuilder = null,
IJsonSchemaReader schemaReader = null
) : this(
deserializerBuilder,
schemaReader
)
{
if (registryConfiguration == null)
{
throw new ArgumentNullException(nameof(registryConfiguration));
}
RegistryClient = new CachedSchemaRegistryClient(registryConfiguration);
_disposeRegistryClient = true;
}
private AsyncSchemaRegistrySerializer(
bool registerAutomatically = false,
Abstract.ISchemaBuilder schemaBuilder = null,
IJsonSchemaReader schemaReader = null,
IJsonSchemaWriter schemaWriter = null,
IBinarySerializerBuilder serializerBuilder = null,
Func <SerializationContext, string> subjectNameBuilder = null
)
{
_cache = new ConcurrentDictionary <string, Task <Func <T, byte[]> > >();
_registerAutomatically = registerAutomatically;
_schemaBuilder = schemaBuilder ?? new Abstract.SchemaBuilder();
_schemaReader = schemaReader ?? new JsonSchemaReader();
_schemaWriter = schemaWriter ?? new JsonSchemaWriter();
_serializerBuilder = serializerBuilder ?? new BinarySerializerBuilder();
_subjectNameBuilder = subjectNameBuilder ??
(c => $"{c.Topic}-{(c.Component == MessageComponentType.Key ? "key" : "value")}");
}
/// <summary>
/// Creates a deserializer.
/// </summary>
/// <param name="registryClient">
/// The client to use for Schema Registry operations. (The client will not be disposed.)
/// </param>
/// <param name="deserializerBuilder">
/// The deserializer builder used to generate deserialization functions for C# types. If
/// none is provided, the default deserializer builder will be used.
/// </param>
/// <param name="schemaReader">
/// The JSON schema reader used to convert schemas received from the registry into abstract
/// representations. If none is provided, the default schema reader will be used.
/// </param>
/// <exception cref="ArgumentNullException">
/// Thrown when the registry client is null.
/// </exception>
public AsyncSchemaRegistryDeserializer(
ISchemaRegistryClient registryClient,
IBinaryDeserializerBuilder?deserializerBuilder = null,
IJsonSchemaReader?schemaReader = null
)
{
if (registryClient == null)
{
throw new ArgumentNullException(nameof(registryClient));
}
DeserializerBuilder = deserializerBuilder ?? new BinaryDeserializerBuilder();
RegistryClient = registryClient;
SchemaReader = schemaReader ?? new JsonSchemaReader();
_cache = new ConcurrentDictionary <int, Task <Func <Stream, T> > >();
_disposeRegistryClient = false;
}
/// <summary>
/// Creates a deserializer.
/// </summary>
/// <param name="registryConfiguration">
/// Schema Registry configuration. Using the <see cref="SchemaRegistryConfig" /> class is
/// highly recommended.
/// </param>
/// <param name="deserializerBuilder">
/// The deserializer builder to use to to generate deserialization functions for C# types.
/// If none is provided, the default deserializer builder will be used.
/// </param>
/// <param name="schemaReader">
/// The JSON schema reader to use to convert schemas received from the registry into abstract
/// representations. If none is provided, the default schema reader will be used.
/// </param>
/// <exception cref="ArgumentNullException">
/// Thrown when the registry configuration is null.
/// </exception>
public AsyncSchemaRegistryDeserializer(
IEnumerable <KeyValuePair <string, string> > registryConfiguration,
IBinaryDeserializerBuilder?deserializerBuilder = null,
IJsonSchemaReader?schemaReader = null
)
{
if (registryConfiguration == null)
{
throw new ArgumentNullException(nameof(registryConfiguration));
}
DeserializerBuilder = deserializerBuilder ?? new BinaryDeserializerBuilder();
RegistryClient = new CachedSchemaRegistryClient(registryConfiguration);
SchemaReader = schemaReader ?? new JsonSchemaReader();
_cache = new ConcurrentDictionary <int, Task <Func <Stream, T> > >();
_disposeRegistryClient = true;
}
/// <summary>
/// Creates a deserializer.
/// </summary>
/// <param name="registryConfiguration">
/// Schema Registry configuration. Using the <see cref="SchemaRegistryConfig" /> class is
/// highly recommended.
/// </param>
/// <param name="deserializerBuilder">
/// A deserializer builder (used to build deserialization functions for C# types). If none
/// is provided, the default deserializer builder will be used.
/// </param>
/// <param name="schemaReader">
/// A JSON schema reader (used to convert schemas received from the registry into abstract
/// representations). If none is provided, the default schema reader will be used.
/// </param>
/// <exception cref="ArgumentNullException">
/// Thrown when the registry configuration is null.
/// </exception>
public AsyncSchemaRegistryDeserializer(
IEnumerable <KeyValuePair <string, string> > registryConfiguration,
IBinaryDeserializerBuilder deserializerBuilder = null,
IJsonSchemaReader schemaReader = null
) : this(
deserializerBuilder,
schemaReader
)
{
if (registryConfiguration == null)
{
throw new ArgumentNullException(nameof(registryConfiguration));
}
_resolve = async id =>
{
using (var registry = new CachedSchemaRegistryClient(registryConfiguration))
{
return(await registry.GetSchemaAsync(id).ConfigureAwait(false));
}
};
}
/// <summary>
/// Creates a serializer.
/// </summary>
/// <param name="registryConfiguration">
/// Schema Registry configuration. Using the <see cref="SchemaRegistryConfig" /> class is
/// highly recommended.
/// </param>
/// <param name="registerAutomatically">
/// Whether to automatically register schemas that match the type being serialized.
/// </param>
/// <param name="schemaBuilder">
/// A schema builder (used to build a schema for a C# type when registering automatically).
/// If none is provided, the default schema builder will be used.
/// </param>
/// <param name="schemaReader">
/// A JSON schema reader (used to convert schemas received from the registry into abstract
/// representations). If none is provided, the default schema reader will be used.
/// </param>
/// <param name="schemaWriter">
/// A JSON schema writer (used to convert abstract schema representations when registering
/// automatically). If none is provided, the default schema writer will be used.
/// </param>
/// <param name="serializerBuilder">
/// A deserializer builder (used to build serialization functions for C# types). If none is
/// provided, the default serializer builder will be used.
/// </param>
/// <param name="subjectNameBuilder">
/// A function that determines the subject name given the topic name and a component type
/// (key or value). If none is provided, the default "{topic name}-{component}" naming
/// convention will be used.
/// </param>
/// <exception cref="ArgumentNullException">
/// Thrown when the registry configuration is null.
/// </exception>
public AsyncSchemaRegistrySerializer(
IEnumerable <KeyValuePair <string, string> > registryConfiguration,
bool registerAutomatically = false,
Abstract.ISchemaBuilder schemaBuilder = null,
IJsonSchemaReader schemaReader = null,
IJsonSchemaWriter schemaWriter = null,
IBinarySerializerBuilder serializerBuilder = null,
Func <SerializationContext, string> subjectNameBuilder = null
) : this(
registerAutomatically,
schemaBuilder,
schemaReader,
schemaWriter,
serializerBuilder,
subjectNameBuilder
)
{
if (registryConfiguration == null)
{
throw new ArgumentNullException(nameof(registryConfiguration));
}
_register = async(subject, json) =>
{
using (var registry = new CachedSchemaRegistryClient(registryConfiguration))
{
return(await registry.RegisterSchemaAsync(subject, json).ConfigureAwait(false));
}
};
_resolve = async subject =>
{
using (var registry = new CachedSchemaRegistryClient(registryConfiguration))
{
return(await registry.GetLatestSchemaAsync(subject).ConfigureAwait(false));
}
};
}
/// <summary>
/// Creates a new array case.
/// </summary>
/// <param name="reader">
/// A schema reader to use to resolve item types.
/// </param>
public ArrayJsonSchemaReaderCase(IJsonSchemaReader reader)
{
Reader = reader ?? throw new ArgumentNullException(nameof(reader), "Schema reader cannot be null.");
}
/// <summary>
/// Initializes a new instance of the <see cref="JsonRecordSchemaReaderCase" /> class.
/// </summary>
/// <param name="deserializerBuilder">
/// A deserializer builder instance that will be used to read default values.
/// </param>
/// <param name="reader">
/// A schema reader instance that will be used to read field types.
/// </param>
public JsonRecordSchemaReaderCase(IJsonDeserializerBuilder deserializerBuilder, IJsonSchemaReader reader)
{
DeserializerBuilder = deserializerBuilder ?? throw new ArgumentNullException(nameof(deserializerBuilder), "Deserializer builder cannot be null.");
Reader = reader ?? throw new ArgumentNullException(nameof(reader), "Schema reader cannot be null.");
}