Question

I have to read image binary from database and save this image binary as a Tiff image on filesystem. I was using the following code

private static bool SavePatientChartImageFileStream(byte[] ImageBytes, string ImageFilePath, string IMAGE_NAME)
    {
        bool success = false;
        try
        {
            using (FileStream str = new FileStream(Path.Combine(ImageFilePath, IMAGE_NAME), FileMode.Create))
            {
                str.Write(ImageBytes, 0, Convert.ToInt32(ImageBytes.Length));
                success = true;

            }
        }
        catch (Exception ex)
        {

            success = false;
        }
        return success;
    }

Since these image binaries are being transferred through merge replication, sometimes it happens that image binary is not completely transferred and we are sending request to fetch Image Binary with a nolock hint. This returns in ImageBytes having 1 byte data and it saves it as a 0 kb corrupted tiff image.

I have changed the above code to :-

private static bool SavePatientChartImage(byte[] ImageBytes, string ImageFilePath, string IMAGE_NAME)
    {
        bool success = false;
        System.Drawing.Image newImage;
        try
        {
            using (MemoryStream stream = new MemoryStream(ImageBytes))
            {
                using (newImage = System.Drawing.Image.FromStream(stream))
                {
                    newImage.Save(Path.Combine(ImageFilePath, IMAGE_NAME));
                    success = true;
                }
            }
        }
        catch (Exception ex)
        {
            success = false;
        }
        return success;
    }

In this case if ImageBytes is of 1 byte or incomplete, it won’t save image and will return success as false.

I cannot remove NOLOCK as we are having extreme locking.

The second code is slower as compared to first one. I tried for 500 images. there was a difference of 5 seconds.

I couldn’t understand the difference between these 2 pieces of code and which code to use when. Please help me understand.

Answer 1

In the first version of the code, you are essentially taking a bunch of bytes and writing them to the filesystem. There’s no verification of a valid TIFF file because the code neither knows nor cares it’s a TIFF file. It’s just a bunch of bytes without any business logic attached.

In the second code, you’re taking the bytes, wrapping them in a MemoryStream, and then feeding them into an Image object, which parses the entire file and reads it as a TIFF file. This give you the validation you need – it can tell when the data is invalid – but you’re essentially going over the entire file twice, once to read it in (with additional overhead for parsing) and once to write it to disk.

Assuming you don’t need any validation that requires deep parsing of the image file (# of colors, image dimensions, etc) you can skip this overhead by simply checking if the byte[] ImageBytes is of length 1 (or find any other good indicator of corrupt data) and skip writing if it doesn’t match. In effect, do your own validation, rather than using the Image class as a validator.