private void Close()
{
if (_messageConsumer != null)
{
_messageConsumer.Close();
_messageConsumer.Dispose();
_messageConsumer = null;
}
if (_messageProducer != null)
{
_messageProducer.Close();
_messageProducer.Dispose();
_messageProducer = null;
}
if (_session != null)
{
_session.Close();
_session.Dispose();
_session = null;
}
if (_connection != null)
{
_connection.Close();
_connection.Dispose();
_connection = null;
}
}
/// <summary>
/// Instruct this <see cref="ActiveMQCache" /> to disconnect from a remote cache system if required.
/// </summary>
public override void Disconnect()
{
if (mConsumer != null)
{
mConsumer.Close();
mConsumer.Dispose();
}
if (mProducer != null)
{
mProducer.Close();
mProducer.Dispose();
}
if (mSession != null)
{
mSession.Close();
mSession.Dispose();
}
if (mConnector != null)
{
mConnector.Stop();
mConnector.Close();
mConnector.Dispose();
}
}
public void OnCompleted()
{
string name = _producer.Name;
_producer.Dispose();
_log.Debug(LoggerContext.New(name), "Killed.");
}
public void Dispose()
{
consument.Dispose();
producer.Dispose();
session.Dispose();
connection.Dispose();
}
private void Connect()
{
if (_disposable == null)
{
lock (_gate)
{
if (_disposable == null)
{
_session = _connection.Value.CreateSession(Apache.NMS.AcknowledgementMode.AutoAcknowledge);
_producer = _session.CreateProducer(_destination);
_disposable = Disposable.Create(() =>
{
_disposed = true;
DrainScheduler();
_producer.Close();
_producer.Dispose();
_session.Close();
_session.Dispose();
});
}
}
}
}
public void Dispose()
{
connection?.Dispose();
session?.Dispose();
messageConsumer?.Dispose();
messageProducer?.Dispose();
}
public virtual void Dispose()
{
db?.Dispose();
redis?.Dispose();
messageProducer?.Dispose();
using (authRepository as IDisposable) {}
}
public void Dispose()
{
if (disposed)
{
return;
}
sender.Close();
sender.Dispose();
if (receiver != null)
{
receiver.Close();
receiver.Dispose();
}
session.Close();
session.Dispose();
connection.Stop();
connection.Close();
connection.Dispose();
disposed = true;
}
public void DestroyMQProducer(IMessageProducer producer)
{
if (producer != null)
{
producer.Close();
producer.Dispose();
}
}
public override void Dispose()
{
base.Dispose();
redis?.Dispose();
cache?.Dispose();
messageProducer?.Dispose();
}
public virtual void Dispose()
{
db?.Dispose();
redis?.Dispose();
messageProducer?.Dispose();
using (authRepository as IDisposable) {}
#if !(NET472 || NETSTANDARD2_0)
using (authRepositoryAsync as IDisposable) {}
#endif
}
/// <summary>
/// </summary>
/// <returns></returns>
public override void Close()
{
if (_producer != null)
{
_producer.Close();
_producer.Dispose();
_producer = null;
}
base.Close();
}
/// <summary>
/// Disposes all created disposable properties of this service
/// and executes disposing of all request <see cref="IDisposable"></see>s
/// (warning, manually triggering this might lead to unwanted disposing of all request related objects and services.)
/// </summary>
public virtual void Dispose()
{
db?.Dispose();
redis?.Dispose();
messageProducer?.Dispose();
using (authRepository as IDisposable) { }
RequestContext.Instance.ReleaseDisposables();
Request.ReleaseIfInProcessRequest();
}
/// <summary>
/// Disposes all created disposable properties of this service
/// and executes disposing of all request <see cref="IDisposable"></see>s
/// (warning, manually triggering this might lead to unwanted disposing of all request related objects and services.)
/// </summary>
public virtual void Dispose()
{
db?.Dispose();
redis?.Dispose();
messageProducer?.Dispose();
using (authRepository as IDisposable) { }
#if !(NET472 || NETSTANDARD2_0)
using (authRepositoryAsync as IDisposable) {}
#endif
RequestContext.Instance.ReleaseDisposables();
Request.ReleaseIfInProcessRequest();
}
static async Task Main()
{
var logger = new ConsoleLogger();
s_producer = new KafkaProducerBase <string, Product>(logger, "localhost:9092",
"prd.test.raw", 3);
foreach (var category in s_sections)
{
await ProcessSection(category.Key, category.Value);
}
s_producer.Dispose();
}
public virtual void Dispose()
{
if (db != null)
{
db.Dispose();
}
if (redis != null)
{
redis.Dispose();
}
if (messageProducer != null)
{
messageProducer.Dispose();
}
}
/// <summary>
/// Disposes all created disposable properties of this service
/// and executes disposing of all request <see cref="IDisposable"></see>s
/// (warning, manually triggering this might lead to unwanted disposing of all request related objects and services.)
/// </summary>
public virtual void Dispose()
{
if (hasDisposed)
{
return;
}
hasDisposed = true;
using (authRepository as IDisposable) { }
db?.Dispose();
redis?.Dispose();
messageProducer?.Dispose();
RequestContext.Instance.ReleaseDisposables();
Request.ReleaseIfInProcessRequest();
}
public virtual void Dispose()
{
try
{
if (this.ChildPage != null)
{
this.ChildPage.Dispose();
}
this.ChildPage = null;
}
catch { }
try
{
if (cache != null)
{
cache.Dispose();
}
cache = null;
}
catch { }
try
{
if (db != null)
{
db.Dispose();
}
db = null;
}
catch { }
try
{
if (redis != null)
{
redis.Dispose();
}
redis = null;
}
catch { }
try
{
if (messageProducer != null)
{
messageProducer.Dispose();
}
messageProducer = null;
}
catch { }
}
public void destroyObjects()
{
try
{
_consumer.Close();
_consumer.Dispose();
_producer.Close();
_producer.Dispose();
_session.Close();
_session.Dispose();
_connection.Stop();
_connection.Close();
_connection.Dispose();
}
catch (Exception e) { }
}
public void destoryClick()
{
try
{
consumer.Close();
consumer.Dispose();
producer.Close();
producer.Dispose();
session.Close();
session.Dispose();
connection.Stop();
connection.Close();
connection.Dispose();
}
catch (Exception e) { }
}
// Methode wird als Eventhandler für Window.Closed-Event verwendet (benoetigt sender/e Argumente)
// und von UpdateConnection() aus (parameterfrei).
void CleanupResources(object sender = null, EventArgs e = null)
{
if (messageProducer != null)
{
messageProducer.Dispose();
}
if (session != null)
{
session.Dispose();
}
if (connection != null)
{
connection.Dispose();
connection = null;
}
connectionFactory = null;
}
public virtual void Dispose()
{
if (db != null)
{
db.Dispose();
}
if (redis != null)
{
redis.Dispose();
}
if (messageProducer != null)
{
messageProducer.Dispose();
}
RequestContext.Instance.ReleaseDisposables();
}
public override void Dispose()
{
base.Dispose();
if (redis != null)
{
redis.Dispose();
}
if (cache != null)
{
cache.Dispose();
}
if (messageProducer != null)
{
messageProducer.Dispose();
}
}
public void CreateAndDisposeWithProducer(bool disposeProducer)
{
using (IConnection connection = CreateConnection("DisposalTestConnection"))
{
connection.Start();
using (ISession session = connection.CreateSession())
{
IQueue queue = session.GetQueue("DisposalTestQueue");
IMessageProducer producer = session.CreateProducer(queue);
connection.Stop();
if (disposeProducer)
{
producer.Dispose();
}
}
}
}
public void Dispose(bool disposing)
{
if (disposing)
{
if (null != connection)
{
//connection.Stop();
connection.Close();
connection.Dispose();
connection = null;
}
if (null != session)
{
session.Close();
session.Dispose();
session = null;
}
if (null != modelProducer)
{
modelProducer.Close();
modelProducer.Dispose();
modelProducer = null;
}
if (null != alertProducer)
{
alertProducer.Close();
alertProducer.Dispose();
alertProducer = null;
}
if (null != performanceProducer)
{
performanceProducer.Close();
performanceProducer.Dispose();
performanceProducer = null;
}
if (null != deskTerminalProducer)
{
deskTerminalProducer.Close();
deskTerminalProducer.Dispose();
deskTerminalProducer = null;
}
}
}
public void SendPersistentMessage()
{
using (IConnection connection = Factory.CreateConnection())
{
connection.Start();
using (ISession session = connection.CreateSession(
AcknowledgementMode.DupsOkAcknowledge))
{
ITopic topic = session.GetTopic(TOPIC);
ITextMessage message = session.CreateTextMessage("Hello");
message.NMSPersistent = true;
IMessageProducer producer = session.CreateProducer();
producer.Send(topic, message);
producer.Dispose();
}
connection.Stop();
}
}
public void CreateAndDisposeWithProducer(
[Values(true, false)] bool disposeProducer)
{
using (IConnection connection = CreateConnection("DisposalTestConnection"))
{
connection.Start();
using (ISession session = connection.CreateSession())
{
IDestination destination = CreateDestination(session, DestinationType.Queue);
IMessageProducer producer = session.CreateProducer(destination);
connection.Stop();
if (disposeProducer)
{
producer.Dispose();
}
}
}
}
//[Test]
public virtual void TestCreateAndDisposeWithProducer(
//[Values(true, false)]
bool disposeProducer, string testQueueRef)
{
using (IConnection connection = CreateConnection("DisposalTestConnection"))
{
connection.Start();
using (ISession session = connection.CreateSession())
{
IDestination destination = GetClearDestination(session, DestinationType.Queue, testQueueRef);
IMessageProducer producer = session.CreateProducer(destination);
connection.Stop();
if (disposeProducer)
{
producer.Dispose();
}
}
}
}
public virtual void Dispose()
{
try
{
this.ChildPage?.Dispose();
this.ChildPage = null;
}
catch { }
try
{
cache?.Dispose();
cache = null;
}
catch { }
try
{
db?.Dispose();
db = null;
}
catch { }
try
{
redis?.Dispose();
redis = null;
}
catch { }
try
{
messageProducer?.Dispose();
messageProducer = null;
}
catch { }
try
{
using (authRepository as IDisposable) { }
authRepository = null;
}
catch { }
}
public void Dispose()
{
messageProducer?.Dispose();
}
