对象、字节流转换

数据表示时间 　　长度（字节）　　 数据类型 　　描述及要求
平台登入时间 　   6　　　　　 　   BYTE[6]      （每个字节分别代表：年、月、日、时、分、秒）
登入流水号           2 　　　　　　   WORD 　　  每登入一次，登入流水号自动加1
平台用户名　　    12 　　　　       STRING 　   平台登入用户名
平台密码　　　　 20                     STRING　　 平台登入密码
加密规则             1　　　　　　    BYTE          0x01:数据不加密；0x02:RSA加密；0x03:AES128加密...

//平台登入类
public class EvPlatformLoginMsg
{
    public DateTime LoginTime{get;set;}

    public ushort SerialNumver{get;set;}

    public string Account{get;set}

    public string Password{get;set;}

    public EvEncryptionMode EncryptMode{get;set;}

    public EvPlatformLoginMsg(byte[] bytes, int offset)
    {
        EvDateTime evDateTime = new EvDateTime(bytes, offset);
        LoginTime = evDateTime.DateTime;
        offset += evDateTime.BytesSize;

        NetBytesUtil.EnsureNetOrder(bytes, index, 2);
        SerialNumver = BitConverter.ToUint16(bytes, index);
        offset += 2;

        Account = Encoding.ASCII.GetString(bytes, index, 12).TrimEnd(‘\0‘);
        offset += 12;

        Password = Encoding.ASCII.GetString(bytes, index, 20);
        offset += 20;

        EncryptMode = (EvEncryptionMode)bytes[index];
    }

    public byte[] ToBytes()
    {
        byte[] bytes = new byte[41];
        int offset = 0;

        offset += new EvDateTime(LoginTime).WriteToBytes(bytes, offset);

        BitExtend.WriteUint16ToBytes(bytes, offset, SerialNumver);
        NetBytesUtil.EnsureNetOrder(bytes, index, 2);
        index += 2;

        byte[] accountBytes = Encoding.ASCII.GetBytes(Account);
        Buffer.BlockCopy(accountBytes, 0, bytes, index, accountBytes.Length > 12 ? 12 : accountBytes.Length);
        index += 12;

        byte[] passwordBytes = Encoding.ASCII.GetBytes(Password);
        Buffer.BlockCopy(passwordBytes, 0, bytes, index, passwordBytes.Length > 20 ? 20 : passwordBytes.Length);
        index += 20；

        bytes[index] = (byte)EncryptMode;

        return bytes;
    }
}

//时间类型
public class EvDateTime
{
    private const int ConstBytesSize = 6;    //6个字节表示时间

    public DateTime DateTime
    {
        get;
        set;
    }

    public EvDateTime(DateTime dateTime)
    {
        DateTime = dateTime;
    }

    public int BytesSize
    {
        get{return ConstBytesSize;}
        set{;}
    }

    public EvDateTime(byte[] bytes, int offset)
    {
        int year = byte[offset] + 2000;
        int month = byte[offset + 1];
        int day = byte[offset + 2];
        int hour = byte[offset + 3];
        int miniute = byte[offset + 4];
        int second = byte[offset + 5];
        DateTime = new DateTime(year, month, day, hour, miniute, second);
    }

    public int WriteToBytes(byte[] bytes, int offset)
    {
        bytes[offset] = (byte)(DateTime.Year - 2000);
        bytes[offset + 1] = (byte)DateTime.Month;
        bytes[offset + 2] = (byte)DateTime.Day;
        bytes[offset + 3] = (byte)DateTime.Hour;
        bytes[offset + 4] = (byte)DateTime.Minute;
        bytes[offset + 5] = (byte)DateTime.Second;
        return ConstBytesSize;
    }
}

//BitExtend类
public class BitExtend
{
    public static unsafe void WriteCharToBytes(byte[] bytes, int start, char value)
    {
        WriteInt16ToBytes(bytes, start, (short)val);
    }

    public static unsafe void WriteSingleToBytes(byte[] bytes, int start, float value)
    {
        WriteInt32ToBytes(bytes, start, *((int*)&value));
    }

    public static unsafe void WriteDoubleToBytes(byte[] bytes, int start, double value)
    {
        WriteInt64ToBytes(bytes, start, *((long*)&value));
    }

    public static unsafe void WriteBooleanToBytes(byte[] bytes, int start, boolean value){
        bytes[start] = value ? (byte)1 : (byte)0;
    }

    public static unsafe void WriteUint16ToBytes(byte[] bytes, int start, ushort value)
    {
        WriteInt16ToBytes(bytes, start, (short)value);
    }

    public static unsafe void WriteUint32ToBytes(byte[] bytes, int start, uint value)
    {
        WriteInt32ToBytes(bytes, start, (short)value);
    }

    public static unsafe void WriteUint64ToBytes(byte[] bytes, int start, ulong value)
    {
        WriteInt64ToBytes(bytes, start, (long)value);
    }

    public static unsafe void WriteInt32ToBytes(byte[] bytes, int start, int value)
    {
        fixed(byte* numRef = bytes)
        {
            *((int*)(numRef = start)) = value;
        }
    }

    public static unsafe void WriteInt16ToBytes(byte[] bytes, int start, short value)
    {
        fixed (byte* numRef = bytes)
        {
            *((short*)(numRef + start)) = value;
        }
    }

    public static unsafe void WriteInt32ToBytes(byte[] bytes, int start, int value)
    {
        fixed(byte* numRef = bytes)
        {
            *((int*)(numRef + start)) = value;
        }
    }

    public static unsafe void WriteInt64ToBytes(byte[] bytes, int start, long value)
    {
        fixed(long* numRef = bytes)
        {
            *((long*)(numRef + start)) = value;
        }
    }
}

//网络序和本机序
public static class NetBytesUtil
{
    public static int[] Byte2Bits(byte b)
    {
        int[] bitArray = new int[8];
        bitArray[0] = b & 1;
        bitArray[1] = b & 2;
        bitArray[2] = b & 4;
        bitArray[3] = b & 8;
        bitArray[4] = b & 16;
        bitArray[5] = b & 32;
        bitArray[6] = b & 64;
        bitArray[7] = b & 128;

        return bitArray;
    }

    public static bool TestBit(long src, byte bitIndex)
    {
        if (src == 0)
        {
            return false;
        }
        else
        {
            return ((ulong)src & (ulong)Math.Pow(2, bitIndex)) == (ulong)Math.Pow(2, bitIndex);
        }
    }

    public static long SetBit(long src, byte bitIndex)
    {
        return src | (long)Math.Pow(2, bitIndex);
    }
    public static void EnsureNetOrder(byte[] bytes, int start, int size)
    {
        if (BitConverter.IsLittleEndian)
        {
            if (bytes == null)
            {
                throw new Exception("bytes is null");
            }
            if (start < 0)
            {
                throw new Exception("start less than 0");
            }
            if (size < 0)
            {
                throw new Exception("size less than 0");
            }
            if (bytes.Length < start + size)
            {
                throw new Exception("bytes length less then that start plus size");
            }
            if (size > 1)
            {
                byte tmp;
                for (int i = 0; i < size / 2; i++)
                {
                    tmp = bytes[start + i];
                    bytes[start + i] = bytes[start + size - 1 - i];
                    bytes[start + size - 1 - i] = tmp;
                }
            }
        }
    }

    public static void EnsureHostOrder(byte[] bytes, int start, int size)
    {
        if (!BitConverter.IsLittleEndian)
        {
            if (bytes == null)
            {
                throw new Exception("bytes is null");
            }
            if (start < 0)
            {
                throw new Exception("start less than 0");
            }
            if (size < 0)
            {
                throw new Exception("size less than 0");
            }
            if (bytes.Length < start + size)
            {
                throw new Exception("bytes length less then that start plus size");
            }
            if (size > 1)
            {
                byte tmp;
                for (int i = 0; i < size / 2; i++)
                {
                    tmp = bytes[start + i];
                    bytes[start + i] = bytes[start + size - 1 - i];
                    bytes[start + size - 1 - i] = tmp;
                }
            }
        }
    }

    public static void WriteIp(byte[] bytes, int start, string ip)
    {
        if (bytes == null)
        {
            throw new Exception("bytes is null");
        }
        if (start < 0)
        {
            throw new Exception("start less than 0");
        }

        if (bytes.Length < start + 4)
        {
            throw new Exception("bytes length less then that start plus size");
        }

        if (string.IsNullOrEmpty(ip))
        {
            throw new Exception("ip is null or empty");
        }

        string[] array = ip.Split(new char[] { ‘.‘ }, StringSplitOptions.RemoveEmptyEntries);
        if (array.Length != 4)
        {
            throw new Exception("ip format is error");
        }

        bytes[start] = byte.Parse(array[0]);
        bytes[start + 1] = byte.Parse(array[1]);
        bytes[start + 2] = byte.Parse(array[2]);
        bytes[start + 3] = byte.Parse(array[3]);
    }

    public static string ReadIp(byte[] bytes, int start)
    {
        if (bytes == null)
        {
            throw new Exception("bytes is null");
        }
        if (start < 0)
        {
            throw new Exception("start less than 0");
        }
        if (bytes.Length < start + 4)
        {
            throw new Exception("bytes length less then that start plus size");
        }
        return string.Format("{0}.{1}.{2}.{3}", bytes[start], bytes[start + 1], bytes[start + 2], bytes[start + 3]);
    }

    [Obsolete]
    public static void WriteInt16ToBytes(byte[] bytes, int start, short val)
    {
        if (bytes == null)
        {
            throw new Exception("bytes is null");
        }
        if (start < 0)
        {
            throw new Exception("start less than 0");
        }

        int size = 2;

        if (bytes.Length < start + size)
        {
            throw new Exception("bytes length less then that start plus size");
        }

        bytes[start] = (byte)(val & 0xff);
        bytes[start + 1] = (byte)(val >> 8 & 0xff);
    }

    [Obsolete]
    public static void WriteInt32ToBytes(byte[] bytes, int start, int val)
    {
        if (bytes == null)
        {
            throw new Exception("bytes is null");
        }
        if (start < 0)
        {
            throw new Exception("start less than 0");
        }

        int size = 4;

        if (bytes.Length < start + size)
        {
            throw new Exception("bytes length less then that start plus size");
        }

        bytes[start] = (byte)(val & 0xff);
        bytes[start + 1] = (byte)(val >> 8 & 0xff);
        bytes[start + 2] = (byte)(val >> 16 & 0xff);
        bytes[start + 3] = (byte)(val >> 24 & 0xff);
    }

    [Obsolete]
    public static void WriteInt64ToBytes(byte[] bytes, int start, long val)
    {
        if (bytes == null)
        {
            throw new Exception("bytes is null");
        }
        if (start < 0)
        {
            throw new Exception("start less than 0");
        }

        int size = 8;

        if (bytes.Length < start + size)
        {
            throw new Exception("bytes length less then that start plus size");
        }

        bytes[start] = (byte)(val & 0xff);
        bytes[start + 1] = (byte)(val >> 8 & 0xff);
        bytes[start + 2] = (byte)(val >> 16 & 0xff);
        bytes[start + 3] = (byte)(val >> 24 & 0xff);
        bytes[start + 4] = (byte)(val >> 32 & 0xff);
        bytes[start + 5] = (byte)(val >> 40 & 0xff);
        bytes[start + 6] = (byte)(val >> 48 & 0xff);
        bytes[start + 7] = (byte)(val >> 56 & 0xff);
    }

    [Obsolete]
    public static void WriteInt64To5Bytes(byte[] bytes, int start, long val)
    {
        if (bytes == null)
        {
            throw new Exception("bytes is null");
        }
        if (start < 0)
        {
            throw new Exception("start less than 0");
        }

        int size = 5;

        if (bytes.Length < start + size)
        {
            throw new Exception("bytes length less then that start plus size");
        }

        bytes[start] = (byte)(val & 0xff);
        bytes[start + 1] = (byte)(val >> 8 & 0xff);
        bytes[start + 2] = (byte)(val >> 16 & 0xff);
        bytes[start + 3] = (byte)(val >> 24 & 0xff);
        bytes[start + 4] = (byte)(val >> 32 & 0xff);
        //bytes[start + 5] = (byte)(val >> 40 & 0xff);
        //bytes[start + 6] = (byte)(val >> 48 & 0xff);
        //bytes[start + 7] = (byte)(val >> 56 & 0xff);
    }

    [Obsolete]
    public static void WriteUInt16ToBytes(byte[] bytes, int start, ushort val)
    {
        if (bytes == null)
        {
            throw new Exception("bytes is null");
        }
        if (start < 0)
        {
            throw new Exception("start less than 0");
        }

        int size = 2;

        if (bytes.Length < start + size)
        {
            throw new Exception("bytes length less then that start plus size");
        }

        //bytes[start] = (byte)(val & 0x11);
        //bytes[start + 1] = (byte)((val & 0x1100) >> 8);

        bytes[start] = (byte)(0xff & val);
        bytes[start + 1] = (byte)((0xff00 & val) >> 8);
    }

    [Obsolete]
    public static void WriteUInt32ToBytes(byte[] bytes, int start, uint val)
    {
        if (bytes == null)
        {
            throw new Exception("bytes is null");
        }
        if (start < 0)
        {
            throw new Exception("start less than 0");
        }

        int size = 4;

        if (bytes.Length < start + size)
        {
            throw new Exception("bytes length less then that start plus size");
        }

        bytes[start] = (byte)(val & 0xff);
        bytes[start + 1] = (byte)(val >> 8 & 0xff);
        bytes[start + 2] = (byte)(val >> 16 & 0xff);
        bytes[start + 3] = (byte)(val >> 24 & 0xff);

    }

    [Obsolete]
    public static void WriteUInt64ToBytes(byte[] bytes, int start, ulong val)
    {
        if (bytes == null)
        {
            throw new Exception("bytes is null");
        }
        if (start < 0)
        {
            throw new Exception("start less than 0");
        }

        int size = 8;

        if (bytes.Length < start + size)
        {
            throw new Exception("bytes length less then that start plus size");
        }

        bytes[start] = (byte)(val & 0xff);
        bytes[start + 1] = (byte)(val >> 8 & 0xff);
        bytes[start + 2] = (byte)(val >> 16 & 0xff);
        bytes[start + 3] = (byte)(val >> 24 & 0xff);
        bytes[start + 4] = (byte)(val >> 32 & 0xff);
        bytes[start + 5] = (byte)(val >> 40 & 0xff);
        bytes[start + 6] = (byte)(val >> 48 & 0xff);
        bytes[start + 7] = (byte)(val >> 56 & 0xff);
    }

    public static int WriteAsc2Bytes(byte[] bytes, int start, string str)
    {
        if (bytes == null)
        {
            throw new Exception("bytes is null");
        }
        if (start < 0)
        {
            throw new Exception("start less than 0");
        }

        int size = str.Length;

        if (bytes.Length < start + size)
        {
            throw new Exception("bytes length less then that start plus size");
        }

        for (int i = 0; i < str.Length; i++)
        {
            try
            {
                bytes[start + i] = Convert.ToByte(str[i]);
            }
            catch (Exception ex)
            {
                ExceptionUtil.WriteLog(ex);
                DebugUtil.WriteLog("错误字符" + str[i]);
            }
        }

        return start + size;
    }
}
时间： 2024-03-01 03:55:48

对象、字节流转换的相关文章

将字节流转换成字符流

readLine方法是字符流BufferedReader类中的方法 键盘read方法是字节流InputStream的方法. 能不能将字节流转换成字符流,在使用字符流缓冲区的readLine方法? InpuStream in = System.in; //将字节流对象转换成字符流 InputStreamReader isr = new InputStreamReader(in); //使用字符流的缓冲区,用于提高效率 BufferedReader bufr = new BufferedReader

jQuery对象与dom对象的转换

jQuery对象与dom对象的转换只有jquery对象才能使用jquery定义的方法.注意dom对象和jquery对象是有区别的,调用方法时要注意操作的是dom对象还是 jquery对象.普通的dom对象一般可以通过$()转换成jquery对象.如:$(document.getElementByIdx_x("msg"))则为jquery对象,可以使用jquery的方法.由于jquery对象本身是一个集合.所以如果jquery对象要转换为dom对象则必须取出其中的某一项,一般可通过索引取

Json对象与Json字符串的转化、JSON字符串与Java对象的转换

Json对象与Json字符串的转化.JSON字符串与Java对象的转换 一.Json对象与Json字符串的转化 1.jQuery插件支持的转换方式: $.parseJSON( jsonstr ); //jQuery.parseJSON(jsonstr),可以将json字符串转换成json对象 2.浏览器支持的转换方式(Firefox,chrome,opera,safari,ie9,ie8)等浏览器: JSON.stringify(obj)将JSON转为字符串.JSON.parse(string)

jQuery对象与dom对象的转换-$(&#39;#id)[0]

取原生态的DOM对象,因为jquery会把选择器匹配的dom对象存放在以$.fn.init为构造函数生成对象的泛型数组里. 一直以来对于通过jQuery方式获取的对象使不能直接使用JavaScript的一些方法的,开始的时候不理解,现在此案知道,原来jQuery获得的对象并不和我们平时使用getElementById获得的对象是一样的对象.所以一些新手就很迷惑,为什么${"#Element"}不能直接innerHTML,这就是原因所在,解决方式请看下文.jQuery对象与dom对象的转

php 对象强制转换成数组

$result=(array)$receive[0]; //对象强制转换成数组 foreach ($result as $key => $value) { $newresult[$key]=array((array)$value); } var_dump($newresult); exit();

黑马程序员_JavaScript变量转换和Jquery对象的转换

在实际编程过程中,有很多对字符串进行判断.拆分.比较.转换类型.校验等操作,下面我会总结下JavaScript变量转换和Jquery对象的转换. 1.JavaScript 变量转换及字符串操作 1.字符串变成int类型 使用函数:parseInt(); 使用此函数,可将string类型变量转换为int类型.而且只能够对string类型变量使用.如果待转换string类型变量无发转换为int类型时,函数会返回NaN. 实例如下: var v_Num = parseInt('256ok'); //

JSON字符串与java对象的转换

所需的jar包: 1.commons-lang.jar 2.commons-beanutils.jar 3.commons-collections.jar 4.commons-logging.jar 5.ezmorph.jar 6.json-lib-2.2.2-jdk15.jar 1. 把java 对象列表转换为json对象数组,并转为字符串 JSONArray array = JSONArray.fromObject(userlist); String jsonstr = array.toSt

jQuery介绍 DOM对象和jQuery对象的转换与区别

jQuery介绍 DOM对象和jQuery对象的转换与区别 jQuery介绍 jQuery: http://jquery.com/ write less, do more. jQuery Hello World程序 <script type=“text/javascript” src=“xxx//jquery-x.y.z.js"> 引入jQuery.存在两个版本,jquery-x.y.z.min.js是精简压缩版,不带min的是开发版,代码中的注释和缩进等都被保留了. 注意路径中的”

转：jQuery对象与dom对象的转换

jQuery对象与dom对象的转换 发布时间:September 20, 2007 分类:JavaScript <新站上线的手记> <Discuz!多附件上传选择框之jQuery版> 最近在闲暇时间用jQuery搞了一个多文件上传的东东,顺便写点笔记. 一直以来对于通过jQuery方式获取的对象使不能直接使用JavaScript的一些方法的,开始的时候不理解,现在此案知道,原来jQuery获得的对象并不和我们平时使用getElementById获得的对象是一样的对象.所以一些新手就

json字符串和json格式对象的转换

json字符串和json格式对象的转换: 实际编码中json字符串和json格式的对象有时候需要进行相互转换,下面就介绍一下如何实现. 一.jQuery插件支持的转换方式: $.parseJSON( jsonstr ); 以上代码可以将json字符串转换为json格式对象. 二.浏览器支持的转换方式: JSON.parse(jsonstr); //可以将json字符串转换成json对象 JSON.stringify(jsonobj); //可以将json对象转换成json对符串 注意:ie7和i