Selecting a thumbnail from among a large, medium, and small image
var thumb = (images == null)
            ? null
            : (images.small == null) || (images.small.Length == 0)
                ? (images.medium == null) || (images.medium.Length == 0)
                    ? (images.large == null) || (images.large.Length == 0)
                        ? null
                        : images.large[0]
                    : images.medium[0]
                : images.small[0];

  
  I understand it but


no one else does ;-) 

Ternary operators are very usefull but you really exaggerated. In a production code I would never accept it.

You should break it to smaller pieces.


  is there a better (i.e. easier to understand) way to express the overall algorithm?


There might be. If the images type is under your control then you could implement the IEnumerable interface on it and return the sub-image collections:

class ImageCollection : IEnumerable&lt;Bitmap[]&gt;
{
    public Bitmap[] small { get; set; }
    public Bitmap[] medium { get; set; }
    public Bitmap[] large { get; set; }

    public IEnumerator&lt;Bitmap[]&gt; GetEnumerator()
    {
        yield return small;
        yield return medium;
        yield return large;
    }

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
    {
        return this.GetEnumerator();
    }
}


Then with a small helper lambda you can encapsulate the first-image-or-default logic and use linq to retrieve the first image found:

var images = new ImageCollection();
var getFirstImageOrDefault = new Func&lt;Bitmap[], Bitmap&gt;(
    bitmaps =&gt; bitmaps == null ? null : bitmaps.FirstOrDefault());
var thumb = images.Select(getFirstImageOrDefault).FirstOrDefault(bitmap =&gt; bitmap != null);