既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,涵盖了95%以上大数据知识点,真正体系化!
由于文件比较多,这里只是将部分目录截图出来,全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频,并且后续会持续更新
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`
>
>
> [Stream](https://bbs.csdn.net/topics/618545628)
>
>
> 当前流。
>
>
>
>
> 首次使用此构造函数初始化对象时 `BufferedStream` 分配共享读/写缓冲区。 如果所有读取和写入大于或等于 `bufferSize`,则不使用共享缓冲区。
>
>
>
###### BufferedStream(Stream, Int32) 使用指定的缓冲区大小初始化 BufferedStream 类的新实例
public BufferedStream (System.IO.Stream stream, int bufferSize);
**参数**
>
> `stream`
>
>
> [Stream](https://bbs.csdn.net/topics/618545628)
>
>
> 当前流。
>
>
> `bufferSize`
>
>
> [Int32](https://bbs.csdn.net/topics/618545628)
>
>
> 缓冲区大小(以字节为单位)。
>
>
>
**示例**
此代码示例是为 [BufferedStream](https://bbs.csdn.net/topics/618545628) 类提供的一个更大示例的一部分。
// 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](https://bbs.csdn.net/topics/618545628) 类提供的一个更大示例的一部分。
if(bufStream.CanRead)
{
ReceiveData(netStream, bufStream);
}
###### CanWrite 获取一个值,该值指示当前流是否支持写入
public override bool CanWrite { get; }
**示例**
此代码示例是为 [BufferedStream](https://bbs.csdn.net/topics/618545628) 类提供的一个更大示例的一部分。
if(bufStream.CanWrite)
{
SendData(netStream, bufStream);
}
###### Length 获取流长度,长度以字节为单位
public override long Length { get; }
##### ♌ 常用方法
###### Close() 关闭当前流并释放与之关联的所有资源(如套接字和文件句柄)
public virtual void Close ();
>
> 注意:此方法调用 [Dispose](https://bbs.csdn.net/topics/618545628) ,指定 `true` 以释放所有资源。 不需要专门调用 [Close](https://bbs.csdn.net/topics/618545628) 方法。 请确保 [Stream](https://bbs.csdn.net/topics/618545628) 已正确释放每个对象。 可以 [Stream](https://bbs.csdn.net/topics/618545628) `using` `Using` 在 Visual Basic) 中 (或块中声明对象,以确保释放流及其所有资源,或者可以显式调用 [Dispose](https://bbs.csdn.net/topics/618545628) 方法。
>
>
>
###### CopyTo(Stream) 从当前流中读取字节并将其写入到另一流中
public void CopyTo (System.IO.Stream destination);
**参数**
>
> `destination`
>
>
> **Stream**
>
>
> 当前流的内容将复制到的流。
>
>
>
**示例**
下面的示例将的内容复制 [FileStream](https://bbs.csdn.net/topics/618545628) 到 [MemoryStream](https://bbs.csdn.net/topics/618545628) 中。
// 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);
**参数**
>
> `destination`
>
>
> **Stream**
>
>
> 当前流的内容将复制到的流。
>
>
> `bufferSize`
>
>
> **Int**
>
>
> 缓冲区的大小。 此值必须大于零。 默认大小为 81920。
>
>
>
###### CopyToAsync(Stream) 从当前流中异步读取字节并将其写入到另一个流中
public System.Threading.Tasks.Task CopyToAsync (System.IO.Stream destination);
**参数**
>
> `destination`
>
>
> **Stream**
>
>
> 当前流的内容将复制到的流。
>
>
>
**示例**
下面的示例演示如何使用两个 [FileStream](https://bbs.csdn.net/topics/618545628) 对象将文件从一个目录异步复制到另一个目录。 [FileStream](https://bbs.csdn.net/topics/618545628) 类是从 [Stream](https://bbs.csdn.net/topics/618545628) 类派生的。 请注意, [Click](https://bbs.csdn.net/topics/618545628) 控件的事件处理程序 [Button](https://bbs.csdn.net/topics/618545628) 使用修饰符标记, `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](https://bbs.csdn.net/topics/618545628)方法使你可以在不阻塞主线程的情况下执行占用大量资源的 i/o 操作。
>
>
>
###### Dispose() 释放由 Stream 使用的所有资源
public void Dispose ();
###### Read(Byte[], Int32, Int32) 将字节从当前缓冲流复制到数组
public override int Read (byte[] buffer, int offset, int count);
**参数**
>
> `buffer`
>
>
> [Byte](https://bbs.csdn.net/topics/618545628)[]
>
>
> 将字节复制到的缓冲区。
>
>
> `offset`
>
>
> [Int32](https://bbs.csdn.net/topics/618545628)
>
>
> 缓冲区中的字节偏移量,从此处开始读取字节。
>
>
> `count`
>
>
> [Int32](https://bbs.csdn.net/topics/618545628)
>
>
> 要读取的字节数。
>
>
>
**返回**
>
> [Int32](https://bbs.csdn.net/topics/618545628)
>
>
> 读入 `array` 中的总字节数。 如果可用的字节没有所请求的那么多,总字节数可能小于请求的字节数;或者如果在可读取任何数据前就已到达流的末尾,则为零。
>
>
>
**示例**
此代码示例是为 [BufferedStream](https://bbs.csdn.net/topics/618545628) 类提供的一个更大示例的一部分。
// 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”));
>
> `Read`仅当到达流的末尾时,该方法才会返回 0。 在所有其他情况下, `Read` 始终在返回之前从流中读取至少一个字节。 根据定义,如果在调用 `Read`时流中没有可用数据,该方法 `Read` 将返回 0 (到达流的末尾会自动) 。 即使尚未到达流的末尾,实现也可以返回比请求的字节少。
>
>
> 用于 [BinaryReader](https://bbs.csdn.net/topics/618545628) 读取基元数据类型。
>
>
>
###### ReadAsync(Byte[], Int32, Int32) 从当前流异步读取字节序列,并将流中的位置提升读取的字节数
public System.Threading.Tasks.Task ReadAsync (byte[] buffer, int offset, int count);
**参数**
>
> `buffer`
>
>
> [Byte](https://bbs.csdn.net/topics/618545628)[]
>
>
> 要写入数据的缓冲区。
>
>
> `offset`
>
>
> [Int32](https://bbs.csdn.net/topics/618545628)
>
>
> `buffer` 中的字节偏移量,从该偏移量开始写入从流中读取的数据。
>
>
> `count`
>
>
> [Int32](https://bbs.csdn.net/topics/618545628)
>
>
> 最多读取的字节数。
>
>
>
**返回**
>
> [Task](https://bbs.csdn.net/topics/618545628)<[Int32](https://bbs.csdn.net/topics/618545628)>
>
>
> 表示异步读取操作的任务。 `TResult` 参数的值包含读入缓冲区的总字节数。 如果当前可用字节数少于所请求的字节数,则该结果值可小于所请求的字节数;如果已到达流结尾时,则为 0(零)。
>
>
>
**示例**
下面的示例演示如何以异步方式从文件读取。 该示例使用 [FileStream](https://bbs.csdn.net/topics/618545628) 类,该类派生自 [Stream](https://bbs.csdn.net/topics/618545628) 类。
using System;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.IO;
namespace WpfApplication1
{
public partial class MainWindow : Window
{
public MainWindow()
{
InitializeComponent();
}
private async void Button_Click(object sender, RoutedEventArgs e)
{
string filename = @"c:\Temp\userinputlog.txt";
byte[] result;
using (FileStream SourceStream = File.Open(filename, FileMode.Open))
{
result = new byte[SourceStream.Length];
await SourceStream.ReadAsync(result, 0, (int)SourceStream.Length);
}
UserInput.Text = System.Text.Encoding.ASCII.GetString(result);
}
}
}
###### ReadByte() 从基础流中读取一个字节,并返回转换为 `int` 的该字节;或者如果从流的末尾读取则返回 -1
public override int ReadByte ();
**返回**
>
> [Int32](https://bbs.csdn.net/topics/618545628)
>
>
> 强制转换为 [Int32](https://bbs.csdn.net/topics/618545628) 的字节;或者如果已到达流的末尾,则为 -1。
>
>
>
###### Write(Byte[], Int32, Int32) 将字节复制到缓冲流,并将缓冲流内的当前位置前进写入的字节数
public override void Write (byte[] buffer, int offset, int count);
**参数**
>
> `buffer`
>
>
> [Byte](https://bbs.csdn.net/topics/618545628)[]
>
>
> 字节数组,从该字节数组将 `count` 个字节复制到当前缓冲流中。
>
>
> `offset`
>
>
> [Int32](https://bbs.csdn.net/topics/618545628)
>
>
> 缓冲区中的偏移量,从此处开始将字节复制到当前缓冲流中。
>
>
> `count`
>
>
> [Int32](https://bbs.csdn.net/topics/618545628)
>
>
> 要写入当前缓冲流中的字节数。
>
>
>
**示例**
此代码示例是为 [BufferedStream](https://bbs.csdn.net/topics/618545628) 类提供的一个更大示例的一部分。
// 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”));
###### WriteAsync(Byte[], Int32, Int32) 将字节序列异步写入当前流,并将流的当前位置提升写入的字节数
public System.Threading.Tasks.Task WriteAsync (byte[] buffer, int offset, int count);
**参数**
>
> `buffer`
>
>
> [Byte](https://bbs.csdn.net/topics/618545628)[]
>
>
> 从中写入数据的缓冲区。
![img](https://img-blog.csdnimg.cn/img_convert/7ab4f23ce506adf68c04edf06afc5f71.png)
![img](https://img-blog.csdnimg.cn/img_convert/b0d72c1d563113884fcc970569d60746.png)
**网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。**
**[需要这份系统化资料的朋友,可以戳这里获取](https://bbs.csdn.net/topics/618545628)**
**一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!**
Time.Now - startTime).TotalSeconds;
Console.WriteLine("{0} bytes sent in {1} seconds.\n",
numberOfLoops * dataToSend.Length,
bufferedTime.ToString("F1"));
WriteAsync(Byte[], Int32, Int32) 将字节序列异步写入当前流,并将流的当前位置提升写入的字节数
public System.Threading.Tasks.Task WriteAsync (byte[] buffer, int offset, int count);
参数
buffer
Byte[]
从中写入数据的缓冲区。
[外链图片转存中…(img-gzXgrBw5-1715798226969)]
[外链图片转存中…(img-sgtEjllh-1715798226969)]
网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。
一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!