Question

In Silverlight I use lambdas for data retrieval from my service (in this example a WCF Data Service). Exceptions inside the callback get swallowed up by the system unless I handle them with a try catch. For Example:

this.Context.BeginSaveChanges(() =>
{
  // throwing an exception is lost and the Application_UnhandledException doesn't catch it

}, null);

I have a helper function to log the exception and redirect to a aspx general error page, but then I have to wrap everything in lambdas with try/catches which is ok, if I have to do it, but is there a better way?

Answer 1

You could create a set of helper methods to wrap the lambda’s with:-

 public static class Helper
 {
    public static AsyncCallback GetAsyncCallback(Action<IAsyncResult> inner)
    {
        return (a) =>
        {
            try
            {
                inner(a);
            }
            catch (Exception err)
            {
                // Your handling for "uncaught" errors
            }
        };
    }

    public static Action GetAction(Action inner)
      {
         return () =>
         {
             try
             {
                 inner();
             }
             catch (Exception err)
             {
                 // Your handling for "uncaught" errors
             }
         };
      }

      public static Action<T> GetAction(Action<T> inner)
      {
         return (a) =>
         {
             try
             {
                 inner(a);
             }
             catch (Exception err)
             {
                 // Your handling for "uncaught" errors
             }
         };
      }
      // and so on also:-

      public static Func<T> GetFunc(Func<T> inner;)
      {
         return () =>
         {
             try
             {
                 return inner();
             }
             catch (Exception err)
             {
                 // Your handling for "uncaught" errors
             }
         };
      }
      public static Func<T1, TReturn> GetFunc(Func<T1, TReturn> inner;)
      {
         return (a) =>
         {
             try
             {
                 return inner(a);
             }
             catch (Exception err)
             {
                 // Your handling for "uncaught" errors
             }
         };
      }
 }

Now you can wrap lambda’s without worrying about default boilerplate exception handling:-

this.Context.BeginSaveChanges(Helper.GetAsyncCallback((ar) =>             
{             
  // Only needs specific exception handling or none at all             

}), null);