Interface Blogs

I've been maintaining my blog in two spots but am going to officially put all content at http://weblogs.asp.net/dwahlin now.  Come on over and visit. :-)

Silverlight 2.0 provides a new and exciting framework for building rich applications using C#, VB.NET or other languages that are capable of running on multiple operating systems and in multiple browsers.  Scott Guthrie recently posted a great set of tutorials on Silverlight 2.0 that are an excellent resource for getting started building Silverlight 2.0 applications. 

Scott recently approved converting the tutorials into video so I've been busy the past few days putting together video tutorials that cover Silverlight 2.0 and the Digg.com application Scott wrote about.  Links to the written tutorials and video tutorials are shown below.

Silverlight 2.0 Video Tutorials

View other cool videos on Silverlight 2.0 and additional .NET technologies from the Mix 08 conference:

Joshua Allen's Mix 08 Blog

Last night we released a new version of the OrgChart.NET ASP.NET server control under a new name of "SmartChartPro".  We decided to give the control a new name since it's capable of doing more than just OrgCharts (although that's what most companies use it for).  We also released a  new company website named SmartWebControls.com based on .NET 3.5 where SmartChartPro and other upcoming controls will now reside. 

I decided to use LINQ and Lambdas in conjunction with LINQ to SQL in the back-end data classes for the new site.  Using these new technologies saved an enormous amount of time and made the process a lot more fun since we didn't have to go through the tedious process of mapping DataReader properties to custom data entity class properties as we'd done in the past.

If you or your boss are holding off on .NET 3.5 I'd definitely recommend taking a closer look as your productivity will increase a lot by using the new features it offers plus your code base will be more maintainable into the future.

Scott Guthrie just released new information about Silverlight 2.0 including 8 tutorials.  It's going to be a "happening" client-side development framework once it's all done!  Here's a list of the tutorials he released:

I've been developing for months on Windows Vista and had everything I needed at my disposal.  Last night, however, I needed to test whether or not email messages were being successfully sent from an ASP.NET application and see what they looked like.  I went to look for an SMTP server in Vista Ultimate and quickly found that there isn't one.  IIS7 includes email forwarding capabilities, but I wanted a simple SMTP server (or something that could emulate one) so that I could see the email messages that were being sent. 

After doing a little research I found a few programs that fit the bill for testing email sent from applications running on Vista.  The first is a free program called "Free SMTP Server" that Steve Schofield blogged about awhile back.  You can read Steve's post about the application here:

http://blogs.orcsweb.com/steve/archive/2007/09/08/vista-and-an-smtp-server-on-port-25-or-587.aspx

Here's what the program looks like while running (it's a stand-alone program rather than a service which actually worked out well for my situation).  It allows you to configure the DHCP server and the port that's used which is nice if your ISP blocks port 25.

The second program was actually even better for my current testing purposes since I really didn't need an SMTP server installed.  I needed to see what the actual email messages that were sent looked like to make sure data was formatted properly.  The program's called "Antix SMTP Server for Developers" and can be found here:

http://channel9.msdn.com/ShowPost.aspx?PostID=281695#281695

This program isn't actually an SMTP server (more of an emulator), but it captures any messages sent to port 25 and stores them in a folder.  You can then view the messages directly to make sure they contain the information you were looking for while testing. 

There are obviously a lot of full-blown SMTP servers out there that would work, but for testing purposes these two programs did the job for me.

Update:  David Findley posted something that I hadn't thought of using that's even easier.  Adding this to web.config will dump email messages sent from an ASP.NET application to the specified path:

<system.net>
  <mailSettings>
    <!--
    Production setting
    
    <smtp deliveryMethod="Network">
      <network host="localhost" port="25" />
    </smtp>
    
    -->

    <smtp deliveryMethod="SpecifiedPickupDirectory">
      <specifiedPickupDirectory pickupDirectoryLocation="C:\TestMessages" />
    </smtp>

  </mailSettings>
</system.net>

Update:  I refactored some of the code and also did a better job ensuring Dispose() is called everywhere so that the DataContext object gets cleaned up properly.

Download the Application Here

.NET 3.5 has a lot of great new features that can significantly enhance developer productivity.  I've been spending some time lately working on a little sample application that demonstrates how an N-Layer ASP.NET 3.5 application can be built using LINQ, lambdas and LINQ with stored procedures.  The application is for a talk I'll be giving at DevConnections in April discussing how LINQ technologies can be used in an N-Layer architecture.  In a previous post comparing different LINQ options I mentioned that I'd be posting the code download as soon as it was ready.

The application provides a presentation layer, business layer, data layer and model layer through separate projects as shown next:

It also demonstrates how the new ListView control can be used to display data, perform insert, update and delete operations and nest other controls such as the GridView.  Databinding on the presentation layer is mainly done using the ObjectDataSource control.

All of the queries performed in the application go against an object model created using the Visual Studio 2008 LINQ to SQL Designer. 

Note:  The included Northwind SQL Express database has been modified slightly to add a TimeStamp field into the Customer and Orders tables.  Doing so simplifies updates so be aware that if you change the connection string to point to a standard Northwind database you'll get an error since the TimeStamp fields will be missing.

3 Options for Data Access

Rather than focusing solely on LINQ, I wanted to show different options for data access that .NET 3.5 offers so that developers can get a feel for what's available in addition to standard LINQ queries that seem to get most of the attention these days.  I ended up creating six main data layer classes as shown next:

Customer Query Classes:

• CustomerDBLINQ - Executes customer related queries using inline LINQ
• CustomerDBLambda - Executes customer related queries using lambda expressions
• CustomerDBSprocs - Executes customer related queries using stored procedures and LINQ
  

Order Query Classes:

• OrderDBLINQ - Executes order related queries using inline LINQ
• OrderDBLambda - Executes order related queries using lambda expressions
• OrderDBSprocs - Executes order related queries using stored procedures and LINQ

I still lean toward using stored procedures due to the security and maintenance benefits they offer in more enterprise environments, but for small queries I actually prefer lambda expressions over LINQ (not sure why...just feels more object oriented I guess).  If you currently use stored procedures in your applications and haven't checked out the new LINQ to SQL Designer you'll be impressed with how easy it is to call stored procedures and pass parameters.  You never have to see or create another SqlCommand or SqlParameter object again (well...in many cases anyway).

Switching Between Data Access Classes

By changing a value in web.config you can switch between the different data layer classes and see which option you prefer (LINQ, lambdas or LINQ with sprocs).  All of the data access classes perform the same overall tasks, they just use different techniques to do it.

<appSettings>
  <!-- 
    Used to define which DB layer class should be loaded and used. 
    Valid customer values include:  Data.CustomerDBSprocs, Data.CustomerLINQ, Data.CustomerLambda
    Valid order values include: Data.OrderDBSprocs, Data.OrderLINQ, Data.OrderLambda
  -->
  <add key="CustomerDBType" value="Data.CustomerDBLINQ" />
  <add key="OrderDBType" value="Data.OrderDBLINQ" />
  <!-- When the following key is set to "true" ensure that 
       EnablePartialRendering is set to false on the Default.aspx ScriptManager control -->
  <add key="EnableDataContextLogging" value="false" />
</appSettings>

Over the next few weeks I'm hoping to make some time to walk through the application pieces.  I may create some video tutorials about it as well....we'll see how time goes.

There's a lot of great stuff in .NET 3.5 and several different ways to work with LINQ technologies such as LINQ to SQL.  I'm currently putting together some demonstration code for a talk I'll be giving at DevConnections in Orlando and showing how LINQ, Lambdas and LINQ with stored procedures can be used to do the same thing so that people get a feel for each technique.  For shorter queries I generally prefer lambdas since it's more object-oriented feeling compared to LINQ (to me anyway).  For more complex queries LINQ is much easier though.  Overall, I still prefer stored procedures since you have much more control over security that way and can maintain queries without resorting to C#/VB.NET code changes in some cases.  Plus, LINQ makes it really easy to pass parameters to stored procedures without having to create SqlParameter objects (something I've always despised).

Although I've found that I like lambdas a lot for more simple queries, I was working on some lambda code yesterday that was just plain out of control and much more complex when compared to using LINQ or LINQ against a sproc.  Here's an example of the overall query I was after which has several inner joins.  This particular query was automatically generated using LINQ code and I logged the output and converted it to a stored procedure named ap_GetOrderDetailsByOrderID.  It's structured a little differently than I would typically write, but accomplishes the same end goal.

CREATE PROCEDURE dbo.ap_GetOrderDetailsByOrderID
    (
        @OrderID int
    )
AS
    BEGIN
        SELECT [t5].[CompanyName] AS [ShipperName], 
        [t5].[ProductName] AS [Product], 
        [t5].[value] AS [Total], 
        CONVERT(Int,[t5].[Quantity]) AS [Quantity], 
        [t5].[UnitPrice], 
        [t5].[CompanyName2] AS [SupplierName] 
        FROM ( 
            SELECT [t0].[OrderID], 
                    [t1].[CompanyName], 
                    [t2].[UnitPrice], 
                    [t2].[Quantity], 
                    [t3].[ProductName], 
                    [t4].[CompanyName] AS [CompanyName2], 
                    (CONVERT(Decimal(29,4),[t2].[Quantity])) * [t2].[UnitPrice] AS [value] 
            FROM [dbo].[Orders] AS [t0] 
            INNER JOIN [dbo].[Shippers] AS [t1] ON [t0].[ShipVia] = ([t1].[ShipperID]) 
            INNER JOIN [dbo].[Order Details] AS [t2] ON [t0].[OrderID] = [t2].[OrderID] 
            INNER JOIN [dbo].[Products] AS [t3] ON [t2].[ProductID] = [t3].[ProductID] 
            INNER JOIN [dbo].[Suppliers] AS [t4] ON [t3].[SupplierID] = ([t4].[SupplierID]) ) 
        AS [t5] WHERE [t5].[OrderID] = @OrderID 

    END

The examples that follow go against the LINQ to SQL objects shown next that I created in Visual Studio 2008 using the LINQ to SQL Designer.  All of the objects came from the Northwind database except the custom OrderDescription object.

Using LINQ

LINQ can be used to automatically generate the query shown above by doing the following:

public override IEnumerable<OrderDescription> GetOrderDetails(int orderID)
{
    NorthwindDataContext db = this.DataContext;
    IEnumerable<OrderDescription> orderDetails =
        from o in db.Orders
        where o.OrderID == orderID
        join s in db.Shippers on o.ShipVia equals s.ShipperID
        join od in db.OrderDetails on o.OrderID equals od.OrderID
        join p in db.Products on od.ProductID equals p.ProductID
        join supplier in db.Suppliers on p.SupplierID equals supplier.SupplierID
        let total = od.Quantity * od.UnitPrice
        select new OrderDescription {Product = p.ProductName, Quantity = od.Quantity, 
                     ShipperName = s.CompanyName, Total = total, UnitPrice=od.UnitPrice,
                     SupplierName = supplier.CompanyName};
    return orderDetails;

}

This code joins 5 tables to grab order details and adds the target fields to the custom OrderDescription object.  By using this code the SQL is created on the fly from LINQ expression trees and sent to the database so any changes to the query require changes to the code of course.  For those that don't like working with stored procedures this certainly is the next best thing.

A better way of doing this that leverages relationships between objects defined in the LINQ to SQL data model is shown next (thanks to Christian Nagel):

IEnumerable<OrderDescription> orderDetails =
  from o in db.Orders
  where o.OrderID == orderID
  from od in o.OrderDetails
  let total = od.Quantity * od.UnitPrice
  select new OrderDescription
  {
      Product = od.Product.ProductName,
      Quantity = od.Quantity,
      ShipperName = o.Shipper.CompanyName,
      Total = total,
      UnitPrice = od.UnitPrice,
      SupplierName = od.Product.Supplier.CompanyName
  };
return orderDetails;

Using Lambdas

I mentioned earlier that I'm a big fan of lambdas when a particular query is reasonable.  However, they can get out of control.  The fairly straightforward LINQ query shown above gets pretty nasty when switching to lambdas since the joins require identifying the primary, foreign keys and fields to select.  This is lambda overkill....there are too many => characters in there for me, but it matches up with the LINQ query shown above pretty well.

public override IEnumerable<OrderDescription> GetOrderDetails(int orderID)
{
    NorthwindDataContext db = this.DataContext;
      IEnumerable<OrderDescription> orderDetails =
        db.Orders.Where(order => order.OrderID == orderID).
        Join(db.Shippers, o => o.ShipVia, s => s.ShipperID, 
          (o, s) => new { o.OrderID, ShipCompanyName = s.CompanyName }).
        Join(db.OrderDetails, o => o.OrderID, od => od.OrderID, 
          (o, od) => new {o.ShipCompanyName, od.ProductID, od.Quantity, od.UnitPrice }).
        Join(db.Products, od => od.ProductID, p => p.ProductID, 
          (OrderDetails, p) => new { OrderDetails, p.ProductName, p.SupplierID }).
        Join(db.Suppliers, p => p.SupplierID, s => s.SupplierID, 
          (OrderData, s) => new { OrderData, SupplierName = s.CompanyName}).
        Select(o => new OrderDescription
        {
            Product = o.OrderData.ProductName,
            Quantity = o.OrderData.OrderDetails.Quantity,
            ShipperName = o.OrderData.OrderDetails.ShipCompanyName,
            Total = o.OrderData.OrderDetails.Quantity * o.OrderData.OrderDetails.UnitPrice,
            UnitPrice = o.OrderData.OrderDetails.UnitPrice,
            SupplierName = o.SupplierName
        });
    return orderDetails;
}

By leveraging relationships in the object model generated by the LINQ to SQL Designer you can simplify this query a lot.  Here's an example of doing that (thanks to Dug for commenting and posting the refactored version):

public override IEnumerable<OrderDescription> GetOrderDetails(int orderID)
{
       NorthwindDataContext db = this.DataContext;

       IEnumerable<OrderDescription> orders =
         db.Orders.Where(order => order.OrderID == orderID).
         Join(db.OrderDetails, o => o.OrderID, od => od.OrderID,
         (o, od) => new { ShipCompanyName = o.Shipper.CompanyName, 
                          od.ProductID, 
                          ProductName = od.Product.ProductName, 
                          Quantity = od.Quantity, 
                          UnitPrice = od.UnitPrice, 
                          SupplierName = od.Product.Supplier.CompanyName }).

                         Select(o => new OrderDescription
                         {
                             Product = o.ProductName,
                             Quantity = o.Quantity,
                             ShipperName = o.ShipCompanyName,
                             Total = o.Quantity * o.UnitPrice,
                             UnitPrice = o.UnitPrice,
                             SupplierName = o.SupplierName
                         });
       return orders;
}

Using LINQ with Stored Procedures

This is my favorite technique.  While LINQ makes it easy to query against a database without embedding inline SQL into C# or VB.NET, using pure LINQ code still doesn't provide the same level of security that stored procedures can provide, requires that SQL be generated dynamically from LINQ expression trees and can complicate application maintenance down the road in my opinion.  To call the stored procedure shown at the beginning of this post using LINQ to SQL techniques you can use the following code once the stored procedure has been drag and dropped onto the LINQ to SQL designer surface.  This code is simple and easy to maintain.  Plus, I can filter the results even more by using LINQ or by adding lambdas onto the ap_GetOrderDetailsByOrderID() method if needed.

public override IEnumerable<OrderDescription> GetOrderDetails(int orderID)
{
    IEnumerable<OrderDescription> orderDetails = DataContext.ap_GetOrderDetailsByOrderID(orderID);
    return orderDetails;
}

Ultimately it all comes down to personal preference.  Having worked through many LINQ, lambda and stored procedure queries I'll be sticking with LINQ to SQL with sprocs since the code is squeaky clean.  I have a few friends who prefer using inline LINQ as shown in the first example and we've argued the pros and cons of each technique back and forth.  The beauty of it all is that we get to use what we want and have multiple options to choose from!

I'll post the demo code I've been working on soon so those who are interested in getting into LINQ, lambdas and LINQ with sprocs can see how each technique can be used in an n-tier application architecture.

I've been working with the new ListView control in ASP.NET 3.5 combining it with LINQ and Lambda expressions and was finding myself duplicating a lot of code between ItemTemplate and AlternatingItemTemplate templates (I'll be posting the sample application that demonstrates using LINQ, Lambdas and Stored Procedures soon).  The AlternatingItemTemplate contained the same code as the ItemTemplate except for a CSS class added to the first <tr> element to change the background color.  Here's an example of both templates that were used initially:

<ItemTemplate>
    <tr class="even">
        <td class="tdControls">
            <asp:LinkButton ID="EditButton" CommandName="Edit" runat="server" 
              Text="Edit"></asp:LinkButton>
            <asp:LinkButton ID="DeleteButton"  
              OnClientClick="return confirm('Delete Record?');" 
              CommandName="Delete" CommandArgument='<%# Eval("CustomerID")%>' 
              runat="server" Text="Delete"></asp:LinkButton>
        </td>
        <td>
            <%# Eval("CustomerID") %>
        </td>
        <td>
            <%# Eval("CompanyName") %>
        </td>
        <td>
            <%# Eval("ContactName") %>
        </td>
        <td>
            <%# Eval("ContactTitle") %>
        </td>
        <td>
            <%# Eval("Address") %>
        </td>
        <td>
            <%# Eval("City") %>
        </td>
        <td>
            <%# Eval("Country") %>
        </td>
        <td>
            <asp:LinkButton ID="lbOrders" runat="server" Text="Orders" 
               CommandName="ViewOrders" 
               CommandArgument='<%# Eval("CustomerID") %>' />
        </td>
    </tr>
    <tr id="trOrders" runat="server" visible="false">
        <td>&nbsp;</td>
        <td colspan="8">
            <asp:GridView id="gvOrders" runat="server" AutoGenerateColumns="False" 
                BackColor="White" BorderColor="#999999" BorderStyle="Solid" 
                BorderWidth="1px" CellPadding="3" ForeColor="Black" 
                GridLines="Vertical" Width="500px" EnableViewState="false">
                    <FooterStyle BackColor="#CCCCCC" />
                    <Columns>
                        <asp:BoundField DataField="OrderID" HeaderText="OrderID" 
                            SortExpression="OrderID" />
                        <asp:BoundField DataField="OrderDate" HeaderText="OrderDate" 
                            SortExpression="OrderDate" HtmlEncode="false" 
                            DataFormatString="{0:d}" />
                        <asp:BoundField DataField="RequiredDate" 
                            HeaderText="RequiredDate" 
                            SortExpression="RequiredDate"  HtmlEncode="false" 
                            DataFormatString="{0:d}" />
                        <asp:BoundField DataField="ShippedDate" 
                            HeaderText="ShippedDate" 
                            SortExpression="ShippedDate" HtmlEncode="false" 
                            DataFormatString="{0:d}" />
                    </Columns>
                    <AlternatingRowStyle BackColor="#eaeaea" />                                        
             </asp:GridView>
        </td>
    </tr>
</ItemTemplate>
<AlternatingItemTemplate>
    <tr class="odd">
        <td class="tdControls">
            <asp:LinkButton ID="EditButton" CommandName="Edit" runat="server" 
              Text="Edit"></asp:LinkButton>
            <asp:LinkButton ID="DeleteButton"  
              OnClientClick="return confirm('Delete Record?');" 
              CommandName="Delete" CommandArgument='<%# Eval("CustomerID")%>' 
              runat="server" Text="Delete"></asp:LinkButton>
        </td>
        <td>
            <%# Eval("CustomerID") %>
        </td>
        <td>
            <%# Eval("CompanyName") %>
        </td>
        <td>
            <%# Eval("ContactName") %>
        </td>
        <td>
            <%# Eval("ContactTitle") %>
        </td>
        <td>
            <%# Eval("Address") %>
        </td>
        <td>
            <%# Eval("City") %>
        </td>
        <td>
            <%# Eval("Country") %>
        </td>
        <td>
            <asp:LinkButton ID="lbOrders" runat="server" Text="Orders" 
               CommandName="ViewOrders" 
               CommandArgument='<%# Eval("CustomerID") %>' />
        </td>
    </tr>
    <tr id="trOrders" runat="server" visible="false">
        <td>&nbsp;</td>
        <td colspan="8">
            <asp:GridView id="gvOrders" runat="server" AutoGenerateColumns="False" 
                BackColor="White" BorderColor="#999999" BorderStyle="Solid" 
                BorderWidth="1px" CellPadding="3" ForeColor="Black" 
                GridLines="Vertical" Width="500px" EnableViewState="false">
                    <FooterStyle BackColor="#CCCCCC" />
                    <Columns>
                        <asp:BoundField DataField="OrderID" HeaderText="OrderID" 
                            SortExpression="OrderID" />
                        <asp:BoundField DataField="OrderDate" HeaderText="OrderDate" 
                            SortExpression="OrderDate" HtmlEncode="false" 
                            DataFormatString="{0:d}" />
                        <asp:BoundField DataField="RequiredDate" 
                            HeaderText="RequiredDate" 
                            SortExpression="RequiredDate"  HtmlEncode="false" 
                            DataFormatString="{0:d}" />
                        <asp:BoundField DataField="ShippedDate" 
                            HeaderText="ShippedDate" 
                            SortExpression="ShippedDate" HtmlEncode="false" 
                            DataFormatString="{0:d}" />
                    </Columns>
                    <AlternatingRowStyle BackColor="#eaeaea" />                                        
             </asp:GridView>
        </td>
    </tr>
</AlternatingItemTemplate>

It seemed like a waste (and a maintenance headache) to have both templates duplicating the same code while only needing background color changes so I decided to adjust it by adding a little code into the first <tr> tag to dynamically assign the CSS class based upon odd or even rows. It calls the ListViewDataItem class's DataItemIndex property and applies a modulus operation to it.  This isn't anything new of course (I've done the same type of thing for years with GridView and DataGrid controls), but it's a nice trick that can save a lot of duplicated code if you haven't seen it.

<ItemTemplate>
    <tr class='<%# (Container.DataItemIndex % 2 == 0)?"even":"odd" %>'>    
        <td>    
            <asp:LinkButton ID="EditButton" CommandName="Edit" runat="server" 
              Text="Edit"></asp:LinkButton>
            <asp:LinkButton ID="DeleteButton"  
              OnClientClick="return confirm('Delete Record?');" 
              CommandName="Delete" CommandArgument='<%# Eval("CustomerID")%>' 
              runat="server" Text="Delete"></asp:LinkButton>
        </td>
        <td>
            <%# Eval("CustomerID") %>
        </td>
        <td>
            <%# Eval("CompanyName") %>
        </td>
        <td>
            <%# Eval("ContactName") %>
        </td>
        <td>
            <%# Eval("ContactTitle") %>
        </td>
        <td>
            <%# Eval("Address") %>
        </td>
        <td>
            <%# Eval("City") %>
        </td>
        <td>
            <%# Eval("Country") %>
        </td>
        <td>
            <asp:LinkButton ID="lbOrders" runat="server" Text="Orders" 
               CommandName="ViewOrders" 
               CommandArgument='<%# Eval("CustomerID") %>' />
        </td>
    </tr>
    <tr id="trOrders" runat="server" visible="false">
        <td>&nbsp;</td>
        <td colspan="8">
            <asp:GridView id="gvOrders" runat="server" AutoGenerateColumns="False" 
                BackColor="White" BorderColor="#999999" BorderStyle="Solid" 
                BorderWidth="1px" CellPadding="3" ForeColor="Black" 
                GridLines="Vertical" Width="500px" EnableViewState="false">
                    <FooterStyle BackColor="#CCCCCC" />
                    <Columns>
                        <asp:BoundField DataField="OrderID" HeaderText="OrderID" 
                            SortExpression="OrderID" />
                        <asp:BoundField DataField="OrderDate" HeaderText="OrderDate" 
                            SortExpression="OrderDate" HtmlEncode="false" 
                            DataFormatString="{0:d}" />
                        <asp:BoundField DataField="RequiredDate" 
                            HeaderText="RequiredDate" 
                            SortExpression="RequiredDate"  HtmlEncode="false" 
                            DataFormatString="{0:d}" />
                        <asp:BoundField DataField="ShippedDate" 
                            HeaderText="ShippedDate" 
                            SortExpression="ShippedDate" HtmlEncode="false" 
                            DataFormatString="{0:d}" />
                    </Columns>
                    <AlternatingRowStyle BackColor="#eaeaea" />                                        
             </asp:GridView>
        </td>
    </tr>
</ItemTemplate> 

Over the past few months I've been writing articles for the .NET Insight insight newsletter covering various ASP.NET AJAX concepts.  You can read those article here.  I've wrapped up that series and have started writing about Silverlight 1.0.  Each week a new article will be published and I'll update them here so check back.  The articles are designed to be focused and concise and get straight to the topic without a lot of fluff.  

• Getting Started with Silverlight
• Using Microsoft's Silverlight Control in a Web Site
• Understanding Silverlight's createObject and createObjectEx Methods
• Silverlight XAML Primer 1: Exploring Canvases
• Silverlight XAML Primer 2: Rectangles, Ellipses, Lines and Text
• Silverlight XAML Primer 3: Working with Image Brushes
• Silverlight XAML Primer 4: Working with Linear Gradients 
• Silverlight XAML Primer 5: Working with Radial Gradients 
• Silverlight XAML Primer 6: Using Inline XAML with Silverlight
• Silverlight XAML Primer 7: Embedding Media into Silverlight 
• Silverlight XAML Primer 8: Working with Events 
• Silverlight XAML Primer 9: Using the Silverlight Downloader Object
• Working with Events in Silverlight (New!)
• Silverlight XAML Primer 10: Creating a Silverlight Downloader Progress Bar
Silverlight XAML Primer 11: Getting Started with Animations (New!)
Introducing Silverlight 2.0 (New!)

Thanks to everyone that attended the Visual Studio 2008 course yesterday.  It was a lot of fun talking about all of the new stuff available in VS 2008 and .NET 3.5 and hearing the different projects people are working on.  As promised, here's the lab code from the course:

http://www.xmlforasp.net/LabFiles/VS2008/VisualStudio2008LabFiles.zip

It's amazing how many different ways there are to accomplish the same task in code.  Talk to 2 developers and you'll almost always get two opinions.  That's part of what keeps it fun (and potentially why that guy in the other cube is constantly annoying you :-)).  In a previous post I wrote, there were several speed enhancement suggestions that were really good so I decided to start a "How Would You Refactor this Code" blog series to get opinions and see different approaches to coding. 

The first sample I wanted to post does a fairly simple string check to see if a string starts with a set of characters.  The value of the string being compared is variable.  There are multiple ways to do this that come to mind ranging from using a single string along with Contains(), regex, character by character comparisons, etc.  After a whole 10 seconds of thought I decided to go with a Lambda expression because I'm using Lambdas and LINQ a lot lately (and it's kind of fun).  It's not "the way" or the "best way" which is the point of this exercise.  So, how would you refactor this code?

string name = "mc_gross_1";  //The prefix and number are variable
string[] cartNames = { "item_number_", "item_name_", "mc_gross_", "quantity_" };
if (cartNames.Where(p => name.StartsWith(p)).Count() > 0)
{
    //process name
}

If you have refactoring ideas for this code or other "How Would You Refactor this Code" suggestions for future posts please add a comment. 

Code Refactoring Suggestions:

Here are some of the code refactoring suggestions to this point (read the comments for additional thoughts).  Great stuff.  If you have other suggestions keep them coming.

Suggestion # 1:

if (cartNames.Any(p => name.StartsWith(p)))
{
    //process name
}

Rationale for this refactoring:

You need only to know if the name is found in the array.  In this case the extension method Any() will do the best job for you.

The solution with Where() and Count() is not good. With Any() at the first match you will have the result and with Where() you will traverse the entire collection and then Count() the items.

Note 1: Count() is an extension method not a property so it has a complexity of O(n).

Note 2: Where() will create a collection to store matches(allocating memory). Any() will return a simple bool.

More semantically correct, because you're not really interesting in counting - just existence - it also has the added bonus of being more succinct.

Fabrice Marguirie was one of several people that suggested this refactoring.  I just purchased the EBook version of his LINQ in Action book and have found it to be very good so far.

Suggestion #2:

//C# 3.0
if (Array.Exists(cartNames, p => name.StartsWith(p)))
{
    // Process name
}

//C# 2.0
if (Array.Exists(cartNames, delegate(string p)
{
    return name.StartsWith(p);
}))
{
    // Process name
}

Rationale for this refactoring:

The most obvious suggestion is to use the .NET 2.0 "Array.Exists" method, rather than a .NET 3.5 LINQ query. Aside from the problem that many PCs don't have .NET 3.5 installed yet - and you can't install it on Windows 2000 - the Exists method can be more efficient than a count, as it will stop after the first match, rather than continuing to the end of the list.

Suggestion #3:

string name = "mc_gross_1";  //The prefix and number are variable
if (new Regex(@"(item_number_|item_name_|mc_gross_|quantity_)\d").Matches(name).Count > 0)
{
    // Process name
}

List<string> cartNames = new List<string>(new string[] { "item_number_", "item_name_", "mc_gross_", "quantity_" });
if (cartNames.Contains(name.Substring(0, name.LastIndexOf("_") + 1)))
{
    // Process name
}

Rationale for this refactoring:

JV (and colleagues) focused on how to solve this coding issue without using LINQ.

Suggestion #4:

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;

public sealed class StringPrefixComparer : IComparer<string>, IComparer
{

    private readonly CompareInfo _compareInfo;
    private readonly CompareOptions _options;

    private StringPrefixComparer(CompareInfo compareInfo, CompareOptions options)
    {
        _compareInfo = compareInfo;
        _options = options;
    }

    public static StringPrefixComparer Ordinal
    {
        get
        {
            return new StringPrefixComparer(
                CultureInfo.InvariantCulture.CompareInfo,
                CompareOptions.Ordinal);
        }
    }

    public int Compare(string x, string y)
    {
        if (string.IsNullOrEmpty(x)) return (string.IsNullOrEmpty(y)) ? 0 : -1;
        if (string.IsNullOrEmpty(y)) return 1;
        int length = (x.Length > y.Length) ? y.Length : x.Length;
        return _compareInfo.Compare(x, 0, length, y, 0, length, _options);
    }

    int IComparer.Compare(object x, object y)
    {
        return this.Compare(x as string, y as string);
    }

}

static class Program
{

    static bool Exists<T>(this T[] list, T item, IComparer<T> comparer)
    {
        return 0 <= Array.BinarySearch(list, item, comparer);
    }

    static void Main()
    {

        string[] cartNames = { "item_name_", "item_number_", "mc_gross_", "quantity_" };
        Array.Sort(cartNames, StringComparer.Ordinal);
        string name = "mc_gross_1";
        if (cartNames.Exists(name, StringPrefixComparer.Ordinal))
        {
            // Process name
        }
    }
}

Rationale for this refactoring:

Assuming that the array of prefixes is constant, ensure that the array is sorted, and use the Array.BinarySearch() method with a custom IComparer<string> implementation.  Uses the new C# 3.0 extension method capability and does a clever trick in the Compare() method that avoids having to explicitly worry about stripping off the numeric character on the end of the name variable.   Thanks to Richard for taking the time to post this one.

.NET 3.5 is out which means all of the great features available in C# 3.0 are available to use now.  Here's a quick list of the main language enhancements available in C# 3.0:

namespace StringExtensions
{
    public static class StringExtensionsClass
    {
        public static string RemoveNonNumeric(this string s)
        {
            MatchCollection col = Regex.Matches(s, "[0-9]");
            StringBuilder sb = new StringBuilder();
            foreach (Match m in col)
                sb.Append(m.Value); 
            return sb.ToString();
        }
    }

using StringExtensions;



....
string phone = "123-123-1234";
string newPhone = phone.RemoveNonNumeric();

Update:  Although the overall point of the post was to simply show how to create extension methods, Andrex posted a more efficient way to remove non-numeric characters for those that may actually need that specific functionality (I'll admit I was just throwing something out there :-)).  Thanks for commenting Andrex!

public static string RemoveNonNumeric(this string s)
{
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < s.Length; i++)
        if (Char.IsNumber(s[i]))
            sb.Append(s[i]);
    return sb.ToString();
}

I gave a talk at Desert Code Camp toward the end of 2007 that discussed how Microsoft's Silverlight product could be integrated with ASP.NET AJAX to dynamically display albums obtained from an Amazon.com Web Service.  It's taken awhile to get the video posted, but i