Thinq Linq

Adding Property Get logging to LINQ to SQL with T4

jwooley — Thu, 16 Jul 2009 16:51:00 GMT

After my last INETA talk in Sarasota, I had two separate people ask me how to enable auditing of LINQ to SQL when properties are read. Currently the classes created by the LINQ to SQL designer and SqlMetal add events to track before and after an individual property are changed through the INotifyPropertyChanged and INotifyPropertyChanging interfaces, but they don't include hooks to detect when a property is read.

One option to add read notification is to replace the default code generator with L2ST4 templates and to modify the template to include the necessary events on the property Gets. So how do we do this?

I'll leave it up to you to download, install and configure the templates to work on your dbml file using the instructions on the L2ST4 CodePlex site. I'll focus here instead on how to extend them after they are already working. You can download the sample T4 implementation if you want to follow along. Since this is a VB project, I'll be modifying the VBNetDataClasses.tt file here, but the same process could be done with the CSharpDataClasses as well.

First, we need a way to identify if we are adding the read tracking. At the top of the file, we will add a property to the anonymous type setting the options that will be used in the code generation process. Here, we'll add a flag called IncludeReadTracking:

var options = new {
    DbmlFileName = Host.TemplateFile.Replace(".tt",".dbml"), // Which DBML file to operate on (same filename as template)
    SerializeDataContractSP1 = false, // Emit SP1 DataContract serializer attributes
    FilePerEntity = true, // Put each class into a separate file
    StoredProcedureConcurrency = false, // Table updates via an SP require @@rowcount to be returned to enable concurrency    
    EntityFilePath = Path.GetDirectoryName(Host.TemplateFile), // Where to put the files    
    IncludeReadTracking = true // Include audit read tracking ability
};

The code generation is a mixture of C# templating code and VB generated code. The processing in the template is done in C# which is why, although we are modifying the VB template, this anonymous type is declared in C#.

Next, we'll add a common delegate, args and interface that each of the classes will consume. This will mimic the implementation of INotifyPropertyChanging and INotifyPropertyChanged in the underlying .Net Framework. We'll call our interface INotifyPropertyRead which will expose a single PropertyRead event. Here is the code that we want to produce once we're done:


Public Interface INotifyPropertyRead
    Event PropertyRead As PropertyReadEventHandler
End Interface
Public Delegate Sub PropertyReadEventHandler(ByVal sender As Object, ByVal e as PropertyReadEventArgs)
Public Class PropertyReadEventArgs
    Inherits EventArgs
    Public Sub New(ByVal propertyName as String)
        _propertyName = propertyName
    End Sub
    Private ReadOnly _propertyName As String
    Public ReadOnly Property PropertyName As String
        Get
            Return _propertyName
        End Get
    End Property
End Class

We could create this separately, in our project, however in this case, I'll go ahead and add id dynamically in the code generation process depending on if the flag is set. We do need to be careful when adding it because we only want it added once rather than copied for each table, and outside of the context's namespace. If you have multiple dbml and template files, you will need to move this to a more centralized location in your project. We'll do this right after the header is generated and before the namespace is specified. Locate the following lines near the top of the original T4 template:

<#manager.EndHeader();
if (!String.IsNullOrEmpty(data.ContextNamespace)) {#>

Replace them with the following:

<# manager.EndHeader(); #>
<#if (options.IncludeReadTracking) {#>
Public Interface INotifyPropertyRead
    Event PropertyRead As PropertyReadEventHandler
End Interface
Public Delegate Sub PropertyReadEventHandler(ByVal sender As Object, ByVal e as PropertyReadEventArgs)
Public Class PropertyReadEventArgs
    Inherits EventArgs
    Public Sub New(ByVal propertyName as String)
        _propertyName = propertyName
    End Sub
    Private ReadOnly _propertyName As String
    Public ReadOnly Property PropertyName As String
        Get
            Return _propertyName
        End Get
    End Property
End Class 
<# } #> 
<#if (!String.IsNullOrEmpty(data.ContextNamespace)) {#>

If you're not familiar with T4, the <# and #> are similar to ASP or MVC's <% %>. Code that is entered inside of the place holders is evaluated and code that is outside of them is considered a string literal. In this case, we have an If block that checks the IncludeReadTracking flag we setup in the options earlier. If the flag is set, then the VB code will be output as the generation process is executed.

Next, we need to modify the class definition corresponding to each table that is being read. The default implementation includes the definition for implements INotifyPropertyChanging, INotifyPropertyChanged. We'll add a designation (if the IncludeReadTracking is set) to also implement our new INotifyPropertyRead as follows:

Implements INotifyPropertyChanging, INotifyPropertyChanged<# if (options.IncludeReadTracking){ #> , INotifyPropertyRead <# } #>

Next, we need to add the actual implementation. This is relatively simple as well. In the #Region for the Property Change Event Handling, add the following:

        <# if (options.IncludeReadTracking){ #>
        Public Event PropertyRead As PropertyReadEventHandler Implements INotifyPropertyRead.PropertyRead
        <#=code.Format(class1.PropertyChangeAccess)#>Sub OnPropertyRead(ByVal propertyName As String)
            RaiseEvent PropertyRead(Me, New PropertyReadEventArgs(propertyName))
        End Sub
        
        <# } #>

Notice here, we will only add this if the flag is set. Also, we check to see if we can override the functionality of OnPropertyRead by checking the class1.PropertyChangeAccess flag.

The last change we make to the template is to modify the code generated for each Property Get which now reads as follows:

            Get
<#                if (options.IncludeReadTracking) { #>
                OnPropertyRead("<#= column.Member #>") 
<#                } #>
                Return <#=column.StorageValue#>
            End Get

That's it for our modifications to the T4 templates. When we save the template, our classes will be regenerated. So how do we consume these? We will need to have a logging implementation which we somehow attach to the new event. A simple case could be to do something like the following:

Private Logger As New HashSet(Of String)
Sub Main()
    Dim dc As New NWindDataContext
    Dim emps = dc.Employees.ToList

    For Each emp In emps
        AddHandler emp.PropertyRead, AddressOf LogHandler
        Console.WriteLine(emp.FirstName & emp.LastName)
    Next

    Console.WriteLine("Log results")
    For Each item In Logger
        Console.WriteLine(item)
    Next
End Sub

Public Sub LogHandler(ByVal sender As Object, ByVal e As PropertyReadEventArgs)
    Dim value As String = sender.GetHashCode.ToString & e.PropertyName
    If Not Logger.Contains(value) Then Logger.Add(value)
End Sub

Here we are fetching the employees from a context set up against Northwind. As we iterate through the employee list, we add a listener to the PropertyRead event to perform the logging. In the logger we somehow need to identify the object that is being logged and the property being read. Here we just track the object's GetHashCode and the arg's PropertyName. Of course you would need to figure out how to log based on the object's unique key. Since you have a handle on the actual sender object, you could determine this from the LINQ to SQL attributes for the IsPrimaryKey value, or you could use some other implementation. Once you have the items logged, saving them back to your persistence store would need to be an additional step added wherever you are calling submit changes.

This sample also suffers from having to manually add the listener to the PropertyRead event. There are plenty of alternative options here, including using MEF to attach your object to a centralized logger. You would need to make the necessary changes to the T4 template, but hopefully that won't be too hard for you after reading this post.

Also, realize that this technique works when working directly with the LINQ to SQL generated classes. However, if you project into an anonymous type, you will no longer receive read notifications as that generated type won't have the necessary hooks any more. When doing read auditing, the challenges build quickly. You may want to consider instead some third party server based profiling systems for a more robust implementation and leave the logging out of the client tier entirely.

As always, there are plenty of alternatives. Let me know if you thinq of others.

LINQ to SQL DataLoadOptions.LoadWith and Take

jwooley — Wed, 15 Jul 2009 11:58:00 GMT

While trying to increase the performance of this site, I found a bug which may drastically slow the performance. By default when navigating to child objects from a parent object, LINQ to SQL lazy loads the children. This is good when you don't know if you want the children.

However, on this site when viewing posts, I ALWAYS display the categories and number of comments. As mentioned in LINQ in Action, you can eager load child records using the context's LoadOptions to set the child to be eagerly loaded with the parent using the following:


Dim dc As New LinqBlogDataContext
Dim options As New DataLoadOptions
options.LoadWith(Function(p As PostItem) p.CategoryPosts)
options.LoadWith(Function(cp As CategoryPost) cp.Category)
options.LoadWith(Function(p As PostItem) p.Comments)
dc.LoadOptions = options

There are a couple issues with the implementation at this point however. First, the LoadWith setting only works for one level of hierarchy. It does not automatically navigate to grandchildren records. In this case, you may need to project into an anonymous type to remove that extra level of the object graph.

The trickier situation comes when trying to do paging over the result sets. When traversing one level, the LoadOptions work fine for standard queries, however as soon as you throw a Take clause in, the LoadWith options are ignored as shown below:


Dim good =  From p In dc.PostItems _
            Order By p.PubDate Descending _
            Select p

Dim bad =   From p In dc.PostItems _
            Order By p.PubDate Descending _
            Take 5
            Select p

In the first case, a single query is sent to the database when navigating to the children. In the second (bad) query, separate statements are sent to the database as we fetch the children. I submitted a bug item on this. The solution here (if you target the 4.0 framework) is to include a Skip(0) clause which will cause the Take to not short circuit the LoadOptions:


Dim fixed = From p In dc.PostItems _
            Order By p.PubDate Descending _
            Skip 0
            Take 5
            Select p

Unfortunately, this trick doesn't work with the current VS 2010 build when targeting 3.5. I suspect that you may need to target 4.0 in order to get Take to play nice with the LoadOptions.

Binding Anonymous Types in MVC Views

jwooley — Sun, 12 Jul 2009 21:20:00 GMT

While translating this site over to MVC, I ran into a challenge when converting the RSS feed implementation. Currently I'm using XML Literals to generate the RSS and I could certainly continue to use that track from the Controller similar to the Sitemap implementation on Mikesdotnetting. However, putting the XML generation in the controller directly conflicts with the separation of concerns that MVC embraces. If I were only displaying one RSS feed, I might be willing to break this here. However, I'm rendering a number of different RSS feeds here: Posts, Posts by Category, and Files.

Since it would be good to have a reusable view, I decided to create a single view which various controllers can use. I was dynamically generating the XML in the past so my queries would now need to project into a type that the view can consume. Here we have several alternatives:

Create a strongly typed object structure which is strictly used to shape our results for the shared Rss view.
Project into a list of System.ServiceModel.SyndicationItem and then bind to that.
Project into an anonymous type and figure out a way to bind to that projection in our view.

I initially thought I would go down the second route similar to the implementation discussed on the DeveloperZen post. However, I wanted to support some of the RSS extensions including comments and enclosures that aren't directly supported in that implementation.

At first I was unsure how to bind an anonymous projection in a View, so I eliminated option 3 and implemented option 1 similar to the strongly typed implementation discussed on Mikesdotnetting blog. To do this, I needed to build the following set of strongly typed structures:


Public Structure RssElement
    Public Title As String
    Public Link As String
    Public PubDate As DateTime
    Public PermaLink As String
    Public TrackBackUrl As String
    Public CommentRss As String
    Public CommentUrl As String
    Public CommentCount As Integer
    Public Description As String
    Public Categories() As Category
    Public Enclosures() As Enclosure
End Structure

Public Structure Category
    Public Url As String
    Public Title As String
End Structure

Public Structure Enclosure
    Public Url As String
    Public Length As Integer
    Public Type As String
End Structure

If I were using VB 10, this would have been done with auto-implemented properties. However I went with structures at this point because I didn't want to type that much for something that was going to be view only anyway.

With this structure in place, I could go ahead and implement the controller and view. The controller simply projected into this new object structure in the Select clause of a LINQ query. The view then was able to consume this as we could strongly type the view as a ModelView(Of IEnumerable(Of RssElement)). Here's the view that I created:

<%@ Page Language="VB" ContentType="application/rss+xml"
         Inherits="System.Web.Mvc.ViewPage(Of IEnumerable(Of RssElement))" %>
<rss version='2.0' xmlns:dc='http://purl.org/dc/elements/1.1/' 
    xmlns:slash='http://purl.org/rss/1.0/modules/slash/' 
    xmlns:wfw='http://wellformedweb.org/CommentAPI/'
    xmlns:trackback='http://madskills.com/public/xml/rss/module/trackback'>
   <channel>
       <title>Thinq Linq</title>
       <link><%=Url.Action("Post") %></link>
       <description>LINQ and related topics.</description>
       <dc:language>en-US</dc:language>
       <generator>LINQ</generator>
       <% For Each item In Model%>
            <item>
                      <title><%=item.Title%></title>
                      <link><%=item.Link%></link>
                      <pubDate><%=item.PubDate%></pubDate>
                      <guid isPermaLink="false"><%= item.PermaLink %></guid>
                      <dc:creator>jwooley</dc:creator>
                      <slash:comments><%=item.CommentCount%></slash:comments>
                      <trackback:ping><%=item.TrackBackUrl%></trackback:ping>
                      <comments><%=item.CommentUrl%></comments>
                      <wfw:commentRss><%=item.CommentRss%></wfw:commentRss>
                      <wfw:comment><%=item.CommentUrl%></wfw:comment>
                      <description><%=Html.Encode(item.Description)%></description>
                      <% if Not item.Categories is Nothing then %>
                           <%For Each c In item.Categories%>
                              <category domain="<%= c.Url %>"><%=c.Title%></category> 
                          <% Next %>
                      <% End If%>
                      <%If Not item.Enclosures is Nothing then %>
                          <% For Each e In item.Enclosures%>
                                <enclosure 
                                    url='<%=e.Url %>'
                                    length='<%=e.length %>'
                                    type='<%=e.type %>' />
                          <% Next%>
                      <% end if %>
                  </item>
       <% Next%>
   </channel>
</rss>

In comparing this code with the XML Literal implementation, they are amazingly similar. With MVC, I may be able to live without XML Literals in the views as we simply replace a LINQ projection with a For Each loop. Notice here I check to see if the Categories and Enclosures objects exist before I enumerate over each of those arrays. This is because the Post feed doesn't include enclosures and the File feed doesn't need Categories. This flexibility allows us to create a reusable view for all of our needs.

But, I'm not quite happy with this implementation. I would prefer not to have to declare the additional structure layer just to pass the view something to consume. In this case, it feels like we are having the Controller consume the data Model and create a ModelView (RssElement) to be consumed by the View. We don't really need a new pattern (M-C-MV-V), do we? Instead, I would like to be a bit more "Dynamic" in my implementation so that I didn't need this class and could simply project into an anonymous type and eliminate the RssElement structures entirely.

After a bit of reflection, I realized that this is a case where VB is uniquely positioned crossing the bridge between strong typing and dynamic languages. Normally, I do not recommend using the Option Strict Off option, but this is one case where it does come in useful. To begin, we'll remove those pesky structures. Next, we'll change the controllers to project into anonymous types. Here's the revised code for the Post Rss Controller:


    Function ShowPosts() As ActionResult
        Dim posts = From p In (From post In Context.PostItems _
                    Order By post.PublicationDate Descending _
                    Take 20).AsEnumerable _
                    Select New With { _
                        .Description = p.Description, _
                        .Link = Url.Action("Title/" & p.TitleUrlRewrite & ".aspx", "Post"), _
                        .PubDate = p.PublicationDate.ToString("r"), _
                        .Title = p.Title, _
                        .TrackBackUrl = Url.Action("Trackback/" & p.Id, "Seo"), _
                        .PermaLink = "42f563c8-34ea-4d01-bfe1-2047c2222a74:" & p.Id, _
                        .Categories = (From c In p.CategoryPosts _
                                    Select New With { _
                                         .Title = c.Category.Title, _
                                         .Url = Url.Action("Category/" & c.CategoryID, _
                                                           "Post")}).ToArray, _
                        .Commentrss = Url.Action("Comment/" & p.Id, "Rss"), _
                        .CommentUrl = Url.Action("Title/" & p.TitleUrlRewrite, "Post"), _
                        .CommentCount = p.Comments.Count, _
                        .Enclosures = Nothing}

        Return View("ShowFeed", posts.ToList)
    End Function

Notice here, that we have to be very careful with our property naming and can't leave off anything. This is why we have to initialize our .Enclosures property to Nothing because we can't initialize it to an empty collection. Since our view checks to see if the object is null before binding it, we are fine here.

Now back to the view. How do we tell the view what type of data the Model contains if we can't name it? Here's where option strict off comes in handy. However, in a View page, we can't simply state Option Strict Off at the top of our code. Instead, we need to set the CompilerOptions to set optionstrict- as follows:

<%@ Page Language="VB" ContentType="application/rss+xml" 
         CompilerOptions="/optionstrict-" Inherits="System.Web.Mvc.ViewPage" %>

In this case, we are not only setting the CompilerOptions, but removing the generic type definition in the Inherits clause. The rest of the view remains intact. Now, we can consume our anonymous type (because we aren't typing the view) and let the Option Strict setting dynamically resolve our method and type names. Notice here, if we were using C# 4.0, we wouldn't be able to use the Dynamic option and state that the page inherits ViewPage<Dynamic> because we can't project into a Dynamic type in our LINQ query.

Now that we have modified our view, we can reuse it. First move it to the Shared folder so that the view will be accessible regardless of which controller tries to consume it. Next, we create other controllers making sure that all of the properties are projected correctly in our LINQ query.


    Function Rss() As ActionResult
        Return View("ShowFeed", _
            From f In GetFiles() _
            Select New With { _
                .Description = f.Description, _
                .Link = "http://www.ThinqLinq.com/" & f.URL, _
                .PubDate = f.LastWriteTime.ToString("r"), _
                .PermaLink = "42f563c8-34ea-4d01-bfe1-2047c2222a74:" & f.Name, _
                .TrackBackUrl = "", _
                .CommentRss = "", _
                .CommentUrl = "", _
                .CommentCount = 0, _
                .Categories = Nothing, _
                .Title = f.Name, _
                .Enclosures = New Object() {New With { _
                                            .Length = f.Length, _
                                            .Type = "application/x-zip-compressed", _
                                            .Url = "http://www.ThinqLinq.com/" & f.URL}}})
    End Function

Be aware. Here we are playing with the dangerous part of dynamic languages. We no longer get the compiler to ensure that our type includes all of the necessary properties. If we forget a property or mis-type the property name, we will only know about it when a run-time exception is thrown. Of course, since this is MVC, we can use unit tests to check our type. With dynamic programming, think of the compiler as just another unit test. You need to write the rest of them by hand.

While I like the flexibility that the new dynamic option provides, I miss the comfort that comes from strong typing. Also, I haven't checked the performance differences between these implementations and suspect that the previous strongly typed option may out perform this one. With optimizations in VB 10 around Option Strict Off, I suspect that the performance differences may shrink, but would need to test this as well.

I'll also admit to being relatively new to MVC and welcome better alternatives from those who have been using it longer. What do you Thinq?

VB Syntax Highlighting with JQuery and Chili

jwooley — Fri, 10 Jul 2009 12:40:00 GMT

At CodeStock, I attended Rod Paddock's intro to JQuery session since I hadn't played with JQuery yet. As often happens when I go to conferences, being in the different environment starts to get the mind thinking in different ways. Sometimes the benefit of the conference isn't necessarily something stated directly, but rather a thought when the mind wanders. One such thought occurred during Rod's presentation where I thought that it might be interesting to "query" sets of text over a larger document and apply formatting to selected words (similar to how Visual Studio colors keywords and other code elements).

A quick search on syntax highlighting found that I was not alone thinking that JQuery might be a good option for syntax highlighting. Chili is a JQuery based code highlighter that already supports a number of languages. It is relatively easy to incorporate into the site. First, you need to add a script reference to JQuery by adding the following:

<script type="text/javascript" src=http://jquery.com/src/jquery-latest.pack.js" />

Next, we add a link to the chili script code:

<script type="text/javascript" src="jquery/chili/jquery.chili-2.2.js" />

Third, we designate the path that contains the various language specific implementation details in a script block:

<script id="setup" type="text/javascript"> 
    ChiliBook.recipeFolder = "jquery/chili/";
</script>

Now, when we want to add highlighting to our code, we include it inside a <code> tag that is assigned to the class name of the language we want to colorize. Unlike the popular SyntaxHighlighter, Chili doesn't require you to specify the location of each language individually. It loads it dynamically based on matching up the file name with the class name.

To see how I added colorization to the source on the above code, see how the actual code is wrapped by a <code class="js"> … </code> tag. In this case, there is a js.js file in the recipeFolder that Chili uses to highlight this code. In addition, I'm wrapping the code tag inside a pre tag to eliminate otherwise unnecessary markup (like   and <br />). This makes copying and pasting the code easier.


  <script id="setup" type="text/javascript">
     ChiliBook.recipeFolder = "jquery/chili/";
  </script>

</code></pre>

There's a problem with directly integrating Chili into this site however. Chili does not include a native VB syntax highlighter. However, adding new code definitions is as simple as adding a new .js file containing a collection of JSON objects defining what terms are to be colorized and how the styles should be applied. For the current VB implementation, I've added the following colorizations:

Comments are green
String literals are red
Processing instructions (like #Region and #If) are silver
Keywords and LINQ keywords are #4040c2
XML Literal expression hole symbols (<%= and %>) are a bit different as they use a yellow background with dark gray foreground, but we can easily set this through the style tag.

To do this, we set up a JSON structure to contain the various Regular Expression match patterns and the corresponding styles:

{
      _name: "vb"
    , _case: true
    , _main: {
          com    : { 
              _match: /'.*/ 
            , _style: "color: green;"
        }
        , string : { 
              _match: /(?:\'[^\'\\\n]*(?:\\.[^\'\\\n]*)*\')|(?:\"[^\"\\\n]*(?:\\.[^\"\\\n]*)*\")/ 
            , _style: "color: red;"
        }
        , preproc: { 
              _match: /^\s*#.*/ 
            , _style: "color: silver;"
        }
        , keyword: { 
              _match: /\b(?:AddHandler|AddressOf|AndAlso|Alias|And|Ansi|As|Assembly|Auto|
Boolean|ByRef|Byte|ByVal|Call|Case|Catch|
CBool|CByte|CChar|CDate|CDec|CDbl|Char|CInt|Class|CLng|CObj|
Const|CShort|CSng|CStr|CType|Date|Decimal|Declare|Default|Delegate|
Dim|DirectCast|Do|Double|Each|Else|ElseIf|End|Enum|Erase|Error|Event|Exit|
False|Finally|For|Friend|Function|Get|GetType|GoSub|GoTo|Handles|
If|Implements|Imports|In|Inherits|Integer|Interface|Is|Let|Lib|Like|Long|Loop|
Me|Mod|Module|MustInherit|MustOverride|MyBase|MyClass|
Namespace|New|Next|Not|Nothing|NotInheritable|NotOverridable|
Object|On|Option|Optional|Or|OrElse|Overloads|Overridable|Overrides|
ParamArray|Preserve|Private|Property|Protected|Public|
RaiseEvent|ReadOnly|ReDim|REM|RemoveHandler|Resume|Return|
Select|Set|Shadows|Shared|Short|Single|Static|Step|Stop|String|Structure|
Sub|SyncLock|Then|Throw|To|True|Try|TypeOf|Unicode|Until|Variant|
When|While|With|WithEvents|WriteOnly|Xor)\b/ 
            , _style: "color: #4040c2;"
        }
        , linqkeyword: { 
              _match: /\b(?:From|Select|Where|Order By|Descending|Distinct
|Skip|Take|Aggregate|Sum|Count|Group|Join|Into|Equals)\b/ 
            , _style: "color: #4040c2;"
        }
        , xmlexpressionhole: {
              _match: /\<%=|\%>/
            , _style: "background: #fffebf; color: #555555;"
        }
    }
}

If you want, you can download this file at http://thinqlinq.com/jquery/chili/vbasic.js. Now, to use the new definition, simply add the file to the path you defined as the chiliBook.RecipeFolder above. Then add code to your page like the following:


<pre><code class="vbasic">
   Private Function FormatCategories(ByVal post As PostItem) As String
        If post.CategoryPosts.Count > 0 Then
            'Categories found. Return them
            Dim response = _
                From catPost In post.CategoryPosts _
                Select val = _
                    <span>
                        <a href=<%= "default.aspx?CategoryId=" & _
                        catPost.Category.CategoryId %>>
                           <%= catPost.Category.Description.Trim %></a>
                    </span>.ToString()
            Return String.Join(", ", response.ToArray)
        Else
            Return ""
        End If
    End Function
</code></pre>

There are a couple issues with this implementation: First, the highlighting only works if you view the page on the site. If you are viewing this through an aggregator, you won't see the syntax highlighting. Personally, I find this to be an acceptable tradeoff to the alternative--injecting the styles inline with the code as is done with the CopySourceAsHtml project or the Windows Live Writer VSPaste plug-in. Although the code is correctly highlighted when viewed from an aggregator, it is horrendous when consumed by a reader for the blind with screen reader systems.

The second issue with this implementation is that it doesn't take context into account. As a result, if you have an object with the same name as one of the keywords, it will be highlighted incorrectly. This will become more of an issue in VS 2010 when we (finally) get type colorization in VB. To do type colorization, we need access to the object symbols which are unavailable outside of the compiler's environment.

The third issue is that this version doesn't correctly colorize the XML Literals. While I'm sure it is possible, I'm not enough of a Regular Expression expert to figure out all of the options required to enable syntax highlighting for the XML Literals. If someone wants to add that, I would love to try out your suggestions.

Disable Historical Debugger when using MVC with VS 2010 beta1

jwooley — Wed, 08 Jul 2009 15:06:00 GMT

I've had a bit of down time between contracts recently and have been taking the opportunity to learn some technologies that I haven't had time to get into before. Since I've read so much about it, I thought I would try out ASP.Net MVC. Since it was just for fun, I figured I'd bite the bullet and try it under VS 2010.

I build a small sample following the tutorials at http://www.asp.net/learn/mvc/, however when I try to run it in VS 2010, the app crashes on me. There's enough "Magic" going on inside MVC, including the routing engine and dynamic loading of the controllers and views that trying to debug MVC is challenging enough when the IDE behaves. When it doesn't it makes life significantly more problematic. Naturally VS hard crashes rather than breaking in my code to let me figure out what's going wrong.

It turns out there wasn't a problem in my code, but rather an issue with MVC and the Historical Debugger which is turned on by default in VS 2010. To fix the issue, open the Option dialog (under Tools - Options) and locate the Historical Debugger tab. Uncheck the "Enable Historic Debugging" option.

Joe Cartano of the ASP team assures us that this will be fixed in Beta 2, so hopefully this is only a temporary situation. Maybe next time I'll remember to read the release notes completely before banging my head against the wall.

LINQ Bootcamp coming to Birmingham, AL

jwooley — Wed, 08 Jul 2009 10:30:00 GMT

If you are in the Birmingham, AL area on July 25-26, consider signing up for the free two day LINQ Bootcamp event. I'm hoping to be there to help answer your questions as well. If you're interested in more information, here's a copy of the original announcement:

…The upcoming LINQ Bootcamp [will be] on July 25th and 26th. To register for this great event please go to http://www.clicktoattend.com/?id=139378 . Seating is limited to this free event. We still need volunteers for presenting, currently more than half the chapters are still available. Your participation is needed to make this event a success so be ready to pick out a chapter when you arrive, first come first serve. You can also e-mail us at BhamSoftwareDevAssoc@live.com to volunteer or get more info.
Update: as of 7/6/09 Chapters 3, 9, 10, 11, and 12 have been volunteered for, other chapters are still open to potential presenters. All presenters will get a free copy of the book.

Unfortunately, the book in question isn't "LINQ in Action", but it should be a good event regardless.

How do Stored Procs fit with LINQ

jwooley — Mon, 06 Jul 2009 10:48:00 GMT

At Codestock, David Giard asked me about the pros and cons of using stored procedures or using OR/M tools like LINQ to SQL or Entity Framework. There is no silver bullet in terms of which to use. In many cases you need to use a combination of techniques depending on your particular needs. Watch the video to see what you need to consider when making this decision.

Iterators OR Excuse me waiter theres a goto in my C sharp

jwooley — Mon, 29 Jun 2009 16:30:00 GMT

At Codestock '09, I gave my LINQ Internals talk and had a number of people express shock when I showed the underlying implementation of their beloved iterators when looking at the code through Reflector. Let's look first at the C# that we wrote. This is similar to the implementation of LINQ to Object's Where method as shown in the sequence.cs file that's part of the C# Samples.


public static IEnumerable Where(this QueryableString source, Func predicate)
{
   foreach (char curChar in source)
        if (predicate(curChar))
            yield return curChar;
}

C# Iterators aren't really first class citizens, but syntactic sugar around the actual implementation. The meat of the implementation occurs in a generated class that implements the actual MoveNext method as we foreach over the results. The results are much less pretty:


private bool MoveNext()
{
    bool CS$1$0000;
    try
    {
        switch (this.1__state)
        {
            case 0:
                break;

            case 2:
                goto Label_0087;

            default:
                goto Label_00A5;
        }
        this.1__state = -1;
        this.7__wrap2 = this.4__this.GetEnumerator();
        this.1__state = 1;
        while (this.7__wrap2.MoveNext())
        {
            this.<curString>5__1 = this.7__wrap2.Current;
            if (!this.predicate(this.<curString>5__1))
            {
                continue;
            }
            this.2__current = this.<curString>5__1;
            this.1__state = 2;
            return true;
        Label_0087:
            this.1__state = 1;
        }
        this.m__Finally4();
    Label_00A5:
        CS$1$0000 = false;
    }
    fault
    {
        this.System.IDisposable.Dispose();
    }
    return CS$1$0000;
}

As you can see, the iterator sets up a switch (Select Case) statement that checks to see where we are in the loop (using a state variable). Essentially this is a state machine. The first time through we set up the environment. As we iterate over the results, we call the predicate that was passed in. If the predicate evaluates as true, we exit out of the method returning true.

The next time we return to the MoveNext, we use goto Label_0087 to re-enter the loop and continue the iteration. It's at this point that the jaws dropped in my presentation. Yes, Virginia, there are "Goto's" in C#. Spaghetti code isn't limited to VB. It's this point in my presentation where I quipped that the reason why iterators aren't in VB yet is because we want to do them "Right". While this is partly a joke, there is a level of seriousness in the comment. If you want to dig deeper on iterators, I recommend the following for your reading pleasure (note, these are NOT for the faint of heart):

Wes Dyer's excellent blog post on C# iterators.
Bart Jacobs, Erik Meijer, et al, paper on Iterators.
If you want to do iterators over heirarchical structures (necessary for implementing iterators over streamed XML), check out Martin Ward's thesis.

After reading these, I'm sure you will have a better understanding of why it is taking so long to get iterators in VB. In the mean time, you might also find Bill McCarthy's recent article on using Iterators in VB Now to be interesting.

LINQ Tools coming to Russ Tool Shed

jwooley — Mon, 29 Jun 2009 09:07:00 GMT

Russ Fustino and Stan Schultes have recently started bringing their popular Russ' Tool Shed show to the internet. If you want to check out the show, head on over to http://channel9.msdn.com/shows/toolshed. They also have all of the resources, including source code, slides, and demo scripts available at http://channel9.msdn.com/toolshed. I was there when they recorded the first episode at the South Florida code camp as an attendee.

We're hoping to do a recording at one of the upcoming Florida Code Camps to look at LINQ related tools. I'm planning on covering the following tools.

All of these tools are free (a requirement of the Code Camp manifesto). I may add a couple tools, but only have 10 minutes to cover everything. Let me know if you have a favorite tool that's not on this list.

LINQ in Action XML samples added to LINQPad

jwooley — Sun, 28 Jun 2009 14:03:00 GMT

The beginning of this month, we released the samples from "LINQ in Action" for chapters 1-8 which covers LINQ to Objects, LINQ to SQL, and the new Language features. We're happy to announce that the next three chapters covering LINQ to XML are now available. That's over 70 new samples in VB and C# each. Follow the directions on the original announcement to download and use these samples.