Microsoft has redesigned version 2.0 of the Data Access Block to take advantage of new ADO.NET 2.0 features. You can download the Enterprise Library Data Access Application Block from MSDN.

1] Using Application Data Block (Change in Web.Config)
 To use the Data Access Block successfully, you will need to go through the steps listed below:

Add a reference to the Microsoft.Practices.EnterpriseLibrary.Common.dll and Microsoft.Practices.EnterpriseLibrary.Data.dll assemblies from your solution. You can do this by using the “Add Reference” option and navigating to the <Drive Name>:\Program Files\Microsoft Enterprise Library\bin folder.
Add the necessary configuration entries to the web.config or app.config file or a custom configuration file. To this end, you add the below <configSections> element under the root <configuration> element.
   
         <configSections>
            <section   
              name=”dataConfiguration”            
              type=”Microsoft.Practices.          
              EnterpriseLibrary.Data.
              Configuration.
              DatabaseSettings, 
              Microsoft.Practices.
              EnterpriseLibrary.Data” />
          </configSections>

Then you also add the <dataConfiguration><configuration> element as shown below:

         <dataConfiguration         
            defaultDatabase=
            “AdventureWorksDB”/>

In this example, I have marked AdventureWorks as the default database, declared separately under the <connectionStrings> element.
          <connectionStrings>
            <add
             name=”AdventureWorksDB”
              providerName=
              “System.Data.SqlClient”  
              connectionString=
              “server=localhost;
              database=AdventureWorks;
              UID=user;PWD=word;” />
          </connectionStrings>

2]. Retriving value from the ExecuteDataReader

      Database db = DatabaseFactory.CreateDatabase();
       string sqlCommand = @”Select EmployeeID,
  NationalIDNumber, LoginID, Title from  Employee “;
       DbCommand dbCommand = db.GetSqlStringCommand(sqlCommand);
       using (IDataReader reader = db.ExecuteReader(dbCommand))
       {
         //Bind with DataGrid
       }               
     }

Retriving single row

 Here is the store procedure
 Create Procedure GetEmployeeDetails
 (
      @EmployeeID int,
      @NationalIDNumber nvarchar(15)
        OUTPUT,
      @LoginID nvarchar(256) OUTPUT,
      @Title nvarchar(50) OUTPUT
 )
 AS
      Select @NationalIDNumber =
        NationalIDNumber,
        @LoginID = LoginID,
        @Title = Title from
        Employee
      Where EmployeeID = @EmployeeID
 GO

Here is the code for it.

Database db = DatabaseFactory.CreateDatabase();
string sqlCommand =”GetEmployeeDetails”;
DbCommand dbCommand = db.GetStoredProcCommand(sqlCommand);
//DbCommand dbCommand = db.GetSqlStringCommand(sqlCommand);
//dbCommand.CommandType = CommandType.StoredProcedure;
db.AddInParameter(dbCommand, “EmployeeID”, DbType.Int32, 1);
db.AddOutParameter(dbCommand, “NationalIDNumber”, DbType.String, 15);
db.AddOutParameter(dbCommand, “LoginID”, DbType.String, 256);
db.AddOutParameter(dbCommand, “Title”, DbType.String, 50);
db.ExecuteNonQuery(dbCommand);
Response.Write(“NationalID : ” + db.GetParameterValue(dbCommand, “NationalIDNumber”) + “<br>”);
3]. Retriving DataSet/DataTable

       string   sqlCommand = @”Select EmployeeID,
          NationalIDNumber, LoginID, Title from Employee “;
       DbCommand dbCommand = db.GetSqlStringCommand(sqlCommand);
       DataSet dst = db.ExecuteDataSet(dbCommand);

 //Bind with Datagrid

4]. Insert the records with Return Value

 CREATE PROCEDURE InsertRecordIntoCustomer
 (
    @CustomerID NCHAR(5),
    @CompanyName VARCHAR(50)
 )
 AS
 DECLARE @Result int
 IF EXISTS
 (
    SELECT
       NULL
   FROM
       [Customers]
   WHERE
       [CustomerID] LIKE @CustomerID
 )
    BEGIN
       SELECT @Result = -1
       END
 ELSE
    BEGIN
       INSERT INTO [Customers]
   (
   [CustomerID],
   [CompanyName]
   )
   VALUES
   (
   @CustomerID,
   @CompanyName
   )
       SELECT @Result = @@ERROR
       END
 RETURN @Result
 GO
The C# code used to execute the above stored procedure is as follows:
 try
 {
    // Create DataBase Instance
    Database db = DatabaseFactory.CreateDatabase();
    // Initialize the Stored Procedure
    DBCommand dbCommand = db.GetStoredProcCommand(“InsertRecordIntoCustomer”);
    // If There are output parameters, use ExecuteNonQuery only, better performance
    dbCommand.AddInParameter(“@CustomerID”, DbType.String, “JohnY”);
    dbCommand.AddInParameter(“@CompanyName”, DbType.String, “Microsoft”);
    object Internalvalue = new object();
    dbCommand.AddParameter(“@Result”, DbType.Int32, ParameterDirection.ReturnValue, “@Result”, DataRowVersion.Default,Internalvalue);
    // Get output
    int GetResult = 0;
    // Execute Stored Procedure
    db.ExecuteNonQuery(dbCommand);
    GetResult = (int)dbCommand.GetParameterValue(“@Result”);
    switch ( GetResult )
    {
       case 0:
           Response.Write(“Record Inserted.”);
           break;
       case -1:
           Response.Write(“Record Already Found.”);
           break;
       default:
          Response.Write(“Record Not Inserted.”);
          break;
    }
 }
 catch (Exception ex)
 {
    Response.Write(ex.ToString());
 }
5]. Example with Tansactions

   Database db = DatabaseFactory.CreateDatabase();
  
   //Two operations, one to add the order and another to add order details
   string sqlCommand = “InsertOrder”;
   DbCommand orderCommand = db.GetStoredProcCommand(sqlCommand);
   //Add InsertOrder parameters
  
   sqlCommand = “InsertOrderDetails”;
   DbCommand orderDetailsCommand = db.GetStoredProcCommand(sqlCommand);
   //Add InsertOrderDetails parameters

   using (DbConnection connection = db.CreateConnection())
   {
     connection.Open();
     DbTransaction transaction = connection.BeginTransaction();
     try
     {
       //Execute the InsertOrder
       db.ExecuteNonQuery(orderCommand, transaction);
       //Execute the InsertOrderDetails   
       db.ExecuteNonQuery( orderDetailsCommand, transaction);
       //Commit the transaction
       transaction.Commit();                   
     }
     catch
     {
       //Roll back the transaction.
       transaction.Rollback();
     }
   } 

6]. Retrieve a Single Field
 
 CREATE PROCEDURE [dbo].[GetCustomerSingleColumn]
 (
    @CustomerID NCHAR(5)
 )
 AS
 SET NOCOUNT ON
    SELECT
       [CompanyName]
    FROM
       [Customers]
    WHERE
       [CustomerID] LIKE @CustomerID
 GO
The C# code used to execute the above stored procedure is as follows:
 try
 {
    // Create DataBase Instance
    Database db = DatabaseFactory.CreateDatabase();
    // Initialize the Stored Procedure
    DBCommand dbCommand = db.GetStoredProcCommand(“GetCustomerSingleColumn”);
    dbCommand.AddInParameter(“@CustomerID”, DbType.String, “ALFKI”);
    //Execute the stored procedure
    string GetCompanyName = (string) db.ExecuteScalar(dbCommandWrapper);
    //Display results of the query
    string results = string.Format(“Company Name : {0}”,GetCompanyName);
    Response.Write(results);
 }
 catch (Exception ex)
 {
    Response.Write(ex.ToString());
 }

Search following text in Google you can find lots of articles about it 
” how to get the return value from store procedure in application data block dbcommand “

Happy Programming !!!!

http://microsoft.apress.com/asptodayarchive/72141/using-the-calendar-control

Thank you for andreacol.net/blog

In this article I want to show 3 different ways to deal with long running tasks in Asp.net.
If such a task must be initiated from an Asp.net web page, the thread that is serving the page request is bound to the task until it completes or a timeout occurs. Asp.net and .net framework offer different ways to address this issue, in the project used for this article, a sample page attempts to star a long running task in three different ways:

1. Synchronously simply starting the task and waiting for its completion
2. Asynchronously, using Page.RegisterAsyncTask and other features
3. Asynchronously, using asynchronous delegates

Each of these options have pro and cons, and fit in different scenarios, but also these options don’t require to include the Async=”true” attribute in the page’s @ Page directive.

The first option entails to keep busy the thread that is serving the request, until the task completes. This could be a bottleneck, especially if multiple users start multiple tasks. This condition will probably end up to a 503 “Server Unavailable” error.

It’s advisable to start a new thread that will perform the task, allowing the first thread to return in the thread pool and stand-by to serve a new incoming request.
To reach our goal, no modifications are required to the actual codebase that is in charge to execute the task. In the second option we are going to use a Page’s method that first registers an async task, passing three different event handlers: one to begin/launch the task, one to manage its completion and the last one used to recover from a timeout that may occur during the task execution.
This option also uses IAsyncResult interface described here, but no extra coding is needed to use it, take a look to the code sample.
The SimpleWorker class, exposes one method that simulates a long running operation but it only writes a text lines into a log file and waits one second per each line. Imagine an orders fulfillment procedure that creates packing lists and send an email to customers indicating that their orders are “approved”.

   1: PageAsyncTask task = new PageAsyncTask(OnBegin, OnEnd, OnTimeout, null);
   2: Page.RegisterAsyncTask(task);
   3: 
   4: TraceStatusInfo("TEST CASE #2: Start a long running task asynchronously using PageAsyncTask.");
   5: 
   6: //Setting up a 5 secs timeout
   7: Page.AsyncTimeout = new TimeSpan(0, 0, 5);
   8: 
   9: TraceStatusInfo("Starting task");
  10: 
  11: Page.ExecuteRegisteredAsyncTasks();

Whether such a procedure could be started from an Asp.net page, is a good practice to maintain an activity registry or log, because the web application could be suddenly stopped without any warning and the worker process may be recycled due to an excessive, unexpected resource consumption.

The third option is the simplest one, it just uses an asynchronous delegate to start the task before sending the response to the client. When the client browser renders the page after the postback, the task is still running into another thread on the server and the original thread, that initially served the request, is now free and returned in the thread pool. You could look at the ThreadID into the SimpleWorker’s log file and compare the server time when logging entries were added.

1: TraceStatusInfo(“TEST CASE #3: Start a long running task asynchronously using an asynchronous delegate.”);
2: SimpleWorker w=new SimpleWorker();
3: atd2 = new AsyncTaskDelegate(w.DoWork);
4: 
5: TraceStatusInfo(“Starting task”);
6: 
7: atd2.BeginInvoke(int.Parse(txtUnits.Text), null, null);
8: 
9: litStatus.Text = “Test #3 completed.”;

The difference between the two last approaches, is on the fact that the former can get the task result as it completes and inform the user, the latter must poll the server to see what had happened, this should not be an issue for some scenarios, however an Ajax script could periodically hit the server querying an activity registry, like a table or a file, until the task is successfully completed. The second option could also benefit of the timeout handler, the third option instead is best suited for fire and forget tasks.

Here is a snapshot of the log file in which you can see that TreadID changes when an async task is executed in tests cases #2 and 3#.

http://aspalliance.com/1680_Building_ASPNET_Web_Server_Controls_using_XML_and_XSLT.all

http://codebetter.com/blogs/brendan.tompkins/archive/2006/06/27/146875.aspx

http://mgrzyb.blogspot.com/search?updated-min=2007-01-01T00%3A00%3A00%2B01%3A00&updated-max=2008-01-01T00%3A00%3A00%2B01%3A00&max-results=1

http://davestechshop.net/archive/2006/09/21/FormsAuthCookiesAndSubdomainNames2.aspx

http://encosia.com/2007/10/24/are-you-making-these-3-common-aspnet-ajax-mistakes/

http://www.sqlnetframework.com/Articles/GoogleDataPager.aspx

protected

void Button1_PreRender(object sender, EventArgs e)

{

string doubleSubmitScript = String.Format(@”if (typeof(Page_ClientValidate) == ‘function’) {{

if (!Page_ClientValidate()) {{ return false; }}

}}

this.value = ‘Please wait…’;

this.disabled = true;

{0};”

, ClientScript.GetPostBackEventReference(BeginButton, String.Empty));

Button1.OnClientClick = doubleSubmitScript;

}

Than’s to Miron 

The Update Panel response contain the new html for the specific location that needs to be update and the complete new ViewState for the whole page. So, one more thing we can to optimize the UpdatePanel is to compress the ViewState before it been sent to the client. We don’t need to do it in normal response because we use (or should use) a compression module that compress all the page response and that includes the ViewState. Compress the ViewState can save you some more KB from the async response. Another option is to save the ViewState in the server (file os session), and not send it at all. To compress the ViewState we needs to override the ‘LoadPageStateFromPersistenceMedium’ and the ‘SavePageStateToPersistenceMedium’ methods that load and save the view state.

Here is the code how to compress the ViewState for the UpdatePanel response only, just copy it to your base page:

Don’t run production ASP.NET Applications with debug=”true” enabled

One of the things you want to avoid when deploying an ASP.NET application into production is to accidentally (or deliberately) leave the <compilation debug=”true”/> switch on within the application’s web.config file.

Doing so causes a number of non-optimal things to happen including:

1) The compilation of ASP.NET pages takes longer (since some batch optimizations are disabled)

2) Code can execute slower (since some additional debug paths are enabled)

3) Much more memory is used within the application at runtime

4) Scripts and images downloaded from the WebResources.axd handler are not cached

You can see the full article by clicking following links

http://weblogs.asp.net/scottgu/archive/2006/04/11/442448.aspx