There is a performance hit associated with using exceptions!

alessandro — Sun, 30 Sep 2007 15:36:00 GMT

I am a bit annoyed by the fact that the IDataReader interface does not force an implementation that checks to see if the column you are accessing is indeed null or not(if the column is absent or available in the collection).
Basically what will happen when you do eventually try to access a column that does not exist is that the underlying DataReader or DataRow will throw an exception of type "System.ArgumentException" and kindly display one of the most descriptive error messages, "Column 'columnWhatever' does not belong to table".

This is fine, thanks, but a try/catch is a bit expensive in a loop where you are pulling values from your underlying DataReader or DataRowCollection, specifically you will start to feel it when you have 1000's of rows. What wouldof been nice is if it were possible to test for null before accessing the value in the column. Ofcourse a test for null will again throw the exception. Could we have used the TryParse methods of the value types we are expecting from the column ? Yes, we can try this, but the exception will be thrown regardless because TryParse wont get a chance to evaluate the expression since the error will be thrown before this happens, not to mention that not all value types have a TryParse method so this is also useless in this case.

So, in what situation could one have a column that does not exist or why does the column exist based on certain conditions ? Well, what if you have a query returning a resultset from the product of an outer join. As you all know already, while an inner join eliminates the rows that do not match with a row from the other table, an outer join, however, will return all rows from at least one of the tables or views mentioned in the FROM clause, as long as those rows meet any WHERE or HAVING search conditions. This means if i have an outer join, the columns returned could be a variable number of columns, depending on my search condition, either columns from both tables or from one are returned.

Update October, 5th, 2007 : Joe has caught a mistake in my above example situation of an outer join i have used to build my case. He's right to think that I couldof easily resolved checking the column against dbnull. I have left a small comment below, please do read it. The outer join example i speak about above is not valid anymore so please do ignore it. Thanks joe!

How bad is writing code like this to workaround the fact that you cant test for the column existance with null :

DataTable dt = CreateDataTable();
            DateTime time1 = DateTime.Now;
            foreach (DataRow dr in dt.Rows)
            {
                int column1 = (int)dr["column1"];
                int column2 = -1;
                try
                {
                    // not existant column. 
                    // Sometimes we have a column2, sometimes we dont.
                    column2 = (int)dr["column2"];
                }
                catch { }// eat up the exception. :-)
            }

I've always thought that try blocks when used in this manner were effecient and
didnt have the overhead and always was of the thinking that only* once an
exception is thrown, the process of finding the handler and unwinding the stack can be expensive, so to speak.
Yes, we could of done it a bit better like the following example code instead :

DataTable dt = CreateDataTable();
            DateTime time1 = DateTime.Now;
            bool hasColumn2 = dt.Columns.Contains("column2");
            foreach (DataRow dr in dt.Rows)
            {
                int column1 = (int)dr["column1"];
                int column2 = -1;
                if (hasColumn2)
                {
                    // not existant column. 
                    // Sometimes we have a column2, sometimes we dont.
                    column2 = (int)dr["column2"];
                }
                
            }

Since this is just my theory, I've decided to experiment and findout and here,
man oh man, what a surprise. It's much much better to search if the column
exists before looping through the recordset than actually using a try or a
try/catch block! Not only was the try block an overhead, but a try without a
catch block showed to have more overhead than a complete try/catch block!
wooohoo wouldof guessed :-)

And i picked this up from one of microsofts application that in my opinion was
one of the most advanced shared source applications written by ms and the
community at large! Well, I guess not everybody is perfect and they probably
werent returning 1000's of rows so on a 2 - 10 row basis this really didnt effect
or show any signs of performance degradation.

The moral of this traggic findings for me is simple. "There is a performance
hit associated with using exceptions."

Documentation on msdn states :
Exceptions

Some restrictions are introduced when using try blocks that inhibit the
compiler from performing certain optimizations. On x86 platforms there is
additional performance degradation from try blocks due to additional state
information that must be generated during code execution. On the 64-bit
platforms, try blocks do not degrade performance as much, but once an exception
is thrown, the process of finding the handler and unwinding the stack can be
expensive.
Therefore, it is recommended to avoid introducing try/catch blocks
into code that does not really need it. If you must use exceptions, use
synchronous exceptions if possible. For more information, see Structured
Exception Handling.
Lastly, throw exceptions for exceptional cases only.
Using exceptions for general control flow will likely make performance
suffer.

For simplicity, i have chosen to use a DataTable and access DataRows Vs using a DataReader. ASP.NET version 2.0 allows you to register multiple tasks to a page and run them asynchronously prior to rendering the page. I have always wanted to test this feature out and never found an occassion. This experiment has given me that opportunity. Below is the code i have used for testing performance and below it you will find the results.

<%@ Page Language="C#" Async="false" AsyncTimeout="2000" %>

<%@ Import Namespace="System.Data" %>
<%@ Import Namespace="System.Threading" %>
<%@ Import Namespace="System.Collections.Generic" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<script runat="server">

    protected void Page_Load(object sender, EventArgs e)
    {
        // Define the asynchronuous task
        SlowTask slowTask1 = new SlowTask(TaskType.TryBlock);
        SlowTask slowTask2 = new SlowTask(TaskType.TryCatchBlock);
        SlowTask slowTask3 = new SlowTask(TaskType.VerifyDataTableColumn);
        SlowTask slowTask4 = new SlowTask(TaskType.NormalDataTable);
        SlowTask slowTask5 = new SlowTask(TaskType.TryBlock2);
        SlowTask slowTask6 = new SlowTask(TaskType.TryCatchBlock2);
        
        bool executeInParallel = false;// lets make them execute sequentially, one after the other

        PageAsyncTask asyncTask1 = new PageAsyncTask(slowTask1.OnBegin, slowTask1.OnEnd, slowTask1.OnTimeout, "With Try block : ", executeInParallel);
        PageAsyncTask asyncTask2 = new PageAsyncTask(slowTask2.OnBegin, slowTask2.OnEnd, slowTask2.OnTimeout, "With Try/Catch block : ", executeInParallel);
        PageAsyncTask asyncTask3 = new PageAsyncTask(slowTask3.OnBegin, slowTask3.OnEnd, slowTask3.OnTimeout, "Verifying column existance : ", executeInParallel);
        PageAsyncTask asyncTask4 = new PageAsyncTask(slowTask4.OnBegin, slowTask4.OnEnd, slowTask4.OnTimeout, "Without any Try/Catch blocks : ", executeInParallel);
        PageAsyncTask asyncTask5 = new PageAsyncTask(slowTask5.OnBegin, slowTask5.OnEnd, slowTask5.OnTimeout, "With Try block2 : ", executeInParallel);
        PageAsyncTask asyncTask6 = new PageAsyncTask(slowTask6.OnBegin, slowTask6.OnEnd, slowTask6.OnTimeout, "With Try/Catch block2 : ", executeInParallel);

        // Register the asynchronous task.

        Page.RegisterAsyncTask(asyncTask1);
        Page.RegisterAsyncTask(asyncTask2);
        Page.RegisterAsyncTask(asyncTask3);
        
        Page.RegisterAsyncTask(asyncTask4);
        Page.RegisterAsyncTask(asyncTask5);
        Page.RegisterAsyncTask(asyncTask6);
        // Execute the register asynchronous task.
        Page.ExecuteRegisteredAsyncTasks();
        TaskMessage.InnerHtml = slowTask1.GetAsyncTaskProgress() + "<br />" +
                                slowTask2.GetAsyncTaskProgress() + "<br />" +
                                slowTask3.GetAsyncTaskProgress() + "<br />" +
                                slowTask4.GetAsyncTaskProgress() + "<br />" +
                                slowTask5.GetAsyncTaskProgress() + "<br />" +
                                slowTask6.GetAsyncTaskProgress();  


    }

    


</script>

<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
    <title>Untitled Page</title>
</head>

<body>
    <form id="form1" runat="server">
    <div>
      <span id="TaskMessage" runat=server>

      </span>
    </div>
    </form>
</body>
</html>


using System;

using System.Web;
using System.Web.UI;
using System.Threading;
using System.Data;

    public enum TaskType
    {
        TryBlock,
        TryCatchBlock,
        VerifyDataTableColumn,
        TryBlock2,
        TryCatchBlock2,
        NormalDataTable
    }

    public class SlowTask
    {
        public SlowTask(TaskType tt)
        {
            taskValue = tt;
        }
        private String _taskprogress;
        private AsyncTaskDelegate _dlgt;

        private TaskType taskValue;

        public TaskType Task
        {
            get { return taskValue; }
            set { taskValue = value; }
        }
        // Create delegate.

        protected delegate void AsyncTaskDelegate(TaskType tt);

        public String GetAsyncTaskProgress()
        {
            return _taskprogress;
        }

        public void ExecuteAsyncTask(TaskType tt)
        {
            // Introduce an artificial delay to simulate a delayed 

            // asynchronous task.
            switch (tt)
            {
                case TaskType.TryBlock:
                    TryBlock();
                    break;
                case TaskType.TryCatchBlock:
                    TryCatchBlock();
                    break;
                case TaskType.VerifyDataTableColumn:
                    VerifyDataTableColumn();
                    break;
                case TaskType.TryBlock2:
                    TryBlock2();
                    break;
                case TaskType.TryCatchBlock2:
                    TryCatchBlock2();
                    break;
                case TaskType.NormalDataTable:
                    NormalDataTable();
                    break;
            }
        }

        // Define the method that will get called to

        // start the asynchronous task.
        public IAsyncResult OnBegin(object sender, EventArgs e,
            AsyncCallback cb, object extraData)
        {
            _taskprogress = string.Format("<br />{0} started at: {1}" , extraData.ToString(), DateTime.Now);

            _dlgt = new AsyncTaskDelegate(ExecuteAsyncTask);
            extraData = DateTime.Now;
            IAsyncResult result = _dlgt.BeginInvoke(Task, cb, extraData);

            return result;
        }

        // Define the method that will get called when

        // the asynchronous task is ended.
        public void OnEnd(IAsyncResult ar)
        {
            TimeSpan ts = DateTime.Now.Subtract((DateTime)ar.AsyncState);
            _taskprogress += string.Format("<br />Operation took exactly : {1} milliseconds", ar.AsyncState.ToString(),  ts.TotalMilliseconds);
            _dlgt.EndInvoke(ar);
        }

        // Define the method that will get called if the task
        // is not completed within the asynchronous timeout interval.

        public void OnTimeout(IAsyncResult ar)
        {
            _taskprogress += "AsyncTask failed to complete " +
                "because it exceeded the AsyncTimeout parameter.";
        }

        /// <summary>
        /// Operation took exactly : 4562.5 milliseconds

        /// This try block that eats up the exception took longer
        /// than the try/catch block that was actually catching the exception!
        /// </summary>
        private void TryBlock()
        {
            DataTable dt = CreateDataTable();
            DateTime time1 = DateTime.Now;
            foreach (DataRow dr in dt.Rows)
            {
                int column1 = (int)dr["column1"];
                int column2 = -1;
                try

                {
                    // not existant column. 
                    // Sometimes we have a column2, sometimes we dont.
                    column2 = (int)dr["column2"];
                }
                catch { }// eat up the exception. :-)

            }
        }

        /// <summary>
        /// Operation took exactly : 4468.75 milliseconds
        /// This is a try/catch block that catches the 
        /// exception being thrown by the DataRow,
        /// when the column is not found!

        /// </summary>
        private void TryCatchBlock()
        {
            DataTable dt = CreateDataTable();
            DateTime time1 = DateTime.Now;
            foreach (DataRow dr in dt.Rows)
            {
                int column1 = (int)dr["column1"];
                int column2 = -1;
                try

                {
                    // not existant column. 
                    // Sometimes we have a column2, sometimes we dont.
                    column2 = (int)dr["column2"];
                }
                catch (System.ArgumentException) { }// System.ArgumentException :-)

            }
        }

        /// <summary>
        /// Operation took exactly : 421.875 milliseconds
        /// This is the fastest, when you have a column
        /// that might not exist, and need to check for the 
        /// existance of the column, before accesing it.

        /// This can be done once outside the loop. 
        /// And is more efficient than the above
        /// two methods, simply because there is
        /// no exception being thrown here.
        /// </summary>
        private void VerifyDataTableColumn()
        {
            DataTable dt = CreateDataTable();
            DateTime time1 = DateTime.Now;
            bool hasColumn2 = dt.Columns.Contains("column2");
            foreach (DataRow dr in dt.Rows)
            {
                int column1 = (int)dr["column1"];
                int column2 = -1;
                if (hasColumn2)
                {
                    // not existant column. 

                    // Sometimes we have a column2, sometimes we dont.
                    column2 = (int)dr["column2"];
                }
                
            }
        }

        /// <summary>
        /// Operation took exactly : 375 milliseconds
        /// This is the fastest, since we dont have

        /// columns that might not exist and do not
        /// check for this either! The differences btw
        /// this and the above are superficial.
        /// </summary>
        private void NormalDataTable()
        {
            DataTable dt = CreateDataTable();
            DateTime time1 = DateTime.Now;
            foreach (DataRow dr in dt.Rows)
            {
                int column1 = (int)dr["column1"];
            }
        }
        DataTable CreateDataTable()
        {
            DataTable dt = new DataTable();
            DataRow dr;

            dt.Columns.Add(new DataColumn("column1", typeof(Int32)));
            for (int i = 0; i < 100000; i++)
            {
                dr = dt.NewRow();
                dr[0] = i;
                dt.Rows.Add(dr);
            }

            return dt;
        }

        /// <summary>

        /// Operation took exactly : 6390.625 milliseconds
        /// This is just a generic try without the catch.
        /// </summary>
        public void TryBlock2()
        {
            for (int i = 0; i < 100000; i++)
            {
                object x = "not an int";
                int a = 0;
                try

                {
                    a = (int)x;
                }
                catch { }
            }
        }

        /// <summary>
        /// Operation took exactly : 6250 milliseconds
        /// This is a simple try/catch that is actually catching an
        /// exception. It executes faster than the above that 

        /// eats up the exception! What a revelation :-)
        /// </summary>
        public void TryCatchBlock2()
        {
            for (int i = 0; i < 100000; i++)
            {
                object x = "not an int";
                int a = 0;
                try

                {
                    a = (int)x;
                }
                catch (System.InvalidCastException e)
                {
                   //
                }
            }
        }
    }




------------------------------
These are my results on a 32bit AMD Opteron processor and 1.5gb ram
-------------------------------

With Try block in DataRowCollection : started at: 12/12/2006 8:02:55 AM
Operation took exactly : 4562.5 milliseconds

With Try/Catch block in DataRowCollection: started at: 12/12/2006 8:02:59 AM
Operation took exactly : 4468.75 milliseconds

Verifying column existance in DataRowCollection: started at: 12/12/2006 8:03:04 AM
Operation took exactly : 421.875 milliseconds

Without any Try/Catch blocks in DataRowCollection: started at: 12/12/2006 8:03:04 AM
Operation took exactly : 375 milliseconds

Simple Try block2 : started at: 12/12/2006 8:03:05 AM
Operation took exactly : 6390.625 milliseconds

Simple Try/Catch block2 : started at: 12/12/2006 8:03:11 AM
Operation took exactly : 6250 milliseconds

Alessandro Zifiglio : RegisterAsyncTask

There is a performance hit associated with using exceptions!