The Provider Design Pattern and Data Access Component - I

The provider model is used throughout ASP.NET 2.0. It is a means of writing each of the technologies used so that new versions can easily be created and plugged in. For example, if you need to access a different database or authentication server, you can create a provider for it. ASP.NET 2.0 will then work with that provider just as it works with the existing features. This makes ASP.NET 2.0 much more flexible, expandable, and customizable than before. ---- MSDN ( Provider Toolkit )

Generally, an application can be devided into three layers at least: UI Layer, Logic Layer, and Data Access Layer. When designing an application, we should realize that our customers may use different data stores, such as Oracle, Microsoft SQL Server, MySQL, or even text files. Therefore it's very important that the Data Access Layer should be properly designed, since the other two layers of properly designed applications are rarely changed to accommodate new data stores. All what we need to do is just modifying the configuration file to tell our application to use the new Data Access Component. For example, the configuration settings for Microsoft SQL Server may look like:

• <userManager defaultProvider="sqlProvider">
• <providers>
• <clear />
• <add name="sqlProvider" type="Chenglin.Data.SqlUserDataProvider, Chenglin" />
• </providers>
• </dataProviders>

and for the MySQL,

• <userManager defaultProvider="mySQLProvider">
• <providers>
• <clear />
• <add name="mySQLProvider" type="Chenglin.Data.MySQLUserDataProvider, Chenglin" />
• </providers>
• </dataProviders>

ITransactionSupport & DataProviderBase

We should thus carefully design the Data Access Components. First, we declare an interface ITransactionSupport and a class DataProviderBase. The ITransactionSupport interface provides the transaction support for Data Access Components.

Show/hide code: public interface ITransactionSupport

• public interface ITransactionSupport
• {
• /// <summary>
• /// Starts a transaction
• /// </summary>
• void BeginTransaction();
•  
• /// <summary>
• /// Commits the transaction.
• /// </summary>
• void Commit();
•  
• /// <summary>
• /// Rolls back the transaction.
• /// </summary>
• void Rollback();
•  
• /// <summary>
• /// Creates a new <see cref="DataProviderBase"/> object to perform a transaction.
• /// </summary>
• DataProviderBase CreateInstanceForTransaction();
•  
• /// <summary>
• /// Creates a new <see cref="DataProviderBase"/> object to continue the transaction owned by dataProvider.
• /// </summary>
• DataProviderBase ContinueTransaction(DataProviderBase dataProvider);
•  
• /// <summary>
• /// Indicates whether we have begun a transaction.
• /// </summary>
• bool UnderTransaction { get; }
• }

The DataProviderBase class implements the ITransactionSupport interface, so that we can easily perform transactions among various Data Access Components.

Show/hide code: public abstract class DataProviderBase : ProviderBase, IDisposable, ITransactionSupport

• /// <summary>
• /// <see cref="DataProviderBase"/> was designed to simplify various database operations.
• /// </summary>
• public abstract class DataProviderBase
• : System.Configuration.Provider.ProviderBase, System.IDisposable, ITransactionSupport
• {
• /// <summary>
• /// Creates a new <see cref="DataProviderBase"/> object in order to keep on the active transaction.
• /// </summary>
• /// <param name="dataProvider">
• /// A <see cref="DataProviderBase"/> which is under transaction.
• /// </param>
• /// <remarks>
• ///Creates a new <see cref="DataProviderBase"/> object in order to keep on the transaction. the <paramref name="dataProvider"/> object must be the one which is under an active transaction. Invokes <see cref="Commit"/> method to commit the transaction; or <see cref="Rollback"/> method to roll it back.
• /// </remarks>
• /// <exception cref="ArgumentNullException">
• /// <paramref name="dataProvider"/> is a null reference.
• /// </exception>
• /// <exception cref="ArgumentException">
• /// The <paramref name="dataProvider"/> object does not own an active transaction.
• /// </exception>
• protected DataProviderBase(DataProviderBase dataProvider)
• {
• if( dataProvider == null ) {
• throw new ArgumentNullException("dataProvider");
• }
• if( !dataProvider.UnderTransaction ) {
• throw new ArgumentException(
• "The specified DataProviderBase object have not yet begun a transaction.",
• "dataObject");
• }
• }
•  
• /// <summary>
• /// Starts a transaction.
• /// </summary>
• public abstract void BeginTransaction();
•  
• /// <summary>
• /// Commits the transaction.
• /// </summary>
• public abstract void Commit();
•  
• /// <summary>
• /// Rolls back the transcation.
• /// </summary>
• public abstract void Rollback();
•  
• /// <summary>
• /// Creates a new <see cref="DataProviderBase"/> object to perform a transaction.
• /// </summary>
• public abstract DataProviderBase CreateInstanceForTransaction();
•  
• /// <summary>
• /// Creates a new <see cref="DataProviderBase"/> object to continue a transaction owned by dataProvider.
• /// </summary>
• public abstract DataProviderBase ContinueTransaction(DataProviderBase dataProvider);
•  
• /// <summary>
• /// Indicates whether we have begun a transaction.
• /// </summary>
• public abstract bool UnderTransaction { get; }
•  
• /// <summary>
• /// See <see cref="IDisposable.Dispose"/>. Cleans up all the resources.
• /// </summary>
• public void Dispose()
• {
• Dispose(true);
•  
• // Prevents the destructor from being called.
• GC.SuppressFinalize(this);
• }
•  
• /// <summary>
• /// Initializes an instance of <see cref="DataProviderBase"/> object.
• /// </summary>
• protected DataProviderBase()
• { }
•  
• /// <summary>
• /// Cleans up all the resources.
• /// </summary>
• protected abstract void Dispose(bool disposing);
• }

Then, it's very easy to perform transaction operations. For example:

Show/hide code: Sample Code

• public class FirstDataProvider : DataProviderBase{ .... }
• public class SecondDataProvider : DataProviderBase{ .... }
•  
• FirstDataProvider firstDataProvider;
• SecondDataProvider secondDataProvider;
• FirstDataProvider firstInTrans;
• SecondDataProvider secondInTrans;
•  
• // Creates instances for the two classes.
• firstDataProvider = ....;
• secondDataProvider = ....;
•  
• // Executes methods of the two classes separately without transaction support.
• firstDataProvider.Method1();
• firstDataProvider.Method2();
• secondDataProvider.Method1();
•  
•  
• // Performs a transaction operation.
• using( firstInTrans = (FirstDataProvider)firstDataProvider.CreateInstanceForTransaction() ){
• try{
• // Begins a transaction
• firstInTrans.BeginTransaction();
•  
• firstInTrans.Method1();
• firstInTrans.Method2();
•  
• secondInTrans = (SecondDataProvider)secondDataProvider.ContinueTransaction(firstInTrans);
• secondInTrans.Method1();
•  
• // Commits the transaction here.
• firstInTrans.Commit();
• }catch{
• // Some errors. We should roll back the transaction.
• firstInTrans.Rollback();
• throw;
• }
• }