LINQ

WAR between Entity Framework Vs LINQ to SQL

Pedro Rainho — Thu, 04 Dec 2008 11:50:13 GMT

Since the day that ADO.Net team proudly announced "We’re making significant investments in the Entity Framework such that as of .NET 4.0 the Entity Framework will be our recommended data access solution for LINQ to relational scenarios. We are listening to customers regarding LINQ to SQL and will continue to evolve the product based on feedback we receive from the community as well."., In other words LINQ to SQL will be terminated, that we are facing a WAR between these two technologies.

My opinion one of then, LINQ to SQL or Entity Framework, should not been released ever. Only one should be released or a mix of them, not both.

Since the WAR was not prevented, and we (developers) are in battle field (choosing between technologies), we will see who is going win, and my vote goes to LINQ to SQL.

Since that day that I read:

It’s not LINQ to SQL that should be terminated it’s Entity Framework.
Both should terminated and should appear a mix between both having the pros between both and solving the cons.
Finally others are suggesting that LINQ to SQL should be open source and should be maintain by the community.

Who will win this battle???

A question that I love to see the answer before the release of .Net4.0…

Very worrying article…Is LINQ to SQL Truly Dead

Pedro Rainho — Mon, 03 Nov 2008 06:58:32 GMT

Recently I had received an email from a friend about LINQ to SQL. The name of the article is :

Is LINQ to SQL Truly Dead?

And it makes me think, if MS releases a technology such as LINQ to SQL a few months ago and now they start thinking in deprecate that technology just because they have Entity Framework and LINQ to ENTITIES… I’m wondering in what could happen with technologies such as WCF or WF.

My question to them is WHAT ARE YOU THINKING?????? If the technology is released and then is deprecated why did you release it?????

In the end of the article there is a line that says:

“So there you have it; over the long run LINQ to SQL and LINQ to Entities will merge. In the mean time, development work on LINQ to SQL will not end entirely.”

I hope they never merge…

One other thing companies invest TIME, MONEY, STUDDING MS technologies and then those technologies are used to develop products, think about it…

ADO.net Vs Linq to SQL - Conclusion

Pedro Rainho — Fri, 11 Jul 2008 15:36:47 GMT

A few days ago I posted some tests comparing ADO.Net and Linq to SQL. As expected Linq to SQL is worst that ADO.Net, but as could be seen in some tests the values were very approximated.

In one of the post I had received a comment saying that I should do this:

IEnumerable<PerformanceTestTable> resultQuery = (from p in db.PerformanceTestTables
select p).ToList();

instead of this:

IQueryable<PerformanceTestTable> resultQuery = from p in db.PerformanceTestTables
select p;

and that "Using ToList (or any of the four extensions which call GetEnumerator), will force LINQ to get all the records at once. You should see a performance gain after adding ToList()."

I had done the tests and most are best using ToList(). This was the results:

Direct Single Select

previous test results

ADO.Net	ADO.Net	Linq to SQL	Linq to SQL
AVERAGE	MEDIAN	AVERAGE	MEDIAN
469,8076	466	2747,09	2710

ToList() test results

ADO.Net	ADO.Net	Linq to SQL	Linq to SQL
AVERAGE	MEDIAN	AVERAGE	MEDIAN
469,8076	466	2759,952	2719

Direct Select All

previous test results

ADO.Net	ADO.Net	Linq to SQL	Linq to SQL
AVERAGE	MEDIAN	AVERAGE	MEDIAN
2788,928	2733	5476,776	5494

ToList() test results

ADO.Net	ADO.Net	Linq to SQL	Linq to SQL
AVERAGE	MEDIAN	AVERAGE	MEDIAN
2788,928	2733	5250,138	5112

Direct Select All

previous test results

ADO.Net	ADO.Net	Linq to SQL	Linq to SQL
AVERAGE	MEDIAN	AVERAGE	MEDIAN
964660,4	960886	1719343	1716473

ToList() test results

ADO.Net	ADO.Net	Linq to SQL	Linq to SQL
AVERAGE	MEDIAN	AVERAGE	MEDIAN
964660,4	960886	1710777	1713680

Another test that I had done lately in order to understand why I get such different results using Linq to SQL I was able to see that the object DataContext takes lot's of ticks just to be initialized.

AVERAGE	MEDIAN
147,1824	137

One other conclusion that I had take from these tests was that if I want to get similar result, between ADO.Net and Linq to SQL, I had to use Store Procedures.

ADO.net Vs Linq to SQL - Part 5

Pedro Rainho — Wed, 02 Jul 2008 11:27:18 GMT

The second category that I tested was the batch execution.

The tests I had done for batch execution were:

Insert Batch
Update Batch
Delete Batch

Insert Batch

for the insert batch test I had done the following code:

ADO.net

public static double DirectBatchInsert(int numberTimes)
{
    string connection = ConfigurationManager.ConnectionStrings["PerformanceTestsConnectionString"].ConnectionString;
    string date = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");

    System.Diagnostics.Stopwatch stopWatch = new System.Diagnostics.Stopwatch();
    stopWatch.Start();

    System.Data.SqlClient.SqlConnection sqlConnection = new System.Data.SqlClient.SqlConnection(connection);

    for (int i = 0; i < numberTimes; ++i)
    {
        string command = "INSERT into PerformanceTestTable (StringColumn, DateColumn)values('xxx', '" + date + "');";

        System.Data.SqlClient.SqlCommand sqlCommand = new System.Data.SqlClient.SqlCommand(command, sqlConnection);

        sqlConnection.Open();
        sqlCommand.ExecuteNonQuery();

        sqlCommand.Connection.Close();
        sqlCommand.Dispose();
    }

    stopWatch.Stop();
    return stopWatch.ElapsedTicks;
}

Linq to SQL

public static double DirectBatchInsert(int numberTimes)
{
    string connection = ConfigurationManager.ConnectionStrings["PerformanceTestsConnectionString"].ConnectionString;
    DateTime date = DateTime.Now;

    System.Diagnostics.Stopwatch stopWatch = new System.Diagnostics.Stopwatch();
    stopWatch.Start();

    using (TestsDataContext db = new TestsDataContext(connection))
    {
        for (int i = 0; i < numberTimes; ++i)
        {
            PerformanceTestTable perf = new PerformanceTestTable();
            perf.StringColumn = "xxx";
            perf.DateColumn = date;

            db.PerformanceTestTables.InsertOnSubmit(perf);
        }

        db.SubmitChanges();
    }

    stopWatch.Stop();
    return stopWatch.ElapsedTicks;
}

Results

ADO.Net	ADO.Net	Linq to SQL	Linq to SQL
AVERAGE	MEDIAN	AVERAGE	MEDIAN
1113000	1052950	1172881	1170409

Update Batch

for the update batch test I had done the following code:

ADO.net

public static double DirectBatchUpdate()
{
    string connection = ConfigurationManager.ConnectionStrings["PerformanceTestsConnectionString"].ConnectionString;

    System.Diagnostics.Stopwatch stopWatch = new System.Diagnostics.Stopwatch();
    stopWatch.Start();

    System.Data.SqlClient.SqlConnection sqlConnection = new System.Data.SqlClient.SqlConnection(connection);

    string command1 = "SELECT IntColumn , StringColumn, DateColumn from PerformanceTestTable ";
    System.Data.SqlClient.SqlCommand sqlCommand1 = new System.Data.SqlClient.SqlCommand(command1, sqlConnection);
    sqlConnection.Open();
    System.Data.SqlClient.SqlDataReader sqlDataReader = sqlCommand1.ExecuteReader();
    
    List<PerformanceTestTable> ListPerformance = new List<PerformanceTestTable>();

    while (sqlDataReader.Read())
    {
        PerformanceTestTable perf = new PerformanceTestTable();
        perf.IntColumn = sqlDataReader.GetInt32(0);
        perf.StringColumn = sqlDataReader.GetString(1);
        perf.DateColumn = sqlDataReader.GetDateTime(2);

        ListPerformance.Add(perf);
    }

    sqlDataReader.Close();
    sqlCommand1.Connection.Close();
    sqlCommand1.Dispose();

    foreach(PerformanceTestTable perf in ListPerformance)
    {
        string command = "UPDATE PerformanceTestTable set StringColumn = 'ZZZ' where IntColumn = " + perf.IntColumn + ";";

        System.Data.SqlClient.SqlCommand sqlCommand = new System.Data.SqlClient.SqlCommand(command, sqlConnection);

        sqlConnection.Open();
        sqlCommand.ExecuteNonQuery();

        sqlCommand.Connection.Close();
        sqlCommand.Dispose();
    }

    stopWatch.Stop();
    return stopWatch.ElapsedTicks;
}

Linq to SQL

public static double DirectBatchUpdate()
{
    string connection = ConfigurationManager.ConnectionStrings["PerformanceTestsConnectionString"].ConnectionString;

    System.Diagnostics.Stopwatch stopWatch = new System.Diagnostics.Stopwatch();
    stopWatch.Start();

    using (TestsDataContext db = new TestsDataContext(connection))
    {
        IQueryable<PerformanceTestTable> resultQuery = from p in db.PerformanceTestTables
                                                       select p;

        foreach (PerformanceTestTable perf in resultQuery)
        {
            perf.StringColumn = "ZZZ";
        }

        db.SubmitChanges();
    }

    stopWatch.Stop();
    return stopWatch.ElapsedTicks;
}

Results

ADO.Net	ADO.Net	Linq to SQL	Linq to SQL
AVERAGE	MEDIAN	AVERAGE	MEDIAN
231368,3	230136	1801711	1800194

Delete Batch

for the delete batch test I had done the following code:

ADO.net

public static double DirectBatchDelete()
{
    string connection = ConfigurationManager.ConnectionStrings["PerformanceTestsConnectionString"].ConnectionString;

    System.Diagnostics.Stopwatch stopWatch = new System.Diagnostics.Stopwatch();
    stopWatch.Start();

    System.Data.SqlClient.SqlConnection sqlConnection = new System.Data.SqlClient.SqlConnection(connection);

    string command1 = "SELECT IntColumn , StringColumn, DateColumn from PerformanceTestTable ";
    System.Data.SqlClient.SqlCommand sqlCommand1 = new System.Data.SqlClient.SqlCommand(command1, sqlConnection);
    sqlConnection.Open();
    System.Data.SqlClient.SqlDataReader sqlDataReader = sqlCommand1.ExecuteReader();
    
    List<PerformanceTestTable> ListPerformance = new List<PerformanceTestTable>();

    while (sqlDataReader.Read())
    {
        PerformanceTestTable perf = new PerformanceTestTable();
        perf.IntColumn = sqlDataReader.GetInt32(0);
        perf.StringColumn = sqlDataReader.GetString(1);
        perf.DateColumn = sqlDataReader.GetDateTime(2);

        ListPerformance.Add(perf);
    }
    sqlDataReader.Close();
    sqlCommand1.Connection.Close();
    sqlCommand1.Dispose();

    StringBuilder sb = new StringBuilder();
    foreach (PerformanceTestTable perf in ListPerformance)
    {
        string command = "Delete from PerformanceTestTable where IntColumn = " + perf.IntColumn + ";";

        System.Data.SqlClient.SqlCommand sqlCommand = new System.Data.SqlClient.SqlCommand(command, sqlConnection);

        sqlConnection.Open();
        sqlCommand.ExecuteNonQuery();

        sqlCommand.Connection.Close();
        sqlCommand.Dispose();
    }

    stopWatch.Stop();
    return stopWatch.ElapsedTicks;
}

Linq to SQL

public static double DirectBatchDelete()
{
    string connection = ConfigurationManager.ConnectionStrings["PerformanceTestsConnectionString"].ConnectionString;

    System.Diagnostics.Stopwatch stopWatch = new System.Diagnostics.Stopwatch();
    stopWatch.Start();

    using (TestsDataContext db = new TestsDataContext(connection))
    {
        IQueryable<PerformanceTestTable> resultQuery = from p in db.PerformanceTestTables
                                                       select p;

        db.PerformanceTestTables.DeleteAllOnSubmit(resultQuery);

        db.SubmitChanges();
    }

    stopWatch.Stop();
    return stopWatch.ElapsedTicks;
}

Results

ADO.Net	ADO.Net	Linq to SQL	Linq to SQL
AVERAGE	MEDIAN	AVERAGE	MEDIAN
964660,4	960886	1719343	1716473

In the next part I will talk about conclusions

ADO.net Vs Linq to SQL - Part 4

Pedro Rainho — Wed, 02 Jul 2008 11:19:51 GMT

The second category that I tested was the store procedure execution.

The tests I had done for store procedure execution were:

Single Select
Select All
Single Insert
Single Update
Single Delete

Single Select

for the single select test I had done the following code:

ADO.net

public static double SelectSingleViaSp()
{
    string connection = ConfigurationManager.ConnectionStrings["PerformanceTestsConnectionString"].ConnectionString;

    System.Diagnostics.Stopwatch stopWatch = new System.Diagnostics.Stopwatch();
    stopWatch.Start();

    System.Data.SqlClient.SqlConnection sqlConnection = new System.Data.SqlClient.SqlConnection(connection);

    string command = "SelectFromPerformanceTestTable";
    System.Data.SqlClient.SqlCommand sqlCommand = new System.Data.SqlClient.SqlCommand(command, sqlConnection);
    sqlCommand.CommandType = System.Data.CommandType.StoredProcedure;
    sqlConnection.Open();
    System.Data.SqlClient.SqlDataReader sqlDataReader = sqlCommand.ExecuteReader();
    int count = 0;
    int sum = 0;
    List<SelectFromPerformanceTestTableResult> ListPerformance = new List<SelectFromPerformanceTestTableResult>();

    if (sqlDataReader.Read())
    {
        SelectFromPerformanceTestTableResult perf = new SelectFromPerformanceTestTableResult();
        perf.IntColumn = sqlDataReader.GetInt32(0);
        perf.StringColumn = sqlDataReader.GetString(1);
        perf.DateColumn = sqlDataReader.GetDateTime(2);
        ListPerformance.Add(perf);
    }

    sqlDataReader.Close();
    sqlCommand.Connection.Close();
    sqlCommand.Dispose();

    foreach (SelectFromPerformanceTestTableResult perf in ListPerformance)
    {
        ++count;
        sum += perf.IntColumn;
    }

    stopWatch.Stop();
    return stopWatch.ElapsedTicks;
}

Linq to SQL

public static double SelectSingleViaSp()
{
    string connection = ConfigurationManager.ConnectionStrings["PerformanceTestsConnectionString"].ConnectionString;

    System.Diagnostics.Stopwatch stopWatch = new System.Diagnostics.Stopwatch();
    stopWatch.Start();

    int count = 0;
    int sum = 0;

    using (TestsDataContext db = new TestsDataContext(connection))
    {
        ISingleResult<SelectFromPerformanceTestTableResult> resultQuery = db.SelectFromPerformanceTestTable();

        foreach (SelectFromPerformanceTestTableResult res in resultQuery)
        {
            ++count;
            sum += res.IntColumn;
        }
    }

    stopWatch.Stop();
    return stopWatch.ElapsedTicks;
}

Results

ADO.Net	ADO.Net	Linq to SQL	Linq to SQL
AVERAGE	MEDIAN	AVERAGE	MEDIAN
478,3968	477	1621,371	1600

Select All

for the select all test I had done the following code:

ADO.net

public static double SelectAllViaSp()
{
    string connection = ConfigurationManager.ConnectionStrings["PerformanceTestsConnectionString"].ConnectionString;

    System.Diagnostics.Stopwatch stopWatch = new System.Diagnostics.Stopwatch();
    stopWatch.Start();

    System.Data.SqlClient.SqlConnection sqlConnection = new System.Data.SqlClient.SqlConnection(connection);

    string command = "SelectAllFromPerformanceTestTable";
    System.Data.SqlClient.SqlCommand sqlCommand = new System.Data.SqlClient.SqlCommand(command, sqlConnection);
    sqlCommand.CommandType = System.Data.CommandType.StoredProcedure;
    sqlConnection.Open();
    System.Data.SqlClient.SqlDataReader sqlDataReader = sqlCommand.ExecuteReader();
    int count = 0;
    int sum = 0;
    List<SelectAllFromPerformanceTestTableResult> ListPerformance = new List<SelectAllFromPerformanceTestTableResult>();

    while (sqlDataReader.Read())
    {
        SelectAllFromPerformanceTestTableResult perf = new SelectAllFromPerformanceTestTableResult();
        perf.IntColumn = sqlDataReader.GetInt32(0);
        perf.StringColumn = sqlDataReader.GetString(1);
        perf.DateColumn = sqlDataReader.GetDateTime(2);
        ListPerformance.Add(perf);
    }

    sqlDataReader.Close();
    sqlCommand.Connection.Close();
    sqlCommand.Dispose();

    foreach (SelectAllFromPerformanceTestTableResult perf in ListPerformance)
    {
        ++count;
        sum += perf.IntColumn;
    }

    stopWatch.Stop();
    return stopWatch.ElapsedTicks;
}

Linq to SQL

public static double SelectAllViaSp()
{
    string connection = ConfigurationManager.ConnectionStrings["PerformanceTestsConnectionString"].ConnectionString;

    System.Diagnostics.Stopwatch stopWatch = new System.Diagnostics.Stopwatch();
    stopWatch.Start();

    int count = 0;
    int sum = 0;

    using (TestsDataContext db = new TestsDataContext(connection))
    {
        ISingleResult<SelectAllFromPerformanceTestTableResult> resultQuery = db.SelectAllFromPerformanceTestTable();

        foreach (SelectAllFromPerformanceTestTableResult res in resultQuery)
        {
            ++count;
            sum += res.IntColumn;
        }
    }

    stopWatch.Stop();
    return stopWatch.ElapsedTicks;
}

Results

ADO.Net	ADO.Net	Linq to SQL	Linq to SQL
AVERAGE	MEDIAN	AVERAGE	MEDIAN
3615,357	3753	4368,214	4383

Single Insert

for the single insert test I had done the following code:

ADO.net

public static double InsertSingleViaSp()
{
    string connection = ConfigurationManager.ConnectionStrings["PerformanceTestsConnectionString"].ConnectionString;

    System.Diagnostics.Stopwatch stopWatch = new System.Diagnostics.Stopwatch();
    stopWatch.Start();

    System.Data.SqlClient.SqlConnection sqlConnection = new System.Data.SqlClient.SqlConnection(connection);

    string command = "InsertIntoPerformanceTestTable";
    System.Data.SqlClient.SqlCommand sqlCommand = new System.Data.SqlClient.SqlCommand(command, sqlConnection);
    sqlCommand.CommandType = System.Data.CommandType.StoredProcedure;

    sqlConnection.Open();
    sqlCommand.ExecuteNonQuery();

    sqlCommand.Connection.Close();
    sqlCommand.Dispose();

    stopWatch.Stop();
    return stopWatch.ElapsedTicks;
}

Linq to SQL

public static double InsertSingleViaSp()
{
    string connection = ConfigurationManager.ConnectionStrings["PerformanceTestsConnectionString"].ConnectionString;

    System.Diagnostics.Stopwatch stopWatch = new System.Diagnostics.Stopwatch();
    stopWatch.Start();

    using (TestsDataContext db = new TestsDataContext(connection))
    {
        db.InsertIntoPerformanceTestTable();
    }

    stopWatch.Stop();
    return stopWatch.ElapsedTicks;
}

Results

ADO.Net	ADO.Net	Linq to SQL	Linq to SQL
AVERAGE	MEDIAN	AVERAGE	MEDIAN
2657,916	1588	1955,587	1786

Single Update

for the single update test I had done the following code:

ADO.net

public static double UpdateSingleViaSp()
{
    string connection = ConfigurationManager.ConnectionStrings["PerformanceTestsConnectionString"].ConnectionString;

    System.Diagnostics.Stopwatch stopWatch = new System.Diagnostics.Stopwatch();
    stopWatch.Start();

    System.Data.SqlClient.SqlConnection sqlConnection = new System.Data.SqlClient.SqlConnection(connection);

    string command = "UpdatePerformanceTestTable";
    System.Data.SqlClient.SqlCommand sqlCommand = new System.Data.SqlClient.SqlCommand(command, sqlConnection);
    sqlCommand.CommandType = System.Data.CommandType.StoredProcedure;

    sqlConnection.Open();
    sqlCommand.ExecuteNonQuery();

    sqlCommand.Connection.Close();
    sqlCommand.Dispose();

    stopWatch.Stop();
    return stopWatch.ElapsedTicks;
}

Linq to SQL

public static double UpdateSingleViaSp()
{
    string connection = ConfigurationManager.ConnectionStrings["PerformanceTestsConnectionString"].ConnectionString;

    System.Diagnostics.Stopwatch stopWatch = new System.Diagnostics.Stopwatch();
    stopWatch.Start();

    using (TestsDataContext db = new TestsDataContext(connection))
    {
        db.UpdatePerformanceTestTable();
    }

    stopWatch.Stop();
    return stopWatch.ElapsedTicks;
}

Results

ADO.Net	ADO.Net	Linq to SQL	Linq to SQL
AVERAGE	MEDIAN	AVERAGE	MEDIAN
882,9599	890	1015,068	1004

Single Delete

for the single delete test I had done the following code:

ADO.net

public static double DeleteSingleViaSp()
{
    string connection = ConfigurationManager.ConnectionStrings["PerformanceTestsConnectionString"].ConnectionString;

    System.Diagnostics.Stopwatch stopWatch = new System.Diagnostics.Stopwatch();
    stopWatch.Start();

    System.Data.SqlClient.SqlConnection sqlConnection = new System.Data.SqlClient.SqlConnection(connection);

    string command = "DeleteFromPerformanceTestTable";
    System.Data.SqlClient.SqlCommand sqlCommand = new System.Data.SqlClient.SqlCommand(command, sqlConnection);
    sqlCommand.CommandType = System.Data.CommandType.StoredProcedure;
    
    sqlConnection.Open();
    sqlCommand.ExecuteNonQuery();

    sqlCommand.Connection.Close();
    sqlCommand.Dispose();

    stopWatch.Stop();
    return stopWatch.ElapsedTicks;
}

Linq to SQL

public static double DeleteSingleViaSp()
{
    string connection = ConfigurationManager.ConnectionStrings["PerformanceTestsConnectionString"].ConnectionString;

    System.Diagnostics.Stopwatch stopWatch = new System.Diagnostics.Stopwatch();
    stopWatch.Start();

    using (TestsDataContext db = new TestsDataContext(connection))
    {
        db.DeleteFromPerformanceTestTable();
    }

    stopWatch.Stop();
    return stopWatch.ElapsedTicks;
}

Results

ADO.Net	ADO.Net	Linq to SQL	Linq to SQL
AVERAGE	MEDIAN	AVERAGE	MEDIAN
475,7856	477	1202,613	1190

In the next part I will talk about batch execution

ADO.net Vs Linq to SQL - Part 3

Pedro Rainho — Wed, 02 Jul 2008 08:29:30 GMT

The first category that I had start testing was the direct query execution.

Direct query execution in ADO.net it's only execution a string with a query, but in Linq to SQL I had used the query notation.

So, the tests I had done for direct query execution were:

Single Select
Select All
Single Insert
Single Update
Single Delete

Single Select

for the single select test I had done the following code:

ADO.net

public static double DirectSingleSelect()
{
    string connection = ConfigurationManager.ConnectionStrings["PerformanceTestsConnectionString"].ConnectionString;

    System.Diagnostics.Stopwatch stopWatch = new System.Diagnostics.Stopwatch();
    stopWatch.Start();

    System.Data.SqlClient.SqlConnection sqlConnection = new System.Data.SqlClient.SqlConnection(connection);

    string command = "SELECT IntColumn , StringColumn, DateColumn from PerformanceTestTable where IntColumn = 1";
    System.Data.SqlClient.SqlCommand sqlCommand = new System.Data.SqlClient.SqlCommand(command, sqlConnection);
    sqlConnection.Open();
    System.Data.SqlClient.SqlDataReader sqlDataReader = sqlCommand.ExecuteReader();
    int count = 0;
    int sum = 0;
    List<PerformanceTestTable> ListPerformance = new List<PerformanceTestTable>();

    if (sqlDataReader.Read())
    {
        PerformanceTestTable perf = new PerformanceTestTable();
        perf.IntColumn = sqlDataReader.GetInt32(0);
        perf.StringColumn = sqlDataReader.GetString(1);
        perf.DateColumn = sqlDataReader.GetDateTime(2);
        ListPerformance.Add(perf);
    }

    sqlDataReader.Close();
    sqlCommand.Connection.Close();
    sqlCommand.Dispose();

    foreach (PerformanceTestTable perf in ListPerformance)
    {
        ++count;
        sum += perf.IntColumn;
    }

    stopWatch.Stop();
    return stopWatch.ElapsedTicks;
}

Linq to SQL

public static double DirectSingleSelect()
{
    string connection = ConfigurationManager.ConnectionStrings["PerformanceTestsConnectionString"].ConnectionString;

    System.Diagnostics.Stopwatch stopWatch = new System.Diagnostics.Stopwatch();
    stopWatch.Start();

    int count = 0;
    int sum = 0;

    using (TestsDataContext db = new TestsDataContext(connection))
    {
        IQueryable<PerformanceTestTable> resultQuery = from p in db.PerformanceTestTables
                                                       where p.IntColumn == 1
                                                       select p;

        foreach (PerformanceTestTable perf in resultQuery)
        {
            ++count;
            sum += perf.IntColumn;
        }
    }

    stopWatch.Stop();
    return stopWatch.ElapsedTicks;
}

As you all can see, linq test I had much less code, plus it's more simple to read, plus all the code is verified in compile time.

The other thing that can be seen is that I try to approach ADO.net to Linq to SQL, and that explains the reason why I had done this:

List<PerformanceTestTable> ListPerformance = new List<PerformanceTestTable>();

if (sqlDataReader.Read())
{
    PerformanceTestTable perf = new PerformanceTestTable();
    perf.IntColumn = sqlDataReader.GetInt32(0);
    perf.StringColumn = sqlDataReader.GetString(1);
    perf.DateColumn = sqlDataReader.GetDateTime(2);
    ListPerformance.Add(perf);
}

Because since Linq to SQL internally constructs a IEnumerable<PerformanceTestTable> as a result of the query I try the same approach in ADO.net.

Results

ADO.Net	ADO.Net	Linq to SQL	Linq to SQL
AVERAGE	MEDIAN	AVERAGE	MEDIAN
469,8076	466	2747,09	2710

as you all can see there is a big difference between ADO.Net and Linq to SQL, And in all the tests I had done I never was able to get best performance with Linq to SQL than to ADO.Net.

Select All

for the select all test I had done the following code:

ADO.net

public static double DirectSelectAll()
{
    string connection = ConfigurationManager.ConnectionStrings["PerformanceTestsConnectionString"].ConnectionString;

    System.Diagnostics.Stopwatch stopWatch = new System.Diagnostics.Stopwatch();
    stopWatch.Start();

    System.Data.SqlClient.SqlConnection sqlConnection = new System.Data.SqlClient.SqlConnection(connection);

    string command = "SELECT IntColumn , StringColumn, DateColumn from PerformanceTestTable ";
    System.Data.SqlClient.SqlCommand sqlCommand = new System.Data.SqlClient.SqlCommand(command, sqlConnection);
    sqlConnection.Open();
    System.Data.SqlClient.SqlDataReader sqlDataReader = sqlCommand.ExecuteReader();
    int count = 0;
    int sum = 0;
    List<PerformanceTestTable> ListPerformance = new List<PerformanceTestTable>();

    while (sqlDataReader.Read())
    {
        PerformanceTestTable perf = new PerformanceTestTable();
        perf.IntColumn = sqlDataReader.GetInt32(0);
        perf.StringColumn = sqlDataReader.GetString(1);
        perf.DateColumn = sqlDataReader.GetDateTime(2);

        ListPerformance.Add(perf);
    }

    sqlDataReader.Close();
    sqlCommand.Connection.Close();
    sqlCommand.Dispose();

    foreach (PerformanceTestTable perf in ListPerformance)
    {
        ++count;
        sum += perf.IntColumn;
    }

    stopWatch.Stop();

    return stopWatch.ElapsedTicks;
}

Linq to SQL

public static double DirectSelectAll()
{
    string connection = ConfigurationManager.ConnectionStrings["PerformanceTestsConnectionString"].ConnectionString;

    System.Diagnostics.Stopwatch stopWatch = new System.Diagnostics.Stopwatch();
    stopWatch.Start();

    int count = 0;
    int sum = 0;

    using (TestsDataContext db = new TestsDataContext(connection))
    {
        IQueryable<PerformanceTestTable> resultQuery = from p in db.PerformanceTestTables
                                                       select p;

        foreach(PerformanceTestTable perf in resultQuery)
        {
            ++count;
            sum += perf.IntColumn;
        }
    }

    stopWatch.Stop();
    return stopWatch.ElapsedTicks;
}

Results

ADO.Net	ADO.Net	Linq to SQL	Linq to SQL
AVERAGE	MEDIAN	AVERAGE	MEDIAN
2788,928	2733	5476,776	5494

Single Insert

for the single insert test I had done the following code:

ADO.net

public static double DirectSingleInsert()
{
    string connection = ConfigurationManager.ConnectionStrings["PerformanceTestsConnectionString"].ConnectionString;
    string date = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");

    System.Diagnostics.Stopwatch stopWatch = new System.Diagnostics.Stopwatch();
    stopWatch.Start();

    System.Data.SqlClient.SqlConnection sqlConnection = new System.Data.SqlClient.SqlConnection(connection);

    string command = "INSERT into PerformanceTestTable (StringColumn, DateColumn)values('xxx', '" + date + "')";
    System.Data.SqlClient.SqlCommand sqlCommand = new System.Data.SqlClient.SqlCommand(command, sqlConnection);

    sqlConnection.Open();
    sqlCommand.ExecuteNonQuery();

    sqlCommand.Connection.Close();
    sqlCommand.Dispose();

    stopWatch.Stop();
    return stopWatch.ElapsedTicks;
}

Linq to SQL

public static double DirectSingleInsert()
{
    string connection = ConfigurationManager.ConnectionStrings["PerformanceTestsConnectionString"].ConnectionString;
    DateTime date = DateTime.Now;

    System.Diagnostics.Stopwatch stopWatch = new System.Diagnostics.Stopwatch();
    stopWatch.Start();

    using (TestsDataContext db = new TestsDataContext(connection))
    {
        PerformanceTestTable perf = new PerformanceTestTable();
        perf.StringColumn = "xxx";
        perf.DateColumn = date;

        db.PerformanceTestTables.InsertOnSubmit(perf);
        db.SubmitChanges();
    }

    stopWatch.Stop();
    return stopWatch.ElapsedTicks;
}

Results

ADO.Net	ADO.Net	Linq to SQL	Linq to SQL
AVERAGE	MEDIAN	AVERAGE	MEDIAN
1985,573	2126	4389,587	4196

Single Update

for the single update test I had done the following code:

ADO.net

public static double DirectSingleUpdate()
{
    string connection = ConfigurationManager.ConnectionStrings["PerformanceTestsConnectionString"].ConnectionString;

    System.Diagnostics.Stopwatch stopWatch = new System.Diagnostics.Stopwatch();
    stopWatch.Start();

    System.Data.SqlClient.SqlConnection sqlConnection = new System.Data.SqlClient.SqlConnection(connection);

    string command = "UPDATE PerformanceTestTable set StringColumn = 'ZZZ' where IntColumn = 1";
    System.Data.SqlClient.SqlCommand sqlCommand = new System.Data.SqlClient.SqlCommand(command, sqlConnection);

    sqlConnection.Open();
    sqlCommand.ExecuteNonQuery();

    sqlCommand.Connection.Close();
    sqlCommand.Dispose();

    stopWatch.Stop();
    return stopWatch.ElapsedTicks;
}

Linq to SQL

public static double DirectSingleUpdate()
{
    string connection = ConfigurationManager.ConnectionStrings["PerformanceTestsConnectionString"].ConnectionString;

    System.Diagnostics.Stopwatch stopWatch = new System.Diagnostics.Stopwatch();
    stopWatch.Start();

    using (TestsDataContext db = new TestsDataContext(connection))
    {
        PerformanceTestTable perf = (from p in db.PerformanceTestTables
                                     where p.IntColumn == 1
                                     select p).SingleOrDefault();

        perf.StringColumn = "ZZZ";

        db.SubmitChanges();
    }

    stopWatch.Stop();
    return stopWatch.ElapsedTicks;
}

Results

ADO.Net	ADO.Net	Linq to SQL	Linq to SQL
AVERAGE	MEDIAN	AVERAGE	MEDIAN
521,4088	535	7249,539	7126

Single Delete

for the single delete test I had done the following code:

ADO.net

public static double DirectSingleDelete(int deleteId)
{
    string connection = ConfigurationManager.ConnectionStrings["PerformanceTestsConnectionString"].ConnectionString;

    System.Diagnostics.Stopwatch stopWatch = new System.Diagnostics.Stopwatch();
    stopWatch.Start();

    System.Data.SqlClient.SqlConnection sqlConnection = new System.Data.SqlClient.SqlConnection(connection);

    string command = "Delete from PerformanceTestTable where IntColumn = " + deleteId;
    System.Data.SqlClient.SqlCommand sqlCommand = new System.Data.SqlClient.SqlCommand(command, sqlConnection);

    sqlConnection.Open();
    sqlCommand.ExecuteNonQuery();

    sqlCommand.Connection.Close();
    sqlCommand.Dispose();

    stopWatch.Stop();
    return stopWatch.ElapsedTicks;
}

Linq to SQL

public static double DirectSingleDelete(int deleteId)
{
    string connection = ConfigurationManager.ConnectionStrings["PerformanceTestsConnectionString"].ConnectionString;

    System.Diagnostics.Stopwatch stopWatch = new System.Diagnostics.Stopwatch();
    stopWatch.Start();

    using (TestsDataContext db = new TestsDataContext(connection))
    {
        PerformanceTestTable perf = (from p in db.PerformanceTestTables
                                     where p.IntColumn == deleteId
                                     select p).SingleOrDefault();

        db.PerformanceTestTables.DeleteOnSubmit(perf);

        db.SubmitChanges();
    }

    stopWatch.Stop();
    return stopWatch.ElapsedTicks;
}

Results

ADO.Net	ADO.Net	Linq to SQL	Linq to SQL
AVERAGE	MEDIAN	AVERAGE	MEDIAN
1672,389	1654	11409,34	10835

As you all can see Linq to SQL is always more slow that ADO.Net, nothing that I wasn't expecting, but I never thought the difference would be so much :(

In the next part I will talk about Store procedure execution

ADO.net Vs Linq to SQL - Part 2

Pedro Rainho — Wed, 02 Jul 2008 07:56:39 GMT

To measure performance I used the class System.Diagnostics.Stopwatch that was introduced with Dot.Net 2.0.

"The Stopwatch class assists the manipulation of timing-related performance counters within managed code"

I could use kernel function QueryPerformanceCounter and QueryPerformanceFrequency but I has decided to used this managed class Stopwatch.

In Stopwatch class I had used properties ElapsedMilliseconds and ElapsedTicks and I had also used Start method and Stop method.

The first property ElapsedMilliseconds was soon abandoned by me because in some tests the result was zero. If I want to measure anything and the result is zero it's kind a strange :|.

So I started only using ElapsedTicks and if I want the value in milliseconds I only had to do ElapsedTicks / Frequency / 1000d and I get the value in milliseconds.

So in all my tests and in the charts the value that appear is always in Ticks.

In next part I will start talking about my tests

ADO.net Vs Linq to SQL - Part 1

Pedro Rainho — Wed, 02 Jul 2008 07:42:16 GMT

First of all I love Linq.

And ever since I started using Linq to SQL that I want to do some tests comparing the old ADO.net and Linq to SQL, and finally I had some free time this weekend so I did it.

For doing the tests I had:

Create a Database
Create a Table named "PerformanceTestTable"
Create 3 columns
- IntColumn
- StringColumn
- DateColumn

CREATE TABLE [dbo].[PerformanceTestTable](
    [IntColumn] [int] IDENTITY(1,1) NOT NULL,
    [StringColumn] [nchar](10) NOT NULL,
    [DateColumn] [datetime] NOT NULL,
 CONSTRAINT [PK_PerformanceTestTable] PRIMARY KEY CLUSTERED 
(
    [IntColumn] ASC
)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
) ON [PRIMARY]

Now, for every test I had done the following:

Every test started from a initial condition
- This initial condition is a reset in the table (delete all records and insert 500 test records)
Repeat every test 500 times
Every test using ADO.net has a similar test in Linq to SQL

For reset the table I had done this procedure

CREATE PROCEDURE ResetPerformanceTestTable AS
BEGIN
    SET NOCOUNT ON;
    delete from PerformanceTestTable
    
    DBCC CHECKIDENT (PerformanceTestTable, reseed, 0)

INSERT into PerformanceTestTable (StringColumn, DateColumn)values('aaa', getdate())

...

500 times

...

END
GO

The tests I had done were divided in tree categories:

Direct query execution
Store Procedure Executing
Batch execution

In the next part I will be talking about what I had used for measure performance

xmlns:xsi with Linq to XML

Pedro Rainho — Fri, 30 May 2008 07:54:53 GMT

If someone needs to add a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" to a xml element using Linq to XML all you have to do is something like this

XNamespace xsi = "http://www.w3.org/2001/XMLSchema-instance";
XDocument doc = new XDocument(
    new XElement("Root",
        new XAttribute(XNamespace.Xmlns + "xsi", xsi)));

maybe it's not very intuitive but works :)

Last book I read

Pedro Rainho — Tue, 27 May 2008 20:32:37 GMT

This month I haven't write much here in the blog, so I will talk a little about the last book I read. The book name is "Pro Linq Language Integrated Query in C# 2008", it's from the publisher APRESS and the author is Joseph Rattz Jr. The book is available here.

My opinion is simple, I love the book. It's a good book to start and a good book to consult when I have some problem to resolve.

The book starts covering the new C# 3.0 language additions, in my opinion this is essential to start using Linq, and covers Linq to objects, Linq to XML, Linq to Dataset and Linq to SQL.

The book in general is very good and don't fool your self with the name "Pro Linq...." because I recommend the book to every one that wants to start using Linq. This is a simple book to read and has lots of samples well commented that explains most of the extension methods used in queries.

This is another benefit of this book is that explains how to use Dot Notation and the Query Notation. And believe me you can choose any one because both generate the same IL code.

There are some things is missing in this book, or with a very small explanation

Linq to Entities, even in a beta stage would be great to see it in this book
Expressions trees, even now I'm try to find a real good book that contains everything I need to know about expressions trees
And final this book doesn't cover custom Linq providers. :(

These last two I really like to know a book where they are covered in deep. If any one knows a book that covers those two in deep mail me :)