public void Cleanup() { if (connection != null) { // Work around, close the connection manually. if (connection.State == ConnectionState.Open) { connection.Close(); } connection.Dispose(); } }
/// <summary> /// Releases the unmanaged resources used by the <see cref="T:System.ComponentModel.Component"></see> and optionally releases the managed resources. /// </summary> /// <param name="disposing">true to release both managed and unmanaged resources; false to release only unmanaged resources.</param> protected override void Dispose(bool disposing) { if (disposed) { return; } if (disposing) { ReliableConnection.Dispose(); } disposed = true; base.Dispose(disposing); }
/// <summary> /// Retrieves data from the specified queue item stored in the persistence queue. /// </summary> /// <param name="queueItemId">The unique identity of the item.</param> /// <param name="headerXPath">The optional set of XPath expressions defining a header portion of the queue data.</param> /// <param name="bodyXPath">The optional set of XPath expressions defining a body portion of the queue data.</param> /// <param name="footerXPath">The optional set of XPath expressions defining a footer portion of the queue data.</param> /// <param name="nsManager">The optional XML namespace manager that will be used for XML namespace resolution.</param> /// <returns>An instance of the XML reader that provides non-cached, forward-only access to queue item data.</returns> public XmlReader DequeueXmlData(Guid queueItemId, IEnumerable <string> headerXPath, IEnumerable <string> bodyXPath, IEnumerable <string> footerXPath, XmlNamespaceManager nsManager) { var callToken = TraceManager.DataAccessComponent.TraceIn(queueItemId.ToString()); var scopeStartMain = TraceManager.DataAccessComponent.TraceStartScope(Resources.ScopeSqlAzurePersistenceQueueDequeueXmlDataMain, callToken); ReliableSqlConnection dbConnection = null; bool leaveConnectionOpen = false; try { // SQL connection is intentionally left non-disposed here. It will be disposed along with XmlReader which this method returns (if at all). // This behavior is enforced through specifying CommandBehavior.CloseConnection when invoking the ExecuteCommand method. dbConnection = new ReliableSqlConnection(this.dbConnectionString, this.connectionRetryPolicy, this.commandRetryPolicy); using (IDbCommand dequeueCommand = CustomSqlCommandFactory.SqlAzurePersistenceQueue.CreateDequeueXmlDataCommand(dbConnection, queueItemId, headerXPath != null ? headerXPath.ToArray <string>() : null, bodyXPath != null ? bodyXPath.ToArray <string>() : null, footerXPath != null ? footerXPath.ToArray <string>() : null, nsManager)) { TraceManager.DataAccessComponent.TraceCommand(dequeueCommand); XmlReader xmlDataReader = dbConnection.ExecuteCommand <XmlReader>(dequeueCommand, CommandBehavior.CloseConnection); if (xmlDataReader != null && xmlDataReader.Read()) { XmlReaderSettings readerSettings = new XmlReaderSettings() { CheckCharacters = false, IgnoreComments = true, IgnoreProcessingInstructions = true, IgnoreWhitespace = true, ValidationType = ValidationType.None, ConformanceLevel = ConformanceLevel.Auto }; XmlReader nonValidatingReader = XmlReader.Create(xmlDataReader, readerSettings); leaveConnectionOpen = true; return(nonValidatingReader); } } } catch (Exception ex) { TraceManager.DataAccessComponent.TraceError(ex, callToken); } finally { if (dbConnection != null && !leaveConnectionOpen) { dbConnection.Dispose(); } TraceManager.DataAccessComponent.TraceEndScope(Resources.ScopeSqlAzurePersistenceQueueDequeueXmlDataMain, scopeStartMain, callToken); TraceManager.DataAccessComponent.TraceOut(callToken); } return(null); }
public void Cleanup() { RetryPolicyFactory.SetRetryManager(null, false); if (connection != null) { // Work around, close the connection manually. if (connection.State == ConnectionState.Open) { connection.Close(); } connection.Dispose(); } }
/// <summary> /// Performs a query against the XML data stored in the queue item. /// </summary> /// <param name="queueItemId">The unique identity of the queue item.</param> /// <param name="xPathCollection">One or more XPath expressions which will be invoked against the queue item's XML data.</param> /// <param name="nsManager">The XML namespace manager that will be used for XML namespace resolution.</param> /// <returns>An instance of the XML reader that provides non-cached, forward-only access to queue item data.</returns> public XmlReader QueryXmlData(Guid queueItemId, IEnumerable <string> xPathCollection, XmlNamespaceManager nsManager) { var callToken = TraceManager.DataAccessComponent.TraceIn(queueItemId.ToString()); var scopeStartMain = TraceManager.DataAccessComponent.TraceStartScope(Resources.ScopeSqlAzurePersistenceQueueQueryXmlDataMain, callToken); ReliableSqlConnection dbConnection = null; bool leaveConnectionOpen = false; try { // SQL connection is intentionally left non-disposed here. It will be disposed along with XmlReader which this method returns (if at all). // This behavior is enforced through specifying CommandBehavior.CloseConnection when invoking the ExecuteCommand method. dbConnection = new ReliableSqlConnection(this.dbConnectionString, this.connectionRetryPolicy, this.commandRetryPolicy); using (IDbCommand queryCommand = CustomSqlCommandFactory.SqlAzurePersistenceQueue.CreateQueryXmlDataCommand(dbConnection, queueItemId, xPathCollection != null ? xPathCollection.ToArray <string>() : null, nsManager)) { TraceManager.DataAccessComponent.TraceCommand(queryCommand); XmlReader xmlDataReader = dbConnection.ExecuteCommand <XmlReader>(queryCommand, CommandBehavior.CloseConnection); if (xmlDataReader != null && xmlDataReader.Read()) { leaveConnectionOpen = true; return(xmlDataReader); } } } catch (Exception ex) { TraceManager.DataAccessComponent.TraceError(ex, callToken); } finally { if (dbConnection != null && !leaveConnectionOpen) { dbConnection.Dispose(); } TraceManager.DataAccessComponent.TraceEndScope(Resources.ScopeSqlAzurePersistenceQueueQueryXmlDataMain, scopeStartMain, callToken); TraceManager.DataAccessComponent.TraceOut(callToken); } return(null); }
/// <summary> /// Disposes the underling <see cref="ReliableSqlConnection"/> as well as the current class. /// </summary> public new void Dispose() { ReliableConnection.Dispose(); base.Dispose(); }
public void Dispose() { _sqlConnection.Dispose(); }