var responseFromServer = ServiceRequest.GetResponsePhoto(" AddPhotos" , " ServiceInstances" , photoToUpload, serviceInstanceID.ToString());
var response = responseFromServer.Deserialize>();
bool success = (bool )response[" success" ];

void ReadCallback(IAsyncResult ar)
{
Stream stream = ar.AsyncState as Stream;
try
{
int written = stream.EndRead(ar);
offset += written;
totalWritten += written;
// here, update dialog box.
this.updateProgress(totalWritten, totalSize);

if (totalWritten < totalSize)
{
    int chunkSize = Math.Min(1024, (totalSize-totalWritten));
   // kick off another async write
   stream.BeginWrite(photo, offset, chunkSize, new AsyncCallback(ReadCallback), stream);
}
}
}

You don't evenNEED to do the upload asynchronously (although that's generally a much better pattern anyways, as it allows your UI to continue to be responsive to user input during the upload). As long as you set either HttpWebRequest.ContentLength or HttpWebRequest.SendChunked before calling GetRequestStream, the data you sendwill besent to the server with each call to Stream.[Begin]Write. If you write the file in small chunks as Feroze suggests, you can get an idea of how far along you.

As a slight caution on this approach, the writes complete when the data has been sent, NOT when it has actually been received by the server. On a high-latency connection, the lastchunk of data may be sentwell before the server actually receives it. It may be worth reserving some space at the end of your progress bar for the call to [Begin]GetResponse, after which you can actually be sure that the server has received the entire file.

As another caution, writing lots of small chunks can be less efficient than writing a few large chunks. If raw upload speed is important to your application, it may be worth writing the file in large chunks and not being as precise with the progress bar.

-dave