/// <summary>
/// Occurs after the action method is invoked.
/// </summary>
/// <param name="context">The context for the action.</param>
public void OnActionExecuted(
HttpActionExecutedContext context)
{
if (context.Exception != null)
{
return;
}
if (_session != null)
{
if (_session.Advanced.NumberOfRequests > 30)
{
Debug.WriteLine("Number of recommended (30) remote call requests have been exceeded");
}
lock (_session)
{
_session.SaveChanges();
_session.Advanced.Clear();
_session.Dispose();
}
}
if (_asyncSession != null)
{
_asyncSession.SaveChangesAsync();
_asyncSession.Advanced.Clear();
_asyncSession.Dispose();
}
}
private void Dispose(bool disposing)
{
if (disposing)
{
_session?.Dispose();
}
}
// Dispose
protected void Dispose(bool disposing)
{
if (_disposeDocumentSession && disposing && _documentSession != null)
{
_documentSession.Dispose();
}
}
private void BeginRefreshIndexes(IAsyncDocumentSession session)
{
IsBusy = true;
session.Advanced.AsyncDatabaseCommands
.GetStatisticsAsync()
.ContinueOnSuccess(x => RefreshIndexes(x.Result.CountOfIndexes))
.ContinueWith(task => session.Dispose());
}
public void Dispose(bool disposing)
{
if (disposing && _documentSession != null)
{
_documentSession.Dispose();
}
_disposed = true;
_documentSession = null;
}
private void CheckSession()
{
lock (_lockObject)
{
if (_documentSession != null)
{
if (HasMaxRequestSent)
{
Commit();
_documentSession.Dispose();
}
else
{
return;
}
}
CreateSession();
}
}
public void ReleaseSession()
{
if (session == null)
{
return;
}
session.Dispose();
session = null;
}
private bool _disposedValue = false; // To detect redundant calls
protected virtual void Dispose(bool disposing)
{
if (!_disposedValue)
{
if (disposing)
{
_session?.Dispose();
}
_disposedValue = true;
}
}
public void Dispose()
{
if (_session != null)
{
_session.SaveChangesAsync().GetAwaiter().GetResult();
_session.Dispose();
}
Dispose(true);
GC.SuppressFinalize(this);
}
public void Dispose()
{
if (session != null)
{
session.Dispose();
}
if (asyncSession != null)
{
asyncSession.Dispose();
}
}
private bool _disposedValue = false; // To detect redundant calls
protected override void Dispose(bool disposing)
{
if (!_disposedValue)
{
if (disposing)
{
_session?.Dispose();
}
_disposedValue = true;
}
base.Dispose(disposing);
}
protected virtual void Dispose(bool disposing)
{
if (!_disposed)
{
_disposed = true;
if (disposing)
{
_documentSession?.Dispose();
_asyncDocumentSession?.Dispose();
}
}
}
public void TestCleanup()
{
if (_session != null)
{
_session.Dispose();
_session = null;
}
if (_documentStore != null)
{
_documentStore.Dispose();
_documentStore = null;
}
}
public async Task It_should_return_configured_session()
{
DocumentStore documentStore = null;
IAsyncDocumentSession session = null;
try
{
documentStore = ConfigureEndpointRavenDBPersistence.GetDocumentStore();
session = documentStore.OpenAsyncSession();
RavenSessionTestContext context =
await Scenario.Define <RavenSessionTestContext>()
.WithEndpoint <SharedRavenSessionExtensions>(b =>
b.CustomConfig(config =>
{
config.UsePersistence <RavenDBPersistence>().UseSharedAsyncSession(_ => session);
})
.When((bus, c) =>
{
var sendOptions = new SendOptions();
sendOptions.RouteToThisEndpoint();
return(bus.Send(new SharedRavenSessionExtensions.GenericMessage(), sendOptions));
}))
.Done(c => c.HandlerWasHit)
.Run();
Assert.AreSame(session, context.RavenSessionFromHandler);
}
finally
{
if (session != null)
{
session.Dispose();
session = null;
}
if (documentStore != null)
{
await ConfigureEndpointRavenDBPersistence.DeleteDatabase(documentStore.Database);
}
}
}
public void Dispose()
{
_async.Dispose();
}
public async Task DisposeAsync()
{
await Task.Run(() => _store.Dispose());
await Task.Run(() => _session.Dispose());
}
public void Dispose()
{
_connection.Dispose();
}
public void Dispose()
{
_session.Dispose();
}
protected void Disposeable()
{
_session.Dispose();
}
public void Dispose() => _dbSession.Dispose();
public void TearDown()
{
_session.Dispose();
_store.Dispose();
}
public void Dispose()
{
Session.Dispose();
}
public void Dispose() => _session.Dispose();
public void TestFixtureTearDown()
{
Db.Dispose();
}
public void Dispose()
{
_innerSession.Dispose();
}
public void Dispose()
{
_dao.Dispose();
}
public void Dispose()
{
_inner.Dispose();
}
public void Dispose()
{
_documentSession.Dispose();
}
public async Task CommitAsync(IAsyncDocumentSession session)
{
session.SaveChangesAsync();
session.Dispose();
}
