既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！
由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新
* + [BufferedStream(Stream) 使用默认的缓冲区大小 4096 字节初始化 BufferedStream 类的新实例](#BufferedStreamStream__4096__BufferedStream__319)
+ [BufferedStream(Stream, Int32) 使用指定的缓冲区大小初始化 BufferedStream 类的新实例](#BufferedStreamStream_Int32__BufferedStream__335)
* [♊ 属性](#__370)
* + [BufferSize 获取此缓冲流的缓冲区大小（以字节为单位）](#BufferSize__372)
+ [CanRead 获取一个值，该值指示当前流是否支持读取](#CanRead__378)
+ [CanWrite 获取一个值，该值指示当前流是否支持写入](#CanWrite__395)
+ [Length 获取流长度，长度以字节为单位](#Length__412)
* [♌ 常用方法](#__418)
* + [Close() 关闭当前流并释放与之关联的所有资源（如套接字和文件句柄）](#Close__420)
+ [CopyTo(Stream) 从当前流中读取字节并将其写入到另一流中](#CopyToStream__428)
+ [CopyTo(Stream, Int32) 使用指定的缓冲区大小，从当前流中读取字节并将其写入到另一流中](#CopyToStream_Int32__464)
+ [CopyToAsync(Stream) 从当前流中异步读取字节并将其写入到另一个流中](#CopyToAsyncStream__484)
+ [Dispose() 释放由 Stream 使用的所有资源](#Dispose__Stream__539)
+ [Read(Byte[], Int32, Int32) 将字节从当前缓冲流复制到数组](#ReadByte_Int32_Int32__545)
+ [ReadAsync(Byte[], Int32, Int32) 从当前流异步读取字节序列，并将流中的位置提升读取的字节数](#ReadAsyncByte_Int32_Int32__610)
+ [ReadByte() 从基础流中读取一个字节，并返回转换为 `int` 的该字节；或者如果从流的末尾读取则返回 -1](#ReadByte__int__1_680)
+ [Write(Byte[], Int32, Int32) 将字节复制到缓冲流，并将缓冲流内的当前位置前进写入的字节数](#WriteByte_Int32_Int32__692)
+ [WriteAsync(Byte[], Int32, Int32) 将字节序列异步写入当前流，并将流的当前位置提升写入的字节数](#WriteAsyncByte_Int32_Int32__737)
+ [WriteByte(Byte) 一个字节写入文件流中的当前位置](#WriteByteByte__807)
+ [Flush() 清除此流的缓冲区，使得所有缓冲数据都写入到文件中](#Flush__821)
+ [FlushAsync() 异步清除此流的所有缓冲区并导致所有缓冲数据都写入基础设备中](#FlushAsync__852)
* [♍ 注解](#__864)
* [♎ 更多方法](#__872)
1️⃣ System.IO命名空间
.NET中的IO操作命名空间，包含允许读写文件和数据流的类型以及提供基本文件和目录支持的类型。
我们在.NET中的IO操作，经常需要调用一下几个类。
- FileStream类
文件流类，负责大文件的拷贝，读写。
- Path类
Path类中方法，基本都是对字符串（文件名）的操作，与实际文件没多大关系。
- File类
File类可以进行一些对小文件拷贝、剪切操作，还能读一些文档文件。
- Dirctory类
目录操作，创建文件、删除目录，获取目录下文件名等等。
2️⃣ BufferedStream类
♈ 定义
将缓冲层添加到另一个流上的读取和写入操作。 此类不能被继承。
public sealed class BufferedStream : System.IO.Stream
♉ 示例
下面的代码示例演示如何使用 BufferedStream 类来 NetworkStream 增加某些 I/O 操作的性能。 在启动客户端之前，"开始"菜单远程计算机上的服务器。 启动客户端时，将远程计算机名称指定为命令行参数。 dataArraySize更改常streamBufferSize量以查看它们对性能的影响。
第一个示例演示在客户端上运行的代码，第二个示例显示服务器上运行的代码。
示例 1：在客户端上运行的代码
using System;
using System.IO;
using System.Globalization;
using System.Net;
using System.Net.Sockets;
public class Client
{
const int dataArraySize = 100;
const int streamBufferSize = 1000;
const int numberOfLoops = 10000;
static void Main(string[] args)
{
// Check that an argument was specified when the
// program was invoked.
if(args.Length == 0)
{
Console.WriteLine("Error: The name of the host computer" +
" must be specified when the program is invoked.");
return;
}
string remoteName = args[0];
// Create the underlying socket and connect to the server.
Socket clientSocket = new Socket(AddressFamily.InterNetwork,
SocketType.Stream, ProtocolType.Tcp);
clientSocket.Connect(new IPEndPoint(
Dns.Resolve(remoteName).AddressList[0], 1800));
Console.WriteLine("Client is connected.\n");
// Create a NetworkStream that owns clientSocket and
// then create a BufferedStream on top of the NetworkStream.
// Both streams are disposed when execution exits the
// using statement.
using(Stream
netStream = new NetworkStream(clientSocket, true),
bufStream =
new BufferedStream(netStream, streamBufferSize))
{
// Check whether the underlying stream supports seeking.
Console.WriteLine("NetworkStream {0} seeking.\n",
bufStream.CanSeek ? "supports" : "does not support");
// Send and receive data.
if(bufStream.CanWrite)
{
SendData(netStream, bufStream);
}
if(bufStream.CanRead)
{
ReceiveData(netStream, bufStream);
}
// When bufStream is closed, netStream is in turn
// closed, which in turn shuts down the connection
// and closes clientSocket.
Console.WriteLine("\nShutting down the connection.");
bufStream.Close();
}
}
static void SendData(Stream netStream, Stream bufStream)
{
DateTime startTime;
double networkTime, bufferedTime;
// Create random data to send to the server.
byte[] dataToSend = new byte[dataArraySize];
new Random().NextBytes(dataToSend);
// Send the data using the NetworkStream.
Console.WriteLine("Sending data using NetworkStream.");
startTime = DateTime.Now;
for(int i = 0; i < numberOfLoops; i++)
{
netStream.Write(dataToSend, 0, dataToSend.Length);
}
networkTime = (DateTime.Now - startTime).TotalSeconds;
Console.WriteLine("{0} bytes sent in {1} seconds.\n",
numberOfLoops * dataToSend.Length,
networkTime.ToString("F1"));
// Send the data using the BufferedStream.
Console.WriteLine("Sending data using BufferedStream.");
startTime = DateTime.Now;
for(int i = 0; i < numberOfLoops; i++)
{
bufStream.Write(dataToSend, 0, dataToSend.Length);
}
bufStream.Flush();
bufferedTime = (DateTime.Now - startTime).TotalSeconds;
Console.WriteLine("{0} bytes sent in {1} seconds.\n",
numberOfLoops * dataToSend.Length,
bufferedTime.ToString("F1"));
// Print the ratio of write times.
Console.WriteLine("Sending data using the buffered " +
"network stream was {0} {1} than using the network " +
"stream alone.\n",
(networkTime/bufferedTime).ToString("P0"),
bufferedTime < networkTime ? "faster" : "slower");
}
static void ReceiveData(Stream netStream, Stream bufStream)
{
DateTime startTime;
double networkTime, bufferedTime = 0;
int bytesReceived = 0;
byte[] receivedData = new byte[dataArraySize];
// Receive data using the NetworkStream.
Console.WriteLine("Receiving data using NetworkStream.");
startTime = DateTime.Now;
while(bytesReceived < numberOfLoops * receivedData.Length)
{
bytesReceived += netStream.Read(
receivedData, 0, receivedData.Length);
}
networkTime = (DateTime.Now - startTime).TotalSeconds;
Console.WriteLine("{0} bytes received in {1} seconds.\n",
bytesReceived.ToString(),
networkTime.ToString("F1"));
// Receive data using the BufferedStream.
Console.WriteLine("Receiving data using BufferedStream.");
bytesReceived = 0;
startTime = DateTime.Now;
int numBytesToRead = receivedData.Length;
while (numBytesToRead > 0)
{
// Read may return anything from 0 to numBytesToRead.
int n = bufStream.Read(receivedData,0, receivedData.Length);
// The end of the file is reached.
if (n == 0)
break;
bytesReceived += n;
numBytesToRead -= n;
}
bufferedTime = (DateTime.Now - startTime).TotalSeconds;
Console.WriteLine("{0} bytes received in {1} seconds.\n",
bytesReceived.ToString(),
bufferedTime.ToString("F1"));
// Print the ratio of read times.
Console.WriteLine("Receiving data using the buffered network" +
" stream was {0} {1} than using the network stream alone.",
(networkTime/bufferedTime).ToString("P0"),
bufferedTime < networkTime ? "faster" : "slower");
}
}
示例 2：在服务器上运行的代码
using System;
using System.Net;
using System.Net.Sockets;
public class Server
{
static void Main()
{
// This is a Windows Sockets 2 error code.
const int WSAETIMEDOUT = 10060;
Socket serverSocket;
int bytesReceived, totalReceived = 0;
byte[] receivedData = new byte[2000000];
// Create random data to send to the client.
byte[] dataToSend = new byte[2000000];
new Random().NextBytes(dataToSend);
IPAddress ipAddress =
Dns.Resolve(Dns.GetHostName()).AddressList[0];
IPEndPoint ipEndpoint = new IPEndPoint(ipAddress, 1800);
// Create a socket and listen for incoming connections.
using(Socket listenSocket = new Socket(
AddressFamily.InterNetwork, SocketType.Stream,
ProtocolType.Tcp))
{
listenSocket.Bind(ipEndpoint);
listenSocket.Listen(1);
// Accept a connection and create a socket to handle it.
serverSocket = listenSocket.Accept();
Console.WriteLine("Server is connected.\n");
}
try
{
// Send data to the client.
Console.Write("Sending data ... ");
int bytesSent = serverSocket.Send(
dataToSend, 0, dataToSend.Length, SocketFlags.None);
Console.WriteLine("{0} bytes sent.\n",
bytesSent.ToString());
// Set the timeout for receiving data to 2 seconds.
serverSocket.SetSocketOption(SocketOptionLevel.Socket,
SocketOptionName.ReceiveTimeout, 2000);
// Receive data from the client.
Console.Write("Receiving data ... ");
try
{
do
{
bytesReceived = serverSocket.Receive(receivedData,
0, receivedData.Length, SocketFlags.None);
totalReceived += bytesReceived;
}
while(bytesReceived != 0);
}
catch(SocketException e)
{
if(e.ErrorCode == WSAETIMEDOUT)
{
// Data was not received within the given time.
// Assume that the transmission has ended.
}
else
{
Console.WriteLine("{0}: {1}\n",
e.GetType().Name, e.Message);
}
}
finally
{
Console.WriteLine("{0} bytes received.\n",
totalReceived.ToString());
}
}
finally
{
serverSocket.Shutdown(SocketShutdown.Both);
Console.WriteLine("Connection shut down.");
serverSocket.Close();
}
}
}
♉ 构造函数
BufferedStream(Stream) 使用默认的缓冲区大小 4096 字节初始化 BufferedStream 类的新实例
public BufferedStream (System.IO.Stream stream);
参数
stream当前流。
首次使用此构造函数初始化对象时
BufferedStream分配共享读/写缓冲区。 如果所有读取和写入大于或等于bufferSize，则不使用共享缓冲区。
BufferedStream(Stream, Int32) 使用指定的缓冲区大小初始化 BufferedStream 类的新实例
public BufferedStream (System.IO.Stream stream, int bufferSize);
参数
stream当前流。
bufferSize缓冲区大小（以字节为单位）。
示例
此代码示例是为 BufferedStream 类提供的一个更大示例的一部分。
// Create a NetworkStream that owns clientSocket and
// then create a BufferedStream on top of the NetworkStream.
// Both streams are disposed when execution exits the
// using statement.
using(Stream
netStream = new NetworkStream(clientSocket, true),
bufStream =
new BufferedStream(netStream, streamBufferSize))
♊ 属性
BufferSize 获取此缓冲流的缓冲区大小（以字节为单位）
public int BufferSize { get; }
CanRead 获取一个值，该值指示当前流是否支持读取
public override bool CanRead { get; }
示例
此代码示例是为 BufferedStream 类提供的一个更大示例的一部分。
if(bufStream.CanRead)
{
ReceiveData(netStream, bufStream);
}
CanWrite 获取一个值，该值指示当前流是否支持写入
public override bool CanWrite { get; }
示例
此代码示例是为 BufferedStream 类提供的一个更大示例的一部分。
if(bufStream.CanWrite)
{
SendData(netStream, bufStream);
}
Length 获取流长度，长度以字节为单位
public override long Length { get; }
♌ 常用方法
Close() 关闭当前流并释放与之关联的所有资源（如套接字和文件句柄）
public virtual void Close ();
注意：此方法调用 Dispose ，指定
true以释放所有资源。 不需要专门调用 Close 方法。 请确保 Stream 已正确释放每个对象。 可以 StreamusingUsing在 Visual Basic) 中 (或块中声明对象，以确保释放流及其所有资源，或者可以显式调用 Dispose 方法。
CopyTo(Stream) 从当前流中读取字节并将其写入到另一流中
public void CopyTo (System.IO.Stream destination);
参数
destinationStream
当前流的内容将复制到的流。
示例
下面的示例将的内容复制 FileStream 到 MemoryStream 中。
// Create the streams.
MemoryStream destination = new MemoryStream();
using (FileStream source = File.Open(@"c:\temp\data.dat",
FileMode.Open))
{
Console.WriteLine("Source length: {0}", source.Length.ToString());
// Copy source to destination.
source.CopyTo(destination);
}
Console.WriteLine("Destination length: {0}", destination.Length.ToString());
CopyTo(Stream, Int32) 使用指定的缓冲区大小，从当前流中读取字节并将其写入到另一流中
public virtual void CopyTo (System.IO.Stream destination, int bufferSize);
参数
destinationStream
当前流的内容将复制到的流。
bufferSizeInt
缓冲区的大小。 此值必须大于零。 默认大小为 81920。
CopyToAsync(Stream) 从当前流中异步读取字节并将其写入到另一个流中
public System.Threading.Tasks.Task CopyToAsync (System.IO.Stream destination);
参数
destinationStream
当前流的内容将复制到的流。
示例
下面的示例演示如何使用两个 FileStream 对象将文件从一个目录异步复制到另一个目录。 FileStream 类是从 Stream 类派生的。 请注意， Click 控件的事件处理程序 Button 使用修饰符标记， async 因为它调用异步方法
using System;
using System.Threading.Tasks;
using System.Windows;
using System.IO;
namespace WpfApplication
{
public partial class MainWindow : Window
{
public MainWindow()
{
InitializeComponent();
}
private async void Button_Click(object sender, RoutedEventArgs e)
{
string StartDirectory = @"c:\Users\exampleuser\start";
string EndDirectory = @"c:\Users\exampleuser\end";
foreach (string filename in Directory.EnumerateFiles(StartDirectory))
{
using (FileStream SourceStream = File.Open(filename, FileMode.Open))
{
using (FileStream DestinationStream = File.Create(EndDirectory + filename.Substring(filename.LastIndexOf('\\'))))
{
await SourceStream.CopyToAsync(DestinationStream);
}
}
}
}
}
}
CopyToAsync方法使你可以在不阻塞主线程的情况下执行占用大量资源的 i/o 操作。
Dispose() 释放由 Stream 使用的所有资源
public void Dispose ();
Read(Byte[], Int32, Int32) 将字节从当前缓冲流复制到数组
public override int Read (byte[] buffer, int offset, int count);
参数
bufferByte[]
将字节复制到的缓冲区。
offset缓冲区中的字节偏移量，从此处开始读取字节。
count要读取的字节数。
返回
读入
array中的总字节数。 如果可用的字节没有所请求的那么多，总字节数可能小于请求的字节数；或者如果在可读取任何数据前就已到达流的末尾，则为零。
示例
此代码示例是为 BufferedStream 类提供的一个更大示例的一部分。
// Receive data using the BufferedStream.
Console.WriteLine("Receiving data using BufferedStream.");
bytesReceived = 0;
startTime = DateTime.Now;
int numBytesToRead = receivedData.Length;
while (numBytesToRead > 0)
{
// Read may return anything from 0 to numBytesToRead.
int n = bufStream.Read(receivedData,0, receivedData.Length);
**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！**
**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**
**[需要这份系统化资料的朋友，可以戳这里获取](https://bbs.csdn.net/forums/4f45ff00ff254613a03fab5e56a57acb)**
dn.net/forums/4f45ff00ff254613a03fab5e56a57acb) 类提供的一个更大示例的一部分。
// Receive data using the BufferedStream.
Console.WriteLine(“Receiving data using BufferedStream.”);
bytesReceived = 0;
startTime = DateTime.Now;
int numBytesToRead = receivedData.Length;
while (numBytesToRead > 0)
{
// Read may return anything from 0 to numBytesToRead.
int n = bufStream.Read(receivedData,0, receivedData.Length);
[外链图片转存中…(img-w7zunklt-1715286351197)]
[外链图片转存中…(img-VaIvzIiv-1715286351198)]
[外链图片转存中…(img-UknAs2xk-1715286351198)]
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！
由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新
948
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
