查看: 1231|回复: 3

[其他] ByteArrary(优化数据存储和数据流)

2722 主题	42 听众	3万积分

资深设计师

Rank: 7 Rank: 7 Rank: 7

纳金币: 38268
精华: 111

电梯直达

楼主

发表于 2014-9-29 02:02:51 |只看该作者 |倒序浏览

public class ByteArray
{
private MemoryStream m_Stream = new MemoryStream();
private BinaryReader m_Reader = null;
private BinaryWriter m_Writer = null;
public ByteArray()
{
Init();
}
public ByteArray(MemoryStream ms)
{
m_Stream = ms;
Init();
}
public ByteArray(byte[] buffer)
{
m_Stream = new MemoryStream(buffer);
Init();
}
private void Init()
{
m_Writer = new BinaryWriter(m_Stream);
m_Reader = new BinaryReader(m_Stream);
}
public int Length
{
get { return (int)m_Stream.Length; }
}
public int Postion
{
get { return (int)m_Stream.Position; }
set { m_Stream.Position = value; }
}
public byte[] Buffer
{
get { return m_Stream.GetBuffer(); }
}
internal MemoryStream MemoryStream { get { return m_Stream; } }
public bool ReadBoolean()
{
return m_Reader.ReadBoolean();
}
public byte ReadByte()
{
return m_Reader.ReadByte();
}
public void ReadBytes(byte[] bytes, uint offset, uint length)
{
byte[] tmp = m_Reader.ReadBytes((int)length);
for (int i = 0; i < tmp.Length; i++)
bytes[i + offset] = tmp[i];
//m_Reader.ReadBytes(bytes, offset, length);
}
public double ReadDouble()
{
return m_Reader.ReadDouble();
}
public float ReadFloat()
{
byte[] bytes = m_Reader.ReadBytes(4);
byte[] invertedBytes = new byte[4];
//Grab the bytes in reverse order from the backwards index
for (int i = 3, j = 0; i >= 0; i--, j++)
{
invertedBytes[j] = bytes[i];
}
float value = BitConverter.ToSingle(invertedBytes, 0);
return value;
// return m_Reader.ReadFloat();
}
public int ReadInt()
{
return m_Reader.ReadInt32();
}
public short ReadShort()
{
return m_Reader.ReadInt16();
}
public byte ReadUnsignedByte()
{
return m_Reader.ReadByte();
}
public uint ReadUnsignedInt()
{
return (uint)m_Reader.ReadInt32();
}
public ushort ReadUnsignedShort()
{
return m_Reader.ReadUInt16();
}
public string ReadUTF()
{
return m_Reader.ReadString();
}
public string ReadUTFBytes(uint length)
{
if (length == 0)
return string.Empty;
UTF8Encoding utf8 = new UTF8Encoding(false, true);
byte[] encodedBytes = m_Reader.ReadBytes((int)length);
string decodedString = utf8.GetString(encodedBytes, 0, encodedBytes.Length);
return decodedString;
}
public void WriteBoolean(bool value)
{
m_Writer.BaseStream.WriteByte(value ? ((byte)1) : ((byte)0));
// m_Writer.WriteBoolean(value);
}
public void WriteByte(byte value)
{
m_Writer.BaseStream.WriteByte(value);
// m_Writer.WriteByte(value);
}
public void WriteBytes(byte[] buffer)
{
for (int i = 0; buffer != null && i < buffer.Length; i++)
m_Writer.BaseStream.WriteByte(buffer[i]);
}
public void WriteBytes(byte[] bytes, int offset, int length)
{
for (int i = offset; i < offset + length; i++)
m_Writer.BaseStream.WriteByte(bytes[i]);
}
public void WriteDouble(double value)
{
byte[] bytes = BitConverter.GetBytes(value);
WriteBigEndian(bytes);
}
public void WriteFloat(float value)
{
byte[] bytes = BitConverter.GetBytes(value);
WriteBigEndian(bytes);
}
private void WriteBigEndian(byte[] bytes)
{
if (bytes == null)
return;
for (int i = bytes.Length - 1; i >= 0; i--)
{
m_Writer.BaseStream.WriteByte(bytes[i]);
}
}
public void WriteInt32(int value)
{
byte[] bytes = BitConverter.GetBytes(value);
WriteBigEndian(bytes);
}
public void WriteInt(int value)
{
WriteInt32(value);
}
public void WriteShort(int value)
{
byte[] bytes = BitConverter.GetBytes((ushort)value);
WriteBigEndian(bytes);
}
public void WriteUnsignedInt(uint value)
{
WriteInt32((int)value);
}
public void WriteUTF(string value)
{
UTF8Encoding utf8Encoding = new UTF8Encoding();
int byteCount = utf8Encoding.GetByteCount(value);
byte[] buffer = utf8Encoding.GetBytes(value);
WriteShort(byteCount);
if (buffer.Length > 0)
m_Writer.Write(buffer);
}
public void WriteUTFBytes(string value)
{
UTF8Encoding utf8Encoding = new UTF8Encoding();
byte[] buffer = utf8Encoding.GetBytes(value);
if (buffer.Length > 0)
m_Writer.Write(buffer);
}
public void WriteStringBytes(string value)
{
UTF8Encoding utf8Encoding = new UTF8Encoding();
byte[] buffer = utf8Encoding.GetBytes(value);
if (buffer.Length > 0)
{
m_Writer.Write(buffer.Length);
m_Writer.Write(buffer);
}
}
}

复制代码

ByteArray()
创建一个表示填充的字节数组的 ByteArray 实例，以便使用此类中的方法和属性来优化数据存储和数据流。 ByteArray
compress(algorithm:String):void
压缩字节数组。 ByteArray
hasOwnProperty(name:String):Boolean
指示对象是否已经定义了指定的属性。 Object
isPrototypeOf(theClass:Object):Boolean
指示 Object 类的实例是否在指定为参数的对象的原型链中。 Object
propertyIsEnumerable(name:String):Boolean
指示指定的属性是否存在、是否可枚举。 Object
readBoolean():Boolean
从字节流中读取布尔值。 ByteArray
readByte():int
从字节流中读取带符号的字节。 ByteArray
readBytes(bytes:ByteArray, offset:uint = 0, length:uint = 0):void
从字节流中读取 length 参数指定的数据字节数。 ByteArray
readDouble():Number
从字节流中读取一个 IEEE 754 双精度（64 位）浮点数。 ByteArray
readFloat():Number
从字节流中读取一个 IEEE 754 单精度（32 位）浮点数。 ByteArray
readInt():int
从字节流中读取一个带符号的 32 位整数。 ByteArray
readMultiByte(length:uint, charSet:String):String
使用指定的字符集从字节流中读取指定长度的多字节字符串。 ByteArray
readObject():*
从字节数组中读取一个以 AMF 序列化格式进行编码的对象。 ByteArray
readShort():int
从字节流中读取一个带符号的 16 位整数。 ByteArray
readUnsignedByte():uint
从字节流中读取无符号的字节。 ByteArray
readUnsignedInt():uint
从字节流中读取一个无符号的 32 位整数。 ByteArray
readUnsignedShort():uint
从字节流中读取一个无符号的 16 位整数。 ByteArray
readUTF():String
从字节流中读取一个 UTF-8 字符串。 ByteArray
readUTFBytes(length:uint):String
从字节流中读取一个由 length 参数指定的 UTF-8 字节序列，并返回一个字符串。 ByteArray
setPropertyIsEnumerable(name:String, isEnum:Boolean = true):void
设置循环操作动态属性的可用性。 Object
toString():String
将字节数组转换为字符串。 ByteArray
uncompress(algorithm:String):void
解压缩字节数组。 ByteArray
valueOf():Object
返回指定对象的原始值。 Object
writeBoolean(value:Boolean):void
写入布尔值。 ByteArray
writeByte(value:int):void
在字节流中写入一个字节。 ByteArray
writeBytes(bytes:ByteArray, offset:uint = 0, length:uint = 0):void
将指定字节数组 bytes（起始偏移量为 bytes，从 0 开始的索引）中包含 length 个字节的字节序列写入字节流。 ByteArray
writeDouble(value:Number):void
在字节流中写入一个 IEEE 754 双精度（64 位）浮点数。 ByteArray
writeFloat(value:Number):void
在字节流中写入一个 IEEE 754 单精度（32 位）浮点数。 ByteArray
writeInt(value:int):void
在字节流中写入一个带符号的 32 位整数。 ByteArray
writeMultiByte(value:String, charSet:String):void
使用指定的字符集将多字节字符串写入字节流。 ByteArray
writeObject(object:*):void
将对象以 AMF 序列化格式写入字节数组。 ByteArray
writeShort(value:int):void
在字节流中写入一个 16 位整数。 ByteArray
writeUnsignedInt(value:uint):void
在字节流中写入一个无符号的 32 位整数。 ByteArray
writeUTF(value:String):void
将 UTF-8 字符串写入字节流。 ByteArray
writeUTFBytes(value:String):void
将 UTF-8 字符串写入字节流。 ByteArray

private, public, 数据流, null