There is a way however, to intercept the message before it is returned to the front-end and log the error automatically the way we are used to with Elmah.

First we set up an ErrorHandlerFilter class which will override the default error stream message ( {“Message”:”There was an error processing the request.”, “StackTrace”:””, “ExceptionType”:””})} with a more meaningful error message with details.

   1: using System;

   2: using System.Collections.Generic;

   3: using System.IO;

   4: using System.Linq;

   5: using System.Text;

   6:  

   7: namespace Namespace.ElmahExtension

   8: {

   9:     public class ErrorHandlerFilter : Stream

  10:     {

  11:  

  12:         private readonly Stream _responseFilter;

  13:  

  14:         public List<byte> OriginalBytesWritten { get; private set; }

  15:  

  16:         private const string Content =

  17:           "{\"Message\":\"There was an error processing the request.\"" +

  18:           ",\"StackTrace\":\"\",\"ExceptionType\":\"\"}";

  19:  

  20:         public ErrorHandlerFilter(Stream responseFilter)

  21:         {

  22:             _responseFilter = responseFilter;

  23:             OriginalBytesWritten = new List<byte>();

  24:         }

  25:  

  26:         public override void Flush()

  27:         {

  28:             byte[] bytes = Encoding.UTF8.GetBytes(Content);

  29:             _responseFilter.Write(bytes, 0, bytes.Length);

  30:             _responseFilter.Flush();

  31:         }

  32:  

  33:         public override long Seek(long offset, SeekOrigin origin)

  34:         {

  35:             return _responseFilter.Seek(offset, origin);

  36:         }

  37:  

  38:         public override void SetLength(long value)

  39:         {

  40:             _responseFilter.SetLength(value);

  41:         }

  42:  

  43:         public override int Read(byte[] buffer, int offset, int count)

  44:         {

  45:             return _responseFilter.Read(buffer, offset, count);

  46:         }

  47:  

  48:         public override void Write(byte[] buffer, int offset, int count)

  49:         {

  50:             for (int i = offset; i < offset + count; i++)

  51:             {

  52:                 OriginalBytesWritten.Add(buffer[i]);

  53:             }

  54:         }

  55:  

  56:         public override bool CanRead

  57:         {

  58:             get { return _responseFilter.CanRead; }

  59:         }

  60:  

  61:         public override bool CanSeek

  62:         {

  63:             get { return _responseFilter.CanSeek; }

  64:         }

  65:  

  66:         public override bool CanWrite

  67:         {

  68:             get { return _responseFilter.CanWrite; }

  69:         }

  70:  

  71:         public override long Length

  72:         {

  73:             get { return _responseFilter.Length; }

  74:         }

  75:  

  76:         public override long Position

  77:         {

  78:             get { return _responseFilter.Position; }

  79:             set { _responseFilter.Position = value; }

  80:         }

  81:     }

  82: }

Now, we’re going to need to set up a class that implements IHttpModule.  which we’ll use to intercept the message being passed after the Request and EndRequest handlers execute.

   1: using System;

   2: using System.Diagnostics;

   3: using System.IO;

   4: using System.Text;

   5: using System.Web;

   6: using System.Web.Services.Protocols;

   7: using Elmah;

   8:  

   9: namespace Namespace.ElmahExtension

  10: {

  11:     public class ElmahExtension : IHttpModule

  12:     {

  13:         private HttpApplication _application;

  14:  

  15:         public void Dispose()

  16:         {

  17:         }

  18:  

  19:         public void Init(HttpApplication context)

  20:         {

  21:             _application = context;

  22:             _application.PostRequestHandlerExecute += OnPostRequestHandlerExecute;

  23:             _application.EndRequest += OnEndRequest;

  24:         }

  25:  

  26:         private void OnPostRequestHandlerExecute(object sender, EventArgs e)

  27:         {

  28:             var context = sender as HttpApplication;

  29:             if(context != null && (context.Request.Path.Contains(".asmx") && (context.Response.StatusCode >= 400 && context.Response.StatusCode < 600)))

  30:             {

  31:                 context.Response.Filter = new ErrorHandlerFilter(context.Response.Filter);

  32:             }

  33:         }

  34:  

  35:         static void OnEndRequest(object sender, EventArgs e) 

  36:         {

  37:             var context = (HttpApplication)sender;

  38:             var errorHandlerFilter = context.Response.Filter as ErrorHandlerFilter;

  39:  

  40:             if (errorHandlerFilter == null)

  41:             {

  42:                 return;

  43:             }

  44:  

  45:             var originalContent = Encoding.UTF8.GetString(errorHandlerFilter.OriginalBytesWritten.ToArray());

  46:             ErrorLog.GetDefault(context.Context).Log(new Error(new Exception(originalContent)));

  47:         }

  48:     }

  49:  

  50: }

Notice in the OnPostRequestHandlerExecute function we’re intercepting any request that comes from a Webservice (.asmx page) and has a status code of greater than 400 (All error code types).  At his point we want to set the ErrorHandelerFilter to the current Response.Filter value.

Now in the OnEndRequest function we want to get the current context and set the error handler based on the filter which should now be persisting the values we set in the previous function.  Once we have the error values all we have to do is call the Elmah manual logging API and log the exception.

The final piece you have to do is set up the webConfig to recognize and use your IHttpModule code. n In your config file navigate down to System.Web >> HttpModules and fill in the attribute accordingly.

   1: <system.web>

   2:     <httpModules>    

   3:       <add name="ElmahExtension" type="Namespace.ElmahExtension.ElmahExtension"/>

   4:     </httpModules>

   5: </system.web>

Once you compile and run, any errors encountered in your web services should now be logged by Elmah just like any others.

Thanks to Reddy Kadasani, Mike Gerety and Dylan Barrett for their contributions to this solution.

This kind of solution can be applied to several situations such as complex data processing, dynamic loading, or combining them all into a seamless form submission process that would clear the form on post backs.

We can accomplish this process simply by grabbing an event, such as a button click, and collecting all the required information using jQuery.  Next using a JSON call, we can pass all the parameters to the web service and execute our code from there.

Here, I’ll start with a simple .aspx page with jquery, a textbox, and link that will be used to call the web service.

   1: <%@ Master Language="C#" MasterPageFile="~/Site.Master" AutoEventWireup="true" CodeBehind="ThisPage.cs" Inherits="ThisSolution.ThisProject.ThisFolder" %>

   2:  

   3: <asp:Content ID="Content1" ContentPlaceHolderID="HeadContent" runat="server">

   4:     <script src="/Scripts/jquery-1.4.1.min.js" type="text/javascript"/>

   5: </asp:Content>

   6:  

   7: <asp:Content ID="Content2" ContentPlaceHolderID="MainContent" runat="server">

   8:     <asp:TextBox ID=”textBox” TextMode="MultiLine" runat="server"></asp:TextBox>

   9:     <a href="#" class="buttonClass"> Save </a>

  10:     <asp:Label ID=”successLabel” runat="server"></asp:Label>

  11: </asp:Content>

Next, you will need to establish your web service and create an .asmx file.  There are a couple of important things to note here. Line 5 will be by default commented out.  So in order for us to make our JSON call we’re going to need this uncommented.  Also, notice I’m returning a string.  For the purposes of this demo I am going to return a string to the UI and display a message, but you can return any kind of object that can be serialized down to a primitive data type.

   1: [WebService(Namespace = "http://tempuri.org/")]

   2: [WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]

   3: [System.ComponentModel.ToolboxItem(false)]

   4: // To allow this Web Service to be called from script, using ASP.NET AJAX, uncomment the following line. 

   5: [System.Web.Script.Services.ScriptService]

   6: public class wService : System.Web.Services.WebService

   7: {

   8:     [WebMethod()]

   9:     [ScriptMethod(UseHttpGet = false, ResponseFormat = ResponseFormat.Json)]

  10:     public string UpdateComment(string textBoxText)

  11:     {

  12:         var success = Service.CallToDb(textBoxText);

  13:  

  14:         if(success)

  15:         {

  16:             return "Call to Database using text was successful";

  17:         }

  18:         else 

  19:         {

  20:             return "Call to Database using text was not successful";

  21:         }    

  22:     }           

  23: }

I use a jQuery selector to pick up on the mouse click of the link and gather our data into an javascript object.  Note that when passing parameters through this object you have to name them the same way as you do in the parameter declaration of the web service.

When setting up the call to the service you’re going to want to remember to call the “JSON.stringify” function on your data object so that it serializes properly and that your contentType as well as dataType are configured properly as well.

   1: <script type='text/javascript>

   2:     $('.buttonClass').live('click', function(){

   3:         var text = $('#textBox').text();

   4:         var data = new Object();

   5:         data.textBoxText = text;

   6:  

   7:         $.ajax({

   8:             type: "POST",

   9:             url: "/Ajax/WbServcie.asmx/UpdateComment",

  10:             data: JSON.stringify(data),

  11:             contentType: "application/json; charset=utf-8",

  12:             dataType: "json",

  13:             success: function(msg){

  14:                 $('#successLabel').val(msg);

  15:             },

  16:             error: function(msg){

  17:                 alert('Something, somewhere, has gone terribly wrong');

  18:                 return false;

  19:             }

  20:         });    

  21: </script>

Once you get a response from the service, you can set any of your data that is returned.  In this case, we’re returning a string indicating the call to the database was successful and will set a label on the page to show that.

And that’s it.  With just a few simple configurations we have a quick call back to the server without having to run an expensive post back.

While SharePoint 2010 supports .NET 3.5, it uses the .NET 2.0 compiler by default for ASP.NET pages.  If you write any UserControls or consume any DLLs in your hosted ASPX pages that utilizes .NET 3.5 features such as the var keyword, extension methods, and LINQ, you’ll get compilation error messages when attempting to access those pages.

To resolve this issue, you can edit the web.config in your site collection’s virtual directory (Usually under \inetpub\wwwroot\wss\virtualdirectories\<site>).  Add the following snippet under the configuration element:

<system.codedom>
  <compilers>
    <compiler language="c#;cs;csharp" extension=".cs" warningLevel="4"
              type="Microsoft.CSharp.CSharpCodeProvider, System, Version=2.0.0.0,
                    Culture=neutral, PublicKeyToken=b77a5c561934e089">
      <providerOption name="CompilerVersion" value="v3.5" />
      <providerOption name="WarnAsError" value="false" />
    </compiler>
  </compilers>
</system.codedom> 

.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, “Courier New”, courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }

Also, look under the Assemblies section and make sure you have the following entries:

   1: <add assembly="System.Web.Extensions, Version=3.5.0.0,Culture=neutral, PublicKeyToken=31BF3856AD364E35" />

   2: <add assembly="System.Xml.Linq, Version=3.5.0.0,Culture=neutral, PublicKeyToken=B77A5C561934E089" />

   3: <add assembly="Microsoft.SharePoint, Version=14.0.0.0,Culture=neutral, PublicKeyToken=71e9bce111e9429c" />

   4: <add assembly="System.Web.Extensions, Version=3.5.0.0,Culture=neutral, PublicKeyToken=31bf3856ad364e35" />

   5: <add assembly="Microsoft.Web.CommandUI, Version=14.0.0.0,Culture=neutral, PublicKeyToken=71e9bce111e9429c" />

   6: <add assembly="Microsoft.SharePoint.Search, Version=14.0.0.0,Culture=neutral, PublicKeyToken=71e9bce111e9429c" />

   7: <add assembly="Microsoft.Office.Access.Server.UI, Version=14.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" />

   8: <add assembly="Microsoft.SharePoint.Publishing, Version=14.0.0.0,Culture=neutral, PublicKeyToken=71e9bce111e9429c" />

Note: You can also add other .NET 3.5 assemblies here as needed.

In general, exceptions should be bubbled up to the highest possible level to be caught and processed.  For example, in our project, a search goes through the following logical tiers:

UI -> Services -> Data/SharePoint/Refinement -> Web Services

There are quite a few instances where we’re catching exceptions in the Data or Services layer, logging them using common logging components or configurations, and then swallowing the exception one way or another.

This is a bad practice for few reasons:

• This behavior is not transparent to developers that may be using the DLL but do not have access to the source code.
• Logging from lower tier components is generally a bad idea, as it either requires a static logging location embedded in the dll or creates a dependency on the UI to provide pre-determined logging mechanism (i.e. EntLib).   (This can get especially ugly with EntLib, and EntLib Logging and ExceptionHandling blocks generally use named “policies” for handling and logging exceptions, and referencing them from a middle-tier component requires any UI consuming it to implement the exact same logging configuration.
• Applications consuming the DLL do not know about or are not given the ability to choose how to react to exceptions in the code.
• Swallowing exceptions dilutes the effectiveness of unit tests testing these functions, as tests can’t explicitly test for scenarios that might cause specific exceptions,
• Swallowing exceptions can make debugging issues a nightmare (if not impossible) for developers that might consume this middle-tier component and not have access to the source code.
• Catch blocks have an inherent performance cost.  Catching exceptions unnecessarily results in unnecessary performance degredataion.

There are a few legitimate cases where this best practice might not be followed:

1. The Exception contains potentially sensitive information

If the exception or exception message contains potentially sensitive information such as user credentials, server names, or any other sensitive information, it likely makes sense to catch the exception, create an exception that accurately describes the issue without the sensitive information, then throw that exception.  Note however, there are very few scenarios where this should not occur at the UI layer.

2. The exception is too vague or needs more metadata to be meaningful to the code consuming it.

If the exception by itself is too vague or requires rebadging or augmented metadata to be useful to the code consuming it, it generally makes sense to wrap the exception by creating an exception that allows the original exception to be set as an “InnerException”, and augments the original exception with more information.  This new exception should then be thrown.

3. The exception that was caught should not affect the execution of the code

If an exception occurs that should not affect the execution of the code, it may be swallowed or ignored in limited cases.  However, exceptions really should not be being thrown unless there is a severe enough issue to potentially interrupt program execution, so I’d suggest reviewing the code throwing the exception you are swallowing in this case.

4. The Exception Occurs At A Physical Tier Boundary

Your multi-tier applications may not only contain multiple logical tiers, but physical tiers as well.  (for example, your web application may rely on a web service layer on a separate physical server).  While your web service layer may be “middle-tier” as far as the overall application is concerned, exceptions should be caught, processed, and logged at the boundary to that physical tier.  Logging on the machine where the services resides aides in issue resolution, and it gives an opportunity to review exceptions for sensitive information before sending them over the network, where they may be intercepted.

Practice #2: You Should (Almost Never) Catch System.Exception

You should almost never write the following:

This code says that you don’t know what type of exception to expect, so catch them all.

Any exception that the code is not expecting is, by definition, an unexpected or unhandled exception.  You probably want your application to crash (or gracefully exit) with an “Unhandled Exception” message if an unexpected exception occurs! How can you be certain of the stability of the currently running instance of your code if an exception occurred somewhere that you didn’t expect?

Also, catching specific exceptions helps greatly in diagnosing issues, and displaying useful and meaningful error messages to your users.  I think we all know how frustrating a generic error message such as “An error occurred.” can be.

If you think an exception might occur but you don’t know the type, either determine the type and catch it or don’t implement a handler at all!   If you need to throw an exception and there’s not an exception type available that is specific to the error that occurred, create a new one.

Practice #3: Always Null-Check Objects Returned from a Function Call

Review the 5 lines of code below.

What’s wrong with this picture?

If you said Null Reference Exception you’re right.  Never, ever access any member of any object that has been returned from a function without checking for null.  You should never assume that a function will return an instantiated object.

Never.

Even if you wrote the function you’re calling.

We all work on projects with multiple developers, and at any given time another developer (or even you) may alter the code and end up returning a null object without realizing that there is some expectation that an instantiated object be returned by some callers.

Taking the extra time to type 15-20 extra characters can mean the difference between stable software and buggy, error-prone code.

Conclusion

I wrote this as an e-mail to my team after doing some refactoring and realized that it could be beneficial to a wider audience being that violations of these practices are so common.  I’ve made these mistakes (as I’m sure many of us have) numerous times in the past, so writing this up was a good reminder for me to focus on these points when writing code.

Please feel free to post additions, corrections, questions, and concerns in the comments section below!  The dialogue will benefit all involved!

This year was filled with a number of announcements at the two keynotes I did my best to update my twitter feed with some of the cool ones.

The first keynote was focused around recent release of IE9, the next generation of web, ASP.NET MVC3, and HTML5, and the new release of IE 10 Platform Preview 1 (watch online):

• IE9 Released
• IE10 Platform Preview1 Released (download)
• HTML5 Labs available to demonstrate HTML5 features and compatibility
• New Developer Conference coming to Anaheim, CA from September 13-16 2011 (PDC maybe? maybe not?)
• Microsoft is commited to pushing and actively contributing to NuGet (an open source package manager)
• Tools update for ASP.NET MVC 3 available for download
• Entity Framework 4.1 released (download)
• Updated Scaffolding support for Entity Framework and MVC
• Updated ASP.NET MVC New Project Dialog (screenshot) with support for the Razor View engine, HTML5 markup
• MVC 3 new projects now include built in Modernizr script support and many scripts and references are updatable via NuGet package references.

The second keynote, which really piqued my interests was all about Windows Phone 7, Silverlight, and the Kinect (watch):

• Windows Phone 7
  • Respectable acknowledgement of the Windows Phone 7 Update state by Joe Belfiore, and announcement of the Where’s my Update? page.
  • New Windows Phone 7 Update codenamed “Mango” shipping this Fall
  • Focus of Mango is on Opportunity (Ecosystem, Countries, Discoverability), Capability (Browser, Phone Integration, Multi-tasking), and Developer Experience and Tools
  • Opportunity
    • Nokia appeared live and affirmed their commitment to partnering with Microsoft to reach hundreds of millions of customers
    • Mango will support for 16 Languages, 38 Countries, and 35 Countries can buy apps from a single Marketplace
    • Marketplace search added to App list on home screen
    • New Pivot view added to App decriptions in Marketplace
    • New Related Apps pivot on in Marketplace
    • Hubs and Search Cards (Movies, Restaurants, etc) have an Extras tab that deep links to relevant content
  • Capability
    • IE9 and HTML5 will be included in the Mango
    • HTML5 audio/video tag support added
    • Background Audio support added to Mango
    • Background Agents available in Mango, with support for running when users battery/wifi are optimal
    • Multiple Live Tiles for Apps
    • Live Tile Animation
    • Updates to Live Tiles without Push notifications
    • Sensor support added for Direct Camera support, Compass, and Gyro
    • Socket Communication added
    • Performance Optimizations – Scrolling and Input, Image Decode, Garbage Collection, and Memory Usage
    • New Motion Sensor API for combining the Compass and Gyro raw data
    • Angry Birds (May 25), Spotify, and Skype are coming to the Windows Phone
  • Developer Tools
    • Phone orientation tool for simulating Accelerometer, with options for pre-recorded gestures and actions
    • Location simulation available via built-in Bing Maps tool, with options for pre-recorded location changes
    • Phone Performance monitoring and analysis tools available
• Silverlight
  • Sliverlight 5 Beta is now available (download)
  • Expression Blend Preview for Silverlight 5 is now available (download)
  • Hardware-Based Video Decode
  • Added 3D support
  • Trick Play support – pitch correction audio
  • Recieve Commands from a remote control
• Kinect
  • Kinect SDK is coming this Fall

In addition to some wonderful keynotes, I wrote a personal summary of the sessions I attended (all of this content is available online):

• Deconstructing Orchard: Build, Customize, Extend, Ship

  Bradley Millington explained the new features of the v1.1 release of Orchard CMS. This release comes with a new Recipes concept to startup development. Think Visual Studio Project Templates but for Orchard sites, these are fully customizable and open to community contributions, so new templates may come out for many common scenarios. Bradley also showed how simple it is to extend modules and themes. Finally we saw how a simplified deployment can round out a solution with minimal barriers to entry.

• Fonts, Form and Function: A Primer on Digital Typography

  Everytime I see Robby Ingebretsen I’m always so impress about how simple he makes design feel. Check out his presentation at the Design Toolbox if you haven’t yet. Robby took us on a journey through the font choices for his group’s new website http://thinkpixellab.com/. He had some musings about fonts having personalities and relating that to a Hollywood cast in a major screenplay. Of course, we were shown with the every important Grid concept.

• Inspiring UX – UX Lightning Series

  ‘UX Lightning sessions are a full hour session with 4 exceptional speakers each presenting 10 minute topics’. There was lots of inspiring content about Natural User interfaces, putting a lot of ownership on us as Developers and Designers. August de los Reyes was truly remarkable in his 21st Century Design Manifesto where he promotes a design process which is focused on Motivation, Needs, Positive Emotion, Learnability, Adaptability, and Revolutionary changes. This is in contrast to a user centric design which puts faith in the users (who often don’t know what, why, and how they like something), and incremental design evolution.

• ECMAScript 5: The New Parts

  We had the pleasure of listening to the godfather, Doug Crockford, show off the new ECMAScript 5 changes. Many of the features have been wanted for some time. Luckily many of them have shims for older browsers. The addition of strict mode allows the type safety to bring javascript to the next level of software craftsmanship.

• Multitasking in the Next Version of Windows Phone, Part I

  Announced after the second keynote, Darin Miller, reviews the new Background/Live Agents, Reminders, and other background and multi-tasking APIs. Mango has some great new features, and they are being designed in a way that respects the user, all while retaining their excellent developer experience. Like optimizing downloads when you are on WiFi and power.

• Building Data-centric N-tier Applications with jQuery

  The WCF RIA Services team has been doing a great job rounding out the REST/jQuery story. Brad Olenick showed a WCF Service that was consumed by jQuery using plugins for templating, data linking, change tracking, sorting and paging on the server side and on the client side. I can see this being a great tool coupled with the coming jQuery UI Grid. I hope the community rallies around this one especially with the recent shift in structure for the offical jQuery templating and dataLinking plugins

• Graphics & 3D with Silverlight 5

  One of most exciting announcements of Silverlight 5 is 3D, I’m really intrigued by it. As expected they brought in the XNA 3D features which is more aligned with the Windows Phone 3D experience. Aaron Oneal wowed everyone with some really cool demos including the Virtual walkthrough of the Windows Cafe. Then he walked us the through the Graphics processing pipeline showed how vertices, colors, triangles, textures, overlays, and lighting can be written straight to the GraphicsDevice. Caution, 3D development is not for yhe faint at heart.

• WCF Web APis: “There’s a URI for That”

  Coupled with Brad Olenick work above Glenn Block wrapped up the other side of what’s included on the http://wcf.codeplex.com release. In addition to consuming json using dynamic objects, they have a fluent API for configuring services and service creation (ie. IoCs). There are also new strongly typed generic request/response wrappers that expose header information. For more details, see Sam’s post.

• Fun with ASP.NET MVC 3 and MEF

  The power of NuGet was very prevalent at Mix this year, and I’m very excited about the power of using MEF and NuGet combined. Maarten Balliauw showed us how setting up your MVC application to accept MEF Imports, then by separating components into different projects you can add/remove them and in turn on/off functionality.

• NuGet In Depth: Empowering Open Source on the .NET Platform

  Another great HaHaa show. Scott and Phil performed a great ping-pong over creating and consuming NuGet packages. They also showed off the new Symbols feature, “which is huge” as Scott would say. Very entertaining session and inspiring for NuGet

During the breaks, I joined up with some other East Coast developers and speakers and worked on a Coding for Fun Project involving the .NET Micro Framework called the Curious Cloud Contest, we had a nice time with the project and we won a Video Production award in the process. You can see our team’s (MADExpo) video here.

I also had two wonderful evening events, the first night I had the pleasure of joining the Microsoft NUI team for some good Mexican food and the usually HTML5 vs. Silverlight discussion. The following night I had the privilege of being invited to join the folks from Telerik at Aureole, we were joined by Walt Ritscher and a number of people from the Windows Phone Team including Jamie Rodriguez and Ben Riga, both of whom did a wonderful job presenting at that morning’s Keynote event.

For those of you who aren’t familiar with LINQ, I’ll try to sum it up in a few sentences. LINQ stands for language-integrated query. It provides .Net developers with a new syntax which makes performing set based operations on a collection, or multiple collections easier. For example, if we have an unordered list of integers which we need to sort, in the past we would have to do something similar to this:

public void RunSort()
{
  var integerList = new List<int> { 5, 63, 23, 1, 0, 91 };
  QuickSort(0, integerList.Count, integerList);
}

public void QuickSort(int left, int right, IList<int> integerList)
{
  var pivot = integerList[left];

  while (left < right)
  {
    while ((integerList[right] >= pivot) && (left < right))
    {
      right--;
    }

    if (left != right)
    {
      integerList[left] = integerList[right];
      left++;
    }

    while ((integerList[left] <= pivot) && (left < right))
    {
      left++;
    }

    if (left == right) continue;
    integerList[right] = integerList[left];
    right--;
  }

  integerList[left] = pivot;
  pivot = left;

  if (left < pivot)
  {
    QuickSort(left, pivot - 1, integerList);
  }

  if (right > pivot)
  {
    QuickSort(pivot + 1, right, integerList);
  }
}

The above example works fine, however as a developer we needed to make the decision of what sorting algorithm to use, and then go ahead and implement the sorting function. This wastes time and can sometimes be error prone. LINQ can solve this problem, and many other set based problems like it quickly and efficiently. Here is an example of the first example re-written to make use of LINQ:

public void RunSort()
{
    var integerList = new List { 5, 63, 23, 1, 0, 91 };
    var sortedIntegerList = from integer in integerList
                            orderby integer ascending
                            select integer;
}

LINQ takes care of the sorting here for us and provides a nice, easy to read syntax. When using LINQ, we can worry less about the details of working with data sets, and focus more about the business rules we are implementing. PLINQ takes LINQ a step further and extends this powerful set based functionality to take advantage of multi-core CPU’s. Here is an example of the second example converted to use PLINQ:

public void RunSort()
{
    var integerList = new List { 5, 63, 23, 1, 0, 91 };
    var sortedIntegerList = from integer in integerList.AsParallel()
                            orderby integer ascending
                            select integer;
}

When comparing the above example with the second example, only a couple of things have changed. One is obvious just by looking at the code. We are now calling the extension method .AsParallel on the list of integers. This tells PLINQ that it is OK to go ahead and try to parallelize the LINQ query. The second is a little more subtle. Instead of the LINQ query returning an IEnumerable type, it is returning an IParallelEnumerable. Luckily, IParallelEnumerable derives from IEnumerable, so existing code should work fine with this change.

This is of course a very basic example of how LINQ and PLINQ differ. But hopefully I’ve sparked some interest.

-Jon

As promised, I’m posting the content from the presentation including the PowerPoint files and Demo Code.

If anyone has any questions about the content, please feel free to e-mail me at mgerety@tallan.com

Presentation and Content Files: LINQ Presentation And Files

1. Create your Windows Service project and Windows Service.
2. Navigate to the designer for your Windows Service. Under the properties for your service you should see (Name) and ServiceName. Fill in both of these properties with your desired names. You will need to reference these later.
3. In the designer for your Windows Service, right-click and click Add Installer. You should now have a ProjectInstaller.cs file, along with a designer file for the installer.
4. Navigate to the designer for your new project installer. You should see two components, a Service Process Installer and a Service Installer. Under the Service Installer properties, you will need to add a DisplayName, and provide the ServiceName of the service you will be installing. The ServiceName must match the (Name) property of the service.
5. Build your Windows Service project. Now in the same solution, add a new Setup Project. This will provide the Wizard interface for the installation process.
6. After adding the project, you need to add the primary output of your Windows Service to the Setup Project. Do this by right-clicking on the Setup Project -> Add -> Project Output. Select your Windows Service project from the drop down, highlight Primary Output and click OK.
7. Up to this point the installer will install the correct files, but it doesn’t know what to do with the files. We can add custom actions to do the service installation work. Right-click on the Setup Project -> View -> Custom Actions. For a Windows Service we need to add actions for Install, Rollback, and Uninstall. Right-click each of these and click Add Action. Double click Application Folder and select the Primary Output from your Windows Service project.
8. You can now build your Setup Project. The output of this build will be two setup files which are used to install your new Windows Service.

-Jon

For our WCF service, we’re using the wsHttpBinding. This binding provides much of the same functionality as a basic web service, with added service features such as reliable messaging, WS-Addressing, and WS-Security. Since this post is mainly on setting up security for a WCF service, I won’t go into too many details of the other features of wsHttpBinding.

After creating the WCF service, open up the web.config file for the WCF Service Application project. After scrolling down for a long time, you should come across a System.serviceModel tag. This tag contains all of the configuration settings for the WCF services contained in this project. Here’s what you should be looking at now:

<system.serviceModel>

<services>

<service name=“WcfService1.Service1“ behaviorConfiguration=“WcfService1.Service1Behavior“>

<!– Service Endpoints –>

<endpoint address=“” binding=“wsHttpBinding“ contract=“WcfService1.IService1“>

<!–

Upon deployment, the following identity element should be removed or replaced to reflect the

identity under which the deployed service runs. If removed, WCF will infer an appropriate identity

automatically.

–>

<identity>

<dns value=“localhost“/>

</identity>

</endpoint>

<endpoint address=“mex“ binding=“mexHttpBinding“ contract=“IMetadataExchange“/>

</service>

</services>

<behaviors>

<serviceBehaviors>

<behavior name=“WcfService1.Service1Behavior“>

<!– To avoid disclosing metadata information, set the value below to false and remove the metadata endpoint above before deployment –>

<serviceMetadata httpGetEnabled=“true“/>

<!– To receive exception details in faults for debugging purposes, set the value below to true. Set to false before deployment to avoid disclosing exception information –>

<serviceDebug includeExceptionDetailInFaults=“false“/>

</behavior>

</serviceBehaviors>

</behaviors>

</system.serviceModel>

By default, a WCF service will use the wsHttpBinding, this is what we want to continue using. We need to make a few modifications to this web.config in order to provide the additional functionality we want. First take a look at the serviceBehaviors section. By default we already have a behavior for our Service1. Here is an example of a modified behavior:

<behavior name=“WcfService1.Service1Behavior“>

<serviceCredentials>

<serviceCertificate findValue=“CN=ServiceCertificate“ storeLocation=“LocalMachine“

storeName=“My“ x509FindType=“FindBySubjectDistinguishedName“ />

<userNameAuthentication userNamePasswordValidationMode=“Windows“/>

</serviceCredentials>

</behavior>

There is a lot of info in this behavior pertaining to security. The first bit describes the x509 certificate we would like to use that is already installed on our machine. We can create our own test x509 certificate for development purposes if need be. We can also describe the user authentication mode, in this case we are just using Windows authentication.

The next section extends the wsHttpBinding to provide some additional features not turned on be default:

<bindings>

<wsHttpBinding>

<binding name=“wsHttpBindingSettings“ messageEncoding=“Text“>

<security mode=“Message“>

<message clientCredentialType=“UserName“ />

</security>

</binding>

</wsHttpBinding>

</bindings>

Here we can describe the transport type, as well as the client credential type. This is fairly simple, we are using Message based transport with UserName security.

Finally we need to tie these sections together with Service1:

<service behaviorConfiguration=“WcfService1.Service1Behavior“ name=“WcfService1.Service1Behavior“>

<endpoint address=“” binding=“wsHttpBinding“ bindingConfiguration=“wsHttpBindingSettings“

contract=“WcfService1.IService1“ listenUriMode=“Explicit“>

<identity>

<dns value=“ServiceCertficate“ />

</identity>

</endpoint>

<endpoint address=“mex“ binding=“mexHttpBinding“ contract=“IMetadataExchange“ />

</service>

The only changes we made here are in the bindingConfiguration property and the dns value. The bindingConfiguration allows you to bind our binding configuration to this service, and the dns value should match the x509 certificate name.

I’ll be posting some more on this topic, including writing your own custom username validation code for WCF, and creating your own test x509 certificate. Hope this helps!

-Jon