/// <summary> /// The serializer to use to serialize values. /// </summary> public ProducerBuilder <TKey, TValue> SetValueSerializer(IAsyncSerializer <TValue> serializer) { if (this.ValueSerializer != null || this.AsyncValueSerializer != null) { throw new ArgumentException("Value serializer may not be specified more than once."); } this.AsyncValueSerializer = serializer; return(this); }
public ProducerFactory( ILogger logger, IAsyncSerializer <TValue> valueSerializer, IOptions <ProducerConfig> options) { _valueSerializer = valueSerializer ?? throw new ArgumentNullException(nameof(valueSerializer)); _config = options?.Value ?? throw new ArgumentNullException(nameof(options)); _logger = logger ?? throw new ArgumentNullException(nameof(logger)); }
/// <summary> /// The serializer to use to serialize keys. /// </summary> /// <remarks> /// If your key serializer throws an exception, this will be /// wrapped in a ProduceException with ErrorCode /// Local_KeySerialization and thrown by the initiating call to /// Produce or ProduceAsync. /// </remarks> public ProducerBuilder <TKey, TValue> SetKeySerializer(IAsyncSerializer <TKey> serializer) { if (this.KeySerializer != null || this.AsyncKeySerializer != null) { throw new InvalidOperationException("Key serializer may not be specified more than once."); } this.AsyncKeySerializer = serializer; return(this); }
private void InitializeSerializers( Serializer <TKey> keySerializer, Serializer <TValue> valueSerializer, IAsyncSerializer <TKey> asyncKeySerializer, IAsyncSerializer <TValue> asyncValueSerializer) { // setup key serializer. if (keySerializer == null && asyncKeySerializer == null) { if (!defaultSerializers.TryGetValue(typeof(TKey), out object serializer)) { throw new ArgumentNullException( $"Key serializer not specified and there is no default serializer defined for type {typeof(TKey).Name}."); } this.keySerializer = (Serializer <TKey>)serializer; } else if (keySerializer == null && asyncKeySerializer != null) { this.asyncKeySerializer = asyncKeySerializer; } else if (keySerializer != null && asyncKeySerializer == null) { this.keySerializer = keySerializer; } else { throw new InvalidOperationException("FATAL: Both async and sync key serializers were set."); } // setup value serializer. if (valueSerializer == null && asyncValueSerializer == null) { if (!defaultSerializers.TryGetValue(typeof(TValue), out object serializer)) { throw new ArgumentNullException( $"Value serializer not specified and there is no default serializer defined for type {typeof(TKey).Name}."); } this.valueSerializer = (Serializer <TValue>)serializer; } else if (valueSerializer == null && asyncValueSerializer != null) { this.asyncValueSerializer = asyncValueSerializer; } else if (valueSerializer != null && asyncValueSerializer == null) { this.valueSerializer = valueSerializer; } else { throw new InvalidOperationException("FATAL: Both async and sync value serializers were set."); } }
private void Init(IAsyncSerializer <TKey> taskKeySerializer, IAsyncSerializer <TValue> taskValueSerializer) { this.taskKeySerializer = taskKeySerializer; this.taskValueSerializer = taskValueSerializer; if (this.taskKeySerializer == null) { throw new ArgumentNullException("Key serializer must be specified."); } if (this.taskValueSerializer == null) { throw new ArgumentNullException("Value serializer must be specified."); } }
public KafkaProducer( ProducerConfig config, string avroSchema, ILogger logger) { this.logger = logger; var builder = new ProducerBuilder <TKey, TValue>(config); IAsyncSerializer <TValue> asyncValueSerializer = null; ISerializer <TValue> valueSerializer = null; IAsyncSerializer <TKey> keySerializer = null; if (!string.IsNullOrEmpty(avroSchema)) { var schemaRegistry = new LocalSchemaRegistry(avroSchema); asyncValueSerializer = new AvroSerializer <TValue>(schemaRegistry); } else { if (typeof(Google.Protobuf.IMessage).IsAssignableFrom(typeof(TValue))) { // protobuf: need to create using reflection due to generic requirements in ProtobufSerializer valueSerializer = (ISerializer <TValue>)Activator.CreateInstance(typeof(ProtobufSerializer <>).MakeGenericType(typeof(TValue))); } } if (asyncValueSerializer != null) { builder.SetValueSerializer(asyncValueSerializer); } else if (valueSerializer != null) { builder.SetValueSerializer(valueSerializer); } if (keySerializer != null) { builder.SetKeySerializer(keySerializer); } this.producer = builder.Build(); }
/// <summary> /// Refer to <see cref="Confluent.Kafka.Producer{TKey,TValue}" />. /// </summary> public Producer( Handle handle, IAsyncSerializer <TKey> keySerializer, IAsyncSerializer <TValue> valueSerializer ) : base(handle) => Init(keySerializer, valueSerializer);
/// <summary> /// Refer to <see cref="Confluent.Kafka.Producer{TKey,TValue}" />. /// </summary> public Producer( IEnumerable <KeyValuePair <string, string> > config, IAsyncSerializer <TKey> keySerializer, IAsyncSerializer <TValue> valueSerializer ) : base(config) => Init(keySerializer, valueSerializer);
/// <summary> /// The async serializer to use to serialize keys. /// </summary> public DependentProducerBuilder <TKey, TValue> SetKeySerializer(IAsyncSerializer <TKey> serializer) { this.AsyncKeySerializer = serializer; return(this); }
/// <summary> /// Create a sync serializer by wrapping an async /// one. For more information on the potential /// pitfalls in doing this, refer to <see cref="Confluent.Kafka.SyncOverAsyncSerializer{T}" />. /// </summary> public static ISerializer <T> AsSyncOverAsync <T>(this IAsyncSerializer <T> asyncSerializer) => new SyncOverAsyncSerializer <T>(asyncSerializer);
/// <summary> /// Initializes a new SyncOverAsyncSerializer /// instance. /// </summary> public SyncOverAsyncSerializer(IAsyncSerializer <T> asyncSerializer) { this.asyncSerializer = asyncSerializer; }
public InnerConfluentSerializerWrapper(Func <object> serializerFactory) { this.serializer = (IAsyncSerializer <T>)serializerFactory(); }
public IProducerBuilderWrapper <TKey, TValue> SetValueSerializer(IAsyncSerializer <TValue> serializer) { _dependentProducerBuilder.SetValueSerializer(serializer); return(this); }