How to get the maximum performance when getting the color of 1 specific pixel, for 35 images?

It seems that the files you are dealing with are simple 24-bit bitmaps, right?

In this case, you can avoid using GDI + alltogether (it's a bad idea to use it in ASP.NET anyway), and just parse the bitmap data directly. This will mean that you don't even need to read the entire file - just the header and whatever pixel you need.

If you are really working with simple 24-bit bitmaps, the following should work very well:

Color GetPixel(string fileName, int x, int y)
{
    var buffer = new byte[32];

    using (var file = File.OpenRead(fileName))
    {
        if (file.Read(buffer, 0, 32) < 32) return Color.Empty;

        // Bitmap type. Pretty much everything you find is BM.
        var type = Encoding.ASCII.GetString(buffer, 0, 2);
        if (type != "BM") return Color.Empty;

        // Data offset
        var offset = BitConverter.ToInt32(buffer, 10);

        // Windows bitmaps have width and height in a fixed place:
        var width = BitConverter.ToInt32(buffer, 18);
        var height = BitConverter.ToInt32(buffer, 22);

        if (width < x || height < y) return Color.Empty;

        // Three bytes per pixel, padded to multiples of four
        var rowSize = width * 3 + ((4 - ((width * 3) % 4)) % 4);

        // And get our pixel - since we're non-compressed, non-indexed, 
        // 32-bit pixels, this is easy. Note that bitmaps are usually stored
        // top to bottom:
        file.Seek(offset + ((rowSize * (height - y - 1)) + x * 3), SeekOrigin.Begin);

        if (file.Read(buffer, 0, 3) < 3) return Color.Empty;
        // Alpha
        buffer[3] = 0xFF;

        var color = BitConverter.ToInt32(buffer, 0);
        return Color.FromArgb(color);
    }
}

      

        
        
        
      

    

Even if your files are not simple 24-bit maps, this cron job should have no problem converting them - if you want to easily index into bitmap data, you don't have much choice anyway :)

Only a few changes are required to support 8-bit indexed bitmaps:

Color GetPixel(string fileName, int x, int y)
{
    var buffer = new byte[32];

    using (var file = File.OpenRead(fileName))
    {
        if (file.Read(buffer, 0, 32) < 32) return Color.Empty;

        // Bitmap type. Pretty much everything you find is BM.
        var type = Encoding.ASCII.GetString(buffer, 0, 2);
        if (type != "BM") return Color.Empty;

        // Data offset
        var offset = BitConverter.ToInt32(buffer, 10);

        // Windows bitmaps have width and height in a fixed place:
        var width = BitConverter.ToInt32(buffer, 18);
        var height = BitConverter.ToInt32(buffer, 22);

        if (width < x || height < y) return Color.Empty;

        // One byte per pixel, padded to multiples of four
        var rowSize = width + ((4 - ((width) % 4)) % 4);

        // Now we're going to read an index into our palette
        file.Seek(offset + ((rowSize * (height - y - 1)) + x), SeekOrigin.Begin);
        if (file.Read(buffer, 0, 1) < 1) return Color.Empty;

        // Jump to the palette record and get the actual color
        file.Seek(54 + buffer[0] * 4, SeekOrigin.Begin);
        if (file.Read(buffer, 0, 4) < 4) return Color.Empty;

        var color = BitConverter.ToInt32(buffer, 0);
        return Color.FromArgb(color);
    }
}

      

        
        
        
      

    

If you want to avoid writing bitmap parsing code, you just need to make sure the bitmaps are always loaded and parsed in memory - the bottleneck is not GetPixel

, it loads Bitmap

from disk.

It might be worth caching the headers and palette of each of the images to avoid some searches - I'm not sure if this helps at all, but the basic idea is this:

private static readonly ConcurrentDictionary<string, byte[]> _cache;

Color GetPixel(string fileName, int x, int y)
{
  var buffer = new byte[3];

  using (var file = File.OpenRead(fileName))
  {
    byte[] headers;
    if (_cache.ContainsKey(fileName))
    {
      headers = _cache[fileName];
    }
    else
    {
      headers = new byte[1078];
      if (file.Read(headers, 0, headers.Length) < headers.Length) return Color.Empty;

      _cache.TryAdd(fileName, headers);
    }

    // Now read the headers as before, using the headers local instead of buffer
    // ...

    file.Seek(offset + ((rowSize * (height - y - 1)) + x), SeekOrigin.Begin);

    if (file.Read(buffer, 0, 1) < 1) return Color.Empty;

    var color = BitConverter.ToInt32(headers, 54 + buffer[0] * 4);

    return Color.FromArgb(color);
  }
}