解决MySql布尔型新旧版本兼容问题，采用枚举来表示布尔型的数据表。由正向工程赋值
|
# Êý¾ÝÀ©Õ¹ IOHelper
## ¸ÅÊö
`IOHelper` ÊÇ NewLife.Core ÖÐµÄ IO ²Ù×÷¹¤¾ßÀ࣬Ìṩ¸ßЧµÄÊý¾ÝÁ÷²Ù×÷¡¢×Ö½ÚÊý×éת»»¡¢Ñ¹Ëõ½âѹ¡¢±àÂëת»»µÈ¹¦ÄÜ¡£Õë¶Ô .NET 6+ µÄ `Stream.Read` ÓïÒå±ä»¯½øÐÐÁ˼æÈÝÐÔ´¦Àí£¬È·±£ÔÚËùÓпò¼Ü°æ±¾ÉÏÐÐΪһÖ¡£
**ÃüÃû¿Õ¼ä**£º`NewLife`
**ÎĵµµØÖ·**£ºhttps://newlifex.com/core/io_helper
## ºËÐÄÌØÐÔ
- **¾«È·¶ÁÈ¡**£º`ReadExactly` È·±£¶ÁÈ¡Ö¸¶¨×Ö½ÚÊý£¬½â¾ö .NET 6+ ²¿·Ö¶ÁÈ¡ÎÊÌâ
- **ѹËõ½âѹ**£ºÖ§³Ö Deflate ºÍ GZip Á½ÖÖËã·¨
- **×Ö½ÚÐòת»»**£ºÖ§³Ö´ó¶Ë/С¶Ë×Ö½ÚÐòת»»
- **Ê®Áù½øÖƱàÂë**£º¸ßЧµÄÊ®Áù½øÖÆ×Ö·û´®×ª»»
- **±ä³¤ÕûÊý**£ºÖ§³Ö 7-bit ±àÂëµÄѹËõÕûÊý¶Áд
## ¿ìËÙ¿ªÊ¼
```csharp
using NewLife;
// ×Ö½ÚÊý×éתʮÁù½øÖÆ×Ö·û´®
var hex = new Byte[] { 0x12, 0xAB, 0xCD }.ToHex(); // "12ABCD"
// Ê®Áù½øÖÆ×Ö·û´®×ª×Ö½ÚÊý×é
var data = "12ABCD".ToHex(); // [0x12, 0xAB, 0xCD]
// Base64 ±à½âÂë
var base64 = data.ToBase64();
var bytes = base64.ToBase64();
// ѹËõÊý¾Ý
var compressed = data.Compress();
var decompressed = compressed.Decompress();
// Á÷ת×Ö·û´®
using var stream = new MemoryStream(Encoding.UTF8.GetBytes("Hello"));
var str = stream.ToStr(); // "Hello"
```
## API ²Î¿¼
### ÊôÐÔÅäÖÃ
#### MaxSafeArraySize
```csharp
public static Int32 MaxSafeArraySize { get; set; } = 1024 * 1024;
```
×î´ó°²È«Êý×é´óС¡£³¬¹ý¸Ã´óСʱ£¬¶ÁÈ¡Êý¾Ý²Ù×÷½«Ç¿ÖÆʧ°Ü¡£
**ÓÃ;**£º±£»¤ÐÔÉèÖ㬱ÜÃâ½âÂë´íÎóÊý¾Ýʱ¶ÁÈ¡³¬´óÊý×éµ¼ÖÂÓ¦ÓñÀÀ£¡£
**ʾÀý**£º
```csharp
// ÐèÒª½âÂë´óÐͶþ½øÖÆÊý¾Ýʱ£¬Êʵ±·Å¿í
IOHelper.MaxSafeArraySize = 10 * 1024 * 1024; // 10MB
```
### Êý¾ÝÁ÷¶ÁÈ¡
#### ReadExactly
```csharp
public static Int32 ReadExactly(this Stream stream, Byte[] buffer, Int32 offset, Int32 count)
public static Byte[] ReadExactly(this Stream stream, Int64 count)
```
¾«È·¶ÁÈ¡Ö¸¶¨×Ö½ÚÊý¡£ÈôÊý¾Ý²»×ãÔòÅ׳ö `EndOfStreamException`¡£
**±³¾°**£º.NET 6 ¿ªÊ¼£¬`Stream.Read` ¿ÉÄÜ·µ»Ø²¿·ÖÊý¾Ý£¨partial read£©£¬±¾·½·¨È·±£¶ÁÈ¡ÍêÕûÊý¾Ý¡£
**ʾÀý**£º
```csharp
using var fs = File.OpenRead("data.bin");
// ¶ÁÈ¡¹Ì¶¨³¤¶ÈµÄÐÒéÍ·
var header = new Byte[16];
fs.ReadExactly(header, 0, 16);
// ¶ÁÈ¡²¢·µ»ØÐÂÊý×é
var data = fs.ReadExactly(1024);
```
#### ReadAtLeast
```csharp
public static Int32 ReadAtLeast(this Stream stream, Byte[] buffer, Int32 offset, Int32 count, Int32 minimumBytes, Boolean throwOnEndOfStream = true)
```
¶ÁÈ¡ÖÁÉÙÖ¸¶¨×Ö½ÚÊý£¬ÔÊÐí¶ÁÈ¡¸ü¶àµ«²»³¬¹ý `count`¡£
**²ÎÊý˵Ã÷**£º
- `minimumBytes`£º×îÉÙÐèÒª¶ÁÈ¡µÄ×Ö½ÚÊý
- `throwOnEndOfStream`£ºÊý¾Ý²»×ãʱÊÇ·ñÅ׳öÒì³£
**ʾÀý**£º
```csharp
var buffer = new Byte[1024];
// ÖÁÉÙ¶ÁÈ¡ 100 ×Ö½Ú£¬×î¶à 1024 ×Ö½Ú
var read = stream.ReadAtLeast(buffer, 0, 1024, 100, throwOnEndOfStream: false);
if (read < 100)
{
Console.WriteLine("Êý¾Ý²»×ã");
}
```
#### ReadBytes
```csharp
public static Byte[] ReadBytes(this Stream stream, Int64 length)
```
´ÓÁ÷ÖжÁÈ¡Ö¸¶¨³¤¶ÈµÄ×Ö½ÚÊý×é¡£
**²ÎÊý˵Ã÷**£º
- `length`£ºÒª¶ÁÈ¡µÄ×Ö½ÚÊý£¬-1 ±íʾ¶ÁÈ¡µ½Á÷ĩβ
**ʾÀý**£º
```csharp
// ¶ÁÈ¡Ö¸¶¨³¤¶È
var data = stream.ReadBytes(1024);
// ¶ÁÈ¡È«²¿Ê£ÓàÊý¾Ý
var all = stream.ReadBytes(-1);
```
### Êý¾ÝÁ÷дÈë
#### Write
```csharp
public static Stream Write(this Stream des, params Byte[] src)
```
½«×Ö½ÚÊý×éдÈëÊý¾ÝÁ÷¡£
**ʾÀý**£º
```csharp
using var ms = new MemoryStream();
ms.Write(new Byte[] { 1, 2, 3 });
ms.Write(new Byte[] { 4, 5, 6 });
```
#### WriteArray / ReadArray
```csharp
public static Stream WriteArray(this Stream des, params Byte[] src)
public static Byte[] ReadArray(this Stream des)
```
дÈë/¶ÁÈ¡´ø³¤¶Èǰ׺µÄ×Ö½ÚÊý×飨ʹÓà 7-bit ±àÂëÕûÊý×÷Ϊ³¤¶È£©¡£
**ʾÀý**£º
```csharp
using var ms = new MemoryStream();
// дÈë´ø³¤¶Èǰ׺µÄÊý¾Ý
ms.WriteArray(new Byte[] { 1, 2, 3, 4, 5 });
// ¶ÁÈ¡
ms.Position = 0;
var data = ms.ReadArray(); // [1, 2, 3, 4, 5]
```
### ѹËõ½âѹ
#### Compress / Decompress£¨Deflate£©
```csharp
public static Stream Compress(this Stream inStream, Stream? outStream = null)
public static Stream Decompress(this Stream inStream, Stream? outStream = null)
public static Byte[] Compress(this Byte[] data)
public static Byte[] Decompress(this Byte[] data)
```
ʹÓà Deflate Ë㷨ѹËõ/½âѹÊý¾Ý¡£
**ʾÀý**£º
```csharp
// ѹËõ×Ö½ÚÊý×é
var data = Encoding.UTF8.GetBytes("Hello World!");
var compressed = data.Compress();
var decompressed = compressed.Decompress();
// ѹËõÊý¾ÝÁ÷
using var input = new MemoryStream(data);
using var output = new MemoryStream();
input.Compress(output);
```
#### CompressGZip / DecompressGZip
```csharp
public static Stream CompressGZip(this Stream inStream, Stream? outStream = null)
public static Stream DecompressGZip(this Stream inStream, Stream? outStream = null)
public static Byte[] CompressGZip(this Byte[] data)
public static Byte[] DecompressGZip(this Byte[] data)
```
ʹÓà GZip Ë㷨ѹËõ/½âѹÊý¾Ý¡£GZip ¸ñʽ°üº¬ÎļþÍ·ÐÅÏ¢£¬¼æÈÝÐÔ¸üºÃ¡£
**ʾÀý**£º
```csharp
var data = File.ReadAllBytes("large-file.txt");
var gzipped = data.CompressGZip();
File.WriteAllBytes("large-file.txt.gz", gzipped);
```
### ×Ö½ÚÐòת»»
#### ToUInt16 / ToUInt32 / ToUInt64
```csharp
public static UInt16 ToUInt16(this Byte[] data, Int32 offset = 0, Boolean isLittleEndian = true)
public static UInt32 ToUInt32(this Byte[] data, Int32 offset = 0, Boolean isLittleEndian = true)
public static UInt64 ToUInt64(this Byte[] data, Int32 offset = 0, Boolean isLittleEndian = true)
```
´Ó×Ö½ÚÊý×é¶ÁÈ¡ÕûÊý£¬Ö§³Ö´ó¶Ë/С¶Ë×Ö½ÚÐò¡£
**ʾÀý**£º
```csharp
var data = new Byte[] { 0x01, 0x00, 0x00, 0x00 };
// С¶ËÐò£¨Ä¬ÈÏ£©
var value1 = data.ToUInt32(); // 1
// ´ó¶ËÐò
var value2 = data.ToUInt32(isLittleEndian: false); // 16777216
```
#### GetBytes
```csharp
public static Byte[] GetBytes(this Int16 value, Boolean isLittleEndian = true)
public static Byte[] GetBytes(this Int32 value, Boolean isLittleEndian = true)
public static Byte[] GetBytes(this Int64 value, Boolean isLittleEndian = true)
// ... ¸ü¶àÖØÔØ
```
½«ÕûÊýת»»Îª×Ö½ÚÊý×é¡£
**ʾÀý**£º
```csharp
var bytes1 = 12345.GetBytes(); // С¶ËÐò
var bytes2 = 12345.GetBytes(isLittleEndian: false); // ´ó¶ËÐò
```
### Ê®Áù½øÖƱàÂë
#### ToHex
```csharp
public static String ToHex(this Byte[] data, Int32 offset = 0, Int32 count = -1)
public static String ToHex(this Byte[] data, String? separate, Int32 lineSize = 0)
```
½«×Ö½ÚÊý×éת»»ÎªÊ®Áù½øÖÆ×Ö·û´®¡£
**ʾÀý**£º
```csharp
var data = new Byte[] { 0x12, 0xAB, 0xCD, 0xEF };
// »ù±¾×ª»»
data.ToHex() // "12ABCDEF"
// ´ø·Ö¸ô·û
data.ToHex("-") // "12-AB-CD-EF"
data.ToHex(" ") // "12 AB CD EF"
// ·ÖÐÐÏÔʾ
var largeData = new Byte[32];
largeData.ToHex(" ", lineSize: 16) // ÿ 16 ×Ö½ÚÒ»ÐÐ
```
#### ToHex£¨×Ö·û´®×ª×Ö½ÚÊý×飩
```csharp
public static Byte[] ToHex(this String? data)
```
½«Ê®Áù½øÖÆ×Ö·û´®×ª»»Îª×Ö½ÚÊý×é¡£
**ʾÀý**£º
```csharp
"12ABCDEF".ToHex() // [0x12, 0xAB, 0xCD, 0xEF]
"12-AB-CD-EF".ToHex() // [0x12, 0xAB, 0xCD, 0xEF]£¨×Ô¶¯ºöÂÔ·Ö¸ô·û£©
"12 AB CD EF".ToHex() // [0x12, 0xAB, 0xCD, 0xEF]
```
### Base64 ±àÂë
#### ToBase64
```csharp
public static String ToBase64(this Byte[] data)
public static Byte[] ToBase64(this String? data)
```
Base64 ±à½âÂë¡£
**ʾÀý**£º
```csharp
// ±àÂë
var data = Encoding.UTF8.GetBytes("Hello");
var base64 = data.ToBase64(); // "SGVsbG8="
// ½âÂë
var bytes = base64.ToBase64(); // [72, 101, 108, 108, 111]
```
### ×Ö·û´®×ª»»
#### ToStr
```csharp
public static String ToStr(this Stream stream, Encoding? encoding = null)
public static String ToStr(this Byte[] buf, Encoding? encoding = null, Int32 offset = 0, Int32 count = -1)
```
½«Á÷»ò×Ö½ÚÊý×éת»»Îª×Ö·û´®£¬×Ô¶¯´¦Àí BOM¡£
**ʾÀý**£º
```csharp
// Á÷ת×Ö·û´®
using var stream = new MemoryStream(Encoding.UTF8.GetBytes("Hello"));
var str = stream.ToStr(); // "Hello"
// ×Ö½ÚÊý×éת×Ö·û´®
var data = Encoding.UTF8.GetBytes("ÊÀ½ç");
var text = data.ToStr(Encoding.UTF8); // "ÊÀ½ç"
```
### ±ä³¤ÕûÊý±àÂë
#### WriteEncodedInt / ReadEncodedInt
```csharp
public static Stream WriteEncodedInt(this Stream stream, Int32 value)
public static Int32 ReadEncodedInt(this Stream stream)
```
ʹÓà 7-bit ±àÂë¶Áд±ä³¤ÕûÊý£¬Ð¡ÖµÕ¼ÓøüÉÙ×Ö½Ú¡£
**±àÂë¹æÔò**£º
- 0-127£º1 ×Ö½Ú
- 128-16383£º2 ×Ö½Ú
- 16384-2097151£º3 ×Ö½Ú
- ÒÔ´ËÀàÍÆ
**ʾÀý**£º
```csharp
using var ms = new MemoryStream();
// дÈëСֵֻÐè 1 ×Ö½Ú
ms.WriteEncodedInt(100); // 1 ×Ö½Ú
// дÈë´óÖµÐèÒª¸ü¶à×Ö½Ú
ms.WriteEncodedInt(10000); // 2 ×Ö½Ú
// ¶ÁÈ¡
ms.Position = 0;
var v1 = ms.ReadEncodedInt(); // 100
var v2 = ms.ReadEncodedInt(); // 10000
```
### ʱ¼ä¶Áд
#### WriteDateTime / ReadDateTime
```csharp
public static Stream WriteDateTime(this Stream stream, DateTime dt)
public static DateTime ReadDateTime(this Stream stream)
```
ÒÔ Unix ʱ¼ä´Á£¨Ã룩¸ñʽ¶Áдʱ¼ä£¬4 ×Ö½Ú´æ´¢¡£
**ʾÀý**£º
```csharp
using var ms = new MemoryStream();
ms.WriteDateTime(DateTime.Now);
ms.Position = 0;
var dt = ms.ReadDateTime();
```
### ×Ö½ÚÊý×é²Ù×÷
#### ReadBytes
```csharp
public static Byte[] ReadBytes(this Byte[] src, Int32 offset, Int32 count)
```
´Ó×Ö½ÚÊý×éÖи´ÖÆÖ¸¶¨·¶Î§µÄÊý¾Ý¡£
**ʾÀý**£º
```csharp
var data = new Byte[] { 1, 2, 3, 4, 5 };
var part = data.ReadBytes(1, 3); // [2, 3, 4]
var rest = data.ReadBytes(2, -1); // [3, 4, 5]£¨-1 ±íʾµ½Ä©Î²£©
```
#### Write
```csharp
public static Int32 Write(this Byte[] dst, Int32 dstOffset, Byte[] src, Int32 srcOffset = 0, Int32 count = -1)
```
Ïò×Ö½ÚÊý×éдÈëÊý¾Ý¡£
**ʾÀý**£º
```csharp
var buffer = new Byte[10];
var data = new Byte[] { 1, 2, 3 };
var written = buffer.Write(0, data); // дÈë 3 ×Ö½Ú
```
#### CopyTo£¨Ö¸¶¨³¤¶È£©
```csharp
public static void CopyTo(this Stream source, Stream destination, Int64 length, Int32 bufferSize)
```
´ÓÔ´Á÷¸´ÖÆÖ¸¶¨³¤¶ÈÊý¾Ýµ½Ä¿±êÁ÷¡£
**ʾÀý**£º
```csharp
using var source = File.OpenRead("large-file.bin");
using var dest = File.Create("part.bin");
// Ö»¸´ÖÆÇ° 1MB
source.CopyTo(dest, 1024 * 1024, bufferSize: 81920);
```
## ʹÓó¡¾°
### 1. ÍøÂçÐÒé½âÎö
```csharp
public class ProtocolParser
{
public Message Parse(Stream stream)
{
// ¶ÁÈ¡¹Ì¶¨³¤¶ÈµÄÐÒéÍ·
var header = stream.ReadExactly(8);
var magic = header.ToUInt32(0);
var length = header.ToUInt32(4);
// ¶ÁÈ¡ÏûÏ¢Ìå
var body = stream.ReadExactly(length);
return new Message { Header = header, Body = body };
}
}
```
### 2. ¶þ½øÖÆÐòÁл¯
```csharp
public class BinarySerializer
{
public void Serialize(Stream stream, Object obj)
{
var json = JsonSerializer.Serialize(obj);
var data = Encoding.UTF8.GetBytes(json);
// дÈ볤¶ÈºÍÊý¾Ý
stream.WriteArray(data);
}
public T Deserialize<T>(Stream stream)
{
var data = stream.ReadArray();
var json = data.ToStr(Encoding.UTF8);
return JsonSerializer.Deserialize<T>(json);
}
}
```
### 3. Êý¾ÝѹËõ´«Êä
```csharp
public class CompressedTransport
{
public Byte[] Send(Byte[] data)
{
// ѹËõÊý¾Ý
var compressed = data.CompressGZip();
// ¹¹½¨´«Êä°ü£º[ѹËõ±êÖ¾][Ôʼ³¤¶È][ѹËõÊý¾Ý]
using var ms = new MemoryStream();
ms.WriteByte(1); // ѹËõ±êÖ¾
ms.WriteEncodedInt(data.Length); // Ôʼ³¤¶È
ms.Write(compressed);
return ms.ToArray();
}
public Byte[] Receive(Byte[] packet)
{
using var ms = new MemoryStream(packet);
var compressed = ms.ReadByte() == 1;
var originalLength = ms.ReadEncodedInt();
var data = ms.ReadBytes(-1);
return compressed ? data.DecompressGZip() : data;
}
}
```
## ×î¼Ñʵ¼ù
### 1. ʹÓà ReadExactly Ìæ´ú Read
```csharp
// ÍƼö£ºÈ·±£¶ÁÈ¡ÍêÕûÊý¾Ý
var data = stream.ReadExactly(100);
// ²»ÍƼö£º¿ÉÄÜÖ»¶ÁÈ¡²¿·ÖÊý¾Ý
var buffer = new Byte[100];
stream.Read(buffer, 0, 100); // .NET 6+ ¿ÉÄÜ·µ»ØСÓÚ 100
```
### 2. ×¢Òâ×Ö½ÚÐò
```csharp
// ÓëÆäËûϵͳ½»»¥Ê±×¢Òâ×Ö½ÚÐò
// ÍøÂçÐÒéͨ³£Ê¹Óôó¶ËÐò
var networkValue = data.ToUInt32(isLittleEndian: false);
// ±¾µØ´æ´¢Í¨³£Ê¹ÓÃС¶ËÐò£¨x86/x64 ĬÈÏ£©
var localValue = data.ToUInt32();
```
### 3. ʹÓöÔÏó³Ø¼õÉÙÄÚ´æ·ÖÅä
```csharp
using NewLife.Collections;
// ʹÓÃÄÚ´æÁ÷³Ø
var ms = Pool.MemoryStream.Get();
try
{
// ʹÓÃÁ÷...
}
finally
{
ms.Return(true); // ¹é»¹²¢Çå¿Õ
}
```
## Ïà¹ØÁ´½Ó
- [·¾¶À©Õ¹ PathHelper](/NewLife/X/Blob/dev/Doc/path_helper-·¾¶À©Õ¹PathHelper.md)
- [°²È«À©Õ¹ SecurityHelper](/NewLife/X/Blob/dev/Doc/security_helper-°²È«À©Õ¹SecurityHelper.md)
- [Êý¾Ý°ü IPacket](/NewLife/X/Blob/dev/Doc/packet-Êý¾Ý°üIPacket.md)
|