Returning a stream from File.OpenRead()
C#FilestreamC# Problem Overview
I'm in the process of writing a WCF service that will allow an ASP.Net web site to retrieve files (based on this article). My problem is that when I return the stream, it's blank.
For simplicity, I've isolated the code into a simple winforms app to try and find what the problem is with returning a stream and this is the code:
private Stream TestStream()
{
Stream fs = File.OpenRead(@"c:\testdocument.docx");
return fs;
}
// This method converts the filestream into a byte array so that when it is
// used in my ASP.Net project the file can be sent using response.Write
private void Test()
{
System.IO.MemoryStream data = new System.IO.MemoryStream();
System.IO.Stream str = TestStream();
str.CopyTo(data);
byte[] buf = new byte[data.Length];
data.Read(buf, 0, buf.Length);
}
The result of this code is that buf
is 12,587 bytes long (the correct length of the file) but it just contains 0's.
The Word document opens without problems if I try it, am I missing something obvious?
C# Solutions
Solution 1 - C#
You forgot to seek:
str.CopyTo(data);
data.Seek(0, SeekOrigin.Begin); // <-- missing line
byte[] buf = new byte[data.Length];
data.Read(buf, 0, buf.Length);
Solution 2 - C#
Options:
-
Use
data.Seek
as suggested by ken2k -
Use the somewhat simpler
Position
property:data.Position = 0;
-
Use the
ToArray
call inMemoryStream
to make your life simpler to start with:byte[] buf = data.ToArray();
The third option would be my preferred approach.
Note that you should have a using
statement to close the file stream automatically (and optionally for the MemoryStream
), and I'd add a using directive for System.IO
to make your code cleaner:
byte[] buf;
using (MemoryStream data = new MemoryStream())
{
using (Stream file = TestStream())
{
file.CopyTo(data);
buf = data.ToArray();
}
}
// Use buf
You might also want to create an extension method on Stream
to do this for you in one place, e.g.
public static byte[] CopyToArray(this Stream input)
{
using (MemoryStream memoryStream = new MemoryStream())
{
input.CopyTo(memoryStream);
return memoryStream.ToArray();
}
}
Note that this doesn't close the input stream.
Solution 3 - C#
You forgot to reset the position of the memory stream:
private void Test()
{
System.IO.MemoryStream data = new System.IO.MemoryStream();
System.IO.Stream str = TestStream();
str.CopyTo(data);
// Reset memory stream
data.Seek(0, SeekOrigin.Begin);
byte[] buf = new byte[data.Length];
data.Read(buf, 0, buf.Length);
}
Update:
There is one more thing to note: It usually pays not to ignore the return values of methods. A more robust implementation should check how many bytes have been read after the call returns:
private void Test()
{
using(MemoryStream data = new MemoryStream())
{
using(Stream str = TestStream())
{
str.CopyTo(data);
}
// Reset memory stream
data.Seek(0, SeekOrigin.Begin);
byte[] buf = new byte[data.Length];
int bytesRead = data.Read(buf, 0, buf.Length);
Debug.Assert(bytesRead == data.Length,
String.Format("Expected to read {0} bytes, but read {1}.",
data.Length, bytesRead));
}
}
Solution 4 - C#
You need
str.CopyTo(data);
data.Position = 0; // reset to beginning
byte[] buf = new byte[data.Length];
data.Read(buf, 0, buf.Length);
And since your Test()
method is imitating the client it ought to Close()
or Dispose()
the str
Stream. And the memoryStream too, just out of principal.
Solution 5 - C#
Try changing your code to this:
private void Test()
{
System.IO.MemoryStream data = new System.IO.MemoryStream(TestStream());
byte[] buf = new byte[data.Length];
data.Read(buf, 0, buf.Length);
}