Works on my machine

Overuse of “as” keyword

Jakub Niemyjski — Sat, 22 Dec 2012 15:34:15 GMT

Originally posted on: http://geekswithblogs.net/nabuk/archive/2012/12/22/overuse-of-ldquoasrdquo-keyword.aspx

Recently I realized that I am overusing "as" keyword. It is probably because its syntax is more fluent for me than ordinary cast. I see this overuse even in Microsoft examples. Let the following code show you what I mean:

  1:  object x = "1.0";
  2:  Version v = x as Version;
  3:  Console.WriteLine(v.Major);

and just for reference reasons ordinary cast:

  1:  object x = "1.0";
  2:  Version v = (Version)x;
  3:  Console.WriteLine(v.Major);

When you run first snippet it will crash on third line throwing NullReferenceException.
Second snippet on the other hand will crash on second line throwing InvalidCastException.

Now tell me, which gives you more info ?

For me the real problem with first one is that it can misguide in more complex scenarios. Imagine a method that returns some reference type and the last action is cast. What would be your first thought when your consuming code throws NullReferenceException ? That was my scenario and frankly I lost too much time analyzing good code. If I had only got InvalidCastException in proper line …

Beware the IEnumerable<T>

Jakub Niemyjski — Tue, 30 Oct 2012 23:23:26 GMT

Originally posted on: http://geekswithblogs.net/nabuk/archive/2012/10/31/beware-the-ienumerablelttgt.aspx

If you see IEnumerable<T> as read only collection crippled brother, this post is for you.

Many times I found myself loosing couple of hours looking for a bug everywhere, but not in a place where it was. From time to time the bug is caused by my simplified perception of IEnumerable. The thing is, if we do not know the mechanism that serves specific IEnumerable elements, we cannot be sure that each iteration will return equal collections with same objects.

It is not a big deal if it hosts immutable objects. With mutable however, we must be careful.

Let’s analyze following properties:

  1:  public static IEnumerable<StringBuilder> ByArray
  2:  {
  3:      get
  4:      {
  5:          return new StringBuilder[] { new StringBuilder("foo") };
  6:      }
  7:  }
  8:  
  9:  public static IEnumerable<StringBuilder> ByYield
 10:  {
 11:      get
 12:      {
 13:          yield return new StringBuilder("foo");
 14:      }
 15:  }

and code that operates on them:

  1:  var enumerable = ByArray;
  2:  enumerable.First()[0] = 'b';
  3:  Console.WriteLine(enumerable.First());
  4:  
  5:  enumerable = ByYield;
  6:  enumerable.First()[0] = 'b';
  7:  Console.WriteLine(enumerable.First());

This will write 2 lines. Can you predict each of them ? If not, I strongly advise you to run the code.

But that is not all. Analyze those two properties:

  1:  public static IEnumerable<StringBuilder> ByDynamicArray
  2:  {
  3:      get
  4:      {
  5:          return new StringBuilder[] { new StringBuilder("foo") };
  6:      }
  7:  }
  8:  
  9:  public static IEnumerable<StringBuilder> ByStaticArray
 10:  {
 11:      get
 12:      {
 13:          return fooArray;
 14:      }
 15:  }
 16:  private static StringBuilder[] fooArray =
 17:      new StringBuilder[] { new StringBuilder("foo") };
 18:  
 19:

and their usage:

  1:  ByDynamicArray.First()[0] = 'b';
  2:  Console.WriteLine(ByDynamicArray.First());
  3:  
  4:  ByStaticArray.First()[0] = 'b';
  5:  Console.WriteLine(ByStaticArray.First());

Notice that now we are operating directly on property, not on a local variable like in previous example. This is also important and can cause different output.

So be careful and think twice before writing code that operates on IEnumerable<T>.

Linq’s ZIP for adjacent items

Jakub Niemyjski — Tue, 30 Oct 2012 20:52:05 GMT

Originally posted on: http://geekswithblogs.net/nabuk/archive/2012/10/30/linqrsquos-zip-for-adjacent-items.aspx

I found that Linq’s ZIP is really great for adjacent item computations.

For example, let’s have a collection of dates:

  1:  var dates = new DateTime[]
  2:  {
  3:      new DateTime(2000,1,1),
  4:      new DateTime(2000,1,2),
  5:      new DateTime(2000,1,5)
  6:  };

How would you compute time difference of adjacent items ?

I like to use Zip for this kind of job:

  1:  dates.Zip(dates.Skip(1), (d1, d2) => d2 - d1);

As you might expect, the result will be: { 1 day, 3 days }

Generic IAsyncResult

Jakub Niemyjski — Tue, 30 Oct 2012 18:24:00 GMT

Originally posted on: http://geekswithblogs.net/nabuk/archive/2012/10/30/generic-iasyncresult.aspx

Today I faced following problem:

User picks many files by OpenFileDialog control. They must be loaded asynchronously. Loading some of them may fail. I want to receive callback when loading completes. How can I encapsulate all of this in single repository Load method signature ?

After some time I came up with following interface:

  1:      interface IAsyncResult<out T>
  2:      {
  3:          T Result { get; }
  4:          Exception Error { get; }
  5:          bool IsCompleted { get; }
  6:          bool Wait(int timeout);
  7:          void AttachCallback(Action<IAsyncResult<T>> callback);
  8:      }

Similarity to .NET's IAsyncResult is intentional, although my version is generic and simplified.
Instead of supporting AsyncWaitHandle I expose only Wait method.

Example

Having IAsyncResult<T> we can define Image repository like this:

  1:      interface IImageRepository
  2:      {
  3:          IEnumerable<IAsyncResult<Image>> LoadImages();
  4:      }

Implementation

Following implementation wraps synchronous job to IAsyncResult<T> job.
ConcurrentBag was use to synchronize callbacks. Callbacks are stored as weak references to avoid memory leaks.

  1:      public class JobResult<T>
  2:      {
  3:          public T Result { get; set; }
  4:          public Exception Error { get; set; }
  5:      }
  6:  
  7:      public class AsyncResultFromSyncJob<T> : IAsyncResult<T>, IDisposable
  8:      {
  9:          private Func<JobResult<T>> synchronousJob;
 10:          private readonly ManualResetEvent completedEvent =
 11:                  new ManualResetEvent(false);
 12:          private readonly ConcurrentBag<WeakReference> completionCallbacks =
 13:                  new ConcurrentBag<WeakReference>();
 14:  
 15:          private void OnCompletion(IAsyncResult ar)
 16:          {
 17:              var jobResult = synchronousJob.EndInvoke(ar);
 18:              this.Result = jobResult.Result;
 19:              this.Error = jobResult.Error;
 20:              this.completedEvent.Set();
 21:  
 22:              synchronousJob = null;
 23:  
 24:              FireCallbacks();
 25:          }
 26:          private void FireCallbacks()
 27:          {
 28:              WeakReference wr;
 29:              Action<IAsyncResult<T>> callback;
 30:  
 31:              while (completionCallbacks.TryTake(out wr))
 32:                  if ((callback = wr.Target as Action<IAsyncResult<T>>) != null)
 33:                      Task.Factory.StartNew(() => callback(this));
 34:          }
 35:  
 36:          public AsyncResultFromSyncJob(Func<JobResult<T>> synchronousJob)
 37:          {
 38:              this.synchronousJob = synchronousJob;
 39:              synchronousJob.BeginInvoke(OnCompletion, null);
 40:          }
 41:  
 42:          #region IAsyncResult<T>
 43:  
 44:          public T Result { get; private set; }
 45:          public Exception Error { get; private set; }
 46:          public bool IsCompleted { get { return this.completedEvent.WaitOne(0); } }
 47:  
 48:          public bool Wait(int timeout = Timeout.Infinite)
 49:          {
 50:              return completedEvent.WaitOne(timeout);
 51:          }
 52:  
 53:          public void AttachCallback(Action<IAsyncResult<T>> callback)
 54:          {
 55:              completionCallbacks.Add(new WeakReference(callback));
 56:              
 57:              if(IsCompleted)
 58:                  FireCallbacks();
 59:          }
 60:  
 61:          #endregion
 62:  
 63:          #region IDisposable
 64:  
 65:          public void Dispose()
 66:          {
 67:              completedEvent.Dispose();
 68:          }
 69:  
 70:          #endregion
 71:      }

I found Mark Seemann's IAsyncResult generic implementation after writing my own:
http://blogs.msdn.com/b/ploeh/archive/2007/02/09/agenericiasyncresultimplementation.aspx