Matt Hidinger

Yet Another Yield Rant

Matt Hidinger — Tue, 22 Sep 2009 05:01:25 GMT

This post was spawned as I was reviewing the latest Oxite source code on CodePlex. I’ve been reading any source code I could get my hands on lately looking for inspiration to cure my “winter coding boredom.” While it isn’t winter yet, it is fast approaching, which means less outdoors time and more computer time. I try to blog more, update my open source projects with a new release, and with any luck begin a new project worth getting passionate about.

Today I'm going to hit the ground running with a short tip, again, on the yield keyword.

The following code is an excerpt from the Oxite Blog class. Blog as it turns out, is a Cacheable Entity (ICacheEntity) where the designer of the interface determined that cached entities can specify any dependencies they may have. Clearly, the developer of the ICacheEntity interface understood iterators and realized that the consumer of any ICacheEntity requires nothing more foreach’ing over the dependencies. For this reason, the method does not return an IList<T>, an ICollection<T>, or (heaven forbid) a List<T>.

Unfortunately, the developer writing the Blog class did not take advantage of the (albeit minor) utility provided. The developer chose to new up a List, insert the single item, then return the list -- as seen in the following code.

IEnumerable<ICacheEntity> ICacheEntity.GetCacheDependencyItems()
{
    List<ICacheEntity> dependencies = new List<ICacheEntity>();

    dependencies.Add(Site);

    return dependencies;
}

We've all written code like this. The bad habit may even be so ingrained into our developer DNA that we don't even realize it. Long story short, if it returns IEnumerable, you should probably use the yield keyword!

The above code can simply be re-written as follows. The benefits of this should be clear: fewer lines of code, easier readability, greater performance (minor of course, but still). Since this topic has been covered at great length on the blogosphere I won't go into any more detail, but just in case, here is a quick article I found that should help explain the benefits.

IEnumerable<ICacheEntity> ICacheEntity.GetCacheDependencyItems()
{
     yield return Site;
}

Bonus Protip

I actually stumbled onto something small but nice while reading the Oxite code. Enumerable.Empty.

IEnumerable<Product> products = Enumerable.Empty<Product>;

Technorati Tags: C#

Automatically roll back your LINQ to SQL integration tests

Matt Hidinger — Wed, 09 Sep 2009 03:59:51 GMT

Today I began integration testing my SqlRepository while I experiment with an MVC prototype. I tried googling for a simple base class for integration testing a LINQ to SQL DataContext that would provide automatic rollback between each test, but after (minimal) searching, decided to simply write my own. Perhaps this will help someone. This base class was written for MS Test, but simply renaming the attributes accordingly would yield the same results on nUnit, xUnit, etc.

The Code

Simply inherit your test class from this base class and any changes done via the internal Context property will be automatically rolled back after each test runs.

/// <summary>
/// The base class will allow LINQ to SQL integration testing with automatic rollbacks after each test
/// </summary>
/// <typeparam name="TContext">The type of data context to use</typeparam>
public abstract class RolledBackDataContextTests<TContext> where TContext : DataContext
{
    private TContext _context;
    private DbTransaction _transaction;

    [TestInitialize]
    public void InitDataContext()
    {
        if(string.IsNullOrEmpty(ConnectionString))
        {
            _context = (TContext)Activator.CreateInstance(typeof(TContext));
        }
        else
        {
            _context = (TContext) Activator.CreateInstance(typeof (TContext), ConnectionString);
        }

        _context.Connection.Open();
        _transaction = _context.Connection.BeginTransaction();
        _context.Transaction = _transaction;
    }

    /// <summary>
    /// Provides access to the internal data context. Any changes made will be automatically rolled back
    /// </summary>
    protected TContext Context
    {
        get
        {
            if(_context == null)
                InitDataContext();

            return _context;
        }
    }

    /// <summary>
    /// Optionally specify the connection string to use
    /// </summary>
    protected virtual string ConnectionString
    {
        get
        {
            return null;
        }
    }

    [TestCleanup]
    public void TestCleanup()
    {
        _transaction.Rollback();
        _context.Dispose();
        _context = null;
    }
}

Usage

[TestClass]
public class SqlRepositoryTests : RolledBackDataContextTests<NorthwindDataContext>
{
    // Insert as many Products as required and then exercise your database integration Test Methods
    public void InsertProductToContext()
    {
        Product p = new Product { ProductName = "Temporary Product"};
        Context.Products.InsertOnSubmit(p);
        Context.SubmitChanges();

        // After each test ends, the transaction will be rolled back, and the new Product will not be in the database
    }

    [TestMethod]
    public void Test1()
    {
        // Test logic here
    }
}

Technorati Tags: LINQ to SQL,Unit Testing

Creating a simple ToDelimitedString extension method

Matt Hidinger — Tue, 08 Sep 2009 02:55:32 GMT

This was one of the first extension methods I wrote when C# 3.0 arrived, since I just stumbled across it on an older project I figured I might as well post it, if for nothing else but future reference. One downside to be aware of if you choose to use this method, is that it will not project the results on a IQueryable provider like LINQ to SQL, so please be aware the conversion will be done on the client side.

The Code

public static class DelimitedStringExtensions
{
    public static string DefaultDelimiter = ", ";

    /// <summary>
    /// Convert a sequence of items to a delimited string. By default, ToString() will be called on each item in the sequence to formulate the result. The default delimiter of ', ' will be used
    /// </summary>
    public static string ToDelimitedString<T>(this IEnumerable<T> source)
    {
        return source.ToDelimitedString(x => x.ToString(), DefaultDelimiter);
    }

    /// <summary>
    /// Convert a sequence of items to a delimited string. By default, ToString() will be called on each item in the sequence to formulate the result
    /// </summary>
    /// <param name="delimiter">The delimiter to separate each item with</param>
    public static string ToDelimitedString<T>(this IEnumerable<T> source, string delimiter)
    {
        return source.ToDelimitedString(x => x.ToString(), delimiter);
    }

    /// <summary>
    /// Convert a sequence of items to a delimited string. The default delimiter of ', ' will be used
    /// </summary>
    /// <param name="selector">A lambda expression to select a string property of <typeparamref name="T"/></param>
    public static string ToDelimitedString<T>(this IEnumerable<T> source, Func<T, string> selector)
    {
        return source.ToDelimitedString(selector, DefaultDelimiter);
    }

    /// <summary>
    /// Convert a sequence of items to a delimited string.
    /// </summary>
    /// <param name="selector">A lambda expression to select a string property of <typeparamref name="T"/></param>
    /// <param name="delimiter">The delimiter to separate each item with</param>
    public static string ToDelimitedString<T>(this IEnumerable<T> source, Func<T, string> selector, string delimiter)
    {
        if (source == null)
            return string.Empty;

        if(selector == null)
            throw new ArgumentNullException("selector", "Must provide a valid property selector");

        if (string.IsNullOrEmpty(delimiter))
            delimiter = DefaultDelimiter;

        return string.Join(delimiter, source.Select(selector).ToArray());
    }
}

Usage

Example using an array of ints

int[] ints = { 1, 4, 5, 7 };

// Returns "1, 4, 5, 7"
string result = ints.ToDelimitedString();

Example using a List

var products = new List<Product>
               {
                   new Product { ProductName = "Chai" },
                   new Product { ProductName = "Chang" },
                   new Product { ProductName = "Tofu" },
               };

// Returns "Chai, Chang, Tofu"
string result1 = products.ToDelimitedString(p => p.ProductName);


// Returns "Chai;Chang;Tofu"
string result2 = products.ToDelimitedString(p => p.ProductName, ";");

Example using a DataTable

// Returns "Chai, Chang, Tofu"
string result = table.AsEnumerable().ToDelimitedString(row => (string)row["ProductName"]);

Technorati Tags: C#,LINQ

Convention based LINQ querying

Matt Hidinger — Fri, 04 Sep 2009 19:14:42 GMT

LINQ and Expression Trees have enabled a ton of possibilities for us as developers, particularly in establishing some code-reducing convention based querying. I have found myself playing with Expressions in C# since their inception and will hopefully be publishing a few other posts I have queued up. For now, this post will simply demonstrate how to take advantage of a popular convention whereby each database table always has a single integer primary key named “Id”

By taking advantage of this primary key convention I can save myself a ton of boilerplate code to query a table by ID.

The Extension Method

public static T GetById<T>(this IQueryable<T> query, int id) where T : class
{
    // Create lambda parameter x of type T
    var param = Expression.Parameter(typeof(T), "x");

    // Given x param, extract the Id property
    var memberExpression = Expression.Property(param, "Id");

    // Build Lambda expression
    // x => x.Id == id
    var whereClause =
        Expression.Lambda<Func<T, bool>>(
            Expression.Equal(
                memberExpression,
                Expression.Constant(id)
                ), param);

    return query.Single(whereClause);
}

Usage

NorthwindDataContext db = new NorthwindDataContext();
var product = db.Products.GetById(1);
var order = db.Orders.GetById(15);

Technorati Tags: LINQ,LINQ to SQL,Expression Trees

Creating a Html.DisplayForMany Helper for MVC 2

Matt Hidinger — Sun, 16 Aug 2009 00:47:27 GMT

Note: This article was written for ASP.NET MVC 2 Preview 1 – it may become outdated in future previews.

The Html helper in ASP.NET MVC 2 comes with some handy methods called “DisplayFor” and “EditFor” – please see Scott Gu’s article if you are not familiar with these new features. Long story short, they provide an ASP.NET Dynamic Data-like mechanism which uses reflection and templating to render a display form or an edit form. It works great for primitive properties like String, DataTime, Int32, as well as complex types like “Address.” However, as I was playing with them, I came across a rather funny exception (excusable, I suppose, due to the preview state of MVC 2 at the time of this writing).

This exception should never occur.
Description: An unhandled exception occurred during the execution of the current web request. Please review the stack trace for more information about the error and where it originated in the code.
Exception Details: System.InvalidOperationException: This exception should never occur.
Source Error:
Line 5:  <%= Html.DisplayFor(m => m.Comments) %>

This error occurs because the “Comments” property is an IList<Comment> – the DisplayFor() method choked because the property type is an interface rather than a concrete class that of course derives from System.Object – which is where the DisplayFor reflection magic comes from. However, that wasn’t really my problem, I could work around that and make my property a List<Comment> instead of IList<Comment> (as a workaround). After this change, the exception is gone, but the results are not what I needed.

Capacity: 2

Count: 2

This is what ended up being rendered on my page, which makes sense – DisplayFor() reflected on the 2 public properties of the List<T> type and displayed them for me. What I really wanted to do however, was iterate over the list and call DisplayFor() on each individual item.

Enter the DisplayForMany extension method.

The code is longer than I would like due to a number of complications and restrictions in the current DisplayFor extension methods and internal classes that would have been handy to have access to. The comments hopefully explain the workarounds, but in any case, just copy this code into your helper class and enjoy.

public static string DisplayForMany<TModel, TValue>(this HtmlHelper<TModel> html, Expression<Func<TModel, IEnumerable<TValue>>> expression) where TModel : class
{
    StringBuilder sb = new StringBuilder();

    // Get the items from ViewData
    var items = expression.Compile()(html.ViewData.Model);


    foreach(TValue item in items)
    {
        // Current html.DisplayFor() throws exception if the expression is anything that isn't a "MemberAccessExpression"
        // So we have to trick it and place the item into a dummy wrapper and access the item through a Property
        var dummy = new {Item = item};

        // Get the actual item by accessing the "Item" property from our dummy class
        var memberExpression = Expression.MakeMemberAccess(Expression.Constant(dummy), dummy.GetType().GetProperty("Item"));

        // Create a lambda expression passing the MemberExpression to access the "Item" property and the expression params
        var singleItemExpression = Expression.Lambda<Func<TModel, TValue>>(memberExpression,
                                                                           expression.Parameters);

        string singleItemHtml = html.DisplayFor(singleItemExpression);
        sb.AppendFormat(singleItemHtml);    
    }

    return sb.ToString();
}

Usage and Output

<h3>Comments</h3>
<%= Html.DisplayForMany(m => m.Comments) %>

Technorati Tags: ASPNET MVC

DoddleImport on CodePlex

Matt Hidinger — Sun, 01 Mar 2009 05:47:10 GMT

Well I am heading out to Myrtle Beach tonight at 4am, so I spent today finishing up some cleanup so I could release DoddleImport on CodePlex. It should be pretty feature complete and ready for use, and as always, please let me know if it helps you out!

Objective

Flexible importing of data via a fluid and fully extensible API to easily add support for new Import Sources and Import Destinations.

I will update the documentation and provide some better examples when I get back. Here you can see a quick example of me importing some Excel data into a SharePoint list. As you can see it supports a variety of validation including missing fields and data type conversion problems.

Key Components

Importing relies on 2 distinct (and entirely extensible) mechanisms:

IImportSource - The import framework requires a set of row/field data provided via an IImportSource
IImportDestination - The import framework requires a destination to write the data to via an IImportDestination

Note: Most "importable" classes implement both IImportSource as well as IImportDestination, as such, can be used as a source of import rows and a destination to import into

Import Sources and Destinations

DoddleImport ships with some basic Import Sources, but just like all other Doddle Projects, you can easily create your own by implementing a simple interface.

ImportableCollection - provides importing to and from a generic list
ImportableDictionary - provides importing to and from a basic dictionary
ImportableSPList - provides importing to and from a SharePoint List
Spreadsheet - provides importing from an Excel Spreadsheet

Usage

// Basic import from one type of in-memory collection to another
ImportableDictionary source = new ImportableDictionary();
source.Fields.Add("ProductID", typeof(int));
source.Fields.Add("ProductName", typeof(string));

IDictionary row1 = source.AddRow();
row1["ProductID"] = 1;
row1["ProductName"] = "My Product";

List products = new List<Product>();
IImportDestination destination = new ImportableCollection<Product>(products);

Importer importer = new Importer();
importer.Import(source, destination);

// More realistic example, importing an Excel Spreadsheet into a SharePoint list
Stream uploadedFile = fileUpload.PostedFile.InputStream;
Spreadsheet spreadsheet = new Spreadsheet(uploadedFile);

SPList myList = Web.Lists["My List"];
IImportDestination destination = new ImportableSPList(myList);

Importer importer = new Importer();
importer.Import(spreadsheet, destination);

Validation

DoddleImport will provide automatic validation of your Import Source against the specified destination. This ensures that the entire import contents will be successfully imported as well as provide helpful error messages to your user so they can easily correct errors.

Validation Rules

The validation mechanism works by automatically evaluating rules against each row being imported. This is handled through the IValidationRule interface.

The default rules with DoddleImport are as follows:
- RequiredFieldsRule - validates a row to make sure that data was provided for all required fields
- MissingHeadersRule - validates that the source contains all required fields that the destination expects
- DataTypeValidationRule - valdiates data type mis-match errors

Configuration

If you want to change some of th default behavior of DoddleImport then using your application configuration file is the best place to start.

To use configuration, be sure to register the <section> node between <configSections> in your app.Config or web.Config

From there, you can add or remove validation rules that will be automatically applied to every import. You are also able to customize the default validation messages. Below is a quick sample of some of the changes that can be made.

<configuration>
  <configSections>
    <section name="doddleImport" 
          type="Doddle.Import.Configuration.ImportSection, Doddle.Import, Version=1.0.0.0, Culture=neutral, PublicKeyToken=6f5f0fd458d019c9" />
  </configSections>
  <doddleImport>
    <validation>
      <rules>
        <remove name="MissingHeadersRule" />
        <add name="MyCustomRule" type="MyName.Importing.CustomValidationRule, MyName.Importing" />
      </rules>
      <messages>
        <remove rule="RequiredFieldsRule" />
        <add rule="RequiredFieldsRule" message="Unable to locate field '{0}'"/>
      </messages>
    </validation>
  </doddleImport>
</configuration>

That's all for now, check back for updates on this and some other projects.

Get the Source and Try it out!

Check it out at CodePlex

Technorati Tags: Doddle,SharePoint

WCSF ObjectContainerDataSource with LINQ to SQL

Matt Hidinger — Thu, 19 Feb 2009 20:49:06 GMT

A project I am now working on is using the Web Client Software Factory (WCSF) from the patterns & practices team. It is basically an elaborate MVP-based framework that currently sits on top of ASP.NET Webforms.

One of the components it ships with is the ObjectContainerDataSource which is a lot like the ObjectDataSource that ASP.NET provides. I admittedly have little experience with either of these controls, since I am not a huge fan of declarative data binding in larger applications. It does however offer better integration with the MVP pattern, simplifying the “bubbling” of DataSource events up to the Presenter to handle them. The Presenter is of course where all of the logic for the view and its services belongs.

At first everything was working great: selects, server-side paging, server-side sorting, even inserting. But when I tried some Updates and Deletes with the GridView and the ObjectContainerDataSource I was encountering a frustrating exception I hadn’t seen before.

Row not found or changed.

The exception was being thrown on the dataContext.SubmitChanges(). After some quick digging I found that this error is due to our Timestamp column which is used by the LinqDataContext for optimistic concurrency. Before the Data Source fires its Updated event, it re-creates an instance of the object and populates the properties with the values in the data control using reflection. However, the ObjectContainterDataSource was not setting the Timestamp property when it was re-constructing the object for updating. This was causing the LinqDataContext to throw the “Row not Found” exception because it could not find a row WHERE ContractorId = 1 AND Timestamp = NULL. I needed some way to persist the Timestamp property within the DataSource so it would re-populate it on the Updated event.

exec sp_executesql N'UPDATE [dbo].[Contractors] 
SET [ContractorName] = @p2 WHERE ([ContractorId] = @p0) AND ([Timestamp] = @p1) 

@p0=1,
@p1=NULL,
@p2='My Updated Contractor'

The solution I found, was to include the Timestamp column in the DataKeyNames property. This ensured that the data source would correctly populate the property even though it did not appear as a column in my GridView.

<asp:GridView ID="ContractorGrid" runat="server" 
    AutoGenerateEditButton="true" AutoGenerateDeleteButton="true"
    DataSourceID="ContractorDataSource" DataKeyNames="ContractorId, Timestamp"
    PageSize="5" AllowPaging="true" AllowSorting="true" AutoGenerateColumns="false">

This may be a well-known problem with LINQ to SQL and the DataSources, but as I mentioned I don’t use them that much for declarative data binding. Either way, hopefully this saves someone frustration down the road.

Technorati Tags: WCSF,LINQ to SQL

ASP.NET MVC Recursive TreeView Helper

Matt Hidinger — Sun, 08 Feb 2009 12:57:00 GMT

Update 2/10/2009: I have updated the helper code a little bit to include an ID parameter as well as to inject the jQuery treeview script code automatically. Please modify to your desire, or make sure to include the jQuery TreeView plugin script to your page before running.

The following helper will make it easy to create a tree view from a recursive self-referencing table. Below you are seeing a tree of “Locations” where each Location can contain X number of child locations.

Dependencies

jQuery TreeView Plugin

Rendered Tree

Table Definition

The table itself is extremely simple, each Location has a ParentLocationId which is a relationship to the same table. If the ParentLocationId is null then it is a root location.

Usage

Simple

<%= Html.TreeView("locations", 
    Model.Locations, 
    l => l.ChildrenLocations, 
    l => l.Name) %>

Wrapping a div around each list item

<%= Html.TreeView("dropTree", 
    Model.Locations, 
    l => l.ChildrenLocations, 
    l => "<div class='dropZone'>" + l.Name + "<div>")

Making each list item an ActionLink

<%= Html.TreeView("dropTree", 
    Model.Locations, 
    l => l.ChildrenLocations, 
    l => Html.ActionLink("MyController", "MyAction", l.Name, new { id = l.Name })

The Code

public static class TreeViewHtmlHelper
{
    /// <summary>
    /// Create a TreeView of nodes starting from a root element
    /// </summary>
    /// <param name="treeId">The ID that will be used when the ul is created</param>
    /// <param name="rootItems">The root nodes to create</param>
    /// <param name="childrenProperty">A lambda expression that returns the children nodes</param>
    /// <param name="itemContent">A lambda expression defining the content in each tree node</param>
    public static string TreeView<T>(this HtmlHelper html, string treeId, IEnumerable<T> rootItems, Func<T, IEnumerable<T>> childrenProperty, Func<T, string> itemContent)
    {
        return html.TreeView(treeId, rootItems, childrenProperty, itemContent, true, null);
    }

    /// <summary>
    /// Create a TreeView of nodes starting from a root element
    /// </summary>
    /// <param name="treeId">The ID that will be used when the ul is created</param>
    /// <param name="rootItems">The root nodes to create</param>
    /// <param name="childrenProperty">A lambda expression that returns the children nodes</param>
    /// <param name="itemContent">A lambda expression defining the content in each tree node</param>
    /// <param name="includeJavaScript">If true, output will automatically render the JavaScript to turn the ul into the treeview</param>    
    public static string TreeView<T>(this HtmlHelper html, string treeId, IEnumerable<T> rootItems, Func<T, IEnumerable<T>> childrenProperty, Func<T, string> itemContent, bool includeJavaScript)
    {
        return html.TreeView(treeId, rootItems, childrenProperty, itemContent, includeJavaScript, null);
    }

    /// <summary>
    /// Create a TreeView of nodes starting from a root element
    /// </summary>
    /// <param name="treeId">The ID that will be used when the ul is created</param>
    /// <param name="rootItems">The root nodes to create</param>
    /// <param name="childrenProperty">A lambda expression that returns the children nodes</param>
    /// <param name="itemContent">A lambda expression defining the content in each tree node</param>
    /// <param name="includeJavaScript">If true, output will automatically render the JavaScript to turn the ul into the treeview</param>
    /// <param name="emptyContent">Content to be rendered when the tree is empty</param>
    /// <param name="includeJavaScript">If true, output will automatically into the JavaScript to turn the ul into the treeview</param>    
    public static string TreeView<T>(this HtmlHelper html, string treeId, IEnumerable<T> rootItems, Func<T, IEnumerable<T>> childrenProperty, Func<T, string> itemContent, bool includeJavaScript, string emptyContent)
    {
        StringBuilder sb = new StringBuilder();

        sb.AppendFormat("<ul id='{0}'>\r\n", treeId);

        if(rootItems.Count() == 0)
        {
            sb.AppendFormat("<li>{0}</li>", emptyContent);
        }

        foreach (T item in rootItems)
        {
            RenderLi(sb, item, itemContent);
            AppendChildren(sb, item, childrenProperty, itemContent);
        }

        sb.AppendLine("</ul>");

        if (includeJavaScript)
        {
            sb.AppendFormat(
                @"<script type='text/javascript'>
                    $(document).ready(function() {{
                        $('#{0}').treeview({{ animated: 'fast' }});
                    }});
                </script>", treeId);
        }

        return sb.ToString();
    }

    private static void AppendChildren<T>(StringBuilder sb, T root, Func<T, IEnumerable<T>> childrenProperty, Func<T, string> itemContent)
    {
        var children = childrenProperty(root);
        if(children.Count() == 0)
        {
            sb.AppendLine("</li>");
            return;
        }

        sb.AppendLine("\r\n<ul>");
        foreach (T item in children)
        {
            RenderLi(sb, item, itemContent);
            AppendChildren(sb, item, childrenProperty, itemContent);
        }

        sb.AppendLine("</ul></li>");
    }

    private static void RenderLi<T>(StringBuilder sb, T item, Func<T, string> itemContent)
    {
        sb.AppendFormat("<li>{0}", itemContent(item));            
    }
}

Technorati Tags: ASPNET MVC,jQuery

jQuery UI 1.6rc6 tabs bug with IE6/7

Matt Hidinger — Sat, 07 Feb 2009 12:53:00 GMT

I encountered a rather frustrating problem with jQuery UI tabs this week. The problem occurs when trying to tabify some content after using jQuery’s $().load method to load the tabs HTML via an ajax request.

The following code works perfectly in all browsers except IE6 and IE7 (It works fine in IE8 as well), as can be seen in the screenshot below.

$('#deviceDetailsWrapper').load('/device/details/294', null, function() {
    $('#tabs').tabs();
});

However, here is what renders in IE6/7. For some reason, the jQuery tabs are triggering a GET request of the current URL and loading the content into the tab itself. Below you are actually seeing the entire page loaded inside the tab. I discovered this by inspecting the DOM tree within the tab in Firebug, as well as loading up Fiddler and watching the tab call an entirely separate GET request to the current URL as soon as the tabs were loaded. Strange behavior to me, since I am not entirely familiar with the jQuery tabs.

The Solution

The only thing I discovered was different regarding the .tabs() DOM manipulation in the different browsers was the ID of the tab – instead of being the #tab-id that I named it, the element was being assigned the full URL+#id to the container. So “#tab1” was becoming “http://localhost/device#tab1” – which I believe was triggering the tabs to behave in their “ajax” mode, which is a built-in feature of the jQuery tabs.

The solution I found was opening up jquery.ui.all.js and locating the following code:

this.$tabs.each(function(i, a) {
var href = $(a).attr('href');

// inline tab
if (fragmentId.test(href))
    self.$panels = self.$panels.add(self._sanitizeSelector(href));

Replace it with the following:

this.$tabs.each(function(i, a) {
var href = $(a).attr('href');
            
// Fix tab IDs in IE6/7
href = href.substring(href.indexOf("#"));

// inline tab
if (fragmentId.test(href))
    self.$panels = self.$panels.add(self._sanitizeSelector(href));

Hopefully this helps someone in their googling of this problem. I will be logging this as a bug with the jQuery developers.

Technorati Tags: javascript,jQuery,web standards

LINQ Audit Trail v2 - DoddleAudit

Matt Hidinger — Mon, 12 Jan 2009 12:50:00 GMT

A couple months ago I wrote a basic set of extension methods to handle automatic auditing in LINQ to SQL. Well I have received a large number of emails regarding this particular project so I have decided to focus on cleaning up my v2 API and releasing it on CodePlex. There was a lot of room for improvement from version 1 and today I am going to post the all new LINQ Audit Trail code. This new version is significantly enhanced in the previous version.

Objective

Automatic auditing of all inserts/updates/deletes for any table in your database with a single line of code, including:

What table was modified?

What fields changed?

Who made the change?

When did it occur?

Usage

Simply define your audit definitions at any time before calling SubmitChanges();

this.Products.Audit();
this.Categories.Audit();
this.Orders.Audit().AuditAssociation(o => o.Order_Details);
this.Contacts.Audit().AuditAssociation(c => c.Addresses).AuditAssociation(c => c.PhoneNumbers);

Updates and Download

Please see the CodePlex project for updates and new releases. DoddleAudit

New Features and Fixes in V2

A significantly refined API for defining which tables to audit, including automatic primary key lookups.
Inserted records will have their primary keys correctly stored in the audit table now.
Built-in support for auditing across relationships.
- E.g., assume you want to audit a Contacts table which has a 1-to-many relationship to the Addresses table, thus allowing any number of Addresses to each Contact. Well ideally you want to show these Address audits on your ContactDetails.aspx, which is exactly what you can see in the screenshot below.

Ability to define custom “audit property resolvers” to override the default auditing mechanism for properties that you specify.

For example, notice in the above screenshot that “Address Type” has a value of “1” since that is how the data is stored in the table. This number does little good for the end user, so in V2 it is now possible to customize specific properties as needed. I will explain more details about this soon. Below I am overriding the default auditing of the Product.CategoryID property by querying the category by looking up the CategoryID, returning the Category.CategoryName, and renaming the audit field to “Category” since “CategoryID” is no longer accurate.

public class ProductAuditResolver : AuditPropertyResolver
{
    protected override void CustomizeProperties()
    {
        CustomizeProperty(p => p.CategoryID, categoryId => GetCategoryByID(cid).CategoryName, "Category");
    }
}

Instructions

Download the latest release from CodePlex, the source code and compiled DLL are available, and add reference to Doddle.Linq.Audit.dll in your project that contains your LINQ to SQL DBML
At a minimum you will need to add 2 tables to your database (and your DBML) to store the audit records. Please see the schema below and add these tables to your database.
- NOTE: Keep in mind this database schema is entirely customizable. I chose to use two tables to store all of my audits, but you could very easily change this logic to use a separate table for each entity or whatever storage schema you choose.
Open your DBML and click in the designer surface. In the property pane you will need to change the Base Class property of your generated DataContext to be Doddle.Linq.Audit.LinqToSql.AuditableDataContext

Lastly you will need to create a partial DataContext class to wire up the auditing infrastructure to match your database schema. Add a new Class file to your project and insert the following code. Customize if necessary to match your auditing schema.

public partial class NorthwindEntitiesDataContext
{
    protected override void InsertAuditRecordToDatabase(EntityAuditRecord record)
    {
        AuditRecord audit = new AuditRecord();
        audit.Action = (byte)record.Action;
        audit.AuditDate = DateTime.Now;
        audit.AssociationTable = record.AssociationTable;
        audit.AssociationTableKey = record.AssociationTableKey;
        audit.EntityTable = record.EntityTable;
        audit.EntityTableKey = record.EntityTableKey;

        audit.UserName = HttpContext.Current.User.Identity.Name;

        foreach (ModifiedEntityProperty av in record.ModifiedProperties)
        {
            AuditRecordModifiedField field = new AuditRecordModifiedField();
            field.MemberName = av.MemberName;
            field.OldValue = av.OldValue;
            field.NewValue = av.NewValue;

            audit.AuditRecordModifiedFields.Add(field);
        }

        this.AuditRecords.InsertOnSubmit(audit);
    }

    protected override void DefaultAuditDefinitions()
    {
        this.Products.Audit();
        this.Categories.Audit().AuditAssociation(c => c.Products);
    }
}

Known Issues

I have not finished the support for the Entity Framework implementation of the auditing yet. If anyone more experienced with EF is out there downloading this source please let me know if you want to help complete it.

Hopefully that is enough to get anyone started with the code. I am certainly looking for feedback for any suggestions, problems, or improvements. After some more unit testing and perhaps some slight refinements to the API I will remove the “beta” moniker.

Technorati Tags: LINQ,LINQ to SQL,Doddle

Fixing Web Application Projects with automated TFS Builds

Matt Hidinger — Sun, 09 Nov 2008 12:45:00 GMT

This weekend I started playing with Automated Builds in TFS 2008. Over the next few weeks I am going to setup automated builds for my various projects so I can start running automated integration testing and automated staging releases at certain intervals (nightly, weekly, etc). Unfortunately I hit a snag when I tried building one of my solutions that contained a Web Application Project.

After some digging around, I eventually opened up the “Release.txt” log file which can be found in the deployment directory, I found the following error:

error MSB4019: The imported project "C:\Program Files\MSBuild\Microsoft\VisualStudio\v9.0\WebApplications\Microsoft.WebApplication.targets" was not found. Confirm that the path in the <Import> declaration is correct, and that the file exists on disk.

Now I am no where near an expert on MSBuild or the delicacies of .csproj files, so I did my best to poke around in there and see what might be going on. For those unaware, every .csproj file is actually just an XML file with various details about your actual project. In order to view/edit the project definition you can simply right-click on the project and select “Unload Project.” Once it has been unloaded, you can right-click again and select “Edit YourProject.csproj”

Once open, a search for the <Import> tag revealed the exact line causing the problem.

<Import Project="$(MSBuildExtensionsPath)\Microsoft\VisualStudio\v9.0\WebApplications\Microsoft.WebApplication.targets" />

It would appear the Visual Studio 2008 will install all necessary MSBuild targets into the v9.0 directory – which is exactly what brings us to our problem. My Build Server does not have Visual Studio installed, it is just a basic Server 2008 box with .NET 3.5 and nothing fancy (aside from all the TFS gear). The problem is that these v9.0 targets were not available on my build machine, so I found 2 completely different solutions that ended up resolving my issue.

Solution 1 – Add Conditional Imports (Not Recommended)

A google search of the actual MSBuild error brought me to a single post by Steven Harman which seemed helpful but I was skeptical because it was related to multi-targeting and problems with a machine running both VS 2008 and VS 2005. I decided to try it out by editing my csproj to the following:

I replaced the original <Import> declaration to the following

<ImportCondition="'$(Solutions.VSVersion)' == '8.0'" Project="$(MSBuildExtensionsPath)\Microsoft\VisualStudio\v8.0\WebApplications\Microsoft.WebApplication.targets" />

<ImportCondition="'$(Solutions.VSVersion)' == '9.0'" Project="$(MSBuildExtensionsPath)\Microsoft\VisualStudio\v9.0\WebApplications\Microsoft.WebApplication.targets" />

With this change in place, I re-ran by TFS Build and it worked successfully. Unfortunately, this is extremely tedious to manually edit all of my .csproj files to facilitate automated builds.

Solution 2 – Copy the v9.0 Targets to Build Machine (Recommended)

Once I started really thinking about the error, another solution seemed very clear and simple – just provide my build server with the target files. This solution ends up being much simpler and does not require editing any csproj files:

On your development machine, copy everything in “C:\Program Files\MSBuild\Microsoft\VisualStudio\v9.0” to the same folder on your build machine. This will provide your build machine with the correct target files required by your projects. I have only tested the Web Application projects but I see no reason that everything else would not work properly. Please let me know if anyone runs into issues with this.

Technorati Tags: ASPNET,TFS,CI,ASPNET MVC

Increase AddIn Performance with MAF and WPF using LoaderOptimization

Matt Hidinger — Sun, 12 Oct 2008 11:39:00 GMT

As mentioned in my previous article, the Managed AddIn Framework supports AppDomain isolation out of the box. This can come in very handy as long as you understand what is really happening under the covers. I am not going to cover all the details of AppDomain isolation and assembly loading within the CLR, but there are plenty of great resources about such things on MSDN. All you need to know for this article is that every .NET assembly much be loaded into memory within an AppDomain, and unless you specifically share assemblies across these domains (as explained below) then they will be loaded into memory for every AppDomain you create. This is particularly important for WPF AddIns, because the WPF assemblies consume a rather generous portion of memory, and since your AddIns are each loaded into their own AppDomain, this means that the WPF assemblies must also be loaded into each of these AppDomains. If you are not careful, your application could begin to consume large amounts of memory without you even noticing.

To solve this, you can place an attribute on the Main method of any .NET executable, explicitly stating that you want the CLR to share any assemblies that it can. There are certain rules for an assembly to be shareable, one of which is that it must have a strong name and be placed in the GAC – obviously this is not a problem for the .NET framework assemblies, WPF in our case.

When you create a new WPF Project the project template will create an App.xaml for you. Since WPF does a little magic behind the scenes, there is no way to access the Main method of your application. In this case, you simply delete the App.xaml and create a new Application.cs class with the following code:


public class Application : System.Windows.Application
{
    public Application()
    {
        StartupUri = new Uri("Window1.xaml", UriKind.Relative);
    }
    
    public static Application App;

    [System.STAThreadAttribute()]
    [System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [System.LoaderOptimization(LoaderOptimization.MultiDomainHost)]
    public static void Main()
    {
        // Add attribute above this method
        Application app = new Application();
        App = app;
        app.Run();
    }
}

Technorati Tags: WPF,MAF

Managed AddIn Framework (System.AddIn) with WPF

Matt Hidinger — Sun, 12 Oct 2008 11:36:00 GMT

Disclaimer: This post is mainly for my own reference. Quite honestly, the Managed AddIn Framework (henceforth known as MAF), is a rather complex beast, and I simply cannot remember all the steps necessary to utilize it properly without a small reference guide. This post will cover the complete step-by-step tutorial of every action that a developer must perform to utilize the AddIn framework. It will not be a complete overview of what MAF is or how all the parts tie together. I will do my best to cover these things, but I have also included some very helpful reference material that will cover these topics better than I ever could.

Before continuing

This post does not cover all the intricacies and overall design of the Managed AddIn framework. While it will in fact walk you through a step-by-step creation of a WPF app that supports AddIns, it will not fully explain what the various MAF pipeline projects are used for (or the pipeline itself for that matter). It would be in your best interest to watch this excellent screencast from Daniel Roth first.

What is it?

MAF is the (much overdue, in my opinion) plugin/addin framework for .NET applications. It allows application developers to expose very simple extensibility points that allows third party developers to enhance your product. Common examples are creating an email client and relying on AddIns for services like Spell Checking, Virus Scanning, etc. Whether plugins are a core part of your application or merely a small feature, the Managed AddIn Framework should be employed to your advantage from here on out.

Note: System.AddIn is a .NET 3.5 assembly, and as such means that you must target .NETFX 3.5 to utilize it.

MAF consists of the following assemblies

System.AddIn
System.AddIn.Contract

MAF gives your application the following benefits (at the expense of extra complexity and a steeper learning curve)

Discovery – Find addins at runtime
Activation – Load an addin at runtime
Versioning - Backwards/forward compatibility
Isolation – Load addins into separate AppDomains/Processes so they cannot crash they whole app, among other reasons
Lifetime Management – MAF will handle addin lifetimes and memory/AppDomain management
Sandboxing – Load addins with specific permission sets like “Internet”
Unloading – Unload an addin without worrying about tedious AppDomain management

Our goal

By the end of this article you should be able to produce something like below. I know it doesn’t look like much, but it’s tackling a very specific scenario for a hobby project I am working on currently. The goal is to create a host WPF app that allows me (or third parties) to write addins for the host that will render custom WPF UI and allow interaction with the rest of the application.

Below we have a very basic WPF window with a TabControl. The cool thing about this application is that the TabControl is databound to an AddIn collection -- the tabs themselves as well as the tab content are entirely rendered at runtime from an AddIn via the Managed AddIn framework.

Step 1 – Define Contact Interface and utilize Pipeline Builder

The first thing you need to be (painfully) aware of, is the project/directory structure that the MAF Pipeline requires. There is some flexibility here but not a whole lot of wiggle room. Thankfully, the only project I have to concern myself with is the Contract assembly (CouchPotato.AddIn.Contract below). With a proper directory structure in place you can use a tool that the MAF team released called Pipeline Builder to generate the necessary MAF projects for you automatically. The arrows below indicate which projects were generated by Pipeline Builder – it is important to understand that the only project/code I actually wrote in this entire solution is the ICouchPotatoAddInContract.cs. Please see the screencast above or the resources below for more details on Pipeline Builder.

Ok let’s get started. The following instructions will create the optimal directory/project structure for a MAF-based application.

Prepare the directory structure for your MAF application by creating a parent folder in your Visual Studio 2008\Projects folder (or wherever you choose). I named my folder “CouchPotato”
Next, create a new Class Library project for your AddIn contact, I chose CouchPotato.AddIn.Contract. Create this project inside your parent folder from Step 1.
- Add reference to System.AddIn and System.AddIn.Contract
- Hopefully you have installed Pipeline Builder by now, so you should add reference to “C:\Program Files\Microsoft\Visual Studio Pipeline Builder\PipelineHints.dll”
  - This assembly does not need to be deployed with your application. It is only used by the Pipeline Builder during debugging
- Create your contract interface, I chose the following

[AddInContract]
public interface ICouchPotatoAddInContract : IContract
{
    string Name { get; }
    string Description { get; }
    void Initialize();
    INativeHandleContract HomeScreen { get; }
}

For now, don’t worry about INativeHandleContract. This is an interface that the MAF team added to support much better UI passing between isolation boundaries (AppDomains). This interface allows an AddIn to very easily pass direct UI elements to the host application, which is very important for my application.
Notice that MAF requires two rules for your AddIn Contracts: first you must derive from the IContact interface from System.AddIn.Contract assembly, as well as add the [AddInContract] attribute also from the same assembly.
Next, I chose to specify some naming ‘hints’ to the Pipeline builder. These hints tell the Pipeline Builder utility what to name the 4 assemblies that it will be generating for me. Click here to view all available Pipeline Hints

[assembly: PipelineHints.SegmentAssemblyName(PipelineHints.PipelineSegment.HostView, "CouchPotato.AddIn.HostView")]
[assembly: PipelineHints.SegmentAssemblyName(PipelineHints.PipelineSegment.AddInView, "CouchPotato.AddIn.AddInView")]
[assembly: PipelineHints.SegmentAssemblyName(PipelineHints.PipelineSegment.HostSideAdapter, "CouchPotato.AddIn.HostSideAdapters")]
[assembly: PipelineHints.SegmentAssemblyName(PipelineHints.PipelineSegment.AddInSideAdapter, "CouchPotato.AddIn.AddInSideAdapters")]

We are almost done, but before we build this project we need to change to output path from the default “/bin/Debug” to “../output/Contracts”. For further explanation on this please see the excellent screencast by Daniel Moth.

Ok we are ready to build, go ahead and build your project.
- This step is important because the Pipeline builder does not examine your source code to generate the dependent assemblies, only the compiled code via reflection.
Launch the Pipeline Builder from the Tools menu. Default settings should be fine if you have been following along. Pressing OK should generate 4 new projects to your solution, as seen above.
Note: I believe this is a bug I ran into with the Pipeline Builder CTP, but in my case I was forced to rename the generated Assembly Name/Default Namespace after the first generation as seen below. Take a look at your projects and verify these settings. Once you change them the first time you will not have to do it again, even if you use Pipeline builder again (and you will).

Step 2 – Create our Host WPF Application

Now that our AddIn Pipeline is complete let’s create the host application.

Open a new instance of Visual Studio and create a new WPF Project, create it inside the same parent folder that we used for our Contracts project.

Add reference to System.AddIn
Add reference to your HostView assembly that can be found by browsing to “../output/CouchPotato.AddIn.HostView.dll”
Important: Make sure you set CopyLocal=false for your HostView assembly

Finally, change your build output path to the root output directory

I have created a very simple WPF Window with a TabControl. As you can see I am taking advantage of the ContentPresenter control to handle rending of the AddIn control for me. This is a great trick

<TabControl x:Name="PluginContainer" TabStripPlacement="Bottom">
    <TabControl.ItemTemplate>
        <DataTemplate>
            <StackPanel>
                <TextBlock Text="{Binding Name}" />
            </StackPanel>
        </DataTemplate>
    </TabControl.ItemTemplate>
    <TabControl.ContentTemplate>
        <DataTemplate>
            <Grid>
                <ContentPresenter Content="{Binding HomeScreen}" />
            </Grid>
        </DataTemplate>
    </TabControl.ContentTemplate>
</TabControl>

That is the last of our host configuration. Last thing we need to do is Update our AddInStore and load some AddIns (unfortunately, we don’t have any yet, please see Step 3 :)

public Window1()
{
    InitializeComponent();

    AddInStore.Update(PipelineStoreLocation.ApplicationBase);
    Collection<AddInToken> addinTokens = AddInStore.FindAddIns(typeof(ICouchPotatoAddIn), PipelineStoreLocation.ApplicationBase);

    ObservableCollection<ICouchPotatoAddIn> addins = new ObservableCollection<ICouchPotatoAddIn>();
    foreach (AddInToken addinToken in addinTokens)
    {
        ICouchPotatoAddIn addin = addinToken.Activate<ICouchPotatoAddIn>(AddInSecurityLevel.Internet);
        addins.Add(addin);
    }
    
    PluginContainer.ItemsSource = addins;
}

Step 3 – Create our first AddIn

For this last step we are going to create a fake PhotoGallery AddIn.

Open a new instance of Visual Studio and create a new Class Library project, create it inside the same parent folder that we used for our Contracts project.
- Add reference System.AddIn
- If this is a WPF Addin, add reference PresentationFramework for FrameworkElement
- Add reference to your AddInView assembly that can be found by browsing to “../output/AddInViews/AddInView.dll”
- Important: Make sure you set CopyLocal=false for your AddInView assembly

Set the AddIn output to a specific directory within the output/AddIns folder, for example:
- ..\output\AddIns\PhotoGalleryAddIn

Now that configuration is complete let’s create our UserControl that will represent the UI for the AddIn. Simply right-click on the project and Add New Item, select WPF User Control, add any UI that you choose.

<UserControl x:Class="CouchPotato.PhotoGalleryAddIn.PhotoGalleryControl"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Height="300" Width="300">
    <Grid>
        <TextBlock Text="Happy Photos!" />
    </Grid>
</UserControl>

Lastly, create a the WeatherAddIn.cs file
- Implement the ICouchPotatoAddIn interface
- Add the [AddIn] attribute to describe the AddIn.
- As you can see below, the Pipeline Builder has turned the INativeHandleContract interface into a FrameworkElement for us! This is very handy, as it will allow seamless calls from UI elements across AppDomains without us knowing anything about it! All we have to do is return any FrameworkElement to satisfy the contract, in this case, a WPF UserControl does in fact derive from FrameworkElement, as does just about anything in the WPF visual namespace.

[AddIn("Photo Gallery", Version = "1.0.0.0")]
public class PhotoGalleryAddin : ICouchPotatoAddIn
{
    private readonly PhotoGalleryControl _control;

    public PhotoGalleryAddin()
    {
        _control = new PhotoGalleryControl();
    }

    public string Name
    {
        get { return "Photo Gallery"; }
    }

    public string Description
    {
        get { return "View all your photos"; }
    }

    public void Initialize()
    {
    }

    public FrameworkElement HomeScreen
    {
        get { return _control; }
    }
}

Run it!

With any luck, hopefully you are able to run your host application and find the AddIn you created. There are a lot of working parts when you use the Managed AddIn Framework, and as such, there are many points of failure. As you can see there is a slight learning curve to utilize MAF but hopefully after this article and the Daniel Moth screencasts you should be pretty comfortable with the framework.

Resources

Technorati Tags: MAF,WPF

Code Snippets with Snippet Designer and ReSharper Live Templates

Matt Hidinger — Thu, 02 Oct 2008 11:24:00 GMT

Just what exactly are these snippets?

I believe that snippets are an underused feature built into Visual Studio. This post is my attempt at comparing the two tools I have used for snippet creation, and hoping to make more developers out there aware of just how easy they are to create and use in your existing projects. I am by no means an expert with either of these tools, but I think that is the point: they take a few minutes to create and can be reused for immediate time savers.

Much to my surprise there exists a significant number of .NET developers that are not taking advantage of code snippets, built-in or otherwise. No doubt you have all seen them in intellisense before: they appear with a partially-jagged piece of paper as seen below. When selected, they expand into a template of code that has select editable variables. A number of predefined code-snippets ship with Visual Studio, many of which I use regularly, including ctor, prop, exception, try, etc.

The “prop” snippet “expands” into the following code:

So the big question is how can we create our own snippets? Let’s take a real-world example and find out.

Snipper Designer (free Visual Studio Plugin)

A few weeks ago a project was released on CodePlex called Snipper Designer. Snippet Designer is a plugin for Visual Studio that was previously used internally by Microsoft and has since been released for all of us to enjoy. After downloading the MSI, it istalled in no time and I was on my way to creating a basic snippet I wish I had created long ago.

To start off I took some Configuration Property code that I had already written as the starting point for my snippet. Anyone who has done extensive configuration with the System.Configuration assembly should be very familiar with this code: it is a property declaration for automatic strongly-typed reading and writing to an XML attribute in your app.config. There are a number of similar code snippets I will be creating for various Configuration-related tasks, and I hope to update this post with my complete list of Configuration snippets shortly.

As you can see, the Snipper Designer has added a context menu item to export highlighted code as a snippet. In doing so, the code below was produced in my Snippet Designer:

From here all I had to do was decide which “variables” would be available in my snippet. This is identifiable by the twin dollar signs ($) at the beginning and end of the variable. Finally, I assigned the snippet a shortcut, which is how we will invoke the snippet expansion in a code file. The shortcut I chose was “configProp.”

Our final bit of customization lies in a property pane below the snippet code. From here I can define tooltips to help other developers who may be using my snippets, as well as set default values and expected data types associated with a variable. As you can see, I specified that the isRequired variable should be a Boolean that defaults to true.

ReSharper Live Templates

Many of you will probably be familiar with the Visual Studio plugin ReSharper. ReSharper has quickly become a favorite of mine over the last year or so, and I feel as though I have only scratched the surface of it’s productivity potential. One of said features is their own snippet framework (which they have named Live Templates). ReSharper Live Templates are slightly more powerful than the aforementioned Snippet Designer.

As you can clearly see, the ReSharper snippet code is almost identical to Snippet Designer. This is a great thing. In fact, I copy-pasted my Snippet Designer code into ReSharper and it instantly recognized it, so the two are very interoperable in that regard.

The variable definition pane is where ReSharper really shines. It has significantly more customization over Snippet Designer, given it’s very nice macro support. I have certainly not experimented with all of these predefined macro’s but they seem like they would be great features for advanced and more intelligent snippet scenarios. I hope to play with them a bit more in the near future. Above you will notice that I have used the “Constant value” macro to specify defaults for the isRequired and DataType variable, which are “true” and “string”, respectively..

So what exactly did the last few minutes do for us? Well for me, any time in the future where I need to define a new Configuration Property in code, I will no longer by force into vastly error-prone copy-pasting. Instead, I simply trigger my snippet by it’s predefined shortcut. In my case, I chose “configProp.”

When selected, it expands into this simple code block, which allows me to [tab] through the 5 variables and be on my way. And if you happen to think this won’t save you much time, then I would challenge the fact that you have probably not copy-pasted a significant number of these configuration properties before. As I mentioned in the beginning, I will be creating an army of these snippets, ranging from not only my Configuration-related ones, but repeatable tasks like ViewState-backed property wrappers, etc.

Download

Snippet Designer

ReSharper

Technorati Tags: Visual Studio,ReSharper

Synergy - 3 Desktops, 1 Keyboard

Matt Hidinger — Tue, 17 Jun 2008 11:14:00 GMT

I recently noticed a colleague of mine using a hardware KVM to share his desktop keyboard and mouse with his laptop. He had a standard hardware KVM with basic PS/2 inputs and could toggle between the PCs by pressing Scroll Lock twice. Pretty typical setup for many people who have multiple PCs, and it wasn't more than a few years ago that I was doing that same.

Enter Synergy. Synergy is actually lot more than a basic KVM. It makes multiple computers behave exactly as though they were a single PC with dual-monitors. You simply move your mouse to the edge of one monitor and it instantly jumps to the next one -- even though they are entirely different computers.

Synergy also lets you share your clipboard between all connected PCs, and it can even sync screensavers so they all start and stop together. But probably the best feature for some, is that Synergy works on Linux, Windows, and Mac! If you notice the screenshot to the right, I have a Fedora box on the far left. Oh, and did I mention it's open source and totally free?

From the web site:

Synergy lets you easily share a single mouse and keyboard between multiple computers with different operating systems, each with its own display, without special hardware. It's intended for users with multiple computers on their desk since each system uses its own monitor(s).

Redirecting the mouse and keyboard is as simple as moving the mouse off the edge of your screen. Synergy also merges the clipboards of all the systems into one, allowing cut-and-paste between systems. Furthermore, it synchronizes screen savers so they all start and stop together and, if screen locking is enabled, only one screen requires a password to unlock them all.

LINQ to SQL Audit Trail

Matt Hidinger — Thu, 08 May 2008 11:10:00 GMT

UPDATE: This post is outdated and has significantly enhanced with a new version. Please see LINQ Audit Trail V2

In a project I am currently working on, we had a fairly common requirement of recording an Audit Trail of any data changes. The requirements were typical, provide a running log of any changes in the database, including:

What table was modified?

What fields changed?

Who made the change?

When did it occur?

Naturally, there are many ways to tackle this problem. In the past I have either relied on writing database Triggers for the tables, or wrote the Auditing logic right into the stored procedure that was doing the modification. But this time, since the project is utilizing LINQ to SQL, I had a more ambitious idea in mind.

The Goal

Create a flexible, and automated Auditing solution that would allow my team to add Audit tracking to any table in our database, with only a single line of C# code.

The code I ended up with did in fact meet my goal -- which would add Auditing to the Products table and Categories table -- can be seen below.
As long as you call the Audit<> method before calling SubmitChanges() then any INSERTED/UPDATED/DELETED entities will be properly Audited automatically.
The first parameter in the method, is telling the Auditing code how to identity which property is the Primary Key of the table.

public partial class NorthwindDataContext { public override void SubmitChanges(ConflictMode failureMode) { this.Audit<Product>(p => p.ProductID, "Product modified "); this.Audit<Category>(c => c.CategoryID, "Category modified"); base.SubmitChanges(failureMode); } }

TIP: If you are interested in learning how this code was created, then please feel free to read the rest of this article. If however, you are only interested in the finished product and using the code in your projects, then head down to the bottom :)

Step 1 - Database Tables

Given my requirements I derived the following database schema. For my purposes, these tables did the trick, but of course your requirements may differ slightly so you may tweak as you wish.

The Audits table is used to track any change. Most of the columns should be self-explanatory. The Action is what CUD event occurred (Insert, Update, or Delete). The rest of the columns record who made the change, when, what table, and the Primary Key of the modified record.

The AuditValues table is used to track each modified column in the table being audited: the Old (Original), and the New (Current) value.

Step 2 - The DBML

Now that we have our new tables, we will update our LINQ to SQL Entity classes. I am going to be using Northwind for this example.

Step 3 - The Public Audit Extension Method

First we need to create a public method that client code will use to begin Auditing a table.

/// <summary> /// This method will enlist a LINQ to SQL Entity for automatic Auditing /// </summary> /// <typeparam name="TEntity">The Entity class you want to audit changes on</typeparam> /// <param name="tableKeySelector">A Lambda expression that will return the Primary Key of the Entity</param> /// <param name="title">The text that will be logged in the audit table</param> public static void Audit<TEntity>(this DataContext db, Func<TEntity, int> tableKeySelector, string title) where TEntity : class

This is our public entry point for Auditing a table. This method might look a little bit intimidating to those unfamiliar with generic classes and generic delegates. Let's dissect this method to make it a little more palatable.

The first thing you should be aware of, is that this is an Extenstion method to the DataContext class. This is clear when you notice the "this" keyword in the first parameter. That means that this method will be available on any DataContext in our project (assuming of course, that you import the namespace the extension class resides in).

The second thing that might look strange is the Func<T1, T2> generic parameter. This is actually a Generic Delegate that exists in the System.Core assembly that ships with 3.5. The 5 Func<T1, T2, T3, T4, TResult> overloads are used to designate a method that operates on 1 or more inputs (T1 through T4) and returns a TResult. Func's can be seen all over the LINQ namespace and you will get probably pretty familiar with them once you being extending and using LINQ. Typically, they will define the signature for a Lambda expression (which is a new C# shorthand for defining an expression or anonymous method call). In this particular Func<> parameter, I am expecting a method (a Lambda expression, typically), that accepts a TEntity for input, and returns an int. This is required because we need to know how to find the Primary Key property of an Entity.

The third unique syntax in this method is the "where" keyword. This is telling the generic method that any TEntity that is passed to this method will be a reference type. This is required because LINQ to SQL can only map reference types.

Step 4 - Auditing LINQ to SQL Entity Inheritance

I ran into something unexpected when I began testing the auditing code I wrote: Auditing my Entities that used inheritance. In case you didn't know, LINQ to SQL supports a type of relational inheritance known as Table-Per-Class Hierarchy. This means that every custom field for the derived entity classes are stored in the same table in the database. This article will not go into this subject any further, but please see Guy Burnstein's Inheritance Article on the subject of LINQ to SQL inheritance. The following images are courtesy of him, and only for demonstration's sake -- these entities will not be in my sample code.

Naturally, I assumed that I could use the following code to Audit entities that supported inheritance just like regular Entities:

this.Audit<SalesPerson>(sp => sp.PersonID, "SalesPerson changed"); this.Audit<Contact>(c => c.PersonID, "Contact changed");

Unfortunately for me, I was wrong. The Auditing code that I wrote relies on dataContext.GetTable<TEntity> to obtain a reference to the table being audited -- however, when I tried doing dataContext.GetTable<SalesPerson> I received an unpleasant exception stating that a derived entity cannot be used with the GetTable method -- instead, the exception actually suggested that I try dataContext.GetTable<Person>(), which did indeed work.

So due to this unexpected exception, I had to add an overload to the Audit method that supported two types, a TBaseEntity, and a TSubEntity.

this.Audit<Contact, SalesPerson>(sp => sp.PersonID, "SalesPerson changed");

The method signature for this method is listed below. You will notice an additional Generic Constraint added, defining that TSubEntity must in fact derive from TBaseEntity.

/// <summary> /// This method will enlist a LINQ to SQL Entity for automatic Auditing /// </summary> /// <typeparam name="TBaseEntity">The Base Entity class you want to audit changes on</typeparam> /// <typeparam name="TSubEntity">The Derived Entity class, for use in LINQ to SQL inheritance</typeparam> /// <param name="tableKeySelector">A Lambda expression that will return the Primary Key of the Entity</param> /// <param name="title">The text that will be logged in the audit table</param> public static void Audit<TBaseEntity, TSubEntity>(this DataContext db, Func<TSubEntity, int> tableKeySelector, string title) where TBaseEntity : class where TSubEntity : TBaseEntity

Step 5 - Auditing Inserted Records

The heart and soul of my auditing code relies on the DataContext's Object Tracking Service. You see, the LINQ to SQL DataContext is of course responsible for tracking entity changes. This is a necessary service so that it is able to queue up every insert, update, and delete -- patiently waiting for a call to dataContext.SubmitChanges(), at which point the context runs through every necessary SQL command to INSERT, UPDATE, and DELETE records in the database.

Thankfully, the DataContext exposes a GetChangeSet() method, which will allow us to peek into its pending database calls.

private static void AuditInserts<TEntity, TSubEntity>(DataContext db, Func<TSubEntity, int> tableKeySelector, string title) where TEntity : class where TSubEntity : TEntity { var inserts = db.GetChangeSet().Inserts.OfType<TSubEntity>();

Here we can see a perfect example of LINQ to Objects. The GetChangeSet().Inserts property return a List<Object>, but that doesn't do us much good, because we are only interested in the Entities we want to audit. Therefore, we can use the new OfType<> extension method to only pull back the entities we are concerned with.

Next, we need to obtain a reference to the Table<> that our Entity belongs to.

Table<TEntity> table = db.GetTable<TEntity>();

Then we need to get all the public properties that our Entity has.

PropertyInfo[] props = typeof(TSubEntity).GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.FlattenHierarchy);

I have also created a quick helper-method that will create the row in the Audit table for us

private static Audit CreateAudit<TEntity>(string title, Table<TEntity> table, int key) where TEntity : class { Audit audit = new Audit(); audit.TableName = table.ToString(); audit.TableKey = key; audit.UserName = CurrentUser; audit.AuditDate = DateTime.Now; return audit; }

The rest of the code is simply looping through all of the Entities in the ChangeSet.

foreach (TSubEntity item in inserts) { // Get the Primary Key for our table by Invoking the tableKeySelector delegate on the current TSubEntity item int key = tableKeySelector.Invoke(item); // Create the Audit Audit audit = CreateAudit<TEntity>(title, table, key); audit.Title = title + " added"; audit.Action = "Insert"; // Loop through every property in our inserted entity foreach (PropertyInfo pi in props) { // This code checks to see if the property is a LINQ to SQL column. You may change this if you need. if (pi.HasAttribute(typeof(ColumnAttribute))) { // I chose to ignore any Id columns in the auditing, again, you may change this if (pi.Name.EndsWith("Id")) continue; // Creat the AuditValue row and add it to our current Audit AuditValue values = new AuditValue(); values.MemberName = pi.Name; values.NewValue = GetPropertyValue(pi, item); audit.AuditValues.Add(values); } } // Insert the Audit to the database db.InsertAudit(audit); }

Step 6 - Audit Deletes

Very few things change from the Insert code here.

var deletes = db.GetChangeSet().Deletes.OfType<TSubEntity>();

I also set the OldValue property instead of the NewValue property when creating the AuditValues entity.

AuditValue values = new AuditValue(); values.MemberName = pi.Name; values.OldValue = GetPropertyValue(pi, item);

Step 7 - Audit Updates

Auditing updates is greatly simplified again thanks to our hard-working DataContext. Every Table<T> class has a GetModifiedMembers method that can be invoked on any entity. This method will only return properties which were CHANGED. This is exactly what I need because I did not want to record any values that stayed the same, especially for tables with a large number of columns.

ModifiedMemberInfo[] mmi = table.GetModifiedMembers(item); foreach (TSubEntity item in updates) { int key = tableKey.Invoke(item); Audit audit = CreateAudit<TEntity>(title, table, key); audit.Title = title + " updated"; audit.Action = "Update"; ModifiedMemberInfo[] mmi = table.GetModifiedMembers(item); foreach (ModifiedMemberInfo mi in mmi) { AuditValue values = new AuditValue(); values.MemberName = mi.Member.Name; values.OldValue = GetPropertyValue(mi.OriginalValue); values.NewValue = GetPropertyValue(mi.CurrentValue); audit.AuditValues.Add(values); } db.InsertAudit(audit); }

The Finished Results

I wrote a very quick demo app for this article. You can see below a GridView of the Audits table rows. We can see what we changed, when, by whom, etc. If you select one of the Audits, a DetailsView will display all of the Changed Values that took place during the Audit.

Get the Code!

If you stuck around for that whole article then I am impressed! If however, you just want to view, experiment with, and use the code, then I provide it here for your use. I have also included the sample Northwind Project so you can play with the demo yourself.

To download the latest version of this project please see the CodePlex Project: DoddleAudit

Thanks for reading, and please let me know if you end up using this code or have any cool features or optimizations that you have added or would like to see added!

Technorati Tags: LINQ to SQL,LINQ,Doddle

IE6 Underscore Hack

Matt Hidinger — Wed, 07 May 2008 11:01:00 GMT

So as you can see I've been playing with ASP.NET MVC in my free time lately. But as it turns out I learned something totally unrelated to MVC while I was editing the default stylesheet that MVC Preview 2 ships with.

#mainContent { padding: 30px 30px 15px 30px; background-color: #FFF; border-bottom: 3px groove #4b6f92; margin-bottom: 30px; _height: 1px; /* only IE6 applies CSS properties starting with an underscrore */ }

I can't believe I never knew about this. I have read 3 CSS books in the past few years and don't recall ever reading about this hack. So while it isn't the end-all solution to fixing CSS bugs in IE6, I think it should come in pretty handy in the future now that I know it exists.

I found this URL to WellStyled which describes the hack in more detail. Here are some cool usage examples of this hack:

#box { min-height: 300px; height: auto; _height: 300px; } #menu { position: fixed; _position: absolute; }

Technorati Tags: CSS,web standards

Entity Framework Comparison Frustration: Explained

Matt Hidinger — Tue, 26 Feb 2008 11:59:00 GMT

This post is a follow-up to an article I wrote a few weeks ago, ADO.NET Entity Framework Comparison Frustration. As a quick re-cap, I was simply trying to filter a list of users with a LINQ query expression by comparing custom classes, not primitive types.

TorvusEntities entities = new TorvusEntities(); // Pull my Account Entity from the database Account matt = entities.Accounts.First(a => a.AccountId == 10); // Attempt to get all Teams by a Team Owner var teams = from t in entities.Teams where t.Owner == matt select t;

However, an exception was thrown.

Unable to create a constant value of type 'Closure type'. Only primitive types (for instance Int32, String and Guid) are supported in this context.

So I left it at that. The Entity Framework could only handle comparison on primitive types, which makes sense of course, since the expression needs to be converted into the underlying data storage language (T-SQL in this case). I was simply hoping that they would provide a more object-oriented way of translating the comparison I hoped to express by some other means. E.g., overriding Object.Equals() or the == operator, implementing a certain interface on my entities, something that felt OO to me.

Today however, I found my answer. Embarrassingly enough, it was in the MSDN docs all along.

A comparison expression checks whether a constant value, property value, or method result is equal, not equal, greater than, or less than another value. If a particular comparison is not valid for LINQ to Entities, an exception will be thrown. [Specifically, the exception I wrote above.] All comparisons, both implicit and explicit, require that all components are comparable in the data store. Comparison expressions are often used in Where clauses for restricting the query results.

And here it is, the confirmation I wanted (albeit not the answer I was hoping for):

LINQ to Entities does not support using a user class as a constant. However, a property reference on a user class is considered a constant, and will be converted to a command tree constant expression and executed on the data store.

Oh, another thing worth mentioning, method returns don't count as so-called constant expressions, and will thrown an exception when attempted.

public class MyBusinessObject { public int GetId() { return 5; } } public class Test { public Test() { using (TorvusEntities context = new TorvusEntities()) { MyBusinessObject myBo = new MyBusinessObject(); var accounts = from a in context.Accounts where a.AccountId == myBo.GetId() select a; // Exception will be thrown at run-time, // methods do not count as Constant expressions } } }

Technorati Tags: Entity Framework,LINQ

Styles up Top, Scripts on Bottom

Matt Hidinger — Mon, 25 Feb 2008 11:52:00 GMT

Today I just stumbled onto some interesting information regarding placements of script blocks and CSS links. According to some extensive testing performed at Yahoo!, they have published a list of Best Practices for Speeding Up Your Web Site. Many of these rules came as no surprise, for example:

While researching performance at Yahoo!, we discovered that moving stylesheets to the document HEAD makes pages load faster. This is because putting stylesheets in the HEAD allows the page to render progressively.

However, one rule caught my attention:

Rule 5 described how stylesheets near the bottom of the page prohibit progressive rendering, and how moving them to the document HEAD eliminates the problem. Scripts (external JavaScript files) pose a similar problem, but the solution is just the opposite: it's better to move scripts from the top to as low in the page as possible. One reason is to enable progressive rendering, but another is to achieve greater download parallelization.

So sure I thought, maybe it will provide better performance, but when creating internet-facing web sites I am a firm believer in standards and compliance. I admit I don't run my markup through an XHTML validator as much as I should, but I was always under the impression that for valid XHTML, <script> blocks and includes belong in the <head> element. Nay, according to the working W3C XHTML Draft:

The script element places a script within a document. This element may appear any number of times in the head or body of an XHTML document.

Technorati Tags: javascript,web standards,aspnet css

ASP.NET Debugging Tip

Matt Hidinger — Mon, 25 Feb 2008 11:38:00 GMT

Honestly, I'm not sure if this setting is new to Visual Studio 2008 or not, but I just stumbled onto it. Typically when I'm debugging an ASP.NET application I test one page at a time, by right-clicking on the aspx and selecting View in Browser.

I prefer this method because I can keep the browser open at all times during development and not have to compile the whole site to quickly test something simple like markup changes. The caveat to this however, is that the Visual Studio debugger is not attached to the cassini process, so I cannot hit any break points I have set. For scenarios when I need to debug and step through code, I press the Debug button, wait for the site to compile and spawn a new browser window, and then I manually navigate to the page I want to debug. Sure this isn't a very big deal, but it would be more convenient to use the browser window I already have open, which is usually already on the page I want to test.

So I found this setting in the Web Application Properties for my site. Now when I enter debug mode, Visual Studio won't spawn a browser, it will simply wait for me to hit Refresh on the browser I already have open. It's a pretty minor change, but I find it to be very convenient.

Technorati Tags: Visual Studio,ASPNET,ASPNET MVC