File upload problem

[kows]

I'm not sure where this should go (I don't know whether it's a database problem, or a code problem), but I think it's a code problem, so I'm posting here.

I'm working with a database that is storing images (actually, it's a modified version of the AdventureWorks database from Microsoft), and I'm creating a form that will let you upload a file. I've got a business object based on the table that I'm using (Production.ProductPhoto) and I'm using two stored procedures to either get (Production.ProductPhoto_Get) or add (Production.ProductPhoto_Add) an entry from/to the table. The image is being stored as a varbinary field in the database, and a Byte() in my business object.

The problem I'm having is that when I'm adding a new entry and uploading a file, the length of the file uploaded is correct (so I assume everything is going smoothly), and it gets passed along to my ProductPhotoProvider DAL class where I create a DbCommand and add the parameters for my stored procedure. The information is all added to the database successfully, and I'm returned the identity of the new entry as expected -- however, when I try to read this image back, it seems that the length is 1. I've put in break points and stepped through everything, and I don't know what's going on.

I think that I know my ProductPhotoProvider class is at least reading things correctly -- I can display other images from the database (that came with the database, that is) just fine. Mine just all come back with a length of 1.

I'm just hoping someone knows what the hell I'm talking about; I have a lot of programming experience, but this is my first major venture into ASP.NET. I have no idea which parts of my code are relevant, so I'll just post my Add and Lookup functions for now?!

ProductPhotoProvider.Add:

Public Shared Function Add(ByVal P As ProductPhoto) As Integer
            Dim Command As DbCommand = GetCommand("Production.ProductPhoto_Add")
            With Command.Parameters
                .Add(GetParameter("ThumbNailPhoto", DbType.Binary, P.ThumbnailPhoto))
                .Add(GetParameter("ThumbnailPhotoFileName", DbType.String, P.ThumbnailPhotoFilename))
                .Add(GetParameter("LargePhoto", DbType.Binary, P.LargePhoto))
                .Add(GetParameter("LargePhotoFileName", DbType.String, P.LargePhotoFilename))
            End With
            Return ExecuteScalar(Of Integer)(Command)
        End Function

ProductPhotoProvider.Lookup:

Public Shared Function Lookup(ByVal ProductPhotoID As Integer) As ProductPhoto
            Dim Command As DbCommand = GetCommand("Production.ProductPhoto_Get")
            With Command.Parameters
                .Add(GetParameter("ProductPhotoID", DbType.Int32, ProductPhotoID))
            End With
            Return Hydrator.FillObject(ExecuteReader(Command))
        End Function

ProductPhotoProvider.Hydrator.FillObject:

Public Shared Function FillObject(ByVal reader As INullableReader) As ProductPhoto
                CheckNullOrClosedReader(reader)
                Dim Result As ProductPhoto = Nothing
                Using reader
                    If reader.Read Then
                        Result = Hydrate(reader)
                    End If
                End Using
                Return Result
            End Function

ProductPhotoProvider.Hydrator.Hydrate:

Private Shared Function Hydrate(ByVal reader As INullableReader) As ProductPhoto
                Dim ID As Integer = reader.GetInt32("ProductPhotoID")
 
                'images must be read in as an array of Bytes; no GetByte!
                Dim ThumbnailIndex As Integer = reader.GetOrdinal("ThumbnailPhoto")
                Dim ThumbnailPhoto As Byte() = Nothing
                If Not reader.IsDBNull("ThumbnailPhoto") Then
                    ThumbnailPhoto = CType(reader.GetValue(ThumbnailIndex), Byte())
                End If
 
                Dim ThumbnailPhotoFilename As String = reader.GetNullableString("ThumbnailPhotoFilename")
 
                'images must be read in as an array of Bytes; no GetByte!
                Dim LargePhotoIndex As Integer = reader.GetOrdinal("LargePhoto")
                Dim LargePhoto As Byte() = Nothing
                If Not reader.IsDBNull("LargePhoto") Then
                    LargePhoto = CType(reader.GetValue(LargePhotoIndex), Byte())
                End If
 
                Dim LargePhotoFilename As String = reader.GetNullableString("LargePhotoFilename")
                Dim ModifiedDate As Date = reader.GetDateTime("ModifiedDate")
 
                Dim Result As ProductPhoto = New ProductPhoto(ID, ThumbnailPhoto, ThumbnailPhotoFilename, _
                                                              LargePhoto, LargePhotoFilename, ModifiedDate)
                Return Result
            End Function

My ProductPhotoProvider class is based off of an abstract class called AbstractDALProvider (which I can also provide if needed). I can provide the rest of my project, if needed, too.

Oh, and for good measure: I was told that when you used to store images in Microsoft Access, there was some sort of problem when retrieving the data and you'd have to strip the first 72 bytes of data from it, or something. I can only assume that this is not a problem here, because I have no problem displaying other photos that were not created by me.

[gep13]

Hey,

Is it possible that you can show the code where you are getting the Byte() information for the photo?

As a pointer in the right direction, you might want to have a look here:

http://www.vbforums.com/showthread.php?t=469562

Also, how are you then showing the Image on the page? Are you using an HttpHandler to write the Response out to the page?

As a side note, for my site, I opted to not store the image information directly in the database, but rather a pointer (i.e. the file path) to where the image was stored on the file system. I decided that it was easier to handle the image directly on the file system rather than in the database.

Gary

[kows]

if this were my project, I would never store image data in the database (I'm a PHP developer and know the difficulties) -- I'm firmly against that and the unnecessary complexity of doing so. however, it isn't my choice.

anyway, to answer your questions -- this is the code on my form that gets an uploaded file (there is an abstract class here that is used to only allow certain mime types, by the way):

Private Function GetUploadedPhoto(ByVal UploadedFile As FileUpload) As Byte()
        Dim Photo As Byte() = Nothing
        If UploadedFile.HasFile AndAlso UploadedFile.PostedFile IsNot Nothing Then
            Dim Extension As String = Path.GetExtension(UploadedFile.PostedFile.FileName).ToLower
            Dim MIMEType As String = "image/" + Extension.Replace(".", "")
            If WebClient.UI.Handlers.AbstractStreamableImage.ImageFormats.ContainsValue(MIMEType) Then
                Dim Length As Long = UploadedFile.PostedFile.InputStream.Length
                Dim ImageBytes(Length) As Byte
                UploadedFile.PostedFile.InputStream.Read(ImageBytes, 0, Length)
                Photo = ImageBytes
            Else
                Throw New Exception("Invalid file type uploaded - only picture files are allowed.")
            End If
        End If
        Return Photo
    End Function

then, in my event handler for adding:

Dim aLargePhoto As Byte() = GetUploadedPhoto(LargePhotoUpload)
                Dim aThumbnailPhoto As Byte() = GetUploadedPhoto(ThumbnailPhotoUpload)
 
                Dim Item As ProductPhoto = New ProductPhoto(aThumbnailPhoto, ThumbnailFilename.Text, aLargePhoto, LargePhotoFilename.Text)

yes, I have an HTTPHandler that is reading the image. my business object has a readonly method that uses MemoryStream (like in the post you linked to) to stream the Byte() and create a new Bitmap() out of it, and returns an Image. for example:

Private _thumbnailPhotoImage As Image = Nothing
    Public ReadOnly Property ThumbnailPhotoImage() As Image
        Get
            If _thumbnailPhotoImage Is Nothing Then
                If ThumbnailPhoto IsNot Nothing Then
                    Dim Stream As MemoryStream = New MemoryStream(ThumbnailPhoto)
                    _thumbnailPhotoImage = New Bitmap(Stream)
                End If
            End If
            Return _thumbnailPhotoImage
        End Get
    End Property

and I do the same for the larger photo.

this is the handler I'm using to load the images:

<%@ WebHandler Language="VB" Class="Handler" %>
 
Imports System
Imports System.Drawing
Imports System.Web
Imports System.IO
Imports WebClient.UI.Handlers
 
Public Class Handler : Implements IHttpHandler
    Public Sub ProcessRequest(ByVal context As HttpContext) Implements IHttpHandler.ProcessRequest
        Try
            Dim SizeParam As String = context.Request.Params("Size")
            Dim IDParam As String = context.Request.Params("ID")
            Dim ID As Integer
            Dim Streamer As AbstractStreamableImage = Nothing
            If Not String.IsNullOrEmpty(SizeParam) AndAlso Integer.TryParse(IDParam, ID) Then
                Select Case SizeParam.ToLower
                    Case "large"
                        Streamer = New ProductPhotoImage(ID, True) 'second parameter is a boolean of whether or not the size is large
                    Case "thumbnail"
                        Streamer = New ProductPhotoImage(ID, False)
                End Select
            End If
            If Streamer Is Nothing OrElse Streamer.StreamableImage Is Nothing Then
                Streamer = New DefaultImage("")
            End If
            Streamer.Write(context.Response)
        Catch ex As Exception
            context.Response.ContentType = "text/plain"
            context.Response.Write("no image")
        End Try
        context.Response.Cache.SetCacheability(HttpCacheability.NoCache)
    End Sub
 
    Public ReadOnly Property IsReusable() As Boolean Implements IHttpHandler.IsReusable
        Get
            Return False
        End Get
    End Property
 
End Class

and the ProductPhotoImage class that it's using simply looks up the data in the database, populates a business object, and returns it depending on the size used (_large is a boolean variable for either thumbnail/large photo). this class is based off of an abstract class that I can also post if needed:

Imports Microsoft.VisualBasic
Imports System.Drawing
Imports System.Drawing.Imaging
Imports System.IO
Imports AWSystem.Data
Imports AWSystem.BLL
 
Namespace WebClient.UI.Handlers
    Public Class ProductPhotoImage
        Inherits AbstractStreamableImage
 
        Private _productPhotoID As Integer
        Private _large As Boolean
 
        Public Sub New(ByVal pProductPhotoID As Integer, Optional ByVal pLarge As Boolean = True)
            _productPhotoID = pProductPhotoID
            _large = pLarge
        End Sub
 
        Public Overrides ReadOnly Property StreamableImage() As Image
            Get
                If _StreamableImage Is Nothing Then
 
                    Dim Controller As New ProductPhotoController()
                    Dim Info As ProductPhoto = Controller.Lookup(_productPhotoID)
                    Dim ProductPhoto As Image = Nothing
 
                    If Info IsNot Nothing Then
                        If _large Then
                            _StreamableImage = Info.LargePhotoImage
                        Else
                            _StreamableImage = Info.ThumbnailPhotoImage
                        End If
                    End If
                End If
 
                Return _StreamableImage
            End Get
        End Property
    End Class
End Namespace

however, the fact that all the other images display fine leads me to believe that my HTTPHandler and my readonly properties are working correctly.

I'll take a look at some more of the code in the thread you posted and try a few things (though most of it looks very similar already at just a glance), and thanks for the reply!

[kows]

after examining the thread you posted, I'm at a loss. The only big difference is that they're using an SQLCommand and I'm using a DBCommand, and thus they are using SqlDbType.VarBinary. There is no DbType.VarBinary, though, so I'm just using DbType.Binary. but, I would think that this wouldn't matter.

other than that, they're taking image data from the file system as an Image type and creating a MemoryStream to load it in so that Stream.GetBuffer() would have all of the binary data, correct? so if I'm having a user upload a file, I already have the binary data. I may not be using the correct method to store it, though, or something (in GetUploadedPhoto()). I'd appreciate any more help you may be able to provide!

[gep13]

Hey,

It's been a long day for me, just finished a round of golf, and not really in the right mind set to have a look at all that code

Will try and take a look at it tomorrow.

Given that you are able to retrieve images that are already in the database, then that leads me to suspect that it has to be the import code that has the problem.

On a side note, and to allow you to continue investigating, have a look here:

http://www.asp.net/downloads/starter-kits/personal/

It have a photo upload and storage section that does exactly what you are trying to implement, might be worth taking a look at that and comparing what they are doing.

Gary

[kows]

hi! I got it fixed, but thanks for your help. thankfully, nothing was wrong with anything that I had done but instead it was the fault of whoever created the _Add/_Update stored procedures. the photo parameters that the procedures were taking in were VARBINARY, but a VARBINARY stores only one byte (didn't specify a length!), whereas the table stores the photos as VARBINARY(MAX). updating the stored procedures seems to have fixed everything! woohoo.

[gep13]

Hey,

Glad to hear that you got it working!! I can only imagine the debugging and fault finding you had to go through to pin that one down!!

Gary