The main feature of these enhancements is the avoidance of the repeated allocation and synchronization of objects during high-volume asynchronous socket I/O. The Begin/End design pattern currently implemented by the System.Net.Sockets…: .Socket class requires a System…: .IAsyncResult object be allocated for each asynchronous socket operation.

In the new System.Net.Sockets…: .Socket class enhancements, asynchronous socket operations are described by reusable SocketAsyncEventArgs objects allocated and maintained by the application. High-performance socket applications know best the amount of overlapped socket operations that must be sustained. The application can create as many of the SocketAsyncEventArgs objects that it needs. For example, if a server application needs to have 15 socket accept operations outstanding at all times to support incoming client connection rates, it can allocate 15 reusable SocketAsyncEventArgs objects for that purpose.

The pattern for performing an asynchronous socket operation with this class consists of the following steps:

1. Allocate a new SocketAsyncEventArgs context object, or get a free one from an application pool.
2. Set properties on the context object to the operation about to be performed (the completion callback method, the data buffer, the offset into the buffer, and the maximum amount of data to transfer, for example).
3. Call the appropriate socket method (xxxAsync) to initiate the asynchronous operation.
4. If the asynchronous socket method (xxxAsync) returns true, in the callback, query the context properties for completion status.
5. If the asynchronous socket method (xxxAsync) returns false, the operation completed synchronously. The context properties may be queried for the operation result.
6. Reuse the context for another operation, put it back in the pool, or discard it.

The lifetime of the new asynchronous socket operation context object is determined by references by the application code and asynchronous I/O references. It is not necessary for the application to retain a reference to an asynchronous socket operation context object after it is submitted as a parameter to one of the asynchronous socket operation methods. It will remain referenced until the completion callback returns. However it is advantageous for the application to retain the reference to the context so that it can be reused for a future asynchronous socket operation.

 Examples

The following code example implements the connection logic for the socket server that uses the SocketAsyncEventArgs class. After accepting a connection, all data read from the client is sent back to the client. The read and echo back to the client pattern is continued until the client disconnects. The BufferManager class that is used by this example is displayed in the code example for the SetBuffer (array<Byte> [] () [], Int32, Int32) method. The SocketAsyncEventArgsPool class that is used in this example is displayed in the code example for the SocketAsyncEventArgs constructor.

C#

Copy Code

// Implements the connection logic for the socket server. 

// after accepting a connection, all data read from the client

// is sent back to the client. The read and echo back to the client pattern

// is continued until the client disconnects.

class Server

{

    private int m_numConnections;   // the maximum number of connections the sample is designed to handle simultaneously

    private int m_receiveBufferSize; // buffer size to use for each socket I/O operation

    BufferManager m_bufferManager;   // represents a large reusable set of buffers for all socket operations

    const int opsToPreAlloc = 2;    // read, write (don’t alloc buffer space for accepts)

    Socket listenSocket;            // the socket used to listen for incoming connection requests

    // pool of reusable SocketAsyncEventArgs objects for write, read and accept socket operations

    SocketAsyncEventArgsPool m_readWritePool;

    int m_totalBytesRead;           // counter of the total # bytes received by the server

    int m_numConnectedSockets;      // the total number of clients connected to the server

    Semaphore m_maxNumberAcceptedClients;

    // Create an uninitialized server instance. 

    // To start the server listening for connection requests

    // call the Init method followed by Start method

    // <param name=”numConnections”>the maximum number of connections the sample is designed to handle simultaneously</param>

    // <param name=”receiveBufferSize”>buffer size to use for each socket I/O operation</param>

    public Server(int numConnections, int receiveBufferSize)

    {

        m_totalBytesRead = 0;

        m_numConnectedSockets = 0;

        m_numConnections = numConnections;

        m_receiveBufferSize = receiveBufferSize;

        // allocate buffers such that the maximum number of sockets can have one outstanding read and

        //write posted to the socket simultaneously 

        m_bufferManager = new BufferManager (receiveBufferSize * numConnections * opsToPreAlloc,

            receiveBufferSize);

        m_readWritePool = new SocketAsyncEventArgsPool (numConnections);

        m_maxNumberAcceptedClients = new Semaphore (numConnections, numConnections);

    }

    // Initializes the server by preallocating reusable buffers and

    // context objects.  These objects do not need to be preallocated

    // or reused, but it is done this way to illustrate how the API can

    // easily be used to create reusable objects to increase server performance.

    //

    public void Init()

    {

        // Allocates one large byte buffer which all I/O operations use a piece of.  This gaurds

        // against memory fragmentation

        m_bufferManager.InitBuffer();

        // preallocate pool of SocketAsyncEventArgs objects

        SocketAsyncEventArgs readWriteEventArg;

        for (int i = 0; i < m_numConnections; i++)

        {

            //Pre-allocate a set of reusable SocketAsyncEventArgs

            readWriteEventArg = new SocketAsyncEventArgs();

            readWriteEventArg.Completed += new EventHandler<SocketAsyncEventArgs>(IO_Completed);

            readWriteEventArg.UserToken = new AsyncUserToken();

            // assign a byte buffer from the buffer pool to the SocketAsyncEventArg object

            m_bufferManager.SetBuffer(readWriteEventArg);

            // add SocketAsyncEventArg to the pool

            m_readWritePool.Push(readWriteEventArg);

        }

    }

    // Starts the server such that it is listening for

    // incoming connection requests.   

    //

    // <param name=”localEndPoint”>The endpoint which the server will listening

    // for connection requests on</param>

    public void Start(IPEndPoint localEndPoint)

    {

        // create the socket which listens for incoming connections

        listenSocket = new Socket(localEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);

        listenSocket.Bind(localEndPoint);

        // start the server with a listen backlog of 100 connections

        listenSocket.Listen(100);

        // post accepts on the listening socket

        StartAccept(null);           

        //Console.WriteLine(“{0} connected sockets with one outstanding receive posted to each….press any key”, m_outstandingReadCount);

        Console.WriteLine(“Press any key to terminate the server process….”);

        Console.ReadKey();

    }

    // Begins an operation to accept a connection request from the client

    //

    // <param name=”acceptEventArg”>The context object to use when issuing

    // the accept operation on the server’s listening socket</param>

    public void StartAccept(SocketAsyncEventArgs acceptEventArg)

    {

        if (acceptEventArg == null)

        {

            acceptEventArg = new SocketAsyncEventArgs();

            acceptEventArg.Completed += new EventHandler<SocketAsyncEventArgs>(AcceptEventArg_Completed);

        }

        else

        {

            // socket must be cleared since the context object is being reused

            acceptEventArg.AcceptSocket = null;

        }

        m_maxNumberAcceptedClients.WaitOne();

        bool willRaiseEvent = listenSocket.AcceptAsync(acceptEventArg);

        if (!willRaiseEvent)

        {

            ProcessAccept(acceptEventArg);

        }

    }

    // This method is the callback method associated with Socket.AcceptAsync

    // operations and is invoked when an accept operation is complete

    //

    void AcceptEventArg_Completed(object sender, SocketAsyncEventArgs e)

    {

        ProcessAccept(e);

    }

    private void ProcessAccept(SocketAsyncEventArgs e)

    {

        Interlocked.Increment(ref m_numConnectedSockets);

        Console.WriteLine(“Client connection accepted. There are {0} clients connected to the server”,

            m_numConnectedSockets);

        // Get the socket for the accepted client connection and put it into the

        //ReadEventArg object user token

        SocketAsyncEventArgs readEventArgs = m_readWritePool.Pop();

        ((AsyncUserToken)readEventArgs.UserToken).Socket = e.AcceptSocket;

        // As soon as the client is connected, post a receive to the connection

        bool willRaiseEvent = e.AcceptSocket.ReceiveAsync(readEventArgs);

        if(!willRaiseEvent){

            ProcessReceive(readEventArgs);

        }

        // Accept the next connection request

        StartAccept(e);

    }

    // This method is called whenever a receive or send operation is completed on a socket

    //

    // <param name=”e”>SocketAsyncEventArg associated with the completed receive operation</param>

    void IO_Completed(object sender, SocketAsyncEventArgs e)

    {

        // determine which type of operation just completed and call the associated handler

        switch (e.LastOperation)

        {

            case SocketAsyncOperation.Receive:

                ProcessReceive(e);

                break;

            case SocketAsyncOperation.Send:

                ProcessSend(e);

                break;

            default:

                throw new ArgumentException(“The last operation completed on the socket was not a receive or send”);

        }      

    }

    // This method is invoked when an asynchronous receive operation completes.

    // If the remote host closed the connection, then the socket is closed. 

    // If data was received then the data is echoed back to the client.

    //

    private void ProcessReceive(SocketAsyncEventArgs e)

    {

        // check if the remote host closed the connection

        AsyncUserToken token = (AsyncUserToken)e.UserToken;

        if (e.BytesTransferred > 0 && e.SocketError == SocketError.Success)

        {

            //increment the count of the total bytes receive by the server

            Interlocked.Add(ref m_totalBytesRead, e.BytesTransferred);

            Console.WriteLine(“The server has read a total of {0} bytes”, m_totalBytesRead);

            //echo the data received back to the client

            e.SetBuffer(e.Offset, e.BytesTransferred);

            bool willRaiseEvent = token.Socket.SendAsync(e);

            if (!willRaiseEvent)

            {

                ProcessSend(e);

            }

        }

        else

        {

            CloseClientSocket(e);

        }

    }

    // This method is invoked when an asynchronous send operation completes. 

    // The method issues another receive on the socket to read any additional

    // data sent from the client

    //

    // <param name=”e”></param>

    private void ProcessSend(SocketAsyncEventArgs e)

    {

        if (e.SocketError == SocketError.Success)

        {

            // done echoing data back to the client

            AsyncUserToken token = (AsyncUserToken)e.UserToken;

            // read the next block of data send from the client

            bool willRaiseEvent = token.Socket.ReceiveAsync(e);

            if (!willRaiseEvent)

            {

                ProcessReceive(e);

            }

        }

        else

        {

            CloseClientSocket(e);

        }

    }

private void CloseClientSocket(SocketAsyncEventArgs e)
{
        AsyncUserToken token = e.UserToken as AsyncUserToken;

        // close the socket associated with the client
        try
        {
            token.Socket.Shutdown(SocketShutdown.Send);
        }
        // throws if client process has already closed
        catch (Exception) { }
        token.Socket.Close();

        // Before releasing the Semaphore..
          // Free the SocketAsyncEventArg so they can be reused by another client
          m_readWritePool.Push(e);

          // decrement the counter keeping track of the total number of clients connected to the server
          Interlocked.Decrement(ref m_numConnectedSockets);

        // Finally, release the m_maxNumberAcceptedClients semaphore
        m_maxNumberAcceptedClients.Release();
        Console.WriteLine(“A client has been disconnected from the server. There are {0} clients connected to the server“, m_numConnectedSockets);
    }

class AsyncUserToken
{
    private System.Net.Socket _socket;

    public AsyncUserToken()
    {
    }

    // public property to get and set the internal private _socket member
    public System.Net.Socket Socket
    {
       get { return _socket; }
       set { _socket = value; }
    }

}

Note: If the passwordFormat is initially “Clear” or “Encrypted”, use the membership.provider.GetPassword method to cache the original password before calling the stored procedures.

1.      Use the stored procedure aspnet Membership GetPasswordWithFormat to retrieve the current passwordSalt.

2.      Use the stored procedure aspnet Membership ResetPassword to set the passwordFormat to its intended (integer) value. The stored procedure requires readily available parameter values including passwordSalt (retrieved earlier), password (empty string) and passwordAnswer (Null).

At this point, the membership record has been placed into an initialized (unusable) state and the PasswordAnswer has been lost. If the original password was hashed, then it too will be unrecoverable.  The provider methods listed below and described in previous sections allow for resetting the credentials and, as they are used, the password and password answer will be stored in the new password format (clear, encrypted, hashed.)

1.      Call the ResetPassword method to generate and retrieve a new random Password. Remember that the second parameter (answer) is not required if “requiresQuestionAndAnswer” is set to false in web.config.

2.      Call the ChangePassword method, using the now-current password retrieved in the previous step, to set the password to a desired value.  If the original password was saved at the start of the procedure, it may be restored at this point.

For originally un-hashed passwords, the preceding steps allow for a change of passwordFormat with complete restoration of the original password.

The Password Answer could have easily been retrieved from the database at the outset if it was stored in clear text. In the case of an encrypted Password Answer, a more complicated approach which involves the provider’s protected DecryptPassword method could have been used to cache the original Password Answer.  If the original Password Answer were available, it could be restored with a call to the ChangePasswordQuestionAndAnswer provider method.

So, what can be done if the Password and/or Password Answer had to be sacrificed in favor of a new passwordFormat?  One solution might be to reset everyone’s credentials then send them by Email. Another solution might be to place a notice onto the web site that informs users and provides further instructions. Either way, the web site should leverage the self-service membership controls which allow the member to reset his/her own credentials.  The following outlines a series of steps that can be taken:

1.      A new arbitrary password can be assigned using either the ResetPassword or ChangePassword provider method. Similarly, a new arbitrary Password Question and Password Answer can be assigned using the ChangePasswordQuestionAndAnswer provider method.

2.      Since the user will not know his/her new credentials, ensure the Login Control includes the necessary properties (PasswordRecoveryText and PasswordRecoveryURL) to link the user to a page that includes a PasswordRecovery Control.

3.      Recall that the PasswordRecovery Control is driven by the provider settings in web.config. In particular, ensure that “requiresQuestionAndAnswer” is set to false so the PasswordRecovery Control does not prompt the user for a Password Answer. Also, ensure that the SMTP setting is specified in web.config so that the Email will be sent. If the membership record uses a hashed password format then a new (random) password will be sent, otherwise the password you assigned in the previous step will be sent.

Clear text :  Call the GetPassword method with the username and without the need for a password answer to retrieve the password. Now, armed with the password, call ChangePasswordQuestionAndAnswer to set the Password Question and Password Answer to a desired value.

Encrypted    Call the GetPassword method with the username and without the need for a password answer to retrieve the password. Now, armed with the password, call ChangePasswordQuestionAndAnswer to set the Password Question and Password Answer to a desired value.

              Hashed:    Call the ResetPassword method with the username and without the need for a password answer to reset the password to a new random value. Using the newly generated password, call ChangePasswordQuestionAndAnswer to set the Password Question and Password Answer to a desired value. Optionally call ChangePassword to set the password to a more user-friendly value.

 If password is:

Clear text:   Simply call the GetPassword method with the username and without the need for a password answer to retrieve the password

Encrypted:   Simply call the GetPassword method with the username and without the need for a password answer to retrieve the password

             Hashed:       Not possible, however the password may be reset as described below.

string password = Membership.Providers”MembershipProviderForAdmin”].GetPassword(currentUser,string.Empty);

 string username = "username";
 string password = "pass@word";
 MembershipUser mUser = Membership.GetUser(username);
 mu.ChangePassword(mUser.ResetPassword(), password);

You will find that if you have in your web.config requiresQuestionAnswer=”true”, you will get an error when you try and reset the password.  The elegant solution to this is to create an additional membeship tag in your web.config and reference it when you change passwords.  That is, add another provider like this:

<!– To Reset password of the user. –>

Then, when you change your password, reference it as follows:

string username = “username“;
string password = “pass@word“;
MembershipUser mUser = Membership.Providers["SqlMembershipProviderAdmin"].GetUser(username);
mu.ChangePassword(mUser.ResetPassword(), password);

 Hope this helps.

<EmptyDataTemplate>
<asp:Table ID="tblEmptyHeadCount" runat="server" Width="100%">
<asp:TableRow ID="TableRow17" runat="server" HorizontalAlign="right" Width="100%">
<asp:TableCell ID="TableCell42" runat="server" Width="15%"></asp:TableCell>
<asp:TableCell ID="TableCell43" runat="server" Width="40%" HorizontalAlign="center">
<asp:Label ID="lbl1" runat="server" Text="Position"></asp:Label>
</asp:TableCell>
<asp:TableCell ID="TableCell48" runat="server" Width="15%" HorizontalAlign="center">
<asp:Label ID="Label6" runat="server" Text="FTE Salary"></asp:Label>
</asp:TableCell>
<asp:TableCell ID="TableCell49" runat="server" Width="10%" HorizontalAlign="center">
<asp:Label ID="Label7" runat="server" Text="HC"></asp:Label>
</asp:TableCell>
<asp:TableCell ID="TableCell50" runat="server" Width="20%" HorizontalAlign="center">
</asp:TableCell>
</asp:TableRow>
</asp:Table></EmptyDataTemplate>

namespace PortableDAL
{
internal class DataProviderFactory
{
public static IDbConnection CreateConnection(Type providerType)
{
return ((IDbConnection) Activator.CreateInstance(providerType));
} //CreateConnection
public static IDbConnection CreateConnection(Type providerType, string connectionString)
{
object[] args = new object[] { connectionString };
return ((IDbConnection) Activator.CreateInstance(providerType, args));
} //CreateConnection
public static IDbCommand CreateCommand(Type providerType)
{
return ((IDbCommand) Activator.CreateInstance(providerType));
} //CreateCommand
public static IDbCommand CreateCommand(Type providerType, string cmdText)
{
object[] args = new object[] { cmdText };
return ((IDbCommand) Activator.CreateInstance(providerType, args));
} //CreateCommand
public static IDbCommand CreateCommand(Type providerType, string cmdText, IDbConnection connection)
{
object[] args = new object[] { cmdText, connection };
return ((IDbCommand) Activator.CreateInstance(providerType, args));
} //CreateCommand
public static IDbCommand CreateCommand(Type providerType, string cmdText, IDbConnection connection, IDbTransaction transaction)
{
object[] args = new object[] { cmdText, connection, transaction };
return ((IDbCommand) Activator.CreateInstance(providerType, args));
} //CreateCommand
public static IDbDataAdapter CreateDataAdapter(Type providerType)
{
return ((IDbDataAdapter) Activator.CreateInstance(providerType));
} //CreateDataAdapter
public static IDbDataAdapter CreateDataAdapter(Type providerType, IDbCommand selectCommand)
{
object[] args = new object[] { selectCommand };
return ((IDbDataAdapter) Activator.CreateInstance(providerType, args));
} //CreateDataAdapter
public static IDbDataAdapter CreateDataAdapter(Type providerType, string selectCommandText, IDbConnection selectConnection)
{
object[] args = new object[] { selectCommandText, selectConnection };
return ((IDbDataAdapter) Activator.CreateInstance(providerType, args));
} //CreateDataAdapter
public static IDbDataAdapter CreateDataAdapter(Type providerType, string selectCommandText, string selectConnectionString)
{
object[] args = new object[] { selectCommandText, selectConnectionString };
return ((IDbDataAdapter) Activator.CreateInstance(providerType, args));
} //CreateDataAdapter
public static IDbDataParameter CreateDataParameter(Type providerType)
{
return ((IDbDataParameter) Activator.CreateInstance(providerType));
} //CreateDataParameter
public static IDbDataParameter CreateDataParameter(Type providerType, string parameterName, object value)
{
object[] args = new object[] { parameterName, value };
return ((IDbDataParameter) Activator.CreateInstance(providerType, args));
} //CreateDataParameter
public static IDbDataParameter CreateDataParameter(Type providerType, string parameterName, object value, DbType dataType)
{
IDbDataParameter param = CreateDataParameter(providerType);
if (!(param == null))
{
param.ParameterName = parameterName;
param.DbType = dataType;
param.Value = value;
}
return param;
} //CreateDataParameter
public static IDbDataParameter CreateDataParameter(Type providerType, string parameterName, DbType dataType, int size)
{
IDbDataParameter param = CreateDataParameter(providerType);
if (!(param == null))
{
param.ParameterName = parameterName;
param.DbType = dataType;
param.Size = size;
}
return param;
} //CreateDataParameter
public static IDbDataParameter CreateDataParameter(Type providerType, string parameterName, DbType dataType, int size, string sourceColumn)
{
IDbDataParameter param = CreateDataParameter(providerType);
if (!(param == null))
{
param.ParameterName = parameterName;
param.DbType = dataType;
param.Size = size;
param.SourceColumn = sourceColumn;
}
return param;
} //CreateDataParameter
public static IDbDataParameter CreateDataParameter(Type providerType, string parameterName, DbType dataType, int size, ParameterDirection direction)
{
IDbDataParameter param = CreateDataParameter(providerType);
if (!(param == null))
{
param.ParameterName = parameterName;
param.DbType = dataType;
param.Size = size;
param.Direction = direction;
}
return param;
} //CreateDataParameter
public static IDbDataParameter CreateDataParameter(Type providerType, string parameterName, DbType dataType, object value, int size, ParameterDirection direction)
{
IDbDataParameter param = CreateDataParameter(providerType);
if (!(param == null))
{
param.ParameterName = parameterName;
param.DbType = dataType;
param.Size = size;
param.Direction = direction;
param.Value = value;
}
return param;
} //CreateDataParameter
}
}
#########################################
DataAccessor.cs Class
#########################################

using System.Data;
using System.Configuration;
using System.Collections;
using Microsoft.VisualBasic;
using System.Diagnostics;
using System;
using System.Data.SqlClient;
using System.Data.OleDb;
using System.Data.Odbc;
using System.Data.OracleClient;
using MySql.Data.MySqlClient;
namespace PortableDAL
{
public enum ProviderType
{
Odbc = 0,
OleDb,
Oracle,
SqlClient,
MySqlClient
}
///—————————————————————————–
/// Project : DataAccess
/// Class : DataAccessor
///
///—————————————————————————–
///
/// Helper for data access
/// Wraps the database access calls
///
/// this class requires a reference to System.Data.OracleClient.dll
/// this class requires a reference to MySql.Data.dll
/// This class is dependent on the DataProviderFactory
///
///—————————————————————————–
public class DataAccessor : IDisposable
{
#region “Private Fields”
private const string PARAMS_FAILED = “Could not attach parameters.”;
private const int COMMAND_TIMEOUT = 120;
private static Type[] m_connectionTypes = new Type[] { typeof(OdbcConnection), typeof(OleDbConnection), typeof(OracleConnection), typeof(SqlConnection),typeof(MySqlConnection) };
private static Type[] m_dataAdapterTypes = new Type[] { typeof(OdbcDataAdapter), typeof(OleDbDataAdapter), typeof(OracleDataAdapter), typeof(SqlDataAdapter),typeof(MySqlDataAdapter) };
private static Type[] m_parameterTypes = new Type[] { typeof(OdbcParameter), typeof(OleDbParameter), typeof(OracleParameter), typeof(SqlParameter),typeof(MySqlParameter) };
private static Type[] m_commandTypes = new Type[] { typeof(OdbcCommand), typeof(OleDbCommand), typeof(OracleCommand), typeof(SqlCommand),typeof(MySqlCommand) };
private static Type[] m_commandBuilderTypes = new Type[] { typeof(OdbcCommandBuilder), typeof(OleDbCommandBuilder), typeof(OracleCommandBuilder), typeof(SqlCommandBuilder),typeof(MySqlCommandBuilder) };
private IDbConnection m_connection; // connection used by the class
private IDbTransaction m_transaction; // transaction used by the class
private string m_connectionString; // connection string used for the connection
private ProviderType m_provider; // provider type to use for the data objects
private int m_commandTimeout = 120; // Timeout for the command execution
#endregion
#region “Constructors”
public DataAccessor(ProviderType provider)
{
m_provider = provider;
} //New
public DataAccessor(string connectionString, ProviderType provider)
{
m_provider = provider;
m_connectionString = connectionString;
} //New
public DataAccessor(ProviderType provider, string key)
{
//get the connection string from the configuration file
System.Configuration.AppSettingsReader appRead = new System.Configuration.AppSettingsReader();
m_connectionString = (string) appRead.GetValue(key, typeof(System.String));
m_provider = provider;
} //New
#endregion
#region “Properties”
public ProviderType Provider
{
get
{
return m_provider;
}
set
{
m_provider = value;
}
} //Provider
public string ConnectionString
{
get
{
return m_connectionString;
}
set
{
m_connectionString = value;
}
} //ConnectionString
public IDbConnection Connection
{
get
{
// if the connection does not exist, create and open it
if (m_connection == null)
{
m_connection = DataProviderFactory.CreateConnection(m_connectionTypes[ (int) m_provider], m_connectionString);
m_connection.Open();
}
else
{
if (m_connection.State != ConnectionState.Open)
{
m_connection.Open();
}
}
return m_connection;
}
set
{
m_connection = value;
}
} //Connection
public IDbTransaction Transaction
{
get
{
return m_transaction;
}
set
{
m_transaction = value;
}
} //Transaction
public int CommandTimeout
{
get
{
return m_commandTimeout;
}
set
{
m_commandTimeout = value;
}
} // CommandTimeout
#endregion
#region “Public Methods”
public void Dispose()
{
// dispose of the transaction if it exists
if (m_transaction != null)
{
m_transaction.Dispose();
}
// dispose of the connection
if (m_connection != null)
{
if (m_connection.State == ConnectionState.Open)
{
m_connection.Close();
}
m_connection.Dispose();
}
} //Dispose
public IDbTransaction BeginTransaction()
{
if (m_transaction == null)
{
m_transaction = Connection.BeginTransaction();
}
return m_transaction;
} //BeginTransaction
///
/// Execute a IDbCommand (that returns no resultset and takes commandText & commandType parameters) against the database specified in
/// the connection string
///
///
/// e.g.:
/// int result = ExecuteNonQuery(“GetOrders”,CommandType.StoredProcedure, 24, 36);
///
///
The stored procedure name or T-SQL command
///
The CommandType (stored procedure, text, etc.)
///
Array of objects holding the values to be assigned
/// An int representing the number of rows affected by the command
public int ExecuteNonQuery(string query, CommandType queryType, IDbDataParameter[] param)
{
IDbCommand cmd = CreateCommand(query, queryType);
AppendParameters(param, cmd);
cmd.Transaction = m_transaction;
int retVal = cmd.ExecuteNonQuery();
if (m_transaction == null)
{
m_connection.Close();
}
cmd.Dispose();
return retVal;
} //ExecuteNonQuery
///
/// Execute a IDbCommand (that returns no resultset and takes commandText & commandType parameters) against the database specified in
/// the connection string
///
///
/// e.g.:
/// DataSet ds = ExecuteDataset(“GetOrders”,CommandType.StoredProcedure,24,36 );
///
///
The CommandType (stored procedure, text, etc.)
///
The stored procedure name or T-SQL command
///
Array of objects holding the values to be assigned
///
A dataset containing the resultset generated by the command
/// A dataset containing the resultset generated by the command
public int ExecuteDataset ( string query, CommandType queryType, IDbDataParameter[] param, DataSet ds )
{
IDbCommand cmd = CreateCommand(query, queryType);
AppendParameters(param, cmd);
IDbDataAdapter da = DataProviderFactory.CreateDataAdapter(m_dataAdapterTypes[(int)m_provider]);
da.SelectCommand = cmd;
cmd.Transaction = m_transaction;
int retVal = da.Fill(ds);
if (m_transaction == null)
{
m_connection.Close();
}
cmd.Dispose();
return retVal;
} //ExecuteQuery
///
/// Execute a IDbCommand (that returns no resultset and takes commandText & commandType parameters) against the database specified in
/// the connection string
///
///
/// e.g.:
/// DataSet ds = ExecuteDataset(“GetOrders”,CommandType.StoredProcedure,24,36 );
///
///
The CommandType (stored procedure, text, etc.)
///
The stored procedure name or T-SQL command
///
Array of objects holding the values to be assigned
/// A dataset containing the resultset generated by the command
public DataSet ExecuteDataset(string query, CommandType queryType, IDbDataParameter[] param)
{
IDbCommand cmd = CreateCommand(query, queryType);
DataSet ds = new DataSet();
AppendParameters(param, cmd);
IDbDataAdapter da = DataProviderFactory.CreateDataAdapter(m_dataAdapterTypes[ (int) m_provider]);
da.SelectCommand = cmd;
cmd.Transaction = m_transaction;
da.Fill(ds);
cmd.Parameters.Clear();
if (m_transaction == null)
{
m_connection.Close();
}
cmd.Dispose();
return ds;
} //ExecuteDataset
///
/// Execute a IDbCommand (that returns no resultset and takes commandText & commandType parameters) against the database specified in
/// the connection string
///
///
/// e.g.:
/// int orderCount = (int)ExecuteScalar(“GetOrderCount”,CommandType.StoredProcedure,24 );
///
///
The CommandType (stored procedure, text, etc.)
///
The stored procedure name or T-SQL command
///
Array of objects holding the values to be assigned
/// An object containing the value in the 1×1 resultset generated by the command
public object ExecuteScalar(string query, CommandType queryType, IDbDataParameter[] param)
{
IDbCommand cmd = CreateCommand(query, queryType);
AppendParameters(param, cmd);
cmd.Transaction = m_transaction;
object retVal = cmd.ExecuteScalar();
if (m_transaction == null)
{
m_connection.Close();
}
cmd.Dispose();
return retVal;
} //ExecuteScalar
///
/// Execute a IDbCommand (that returns no resultset and takes commandText & commandType parameters) against the database specified in
/// the connection string
///
///
/// e.g.:
/// SqlDataReader dr = ExecuteReader( “GetOrders”,CommandType.StoredProcedure,24,34);
///
///
The CommandType (stored procedure, text, etc.)
///
The stored procedure name or T-SQL command
///
Array of objects holding the values to be assigned
/// A IDataReader containing the resultset generated by the command
public IDataReader ExecuteReader ( string query, CommandType queryType, IDbDataParameter[] param )
{
IDbCommand cmd = CreateCommand(query, queryType);
AppendParameters(param, cmd);
IDataReader dr;
dr = cmd.ExecuteReader();
cmd.Dispose();
return dr;
} //GetReader
public IDbDataParameter[] GetParameters(string query, CommandType queryType)
{
IDbCommand cmd = CreateCommand(query, queryType);
m_commandBuilderTypes[ (int) m_provider].GetMethod(“DeriveParameters”).Invoke(null, new object[] {cmd});
IDbDataParameter[] parameters = new IDbDataParameter[cmd.Parameters.Count-1 + 1];
cmd.Parameters.CopyTo(parameters, 0);
return CloneParameters(parameters);
}
#endregion
#region “Private Methods”
///
/// Deep copy of cached IDbDataParameter array
///
///

///
private IDbDataParameter[] CloneParameters(IDbDataParameter[] originalParameters)
{
int i;
int j = originalParameters.Length – 1;
IDbDataParameter[] clonedParameters = new IDbDataParameter[j + 1];
for (i = 0; i <= j; i++)
{
clonedParameters[i] = (IDbDataParameter) (((ICloneable) originalParameters[i]).Clone());
}
return clonedParameters;
} // CloneParameters
///
/// This method is used to attach array of IDbDataParameter to a IDbCommand.
///
///
An array of IDbDataParameter to be added to command
///
The command to which the parameters will be added
private void AppendParameters(IDbDataParameter[] @params, IDbCommand cmd)
{
// add the parameters to the command
try
{
if (!(@params == null))
{
foreach (IDbDataParameter parameter in @params)
{
cmd.Parameters.Add(parameter);
}
}
}
catch (Exception e)
{
throw (new Exception(PARAMS_FAILED, e));
}
} //AppendParameters
///
/// This method opens (if necessary) and assigns a command type and command text
/// to the provided command
///
///
The IDbCommand to be prepared
///
The CommandType (stored procedure, text, etc.)
///
The stored procedure name or T-SQL command
private IDbCommand CreateCommand(string query, CommandType queryType)
{
// Associate the connection with the command
IDbCommand cmd = Connection.CreateCommand();
// Set the command text (stored procedure name or SQL statement)
cmd.CommandText = query;
// Set the command type
cmd.CommandType = queryType;
// Set the command timeout
cmd.CommandTimeout = m_commandTimeout;
return cmd;
} //CreateCommand
#endregion
} //DataAccessor
}
###############################################
Form1.cs
###############################################
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
namespace PortableDataAccessLayer
{
public partial class Form1 : Form
{
public Form1 ()
{
InitializeComponent();
M_Test();
}
public void M_Test ()
{

// Using Portable Data Access Layer
// To get connection string form configuration file
string m_connectionString = ConfigurationManager.AppSettings.Get(“ConnectionString”);
// Passing provider type and configuration key for connection string in configuration file
DataAccessor helper = new DataAccessor(ProviderType.MySqlClient, “ConnectionString”);
#region Execute Scalar
// How to get scalar value
IDbDataParameter[] @params = new IDbDataParameter[1];
@params = helper.GetParameters(“p_GetGlobalBalance”, CommandType.StoredProcedure);
@params[0].Value = 2;
object dBal = helper.ExecuteScalar(“p_GetGlobalBalance”, CommandType.StoredProcedure, @params);
#endregion
#region DataSet
// How to get DataSet
//IDbDataParameter[] @params = new IDbDataParameter[1];
//@params = helper.GetParameters(“p_ItemUpdates”, CommandType.StoredProcedure);
//@params[0].Value = objRequest.TerminalID;
//DataSet ds = helper.ExecuteDataset(“p_ItemUpdates”, CommandType.StoredProcedure, @params);
#endregion
#region Data Reader
// How to get Data Reader
//IDbDataParameter[] @params = new IDbDataParameter[1];
//@params = helper.GetParameters(“p_ItemUpdates”, CommandType.StoredProcedure);
//@params[0].Value = objRequest.TerminalID;
//DbDataReader dr = (DbDataReader)helper.GetReader(“p_ItemUpdates”, CommandType.StoredProcedure, @params);
//while(dr.Read())
//{
// string aa = dr.GetValue(3).ToString();
//}
#endregion
helper.Dispose();
}
}
}