/// <summary>
/// Releases the unmanaged resources used by the
/// <see cref="Producer{TKey,TValue}" />
/// and optionally disposes the managed resources.
/// </summary>
/// <param name="disposing">
/// true to release both managed and unmanaged resources;
/// false to release only unmanaged resources.
/// </param>
protected virtual void Dispose(bool disposing)
{
// Calling Dispose a second or subsequent time should be a no-op.
lock (disposeHasBeenCalledLockObj)
{
if (disposeHasBeenCalled)
{
return;
}
disposeHasBeenCalled = true;
}
// do nothing if we borrowed a handle.
if (ownedKafkaHandle == null)
{
return;
}
if (disposing)
{
// Unpin partitioner functions
foreach (var ph in this.partitionerHandles)
{
ph.Free();
}
if (!this.manualPoll)
{
callbackCts.Cancel();
try
{
// Note: It's necessary to wait on callbackTask before disposing kafkaHandle
// since the poll loop makes use of this.
callbackTask.Wait();
}
catch (AggregateException e)
{
if (e.InnerException.GetType() != typeof(TaskCanceledException))
{
throw e.InnerException;
}
}
finally
{
callbackCts.Dispose();
}
}
// calls to rd_kafka_destroy may result in callbacks
// as a side-effect. however the callbacks this class
// registers with librdkafka ensure that any registered
// events are not called if kafkaHandle has been closed.
// this avoids deadlocks in common scenarios.
ownedKafkaHandle.Dispose();
}
}
public void Dispose()
{
topicHandles.Dispose();
if (!this.manualPoll)
{
// Note: It's necessary to wait on callbackTask before disposing kafkaHandle.
// TODO: If called in a finalizer, can callbackTask be potentially null?
callbackCts.Cancel();
callbackTask.Wait();
}
kafkaHandle.Dispose();
}
public virtual void Dispose()
{
callbackCts.Cancel();
callbackTask.Wait();
// Wait until all outstanding sends have completed
while (OutQueueLength > 0)
{
handle.Poll((IntPtr)100);
}
handle.Dispose();
}
protected virtual void Dispose(bool disposing)
{
callbackCts.Cancel();
callbackTask.Wait();
if (disposing)
{
// Wait until all outstanding sends have completed
while (OutQueueLength > 0)
{
handle.Poll((IntPtr)100);
}
handle.Dispose();
}
}
/// <summary>
/// Releases the unmanaged resources used by the
/// <see cref="Confluent.Kafka.Consumer{TKey,TValue}" />
/// and optionally disposes the managed resources.
/// </summary>
/// <param name="disposing">
/// true to release both managed and unmanaged resources;
/// false to release only unmanaged resources.
/// </param>
protected virtual void Dispose(bool disposing)
{
// Calling Dispose a second or subsequent time should be a no-op.
lock (disposeHasBeenCalledLockObj)
{
if (disposeHasBeenCalled)
{
return;
}
disposeHasBeenCalled = true;
}
if (disposing)
{
// calls to rd_kafka_destroy may result in callbacks
// as a side-effect. however the callbacks this class
// registers with librdkafka ensure that any registered
// events are not called if the kafkaHandle is closed.
// this avoids deadlocks in common scenarios.
kafkaHandle.Dispose();
}
}