Answers:
从.NET 4.5开始,有Stream.CopyToAsync
方法
input.CopyToAsync(output);
这将返回一个Task
可以在完成时继续进行的操作,如下所示:
await input.CopyToAsync(output)
// Code from here on will be run in a continuation.
请注意,取决于在何处进行调用CopyToAsync
,随后的代码可能会或可能不会在调用它的同一线程上继续。
在SynchronizationContext
调用时被抓获await
将决定线程的延续将上执行。
此外,此调用(这是一个可能会更改的实现细节)仍然按顺序进行读写操作(它不会浪费线程阻塞I / O完成)。
从.NET 4.0开始,有Stream.CopyTo
一种方法
input.CopyTo(output);
对于.NET 3.5及更低版本
框架中没有任何东西可以帮助实现这一点。您必须手动复制内容,如下所示:
public static void CopyStream(Stream input, Stream output)
{
byte[] buffer = new byte[32768];
int read;
while ((read = input.Read(buffer, 0, buffer.Length)) > 0)
{
output.Write (buffer, 0, read);
}
}
注1:此方法将允许您报告进度(到目前为止已读取x字节...)
注2:为什么使用固定缓冲区大小而不是input.Length
?因为该长度可能不可用!从文档:
如果从Stream派生的类不支持查找,则对Length,SetLength,Position和Seek的调用将引发NotSupportedException。
81920
字节,不是32768
MemoryStream具有.WriteTo(outstream);
.NET 4.0在普通流对象上具有.CopyTo。
.NET 4.0:
instream.CopyTo(outstream);
我使用以下扩展方法。当一个流是MemoryStream时,它们具有优化的重载。
public static void CopyTo(this Stream src, Stream dest)
{
int size = (src.CanSeek) ? Math.Min((int)(src.Length - src.Position), 0x2000) : 0x2000;
byte[] buffer = new byte[size];
int n;
do
{
n = src.Read(buffer, 0, buffer.Length);
dest.Write(buffer, 0, n);
} while (n != 0);
}
public static void CopyTo(this MemoryStream src, Stream dest)
{
dest.Write(src.GetBuffer(), (int)src.Position, (int)(src.Length - src.Position));
}
public static void CopyTo(this Stream src, MemoryStream dest)
{
if (src.CanSeek)
{
int pos = (int)dest.Position;
int length = (int)(src.Length - src.Position) + pos;
dest.SetLength(length);
while(pos < length)
pos += src.Read(dest.GetBuffer(), pos, length - pos);
}
else
src.CopyTo((Stream)dest);
}
实际上,有一种不那么费力的方式来进行流复制。但是请注意,这意味着您可以将整个文件存储在内存中。如果要处理的文件大小达到数百兆字节甚至更多,请不要尝试并使用它,而无需小心。
public static void CopyStream(Stream input, Stream output)
{
using (StreamReader reader = new StreamReader(input))
using (StreamWriter writer = new StreamWriter(output))
{
writer.Write(reader.ReadToEnd());
}
}
注意:可能还有一些有关二进制数据和字符编码的问题。
reader.ReadToEnd()
将所有内容放入RAM
.NET Framework 4引入了System.IO命名空间的Stream Class的新“ CopyTo”方法。使用此方法,我们可以将一个流复制到另一个不同流类的流。
这是示例。
FileStream objFileStream = File.Open(Server.MapPath("TextFile.txt"), FileMode.Open);
Response.Write(string.Format("FileStream Content length: {0}", objFileStream.Length.ToString()));
MemoryStream objMemoryStream = new MemoryStream();
// Copy File Stream to Memory Stream using CopyTo method
objFileStream.CopyTo(objMemoryStream);
Response.Write("<br/><br/>");
Response.Write(string.Format("MemoryStream Content length: {0}", objMemoryStream.Length.ToString()));
Response.Write("<br/><br/>");
CopyToAsync()
鼓励使用。
不幸的是,没有真正简单的解决方案。您可以尝试类似的方法:
Stream s1, s2;
byte[] buffer = new byte[4096];
int bytesRead = 0;
while (bytesRead = s1.Read(buffer, 0, buffer.Length) > 0) s2.Write(buffer, 0, bytesRead);
s1.Close(); s2.Close();
但是,如果没有要读取的内容,Stream类的不同实现的行为可能会有所不同。从本地硬盘驱动器读取文件的流可能会阻塞,直到读取操作已从磁盘读取足够的数据以填充缓冲区,并且仅在到达文件末尾时才返回较少的数据。另一方面,从网络读取的流可能返回较少的数据,即使还有更多的数据要接收。
在使用通用解决方案之前,请始终检查所使用的特定流类的文档。
如果您希望通过程序将流复制到其他已刻缺的流,但没有位置重置,则应该
public static void CopyStream(Stream input, Stream output)
{
byte[] buffer = new byte[32768];
long TempPos = input.Position;
while (true)
{
int read = input.Read (buffer, 0, buffer.Length);
if (read <= 0)
return;
output.Write (buffer, 0, read);
}
input.Position = TempPos;// or you make Position = 0 to set it at the start
}
但是,如果它在运行时中未使用过程,则应使用内存流
Stream output = new MemoryStream();
byte[] buffer = new byte[32768]; // or you specify the size you want of your buffer
long TempPos = input.Position;
while (true)
{
int read = input.Read (buffer, 0, buffer.Length);
if (read <= 0)
return;
output.Write (buffer, 0, read);
}
input.Position = TempPos;// or you make Position = 0 to set it at the start
由于没有一个答案涵盖了从一个流复制到另一个流的异步方法,因此这是我在端口转发应用程序中成功使用的一种模式,用于将数据从一个网络流复制到另一个。它缺乏异常处理来强调模式。
const int BUFFER_SIZE = 4096;
static byte[] bufferForRead = new byte[BUFFER_SIZE];
static byte[] bufferForWrite = new byte[BUFFER_SIZE];
static Stream sourceStream = new MemoryStream();
static Stream destinationStream = new MemoryStream();
static void Main(string[] args)
{
// Initial read from source stream
sourceStream.BeginRead(bufferForRead, 0, BUFFER_SIZE, BeginReadCallback, null);
}
private static void BeginReadCallback(IAsyncResult asyncRes)
{
// Finish reading from source stream
int bytesRead = sourceStream.EndRead(asyncRes);
// Make a copy of the buffer as we'll start another read immediately
Array.Copy(bufferForRead, 0, bufferForWrite, 0, bytesRead);
// Write copied buffer to destination stream
destinationStream.BeginWrite(bufferForWrite, 0, bytesRead, BeginWriteCallback, null);
// Start the next read (looks like async recursion I guess)
sourceStream.BeginRead(bufferForRead, 0, BUFFER_SIZE, BeginReadCallback, null);
}
private static void BeginWriteCallback(IAsyncResult asyncRes)
{
// Finish writing to destination stream
destinationStream.EndWrite(asyncRes);
}