流操作 #

public abstract class Stream
{
    public abstract bool CanRead { get; }
    public abstract bool CanWrite { get; }
    public abstract bool CanSeek { get; }
    public abstract long Length { get; }
    public abstract long Position { get; set; }
}

public abstract class Stream
{
    public abstract int Read(byte[] buffer, int offset, int count);
    public abstract void Write(byte[] buffer, int offset, int count);
    public abstract long Seek(long offset, SeekOrigin origin);
    public abstract void Flush();
    public abstract void SetLength(long value);
    
    public void CopyTo(Stream destination);
    public Task CopyToAsync(Stream destination);
}

using var fs = new FileStream("data.bin", FileMode.Open);
using var fs = new FileStream("data.bin", FileMode.OpenOrCreate, FileAccess.ReadWrite);
using var fs = new FileStream("data.bin", FileMode.Create, FileAccess.Write, FileShare.None);
using var fs = File.OpenRead("data.bin");
using var fs = File.OpenWrite("data.bin");
using var fs = File.Create("data.bin");

using var fs = new FileStream("data.bin", FileMode.Create);
byte[] data = Encoding.UTF8.GetBytes("Hello World");
fs.Write(data, 0, data.Length);

using var fs = new FileStream("data.bin", FileMode.Open);
byte[] buffer = new byte[1024];
int bytesRead = fs.Read(buffer, 0, buffer.Length);
string content = Encoding.UTF8.GetString(buffer, 0, bytesRead);

using var fs = new FileStream("data.bin", FileMode.Open);

fs.Seek(0, SeekOrigin.Begin);
fs.Seek(-10, SeekOrigin.End);
fs.Seek(100, SeekOrigin.Current);

long position = fs.Position;
long length = fs.Length;

using var reader = new StreamReader("data.txt");
using var reader = new StreamReader("data.txt", Encoding.UTF8);
using var reader = new StreamReader(File.OpenRead("data.txt"));
using var reader = new StreamReader(stream, Encoding.UTF8, detectEncodingFromByteOrderMarks: true);

using var reader = new StreamReader("data.txt");

string content = reader.ReadToEnd();

string line;
while ((line = reader.ReadLine()) != null)
{
    Console.WriteLine(line);
}

int charCode = reader.Read();
char[] buffer = new char[1024];
int charsRead = reader.Read(buffer, 0, buffer.Length);

public async Task<string> ReadFileAsync(string path)
{
    using var reader = new StreamReader(path);
    return await reader.ReadToEndAsync();
}

public async Task ProcessLinesAsync(string path)
{
    using var reader = new StreamReader(path);
    string line;
    while ((line = await reader.ReadLineAsync()) != null)
    {
        await ProcessLineAsync(line);
    }
}

using var writer = new StreamWriter("output.txt");
using var writer = new StreamWriter("output.txt", append: true);
using var writer = new StreamWriter("output.txt", false, Encoding.UTF8);
using var writer = new StreamWriter(stream, Encoding.UTF8);

using var writer = new StreamWriter("output.txt");

writer.Write("Hello");
writer.Write(" ");
writer.WriteLine("World");
writer.WriteLine("新的一行");

writer.Flush();

public async Task WriteFileAsync(string path, string content)
{
    await using var writer = new StreamWriter(path);
    await writer.WriteAsync(content);
}

public async Task WriteLinesAsync(string path, IEnumerable<string> lines)
{
    await using var writer = new StreamWriter(path);
    foreach (var line in lines)
    {
        await writer.WriteLineAsync(line);
    }
}

using var ms = new MemoryStream();
byte[] data = Encoding.UTF8.GetBytes("Hello");
ms.Write(data, 0, data.Length);

ms.Position = 0;
byte[] result = ms.ToArray();

using var ms = new MemoryStream(data);
using var reader = new StreamReader(ms);
string content = reader.ReadToEnd();

using var ms = new MemoryStream();

for (int i = 0; i < 10; i++)
{
    byte[] data = BitConverter.GetBytes(i);
    ms.Write(data, 0, data.Length);
}

byte[] allData = ms.ToArray();

ms.Position = 0;
for (int i = 0; i < 10; i++)
{
    byte[] buffer = new byte[4];
    ms.Read(buffer, 0, 4);
    int value = BitConverter.ToInt32(buffer, 0);
}

using var fs = new FileStream("large.bin", FileMode.Open);
using var bs = new BufferedStream(fs, bufferSize: 8192);

byte[] buffer = new byte[1024];
int bytesRead;
while ((bytesRead = bs.Read(buffer, 0, buffer.Length)) > 0)
{
    Process(buffer, bytesRead);
}

using var source = File.OpenRead("source.txt");
using var dest = File.OpenWrite("dest.txt");
source.CopyTo(dest);

await source.CopyToAsync(dest);

public static void CopyStream(Stream source, Stream dest)
{
    byte[] buffer = new byte[8192];
    int bytesRead;
    while ((bytesRead = source.Read(buffer, 0, buffer.Length)) > 0)
    {
        dest.Write(buffer, 0, bytesRead);
    }
}

public static async Task CopyStreamAsync(Stream source, Stream dest)
{
    byte[] buffer = new byte[8192];
    int bytesRead;
    while ((bytesRead = await source.ReadAsync(buffer, 0, buffer.Length)) > 0)
    {
        await dest.WriteAsync(buffer, 0, bytesRead);
    }
}

public static void CopyFile(string sourcePath, string destPath)
{
    using var source = File.OpenRead(sourcePath);
    using var dest = File.Create(destPath);
    source.CopyTo(dest);
}

public static string StreamToString(Stream stream)
{
    using var reader = new StreamReader(stream);
    return reader.ReadToEnd();
}

public static Stream StringToStream(string content)
{
    var stream = new MemoryStream();
    using var writer = new StreamWriter(stream, leaveOpen: true);
    writer.Write(content);
    writer.Flush();
    stream.Position = 0;
    return stream;
}