Converting Images to Base64 and Back Again

[jmcilhinney]

I'm going to have to take issue with a few things here.

1. Every database that I've worked with allows you to store binary data. As such, while you can't store an Image object as is in a database, you can convert that Image to a Byte array and save that. That means that your conversions between Image and Byte array and vice versa are useful for the stated purpose but the conversions to and from a base-64 String are not only superfluous but actually produce data that takes up more space than the equivalent Byte array.

2. I hate inconsistency in code. You are using Image in some places and System.Drawing.Image in others. That's not going to do any harm in the code itself but someone who doesn't know any better might look at that and think that they are two different things because they could reasonably assume that if they were the same thing then they wouldn't be written differently for no apparent reason.

3. In several places you are passing parameters ByRef for no good reason. If your parameter is a reference type then the one and only reason that you declare it ByRef is that you want to assign a value to that parameter inside the method and have that change reflected in the original reference. You aren't assigning anything to any parameters in any of those methods so none of those parameters should be ByRef. ByVal is the default for a reason in VB.NET and you should only ever use ByRef if you specifically need to, which you don't in this case.

4. You have several functions there with no declared return type. That code wouldn't even compile with Option Strict On, which it should always be unless you specifcally need it Off, which is very rare. Even with Option Strict Off, the return type of those methods defaults to Object instead of what it should be in each case.

5. You have redundant code. You define a method that converts an Image to a Byte array and yet, in your method that converts an Image to a base-64 String, you don't call that method but rather write the same code again to convert the Image to a Byte array. It's not much code but duplication of code is bad no matter how little it is.

6. You're creating disposable objects and not disposing them. If you create an object that can be disposed and only use it in one block then create it with a Using statement so that it gets disposed implicitly. Otherwise, make sure that you call its Dispose method explicitly when you finish with it.

This is what your code should look like:

Public Shared Function ImageToByteArray(img As Image) As Byte()
    Using strm As New MemoryStream
        img.Save(strm, img.RawFormat)
 
        Return strm.GetBuffer()
    End Using
End Function
 
Public Shared Function ImageToBase64(img As Image) As String
    Return Convert.ToBase64String(ImageToByteArray(img))
End Function
 
Public Overloads Shared Function ByteArrayToImage(data As Byte()) As Image
    Using strm As New MemoryStream(data)
        Return Image.FromStream(strm)
    End Using
End Function
 
Public Overloads Shared Function Base64ToImage(text As String) As Image
    Return ByteArrayToImage(Convert.FromBase64String(text))
End Function

Note that, while converting an Image to base-64 text is unnecessary and counter-productive when storing the data in a database, in is still useful in cases where a Byte array cannot be stored either. For example, I answered a question just yesterday about storing an Image in My.Settings and I provided code there to convert the Image to a base-64 String and back again because a String can be saved to My.Settings.