CODEWITHSUNDEEP
c#.netc#-4.0
rohit
rohit

Reputation: 501

difference between Image.Save and FileStream.Write() in c#

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.

Upvotes: 1

Views: 3136

Answers (2)

Avner Shahar-Kashtan
Avner Shahar-Kashtan

Reputation: 14700

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.

Upvotes: 1

Digbyswift
Digbyswift

Reputation: 10410

I think the main difference between the two is that in the second code you are writing the source byte[] to a MemoryStream object first which would mean that if the data becomes essentially independent of the database. So, you could potentially incorporate this MemoryStream into the first code to achieve the same results.

Upvotes: 0

Related Questions