In May of 2009 I discovered some significant performance problems that I blogged about.  In summary, I had tracked it down to the issue of LINQ2SQ having to create a full expression tree on every instantiation of a LINQ2SQL query.  I’m not a compiler write kind of guy but do respect the complexity of that and doing things like building expression trees, but still this really sucked.  Using the compile syntax in LINQ2SQL is very awkward, and IMHO takes all the fun out of using LINQ2SQL.  If you don’t remember my post, here is the graph showing the evil happening.

So, what is a Microsoft MVP to do?  I complained to everyone at Microsoft I knew.  I made this my mission for about a year.  I was told time after time that the problem was hugely complicated and no one was working on making it any faster.  I just could not believe it because I felt this was such a barrier to success to LINQ2SQL type technology (now Entity Framework really) that Microsoft just could not ignore my findings.  I was actually surprised that I was the only one screaming about this.

Well, quietly, Microsoft has announced that in .Net Framework 4.5, Entity Framework will include “Auto-Compiled LINQ Queries”.  This is awesome!   When it comes out, I’ll be testing and it giving feedback.

For now, I’m a very happy camper.

My code starts like this:

public static List<DbProgressReport> DbProgressReportProperty { get; set; }

Then, I try wrapping the updates with a lock as follows (removing the set because I do it someplace else now)

public static List<DbProgressReport> DbProgressReportProperty
{
    get
    {
        lock (lockDbProgressReportProperty)
        {
            return _dbProgressReportList;
        }
    }
}

I then realize that I need to copy the data because it may change while the caller prints it so I decide to return a temporary copy of the data as follows:

public static List<DbProgressReport> DbProgressReportProperty
{
    get
    {
        lock (lockDbProgressReportProperty)
        {
            var dbProgressReportsNew = new List<DbProgressReport>();
            if (_dbProgressReportList != null)
            {
                // make temp copy to avoid locking issues on read
                foreach (var rec in _dbProgressReportList)
                {
                    dbProgressReportsNew.Add(rec);
                }
            }
            return dbProgressReportsNew;
        }
    }
}

I then notice that ReSharper has a suggestion.

Taking the suggestion, Resharper changes the code to:

lock (lockDbProgressReportProperty)
{
    // make temp copy to avoid locking issues on 
    return _dbProgressReportList.ToList();
}

In this post, we’ll take a straight forward procedure based set of code and convert it to LINQ using a ReSharper from JetBrains suggestion.   I’ve found that in general, when I do things with foreach syntax, there is often a better way in Linq to do this.  The better does not jump out at me sometimes, however with ReSharper, it is often a button click away.

The initial code is as follows:

int selectedIndex = 0;
foreach (var rec in codeCampStringDictionary)
{
    if (rec.Key == codeCampYear)
    {
        break;
    }
    selectedIndex++;
}

And, ReSharper is going to suggest turning it into:

int selectedIndex = codeCampStringDictionary.TakeWhile(rec => rec.Key != codeCampYear).Count();

Simply Amazing!  TakeWhile had not even occurred to me.

(All while getting the Silicon Valley Code Camp Site Ready for our V5 Event, October 9th and 10th, 2010)

So, to explain the problem a little better, on the Silicon Valley Code Camp web site (which, by the way is scheduled for October 9th and 10th, 2010 this year), we have an ASP.NET DropDownList in the upper right hand corner that the user can switch between different years. That is, say they want to see all the sessions in 2008’s code camp, they can simply change the dropdown and the site completely updates.  When they do this, we don’t want to re-read the data table that contains the code camp years, we simply want to process the data that has already been stored in the ViewState of the DropDownList and use that to figure out the key value of the table entry for the code camp year they selected.

OK, if you didn’t follow all that, it really doesn’t matter.  This blog post is simply about how clever ReSharper is and how much I enjoy what the tool does.  It’s nice to have a tool teach me things!

The complete commented code is below that includes some comments about how it actually works.  I’m looking forward to several people posting comments letting me know that there is even a simpler way to do this.   I love my job!

// Create a dictionary out of values in a DropDownList.  That is,
// the DropDownList has a Key Value which is it's primary key
// and a text value which is the Code Camp Year.
Dictionary<int, string> codeCampStringDictionary =
    DropDownListCodeCampYearID.Items.Cast<ListItem>().
        OrderBy(a => a.Value).
        ToDictionary(itemdd => Convert.ToInt32(itemdd.Value),
                     itemdd => itemdd.Text);

// Then, loop through the values in the dictionary and figure out
// the offset of a particular value.  That is, if there are 3 values
// in the list of 2008,2009,2010 which have primary keys of 3,4,5
// we want to know, that given codeCampYear is 4, then selectedIndex 
// is the second value and should be 2.
int selectedIndex = codeCampStringDictionary.TakeWhile
    (rec => rec.Key != codeCampYear).Count();

string dateString = Utils.GetCodeCampDateStringByCodeCampYearId(codeCampYear);
DropDownListCodeCampYearID.SelectedIndex = selectedIndex;
HeaderId1.Text = String.Format("Saturday and Sunday, {0}", dateString);

Let the comments roll!

 List<string> strings = new List<string>
 
	{
		"a","b","c"

	};

To something that looks like:

“a:b:c:”

Here is the trick using the foreach syntax:

 var stringBuilder = new StringBuilder();
 strings.ForEach(a=>stringBuilder.AppendFormat("{0}:",a));

In this section, we will talk about what happens when the users presses the “Sessions” hyperlink from the speakers page.  If you remember from the last article, we used a special converter on the Speakers.xaml page and bound that to the hyperlink titled sessions as shown below.

When this link is clicked, the navigation created is as follows:

http://localhost:9951/Presentation1TestPage.aspx#/Sessions?SpeakerId=903

// Executes when the user navigates to this page.

protected override void OnNavigatedTo(NavigationEventArgs e)

{

    //Handle SpeakerId

    var qs = NavigationContext.QueryString;

    if (qs.ContainsKey("SpeakerId"))

    {

        this.sessionsOverviewDomainDataSource.FilterDescriptors =

            new FilterDescriptorCollection();

        this.sessionsOverviewDomainDataSource.FilterDescriptors.Add(

              new FilterDescriptor("AttendeeId",

                  FilterOperator.IsEqualTo, qs["SpeakerId"]));

    }

}

This simply adds a filter to the current DomainDataSource that filters the column AttendeeId with the passed in query parameter SpeakerId.

The resulting page looks as follows assuming Peter Kellner’s Session link was clicked.

The video referenced in this article goes into building this page in more details, but fundamentally, the major point is just the query parameter.

This one is just to amazing to not blog about.  I’ve been a die heart ReSharper user for quite a while and recently have started using their early access versions.  Primarily because they seem to have added a lot of LINQ support which I use heavily now.  I had the following code before the refactor.  I have to admit, it’s a little .Net 1.1/2.0 ish, but what can I say, I’m a production coder and it did the job.

private static int GetTransitTime(string parcelToCheck)
{
    int transitTime = 0;
    foreach (var parcelSCAC in Constant.UPS_SCAC_MAP)
    {
        if (parcelSCAC.Key.Equals(parcelToCheck))
        {
            transitTime = Constant.UPS_TRANSIT_TIME[parcelSCAC.Value];
            break;
        }
    }
    return transitTime;
}

I noticed the little helper icon making a suggestion (ReSharper Icon that is) so I hovered over to see what it wanted.

And, I chose what it suggested, and wow!  check this out.   The way I should have coded it in the first place.

private static int GetTransitTime(string parcelToCheck)
{
    return (from parcelSCAC in Constant.UPS_SCAC_MAP
            where parcelSCAC.Key.Equals(parcelToCheck)
            select Constant.UPS_TRANSIT_TIME[parcelSCAC.Value]).FirstOrDefault();
}

All I can say is I love it.   If you don’t use ReSharper, drop what you are doing and go out and buy it!

So, in my C# code, here is what you need to convert to the Linq.Binary:

Linq.Binary carrierMatrix =
   new ASCIIEncoding().GetBytes(myString);

And, to go back from Linq.Binary:

string carrierMatrixString = Encoding.ASCII.GetString(carrierMatrix.ToArray());

Hope this help!

In my case this:

cmRateResult[] cmRateResults = TransiteUtils.MakeRateRequest(_cmRateRequest);

Then, I want to convert that into

List<cmRateResult]

We all know the foreach way of doing it, about 5 lines of code

var cmRateResultsList = new List<cmRateResult>(cmRateResults.Length);
 foreach (var r in cmRateResults)
 {
      cmRateResultsList.Add(r);
 }

Or, my preferred way is to use the LINQ for syntax as follows:

var recs = (from data in cmRateResults select data).ToList();

But, it’s nicer (IMHO) to do it with LINQ chaining, though exactly the same. here it is:

var recs = cmRateResults.Select(data => data)).ToList()

Hope this helps!

It occurred to me I could do it in LINQ, then grab out the SQL it generated.  The tool?  LINQPad of course.  So, here is what I typed into LINQPad:

(from data in Attendees
let dateNoTime = 
    new DateTime
     (data.CreationDate.Value.Year,
      data.CreationDate.Value.Month,
      data.CreationDate.Value.Day)
orderby dateNoTime
group data by dateNoTime into g
where g.Count() > 0
select new 
    {
    g.Key,
    Number_Registered = g.Count() 
    }).OrderByDescending(f=>f.Key)

Then, After pasting that into LINQPad, choosing the SQL tab on the bottom, it gives me this:

SELECT [t2].[value3] AS [Key], [t2].[value2] AS [Number_Registered]
FROM (
SELECT COUNT(*) AS [value], COUNT(*) AS [value2], [t1].[value] 
          AS [value3]
FROM (
    SELECT CONVERT
         (DATETIME, CONVERT(NCHAR(2), DATEPART(Month, [t0].[CreationDate])) 
           + ('/' + (CONVERT(NCHAR(2), DATEPART(Day, [t0].[CreationDate])) +
              ('/' + CONVERT(NCHAR(4), DATEPART(Year, [t0].[CreationDate]))))), 101) 
                    AS [value]
        FROM [Attendees] AS [t0]
        ) AS [t1]
    GROUP BY [t1].[value]
    ) AS [t2]
WHERE [t2].[value] > @p0
ORDER BY [t2].[value3] DESC

And, the nice screen shot of LINQPad

And, it works perfect!  Even the TSql generated looks pretty nice.  Group By, Convert, DatePart and everything. Somehow, I feel like I’ve cheated, but I’m good with that in this case.

Hope this helps!

So, the problem is you have a record that looks like this:

 public class LoadSegmentInfoFlat
        {
            public double? OriginLattitude { get; set; }
            public double? OriginLongitude { get; set; }
            public double? DestinationLattitude { get; set; }
            public double? DestinationLongitude { get; set; }
            public string Color { get; set; }
        }

You’ve created a list of these and defined it as follows:

var loadSegmentInfoFlats = new List<LoadController.LoadSegmentInfoFlat>();

Now, you want to create a unique list of Lattitude, Longitude Origins and Destinations by color.

The LINQ query that does the trick is a simple group by that creates an anonymous result (which is our answer).  Here is the LINQ query (thanks to my friend in the MSDN LINQ Forums, Lignzhi Sun).

var segments = from a in loadSegmentInfoFlats
               group a by
                   new
                       {
                           a.OriginLattitude,
                           a.OriginLongitude,
                           a.DestinationLattitude,
                           a.DestinationLongitude,
                           a.Color
                       }
               into grouplist
                   select
                   new
                       {
                           grouplist.Key.OriginLattitude,
                           grouplist.Key.OriginLongitude,
                           grouplist.Key.DestinationLattitude,
                           grouplist.Key.DestinationLongitude,
                           grouplist.Key.Color,
                           Count = grouplist.Count()
                       };

The resulting segments in Visual Studio 2008 debugger are as follows:

Hope this helps!

So, How to do this?  Well, first, here is the answer:

   1:         /// <summary>

   2:          /// Returns a list of days that have a loadCount > loadCount

   3:          /// </summary>

   4:          /// <param name="days"></param>

   5:          /// <param name="loadCount"></param>

   6:          /// <returns></returns>

   7:          public List<DateTime> GetLastDaysWithLoadsGreaterThan(int days,int loadCount)

   8:          {

   9:              var dateGroups = (from load in _meta.Load

  10:                                orderby load.DateCreated

  11:                                group load by load.DateCreated

  12:                                into g

  13:                                    where g.Count() > loadCount

  14:                                    select new

  15:                                               {

  16:                                                   g.Key,

  17:                                                   cnt = g.Count()

  18:                                               }).Take(days).OrderByDescending(f => f.Key);

  19:              

  20:              var listDates = dateGroups.Select(a => a.Key).ToList();

  21:              

  22:              return listDates;

  23:          }

And now, a short explanation.

First, the obvious I thought would have been if I did orderby load.DateCreated descending, that I would not have had to reverse the list at the end.  It did not work and I’m not sure why. Luckily, I can sort the list at the very end which is a small penalty since my lists are not that large.

Notice the groupby and the where clause are doing the work.  The resulting anonymous method solves the problem of getting the data out.

Line 20 is one of my favorite tricks to avoid 4 or 5 lines of code.

And of course, the SQL is a lot simpler, but not type safe.

   1:  SELECT datecreated,

   2:         count(*)

   3:  FROM dbo.[Load]

   4:  group by datecreated

   5:  having count(*) > 200

   6:  order by datecreated desc

   7:    

    public partial class CodeGenTestQuery : QueryBase

    {

        public int? Id { get; set; }

        public List<int> Ids { get; set; }

        public bool? IsStarred { get; set; }

        ...

If I pass an empty list of int’s into Ids, I have a line of code that build the query as follows:

if (query.Ids != null) baseQuery = baseQuery.Where(a => query.Ids.Contains(a.Id));

This works fine as long as a pass into ids either null, or a list that contains more than one object. However, if I pass in an empty list like this:

new CodeGenTestQuery
    {
         Ids = new List<int>() { }, MyAge = 2
     }

Then, the result of the LINQ query is it creates a where clause that says something like this:

SELECT [t0].[Id],

       [t0].[IsStarred]

FROM [dbo].[CodeGenTest] AS [t0]

WHERE ([t0].[MyAge] = 2) AND

      (0 = 1)

Which means you will not get the MyAge == 2 record ever

So, I changed my c# as follows and now I get what I expect.

if (query.Ids != null)
            {
                if (query.Ids.Count > 0)
                {
                    baseQuery = baseQuery.Where(a => query.Ids.Contains(a.Id));
                }
}

I can see this kind of thinking on the LINQ2SQL team, but it’s a little insidious if you ask me.

At anyrate, I’m now following Jim’s Twitter feed and he recently mentioned he included all the examples from his book in LINQPAD.  I just downloaded them.  This is just too cool!  He wrote a blog post about it here:  http://www.thinqlinq.com/Default/LINQ-In-Action-Samples-available-in-LINQPad.aspx  Here is what it looks like in LINQPAD

Hope this helps!!!  It’s huge for me.

Here are some assumptions:

• My Notebook Computer Simulates a real world web server (Lenovo W500, Vista64, IIS7)
• All Web Pages do 7 LINQ2SQL executions (Heading speak at  VSLive in Vegas so 7 seemed right)
• All Web Requests Do Only LINQ2SQL, no images, css, JavaScript or anything else

OK, maybe my assumptions are not so good, but I believe overall I’m making a good point so I’m going to keep going rather than just say “take my word for it, trust me”.  So, I’m attaching the web project here that let’s you recreate all this so you can do your own tests.  I think you’ll need Visual Studio Team Suite to do these tests.  If you don’t have that, you can at least look at the code.  The guts are in LINQUtils.cs.  I’m going to show the relevant code below.

But before that, here is the Visual Studio 2008 Project Code if you want to try it yourself:

First, The Results

The code is very straight forward.  Below is the code for the LINQ2SQL Not Compiled Test:

  1: public string ProcessLinqQueryNotCompiled()


  2: {


  3:     if (meta == null)


  4:     {


  5:         meta = new DataClassesDataContext();


  6:     }


  7: 


  8:     Stopwatch stopWatch = new Stopwatch();


  9:     stopWatch.Start();


 10: 


 11:     int retCnt = 0;


 12:     for (int i = 0; i < iterations; i++)


 13:     {


 14:         const int companyTypeIdToFind = 1;


 15:         var q3 = from dataCo in meta.Companies


 16:                  where (from dataCt in meta.CompanyCompanyTypes


 17:                         where dataCt.CompanyTypeId == companyTypeIdToFind


 18:                         select dataCt.CompanyId).Contains(dataCo.Id)


 19:                  select dataCo;


 20: 


 21:         var newList = q3.ToList();


 22:         retCnt = newList.Count;


 23:     }


 24:     stopWatch.Stop();


 25:     double milliSecondsPerIteration = Convert.ToDouble(stopWatch.ElapsedMilliseconds)/Convert.ToDouble(iterations);


 26:     return string.Format("Return Cnt: {0} LINQ Executions: {1}      Milliseconds Per Iteration: {2}", retCnt, iterations,


 27:                          String.Format("{0:0.00}", milliSecondsPerIteration));


 28: }

And, the Compiled LINQ2SQL Code:

  1: public string ProcessLinqQueryCompiled()


  2: {


  3:     var stopWatch = new Stopwatch();


  4:     stopWatch.Start();


  5: 


  6:     int retCnt = 0;


  7:     for (int i = 0; i < iterations; i++)


  8:     {


  9:         const int companyTypeIdToFind = 1;


 10: 


 11:         if (meta == null)


 12:         {


 13:             meta = new DataClassesDataContext();


 14:         }


 15: 


 16:         if (_compiledQuery == null)


 17:         {


 18:             _compiledQuery =


 19:                 CompiledQuery.Compile((DataClassesDataContext metax, int myQuery) =>


 20:                                       (from dataCo in metax.Companies


 21:                                        where (from dataCt in metax.CompanyCompanyTypes


 22:                                               where dataCt.CompanyTypeId == companyTypeIdToFind


 23:                                               select dataCt.CompanyId).Contains(dataCo.Id)


 24:                                        select dataCo)


 25:                     );


 26:         }


 27: 


 28:         


 29:         var query =


 30:             (IOrderedQueryable<Company>)


 31:             _compiledQuery(meta, 1);


 32:         var newList = query.ToList();


 33:         retCnt = newList.Count;


 34:     }


 35:     stopWatch.Stop();


 36:     double milliSecondsPerIteration = Convert.ToDouble(stopWatch.ElapsedMilliseconds) / Convert.ToDouble(iterations);


 37:     return string.Format("Return Cnt: {0} LINQ Executions: {1}      Milliseconds Per Iteration: {2}", retCnt, iterations,


 38:                          String.Format("{0:0.00}", milliSecondsPerIteration));


 39: 


 40: }

Bottom line, You need to compile your LINQ2SQL!

Today, I discovered you can actually put c# right into the editor!  I’m attaching a screen shot of how it helped me solve a simple LINQ command that involved an integer list.  I reviewed it in a little more detail on a previous post here:  http://peterkellner.net/2008/09/20/linqpad-sqlserver-linq-interpreter-nutshell/

Hope you find it useful also!

Well, my fears are put aside.  Though LINQ is somewhat slower, for 100,000 iterations, .052 seconds is pretty good.  (compared with processing a single not to complicated LINQ2SQL statement for 100,000 iterations would take about 20,000 seconds or 333 hours.  Quite a difference to .052 seconds!

Here is the code I ran for my test.  Hope this help!

using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.Linq;

using System.Text;

namespace LINQTimingInMemory

{

     class Program

     {

         static void Main(string[] args)

         {

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

             {

                 List<int> myList = new List<int>() {1,2,3,4,5,6,7,8,9,6,5,5,5,5,5,5};

                 Stopwatch stopWatch = new Stopwatch();

                 stopWatch.Start();

                 int iterations = 100000;

                 for (int t = 0; t < iterations; t++)

                 {

                     if (i == 0)

                     {

                         var ids = myList.Where(a => a > 5).ToList();

                     }

                     else

                     {

                         var ids = new List<int>();

                         foreach (var v in myList)

                         {

                             if (v > 5)

                             {

                                 ids.Add(v);

                             }

                         }

                     }

                 }

                 stopWatch.Stop();

                 int ti = Convert.ToInt32(stopWatch.ElapsedMilliseconds);

                 Console.WriteLine("time for " + i.ToString() + " " + ti/iterations + " " + ti);

                 stopWatch.Reset();

             }

         }

     }

 }

So, say you have a list of objects as follows:

public partial class CompanyAddressResult : ResultBase
    {
        public int Id {get;set;}
        public string Name { get; set; }
        public int CompanyId { get; set; }
        public int AddressId { get; set; }
        public int CompanyAddressTypeId { get; set; }
        public string Notes { get; set; }
        public int? ActiveFlag { get; set; }
}

And, you want to create a list of AddressIds.  Here is all you have to do:

List<int> AddressIds = retList.Select(a => a.AddressId).ToList();

Hope this helps.

At my company, we have been running a workflow process that is taking 6 hours to complete.  This is a new project so we’ve had the good fortune to be able to use the latest Microsoft technologies.  We are a Microsoft shop, so that means Sql Server 2008, C#, ASP.NET, ExtJS, LINQ to SQL (hoping to move to Entity Framework someday) and others.  After spending all day running performance analysis tools and basically performing a full audit of the 6 hour process, we sadly concluded that our time was being eaten up by LINQ to SQL processing.  My experience has always been that anything you do on the compiled code side is usually overwhelmed by database access times, usually at least ten to one.  Well, I learned a lot yesterday.

The Problem

Since I already know the answer, I put together a very trivial problem to solve.  What I want to do is execute one simple SQL statement over and over.   I’m going to query just one table that actually has no records in it just to make sure the database really has nothing to do.  I’m going to make this connection on my blazingly fast Lenovo W500 with a SATA SSD running Sql Server 2008  locally.  I’m going to run that simple query first calling just ADO.NET (bare bones using best practices), Then using LINQ to SQL in the way I’ve always used it (and I would say 99% of the other developers out there), then I’m going to compile that LINQ to SQL and run it again.  Actually, I’m going to iterate 2000 times for each of the three conditions.

So, here is the simple SQL I’m executing:

SELECT 
  Id,
  FileName,
  FileSize,
  UploadDate,
  DownloadDate,
  ProcessDate
FROM
  LinqTest
WHERE 
  dbo.LinqTest.FileName = 'MyVal'

The Shocking Results

Or, for those graphically challenged (like search engines), Here is the actual data.

In English, this says that

• LINQ to SQL is  37 times slower than running a raw ADO.NET Sql query
• LINQ to SQL compiled 1.8 times slower than running a raw ADO.NET Sql query

I’ve read in several places that compiling your LINQ will help, but I have never heard anyone say how drastic the speed improvement can be.  For example, in one of my favorite books (LINQ in Action) by Fabrice Marguerie and others, he quotes on page 296  a blog post by Rico Mariani titled DLINQ (Linq to SQL Performance (Part 1) as saying using a compiled query offers nearly twice the performanced of a non-compiled query, and goes on to say that it brings the performance to within 93% of using a raw data reader.   Well, suffice it to say I never ran the test myself.  I could have lived with twice, but not 37 times.

Here is the Project File Source:

How to Compile you SQL (seems like a duh kind of thing)

It’s actually not very hard.  I’m attaching the Visual Studio 2008 project that I ran this test with to this post so you can run it for yourself as well as see an example of how to write the compiled LINQ code.  Below is the method that actually does the work.  I won’t include in this article the actual ADO.NET and LINQ to SQL not compiled code, but you can see those for yourself in the attached solution.

   1:  /// <summary>

   2:  /// This method compiles the LINQ to SQL query and 

   3:  /// then executes it the number of iterations passed

   4:  /// in.  

   5:  /// </summary>

   6:  /// <param name="iterations">Number of iterations</param>

   7:  /// <returns>time in seconds of execution</returns>

   8:  private static double 

   9:      TestDataAccessSpeedLinq2SqlCompiled(int iterations)

  10:  {

  11:      Func<DataClassesDataContext, string, IQueryable<LinqTest>> compiledQuery =

  12:          CompiledQuery.Compile((DataClassesDataContext meta,string fileNameForSearch) =>

  13:                                (from myData in meta.LinqTests

  14:                                 orderby myData.Id

  15:                                 where myData.FileName.Equals(fileNameForSearch)

  16:                                 select myData));

  17:   

  18:      var metaNew = new DataClassesDataContext();

  19:      DateTime startTime = DateTime.Now;

  20:      for (int i = 0; i < iterations; i++)

  21:      {

  22:          IOrderedQueryable<LinqTest> query = 

  23:              (IOrderedQueryable<LinqTest>) 

  24:              compiledQuery(metaNew,string.Format("abcde{0}", i));

  25:          List<LinqTest> newList = query.ToList();

  26:      }

  27:      return 

  28:          DateTime.Now.Subtract(startTime).Duration().TotalSeconds;

  29:  }

Essentially, line 11 is compiling the code into an instance variable called compileQuery.  Using this instance variable, you can now execute the  LINQ query in a compiled form while still passing in variable data such as fileNameToSearch.  Again, the important thing to note is that one line 24 compiledQuery is already compiled so the IOrderedQueryable result is obtained without having to recompile the LINQ statement.

Conclusions

So, from this, it seems that you should always compile your LINQ to SQL queries.  Well, that’s not quite true.  What I’m recommending is that if you have a reason to execute the same query over and over you should strongly consider compiling.  If for example, you are just making a LINQ to SQL call once, there is no benefit because you have to compile it anyway.  Call it ten times?  Well, you will have to decide for yourself.

Forewarned is forearmed!  good luck and hope this helps.

Among other things, the goes in to great detail on the following topics:

• Domain Driven Design
• Model View Presenter Pattern
• Factory Pattern Using Structure Map (IOC)
• Error Handling
• Social Network Schema Designs (Friends and Groups)
• Messaging
• Data Layers (LINQ to SQL)
• Blog Design
• Forums and Moderation

As well as many other topics including application scaling and many others.  As developers, we have many choices as to what technologies to use and how to use them.  I have to say, I agree with 95% of the choices Andrew makes and whole heartedly recommend reading his book.

asp.net 3.5 social networking

Here is an example:

DataClassesGeneralDataContext db3pLogicContext;

db3pLogicContext.Log = Console.Out;

var companyQuery = from tbl in db3pLogicContext.Companies

                   where tbl.ParentId != 0

                   select tbl;

int totalCntParents = companyQuery.Count();

foreach (DBAccess.Company co in companyQuery)

{

    co.CreateDate = DateTime.Now;

    break;

}

db3pLogicContext.SubmitChanges();

Now, when you run the code, you can look on your debugger output and see something that looks like this:

Also, if you want to actually execute select type statements, take a look at the Query Visualizer posted on Scott Guthrie’s web site:

http://weblogs.asp.net/scottgu/archive/2007/07/31/linq-to-sql-debug-visualizer.aspx