High Performance Enterprise Library by FishDawg

Project License Changed

Mon, 07 Jul 2008 23:35:47 GMT

Copyright (c) 2008, FishDawg LLC All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * All redistribution and use must be limited to personal, non-commercial, internal business, evaluation, academic, and research purposes. Use of this software is not permitted in products and services made available to customers and primarily intended for commercial advantage or private monetary compensation without specific prior written permission. * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of FishDawg LLC nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Project License Changed

Mon, 07 Jul 2008 23:34:20 GMT

Project License Changed

Mon, 07 Jul 2008 23:15:44 GMT

Copyright (c) 2008, FishDawg LLC All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * All redistribution and use must be limited to personal, non-commercial, internal business, evaluation, academic, and research purposes. Use in products and services made available to customers and primarily intended for commercial advantage or private monetary compensation is not permitted by this license. * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of FishDawg LLC nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Updated Wiki: Home

FishDawg — Thu, 26 Jun 2008 05:16:42 GMT

This .Net class library is designed to integrate into enterprise applications to help support their high performance and reliability requirements. The focus of the Enterprise Library is to provide simple and robust mechanisms that take full advantage of the amazing capabilities already in the .Net Framework and extend those capabilities to support the needs of enterprise applications. The first major component of the library is the Operations Framework. The Operations Framework provides flexible and efficient support for asynchronous operations that can fully utilize the power of computers with multiple processors and make I/O operations much faster.

Operations Framework

The library contains the Operations Framework, which is designed to make working with asynchronous tasks simple, robust, and performant. The operation classes are easy to integrate into your code. They help you avoid common mistakes in your code by releasing resources automatically at the right times (including closing database connections), synchronizing work done on multiple threads efficiently, taking advantage of I/O completion ports, and handling critical exceptions correctly (including OutOfMemory, StackOverflow, and ThreadAbort). They make the most of the .Net Framework by leveraging the power of the thread pool, ADO.Net connection pool, and timers. They help you solve common problems by including support for customizable automatic retries, efficient parallel execution, and flexible transactions. As demonstrated in the following examples, these capabilities are highly useful when communicating with a database such as SQL Server.

Code Example

These examples show how easy it is to create highly efficient and reliable code to execute several database commands.

using FishDawg.EnterpriseLibrary.Operations;
 
// Create 3 SQL commands.
const string connectionString = "Server=...;Database=...;Integrated Security=True;MultipleActiveResultSets=True;Asynchronous Processing=True";
const string commandText1 = "INSERT LogEntry (Code, Message) VALUES (111, N'AAA');";
SqlCommand command1 = new SqlCommand(commandText1, new SqlConnection(connectionString));
const string commandText2 = "INSERT LogEntry (Code, Message) VALUES (222, N'BBB');";
SqlCommand command2 = new SqlCommand(commandText2, new SqlConnection(connectionString));
const string commandText3 = "INSERT LogEntry (Code, Message) VALUES (333, N'CCC');";
SqlCommand command3 = new SqlCommand(commandText3, new SqlConnection(connectionString));

private static void Example1()
{
  // Compose together several operation objects to execute the 3 SQL commands in parallel, each in a local transaction with automatic 
  // retries (of up to a maximum of 3 tries by default) when a SqlException gets thrown.
  using (Operation operation = new ParallelOperation(
      new RetryOperation(new TransactionOperation(new SqlNonQueryOperation(command1), TransactionOption.CreateNew), typeof(SqlException)),
      new RetryOperation(new TransactionOperation(new SqlNonQueryOperation(command2), TransactionOption.CreateNew), typeof(SqlException)),
      new RetryOperation(new TransactionOperation(new SqlNonQueryOperation(command3), TransactionOption.CreateNew), typeof(SqlException))
    ))
  {
    // Execute the operation asynchronously (omitting the callback delegate for demonstration purposes only)
    IAsyncResult asyncResult = operation.BeginExecute(null, null);
    operation.EndExecute(asyncResult);
  }
}

private static void Example2()
{
  // Compose together several operation objects to execute the 3 SQL commands in parallel, in a distributed transaction (which participates 
  // in the ambient transaction if one exists) with a timeout of 20 seconds and the read committed isolation level.
  using (Operation operation = new TransactionOperation(new ParallelOperation(
      new SqlNonQueryOperation(command1),
      new SqlNonQueryOperation(command2),
      new SqlNonQueryOperation(command3)
    ), TransactionOption.Create, TimeSpan.FromSeconds(20.0), IsolationLevel.ReadCommitted))
  {
    // Execute the operation synchronously.
    operation.Execute();
  }
}

Releases

Please note that the first version of the framework is under active development at this time. No download is available yet.

Library Usage

The project's default license is a modified form the BSD permissive free software license. For non-commercial, internal business, evaluation, academic, and research purposes, you may freely use the library, its source code, and its documentation in your project. For other purposes, such as commercial applications used directly by your customers, you can obtain a commercial license by contacting the project coordinator. We encourage everyone to contribute to the project by posting lots of feature requests, bug reports, and code enhancements.

UPDATED RELEASE: 1.0 (Aug. 2008)

Thu, 26 Jun 2008 05:07:22 GMT

High Performance Enterprise Library 1.0
The first release of the library focuses on providing the Operations Framework, which is designed to make working with asynchronous tasks simple, robust, and performant.

Feature List:

Operations Framework: Automatic Retries, Parallel Execution, Flexible Transactions.
Operations Framework: SqlClient Commands (DataReader/NonQuery/Scalar).
Operations Framework: Stream Copying.
Transaction Contexts (Committable/Dependent/Suppressed/Empty).
Threading Classes.
Unit Tests (extensive testing includes 99% code coverage, performance tests, and scenario tests).

Schedule:

08/2007 Design Complete (status: Done)
02/2008 Code Complete (status: Done)
06/2008 Test Complete (status: Done)
08/2008 Final Release (status: In Progress)

UPDATED RELEASE: High Performance Enterprise Library 1.0

Thu, 26 Jun 2008 05:05:57 GMT

Operations Framework: Automatic Retries, Parallel Execution, Flexible Transactions.
Operations Framework: SqlClient Commands (DataReader/NonQuery/Scalar).
Operations Framework: Stream Copying.
Transaction Contexts (Committable/Dependent/Suppressed/Empty).
Threading Classes.
Unit Tests (extensive testing includes 99% code coverage, performance tests, and scenario tests).

Schedule:

08/2007 Design Complete (status: Done)
02/2008 Code Complete (status: Done)
06/2008 Test Complete (status: Done)
08/2008 Final Release (status: In Progress)

CREATED RELEASE: Library 1.0

Thu, 26 Jun 2008 04:36:43 GMT

Operations Framework: Automatic Retries, Parallel Execution, Flexible Transactions.
Operations Framework: SqlClient Commands (DataReader/NonQuery/Scalar).
Operations Framework: Stream Copying.
Transaction Contexts (Committable/Dependent/Suppressed/Empty).
Threading Classes.
Unit Tests (extensive testing includes 99% code coverage and scenario tests).

UPDATED WIKI: Home

FishDawg — Sun, 27 Apr 2008 01:51:34 GMT

Operations Framework

Code Example

These examples show how easy it is to create highly efficient and reliable code to execute several database commands.

using FishDawg.EnterpriseLibrary.Operations;
 
// Create 3 SQL commands.
const string connectionString = "Server=...;Database=...;Integrated Security=True;MultipleActiveResultSets=True;Asynchronous Processing=True";
const string commandText1 = "INSERT LogEntry (Code, Message) VALUES (111, N'AAA');";
SqlCommand command1 = new SqlCommand(commandText1, new SqlConnection(connectionString));
const string commandText2 = "INSERT LogEntry (Code, Message) VALUES (222, N'BBB');";
SqlCommand command2 = new SqlCommand(commandText2, new SqlConnection(connectionString));
const string commandText3 = "INSERT LogEntry (Code, Message) VALUES (333, N'CCC');";
SqlCommand command3 = new SqlCommand(commandText3, new SqlConnection(connectionString));

private static void Example1()
{
  // Compose together several operation objects to execute the 3 SQL commands in parallel, each in a local transaction with automatic 
  // retries (of up to a maximum of 3 tries by default) when a SqlException gets thrown.
  using (Operation operation = new ParallelOperation(
      new RetryOperation(new TransactionOperation(new SqlNonQueryOperation(command1), TransactionOption.CreateNew), typeof(SqlException)),
      new RetryOperation(new TransactionOperation(new SqlNonQueryOperation(command2), TransactionOption.CreateNew), typeof(SqlException)),
      new RetryOperation(new TransactionOperation(new SqlNonQueryOperation(command3), TransactionOption.CreateNew), typeof(SqlException))
    ))
  {
    // Execute the operation asynchronously (omitting the callback delegate for demonstration purposes only)
    IAsyncResult asyncResult = operation.BeginExecute(null, null);
    operation.EndExecute(asyncResult);
  }
}

private static void Example2()
{
  // Compose together several operation objects to execute the 3 SQL commands in parallel, in a distributed transaction (which participates 
  // in the ambient transaction if one exists) with a timeout of 20 seconds and the read committed isolation level.
  using (Operation operation = new TransactionOperation(new ParallelOperation(
      new SqlNonQueryOperation(command1),
      new SqlNonQueryOperation(command2),
      new SqlNonQueryOperation(command3)
    ), TransactionOption.Create, TimeSpan.FromSeconds(20.0), IsolationLevel.ReadCommitted))
  {
    // Execute the operation synchronously.
    operation.Execute();
  }
}

Releases

Please note that the first version of the framework is under active development at this time. No download is available yet.

Library Usage

The project's default license is a modified form the BSD permissive free software license limited to non-commercial, internal business, evaluation, academic, and research purposes. For these purposes, you may freely use the library, its source code, and its documentation in your projects in accordance with the license. For other purposes, such as commercial applications used directly by your customers, you can obtain a commercial license by contacting the project coordinator. We encourage everyone to contribute to the project by posting lots of feature requests, bug reports, and code changes.

Project License Changed

Sat, 19 Jan 2008 08:32:05 GMT

Copyright (c) 2008 FishDawg LLC Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

UPDATED WIKI: Home

FishDawg — Fri, 11 Jan 2008 22:02:48 GMT

Operations Framework

Code Example

These examples show how easy it is to create highly efficient and reliable code to execute several database commands.

using FishDawg.EnterpriseLibrary.Operations;
 
// Create 3 SQL commands.
const string connectionString = "Server=...;Database=...;Integrated Security=True;MultipleActiveResultSets=True;Asynchronous Processing=True";
const string commandText1 = "INSERT LogEntry (Code, Message) VALUES (111, N'AAA');";
SqlCommand command1 = new SqlCommand(commandText1, new SqlConnection(connectionString));
const string commandText2 = "INSERT LogEntry (Code, Message) VALUES (222, N'BBB');";
SqlCommand command2 = new SqlCommand(commandText2, new SqlConnection(connectionString));
const string commandText3 = "INSERT LogEntry (Code, Message) VALUES (333, N'CCC');";
SqlCommand command3 = new SqlCommand(commandText3, new SqlConnection(connectionString));

private static void Example1()
{
  // Compose together several operation objects to execute the 3 SQL commands in parallel, each in a local transaction, 
  // and with automatic retries (with up to 3 tries by default) in case any SqlException gets thrown.
  using (Operation operation = new ParallelOperation(new Operation[] {
      new RetryOperation<SqlException>(new TransactionOperation(new SqlNonQueryOperation(command1), TransactionScopeOption.RequiresNew)),
      new RetryOperation<SqlException>(new TransactionOperation(new SqlNonQueryOperation(command2), TransactionScopeOption.RequiresNew)),
      new RetryOperation<SqlException>(new TransactionOperation(new SqlNonQueryOperation(command3), TransactionScopeOption.RequiresNew))
    }))
  {
    // Execute the operation asynchronously (omitting the callback delegate for demonstration purposes only)
    IAsyncResult asyncResult = operation.BeginExecute(null, null);
    operation.EndExecute(asyncResult);
 
    scope.Complete();
  }
}

private static void Example2()
{
  // Compose together several operation objects to execute the 3 SQL commands in parallel, in a distributed transaction 
  // (which participates in the ambient transaction if one exists) with a timeout of 20 seconds.
  using (Operation operation = new TransactionOperation(new ParallelOperation(new Operation[] {
      new SqlNonQueryOperation(command1),
      new SqlNonQueryOperation(command2),
      new SqlNonQueryOperation(command3)
    }), TransactionScopeOption.Required, TimeSpan.FromSeconds(20.0)))
  {
    // Execute the operation synchronously.
    operation.Execute();
 
    scope.Complete();
  }
}

Releases

Please note that the first version of the framework is under active development at this time. No download is available yet.

Library Usage

To encourage reuse and contribution to this project, the library is released under a permissive free software license. We encourage you to contribute to the project by posting feature requests, reporting bugs, and submitting code changes. You may use this library and its source code in your own projects in accordance with the MIT License.

UPDATED WIKI: Home

FishDawg — Thu, 13 Dec 2007 09:17:10 GMT

Operations Framework

Code Example

These examples show how easy it is to create highly efficient and reliable code to execute several database commands.

using FishDawg.EnterpriseLibrary.Operations;
 
// Create 3 SQL commands.
const string connectionString = "Server=...;Database=...;Integrated Security=True;MultipleActiveResultSets=True;Asynchronous Processing=True";
const string commandText1 = "INSERT LogEntry (Code, Message) VALUES (111, N'AAA');";
SqlCommand command1 = new SqlCommand(commandText1, new SqlConnection(connectionString));
const string commandText2 = "INSERT LogEntry (Code, Message) VALUES (222, N'BBB');";
SqlCommand command2 = new SqlCommand(commandText2, new SqlConnection(connectionString));
const string commandText3 = "INSERT LogEntry (Code, Message) VALUES (333, N'CCC');";
SqlCommand command3 = new SqlCommand(commandText3, new SqlConnection(connectionString));

private static void Example1()
{
  // Compose together several operation objects to execute the 3 SQL commands in parallel, each in a local transaction, 
  // and with automatic retries (with up to 3 tries by default) in case any SqlException gets thrown.
  using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Supress))
  using (Operation operation = new ParallelOperation(new Operation[] {
      new RetryOperation<SqlException>(new TransactionOperation(new SqlNonQueryOperation(command1))),
      new RetryOperation<SqlException>(new TransactionOperation(new SqlNonQueryOperation(command2))),
      new RetryOperation<SqlException>(new TransactionOperation(new SqlNonQueryOperation(command3)))
    }))
  {
    // Execute the operation asynchronously (omitting the callback delegate for demonstration purposes only)
    IAsyncResult asyncResult = operation.BeginExecute(null, null);
    operation.EndExecute(asyncResult);
 
    scope.Complete();
  }
}

private static void Example2()
{
  // Compose together several operation objects to execute the 3 SQL commands in parallel, in a distributed transaction 
  // (with a timeout of 20 seconds for each local transaction).
  using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Required))
  using (Operation operation = new ParallelOperation(new Operation[] {
      new TransactionOperation(new SqlNonQueryOperation(command1), TimeSpan.FromSeconds(20.0)),
      new TransactionOperation(new SqlNonQueryOperation(command2), TimeSpan.FromSeconds(20.0)),
      new TransactionOperation(new SqlNonQueryOperation(command3), TimeSpan.FromSeconds(20.0))
    })))
  {
    // Execute the operation synchronously.
    operation.Execute();
 
    scope.Complete();
  }
}

Library Usage

UPDATED WIKI: Home

FishDawg — Wed, 05 Dec 2007 19:09:02 GMT

Operations Framework

Code Example

These examples show how easy it is to create highly efficient and reliable code to execute several database commands.

using FishDawg.EnterpriseLibrary.Operations;
 
// Create 3 SQL commands.
const string connectionString = "Server=...;Database=...;Integrated Security=True;MultipleActiveResultSets=True;Asynchronous Processing=True";
const string commandText1 = "INSERT LogEntry (Code, Message) VALUES (111, N'AAA');";
SqlCommand command1 = new SqlCommand(commandText1, new SqlConnection(connectionString));
const string commandText2 = "INSERT LogEntry (Code, Message) VALUES (222, N'BBB');";
SqlCommand command2 = new SqlCommand(commandText2, new SqlConnection(connectionString));
const string commandText3 = "INSERT LogEntry (Code, Message) VALUES (333, N'CCC');";
SqlCommand command3 = new SqlCommand(commandText3, new SqlConnection(connectionString));

private static void Example1()
{
  // Compose together several operation objects to execute the 3 SQL commands in parallel, each in a local transaction, 
  // and with automatic retries (with up to 3 tries by default) in case any SqlException gets thrown.
  using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Supress))
  using (Operation operation = new ParallelOperation(new Operation[] {
      new RetryOperation<SqlException>(new TransactionOperation(new SqlNonQueryOperation(command1))),
      new RetryOperation<SqlException>(new TransactionOperation(new SqlNonQueryOperation(command2))),
      new RetryOperation<SqlException>(new TransactionOperation(new SqlNonQueryOperation(command3)))
    }))
  {
    // Execute the operation asynchronously (omitting the callback delegate for demonstration purposes only)
    IAsyncResult asyncResult = operation.BeginExecute(null, null);
    operation.EndExecute(asyncResult);
 
    scope.Complete();
  }
}

private static void Example2()
{
  // Compose together several operation objects to execute the 3 SQL commands in parallel, in a distributed transaction 
  // (with a timeout of 20 seconds for each local transaction).
  using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Required))
  using (Operation operation = new ParallelOperation(new Operation[] {
      new TransactionOperation(new SqlNonQueryOperation(command1), TimeSpan.FromSeconds(20.0)),
      new TransactionOperation(new SqlNonQueryOperation(command2), TimeSpan.FromSeconds(20.0)),
      new TransactionOperation(new SqlNonQueryOperation(command3), TimeSpan.FromSeconds(20.0))
    })))
  {
    // Execute the operation synchronously.
    operation.Execute();
 
    scope.Complete();
  }
}

Library Usage

UPDATED WIKI: Home

FishDawg — Fri, 28 Sep 2007 17:30:37 GMT

Operations Framework

Code Example

These examples show how easy it is to create highly efficient and reliable code to execute several database commands.

using FishDawg.EnterpriseLibrary.Operations;
 
// Create 3 SQL commands.
const string connectionString = "Server=...;Database=...;Integrated Security=True;MultipleActiveResultSets=True;Asynchronous Processing=True";
const string commandText1 = "INSERT LogEntry (Code, Message) VALUES (111, N'AAA');";
SqlCommand command1 = new SqlCommand(commandText1, new SqlConnection(connectionString));
const string commandText2 = "INSERT LogEntry (Code, Message) VALUES (222, N'BBB');";
SqlCommand command2 = new SqlCommand(commandText2, new SqlConnection(connectionString));
const string commandText3 = "INSERT LogEntry (Code, Message) VALUES (333, N'CCC');";
SqlCommand command3 = new SqlCommand(commandText3, new SqlConnection(connectionString));
 
private static void Example1()
{
  // Compose together several operation objects to execute the 3 SQL commands in parallel, each in a local transaction, 
  // and with automatic retries (with up to 3 tries by default) in case any SqlException gets thrown.
  using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Supress))
  using (Operation operation = new ParallelOperation(new Operation[] {
      new RetryOperation<SqlException>(new TransactionOperation(new SqlNonQueryOperation(command1))),
      new RetryOperation<SqlException>(new TransactionOperation(new SqlNonQueryOperation(command2))),
      new RetryOperation<SqlException>(new TransactionOperation(new SqlNonQueryOperation(command3)))
    }))
  {
    // Execute the operation asynchronously (omitting the callback delegate for demonstration purposes only)
    IAsyncResult asyncResult = operation.BeginExecute(null, null);
    operation.EndExecute(asyncResult);
 
    scope.Complete();
  }
}
 
private static void Example2()
{
  // Compose together several operation objects to execute the 3 SQL commands in parallel, in a distributed transaction 
  // (with a timeout of 20 seconds for each local transaction).
  using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Required))
  using (Operation operation = new ParallelOperation(new Operation[] {
      new TransactionOperation(new SqlNonQueryOperation(command1), TimeSpan.FromSeconds(20.0)),
      new TransactionOperation(new SqlNonQueryOperation(command2), TimeSpan.FromSeconds(20.0)),
      new TransactionOperation(new SqlNonQueryOperation(command3), TimeSpan.FromSeconds(20.0))
    })))
  {
    // Execute the operation synchronously.
    operation.Execute();
 
    scope.Complete();
  }
}

Library Usage

UPDATED WIKI: Home

FishDawg — Tue, 25 Sep 2007 16:14:32 GMT

Operations Framework

The library contains the Operations Framework, which is designed to make working with asynchronous tasks simple, robust, and performant. The operation classes are easy to integrate into your code. They help you avoid common mistakes in your code by releasing resources automatically at the right times (including closing database connections), synchronizing work done on multiple threads efficiently, and handling critical exceptions correctly (including OutOfMemory, StackOverflow, and ThreadAbort). They make the most of the .Net Framework by leveraging the power of the thread pool, ADO.Net connection pool, and timers. They help you solve common problems by including support for customizable automatic retries, efficient parallel execution, and flexible transactions. As demonstrated in the following examples, these capabilities are highly useful when communicating with a database such as SQL Server.

Code Example

These examples show how easy it is to create highly efficient and reliable code to execute several database commands.

using FishDawg.EnterpriseLibrary.Operations;
 
// Create 3 SQL commands.
const string connectionString = "Server=...;Database=...;Integrated Security=True;MultipleActiveResultSets=True;Asynchronous Processing=True";
const string commandText1 = "INSERT LogEntry (Code, Message) VALUES (111, N'AAA');";
SqlCommand command1 = new SqlCommand(commandText1, new SqlConnection(connectionString));
const string commandText2 = "INSERT LogEntry (Code, Message) VALUES (222, N'BBB');";
SqlCommand command2 = new SqlCommand(commandText2, new SqlConnection(connectionString));
const string commandText3 = "INSERT LogEntry (Code, Message) VALUES (333, N'CCC');";
SqlCommand command3 = new SqlCommand(commandText3, new SqlConnection(connectionString));
 
private static void Example1()
{
  // Compose together several operation objects to execute the 3 SQL commands in parallel, each in a local transaction, 
  // and with automatic retries (with up to 3 tries by default) in case any SqlException gets thrown.
  using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Supress))
  using (Operation operation = new ParallelOperation(new Operation[] {
      new RetryOperation<SqlException>(new TransactionOperation(new SqlNonQueryOperation(command1))),
      new RetryOperation<SqlException>(new TransactionOperation(new SqlNonQueryOperation(command2))),
      new RetryOperation<SqlException>(new TransactionOperation(new SqlNonQueryOperation(command3)))
    }))
  {
    // Execute the operation asynchronously (omitting the callback delegate for demonstration purposes only)
    IAsyncResult asyncResult = operation.BeginExecute(null, null);
    operation.EndExecute(asyncResult);
 
    scope.Complete();
  }
}
 
private static void Example2()
{
  // Compose together several operation objects to execute the 3 SQL commands in parallel, in a distributed transaction 
  // (with a timeout of 20 seconds for each local transaction).
  using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Required))
  using (Operation operation = new ParallelOperation(new Operation[] {
      new TransactionOperation(new SqlNonQueryOperation(command1), TimeSpan.FromSeconds(20.0)),
      new TransactionOperation(new SqlNonQueryOperation(command2), TimeSpan.FromSeconds(20.0)),
      new TransactionOperation(new SqlNonQueryOperation(command3), TimeSpan.FromSeconds(20.0))
    })))
  {
    // Execute the operation synchronously.
    operation.Execute();
 
    scope.Complete();
  }
}

Library Usage

UPDATED WIKI: Home

FishDawg — Tue, 25 Sep 2007 07:32:35 GMT

Operations Framework

The library contains the Operations Framework, which is designed to make working with asynchronous tasks simple, robust, and performant. The operation classes are easy to integrate into your code. They help you avoid common mistakes in your code by releasing resources automatically at the right times (including closing database connections), synchronizing work done on multiple threads efficiently, and handling critical exceptions correctly (including OutOfMemory, StackOverflow, and ThreadAbort). They make the most of the .Net Framework by leveraging the power of the thread pool, ADO.Net connection pool, and timers. They help you solve common problems by including support for customizable automatic retries, efficient parallel execution, and flexible transactions.

Code Example

These examples show how easy it is to create highly efficient and reliable code to execute several database commands.

using FishDawg.EnterpriseLibrary.Operations;
 
// Create 3 SQL commands.
const string connectionString = "Server=...;Database=...;Integrated Security=True;MultipleActiveResultSets=True;Asynchronous Processing=True";
const string commandText1 = "INSERT LogEntry (Code, Message) VALUES (111, N'AAA');";
SqlCommand command1 = new SqlCommand(commandText1, new SqlConnection(connectionString));
const string commandText2 = "INSERT LogEntry (Code, Message) VALUES (222, N'BBB');";
SqlCommand command2 = new SqlCommand(commandText2, new SqlConnection(connectionString));
const string commandText3 = "INSERT LogEntry (Code, Message) VALUES (333, N'CCC');";
SqlCommand command3 = new SqlCommand(commandText3, new SqlConnection(connectionString));
 
private static void Example1()
{
  // Compose together several operation objects to execute the 3 SQL commands in parallel, each in a local transaction, 
  // and with automatic retries (with up to 3 tries by default) in case any SqlException gets thrown.
  using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Supress))
  using (Operation operation = new ParallelOperation(new Operation[] {
      new RetryOperation<SqlException>(new TransactionOperation(new SqlNonQueryOperation(command1))),
      new RetryOperation<SqlException>(new TransactionOperation(new SqlNonQueryOperation(command2))),
      new RetryOperation<SqlException>(new TransactionOperation(new SqlNonQueryOperation(command3)))
    }))
  {
    // Execute the operation asynchronously (omitting the callback delegate for demonstration purposes only)
    IAsyncResult asyncResult = operation.BeginExecute(null, null);
    operation.EndExecute(asyncResult);
 
    scope.Complete();
  }
}
 
private static void Example2()
{
  // Compose together several operation objects to execute the 3 SQL commands in parallel, in a distributed transaction 
  // (with a timeout of 20 seconds for each local transaction).
  using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Required))
  using (Operation operation = new ParallelOperation(new Operation[] {
      new TransactionOperation(new SqlNonQueryOperation(command1), TimeSpan.FromSeconds(20.0)),
      new TransactionOperation(new SqlNonQueryOperation(command2), TimeSpan.FromSeconds(20.0)),
      new TransactionOperation(new SqlNonQueryOperation(command3), TimeSpan.FromSeconds(20.0))
    })))
  {
    // Execute the operation synchronously.
    operation.Execute();
 
    scope.Complete();
  }
}

Library Usage

UPDATED WIKI: Home

FishDawg — Tue, 25 Sep 2007 07:31:10 GMT

Operations Framework

The library contains the Operations Framework, which is designed to make working with asynchronous tasks simple, robust, and performant. The operation classes are easy to integrate into your code. They help you avoid common mistakes in your code by releasing resources automatically at the right times (including closing database connections), synchronizing work done on multiple threads efficiently, and handling critical exceptions correctly (including OutOfMemory, StackOverflow, and ThreadAbort). They make the most of the .Net Framework by leveraging the power of the thread pool, ADO.Net connection pool, and timers. They help you solve common problems by including support for customizable automatic retries, efficient parallel execution, and flexible transactions.

Code Example

These examples show how easy it is to create highly efficient and reliable code to execute several database commands.

using FishDawg.EnterpriseLibrary.Operations;
 
// Create 3 SQL commands.
const string connectionString = "Server=Localhost;Database=MyDatabase;Integrated Security=True;MultipleActiveResultSets=True;Asynchronous Processing=True";
const string commandText1 = "INSERT LogEntry (Code, Message) VALUES (111, N'AAA');";
SqlCommand command1 = new SqlCommand(commandText1, new SqlConnection(connectionString));
const string commandText2 = "INSERT LogEntry (Code, Message) VALUES (222, N'BBB');";
SqlCommand command2 = new SqlCommand(commandText2, new SqlConnection(connectionString));
const string commandText3 = "INSERT LogEntry (Code, Message) VALUES (333, N'CCC');";
SqlCommand command3 = new SqlCommand(commandText3, new SqlConnection(connectionString));
 
private static void Example1()
{
  // Compose together several operation objects to execute the 3 SQL commands in parallel, each in a local transaction, 
  // and with automatic retries (with up to 3 tries by default) in case any SqlException gets thrown.
  using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Supress))
  using (Operation operation = new ParallelOperation(new Operation[] {
      new RetryOperation<SqlException>(new TransactionOperation(new SqlNonQueryOperation(command1))),
      new RetryOperation<SqlException>(new TransactionOperation(new SqlNonQueryOperation(command2))),
      new RetryOperation<SqlException>(new TransactionOperation(new SqlNonQueryOperation(command3)))
    }))
  {
    // Execute the operation asynchronously (omitting the callback delegate for demonstration purposes only)
    IAsyncResult asyncResult = operation.BeginExecute(null, null);
    operation.EndExecute(asyncResult);
 
    scope.Complete();
  }
}
 
private static void Example2()
{
  // Compose together several operation objects to execute the 3 SQL commands in parallel, in a distributed transaction 
  // (with a timeout of 20 seconds for each local transaction).
  using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Required))
  using (Operation operation = new ParallelOperation(new Operation[] {
      new TransactionOperation(new SqlNonQueryOperation(command1), TimeSpan.FromSeconds(20.0)),
      new TransactionOperation(new SqlNonQueryOperation(command2), TimeSpan.FromSeconds(20.0)),
      new TransactionOperation(new SqlNonQueryOperation(command3), TimeSpan.FromSeconds(20.0))
    })))
  {
    // Execute the operation synchronously.
    operation.Execute();
 
    scope.Complete();
  }
}

Library Usage

UPDATED WIKI: Home

FishDawg — Tue, 25 Sep 2007 07:30:15 GMT

Operations Framework

The library contains the Operations Framework, which is designed to make working with asynchronous tasks simple, robust, and performant. The operation classes are easy to integrate into your code. They help you avoid common mistakes in your code by releasing resources automatically at the right times (including closing database connections), synchronizing work done on multiple threads efficiently, and handling critical exceptions correctly (including OutOfMemory, StackOverflow, and ThreadAbort). They make the most of the .Net Framework by leveraging the power of the thread pool, ADO.Net connection pool, and timers. They help you solve common problems by including support for customizable automatic retries, efficient parallel execution, and flexible transactions.

Code Example

These examples show how easy it is to create highly efficient and reliable code to execute several database commands.

using FishDawg.EnterpriseLibrary.Operations;
 
// Create 3 SQL commands.
const string connectionString = "Server=Localhost;Database=MyDatabase;Integrated Security=True;Asynchronous Processing=True";
const string commandText1 = "INSERT LogEntry (Code, Message) VALUES (111, N'AAA');";
SqlCommand command1 = new SqlCommand(commandText1, new SqlConnection(connectionString));
const string commandText2 = "INSERT LogEntry (Code, Message) VALUES (222, N'BBB');";
SqlCommand command2 = new SqlCommand(commandText2, new SqlConnection(connectionString));
const string commandText3 = "INSERT LogEntry (Code, Message) VALUES (333, N'CCC');";
SqlCommand command3 = new SqlCommand(commandText3, new SqlConnection(connectionString));
 
private static void Example1()
{
  // Compose together several operation objects to execute the 3 SQL commands in parallel, each in a local transaction, 
  // and with automatic retries (with up to 3 tries by default) in case any SqlException gets thrown.
  using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Supress))
  using (Operation operation = new ParallelOperation(new Operation[] {
      new RetryOperation<SqlException>(new TransactionOperation(new SqlNonQueryOperation(command1))),
      new RetryOperation<SqlException>(new TransactionOperation(new SqlNonQueryOperation(command2))),
      new RetryOperation<SqlException>(new TransactionOperation(new SqlNonQueryOperation(command3)))
    }))
  {
    // Execute the operation asynchronously (omitting the callback delegate for demonstration purposes only)
    IAsyncResult asyncResult = operation.BeginExecute(null, null);
    operation.EndExecute(asyncResult);
 
    scope.Complete();
  }
}
 
private static void Example2()
{
  // Compose together several operation objects to execute the 3 SQL commands in parallel, in a distributed transaction 
  // (with a timeout of 20 seconds for each local transaction).
  using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Required))
  using (Operation operation = new ParallelOperation(new Operation[] {
      new TransactionOperation(new SqlNonQueryOperation(command1), TimeSpan.FromSeconds(20.0)),
      new TransactionOperation(new SqlNonQueryOperation(command2), TimeSpan.FromSeconds(20.0)),
      new TransactionOperation(new SqlNonQueryOperation(command3), TimeSpan.FromSeconds(20.0))
    })))
  {
    // Execute the operation synchronously.
    operation.Execute();
 
    scope.Complete();
  }
}

Library Usage

UPDATED WIKI: Home

FishDawg — Fri, 07 Sep 2007 21:15:31 GMT

This .Net class library is designed to integrate into enterprise applications that have high performance and reliability requirements. The focus of the Enterprise Library is to make it easy and safe to take full advantage of the amazing capabilities already in the .Net Framework and extend those capabilities to support the needs of enterprise applications. The library includes an Operations Framework, which provides flexible and efficient support for asynchronous operations to allow your code to fully utilize the power of computers with multiple processors.

Operations Framework

The library contains an Operations Framework that is designed to make working with asynchronous tasks easier, safer, and more performant. The operation classes are simple and efficient to use in your code. They help you avoid common mistakes in your code by releasing resources automatically at the right times (including closing database connections), synchronizing work done on multiple threads efficiently, and handling critical exceptions correctly (including OutOfMemory, StackOverflow, and ThreadAbort). They make the most of the .Net Framework by leveraging the power of the thread pool, ADO.Net connection pool, and timers. They help you solve common problems by including support for customizable automatic retries, efficient parallel execution, and flexible transactions.

Code Example

This example shows how easy it is to create highly efficient and reliable code to execute several database commands.

using FishDawg.EnterpriseLibrary.Operations;
 
private static void MyMethod()
{
  // Create 3 SQL commands.
  const string connectionString = "Server=Localhost;Database=MyDatabase;Integrated Security=True;Asynchronous Processing=True";
  const string commandText1 = "INSERT LogEntry (Code, Message) VALUES (111, N'AAA');";
  SqlCommand command1 = new SqlCommand(commandText1, new SqlConnection(connectionString));
  const string commandText2 = "INSERT LogEntry (Code, Message) VALUES (222, N'BBB');";
  SqlCommand command2 = new SqlCommand(commandText2, new SqlConnection(connectionString));
  const string commandText3 = "INSERT LogEntry (Code, Message) VALUES (333, N'CCC');";
  SqlCommand command3 = new SqlCommand(commandText3, new SqlConnection(connectionString));
 
  // Compose together several operation objects to execute the 3 SQL commands in parallel, in a transaction (set to a timeout 
  // of 20 seconds), and with automatic retries (up to 2 times by default) if an exception of type SqlException gets thrown.
  Operation operation = new TransactionOperation(new ParallelOperation(new Operation[] {
      new RetryOperation<SqlException>(new SqlNonQueryOperation(command1)),
      new RetryOperation<SqlException>(new SqlNonQueryOperation(command2)),
      new RetryOperation<SqlException>(new SqlNonQueryOperation(command3))
    }), TimeSpan.FromSeconds(20.0));
 
  // Execute the operation synchronously.
  operation.Execute();
 
  // Execute the operation asynchronously (omitting a callback delegate for simplicity)
  IAsyncResult asyncResult = operation.BeginExecute(null, null);
  operation.EndExecute(asyncResult);
}

Library Usage

To encourage reuse and contribution to this project, it is released under a permissive free software license. We encourage you to contribute by posting feature requests, reporting bugs, and submitting code changes. You may use this library and its source code in your own projects in accordance to the MIT License.

Source code checked in

FishDawg — Sun, 26 Aug 2007 23:10:40 GMT

Create 1.0 branch.

Source code checked in

FishDawg — Sun, 26 Aug 2007 23:08:37 GMT

Create main branch.