C# ByteBuffer.writeBytes方法代码示例

    public override void bytesWrite(ByteBuffer data)
    {
        base.bytesWrite(data);
        if ((this._value == null) || (this._value.Length < 1))
        {
            new ErlNullList().bytesWrite(data);
        }
        else
        {
            ByteBuffer b = new ByteBuffer();
            data.writeBytes(b, 0, b.bytesAvailable);
            b.writeUTFBytes (this._value);
            if (base.isServer) {
                data.writeByte (0x6b);
                data.writeShort(b.top );
            } else {
                data.writeShort(b.top + 1);
                data.writeByte (0x6b);
            }

            data.writeBytes(b, 0, b.bytesAvailable);
        }
    }

 public override void bytesWrite(ByteBuffer data)
 {
     base.bytesWrite(data);
     if ((this._value == null) || (this._value.length() < 1))
     {
         new ErlNullList().bytesWrite(data);
     }
     else
     {
         data.writeShort(this._value.length() + 1);
         data.writeByte(0x6d);
         data.writeBytes(this._value, 0, (uint) this._value.length());
     }
 }

    public Boolean procCmd(int _port , BaseFPort fport)
    {
        if (needProcCmdDict.ContainsKey(_port)) {
            string cCmd = needProcCmdDict [_port];
            if (FilterCmdDict [cCmd]._count >= FilterCmdDict [cCmd]._beginCount) {
                String strValue = ConfigHelper.GetAppConfig (cCmd);
                ErlKVMessage msg = new ErlKVMessage ("r_ok");
                msg.addValue (null, new ErlInt (_port));
                ErlType[] et = StringKit.strToErlTypeArray (strValue);
                ErlArray ea = new ErlArray (et);
                msg.addValue ("msg", ea);
                Log.Info(msg.Cmd+"|"+ msg.toJsonString());
                ByteBuffer data = new ByteBuffer();
                //data.writeBytes (mybak);
                msg.bytesWrite(data);
                data.top = (int)data.bytesAvailable;
                byte[] tmpdata= new byte[(int)data.bytesAvailable];
                data.readBytes (tmpdata, 0, tmpdata.Length);

                fport.erlConnect.tmpBuffer.position = 0;
                Log.Info (fport.erlConnect.tmpBuffer) ;

                ByteBuffer tmp1 = new ByteBuffer();
                tmp1.writeBytes (tmpdata);
                //this.erlConnect.send (this.erlConnect.tmpBuffer);
                if (fport.erlConnect.socket.Connected) {
                    fport.send (fport.erlConnect, msg);
                } else {
                    Log.Info ("客户端已断开不再回传");
                }
                //base.erlConnect.socket.Send (bak);
                FilterCmdDict [cCmd]._count--;
                Log.Info ("处理完成的CMD[" + cCmd + "]");
                return true ;
            }

        }
        return false;
    }

 public void bytesWriteValue(ByteBuffer sc_data, object value)
 {
     ErlType type = value as ErlType;
     if (type == null)
     {
         type = new ErlNullList();
     }
     ByteBuffer data = new ByteBuffer();
     type.bytesWrite(data);
     sc_data.writeBytes(data, 0, data.bytesAvailable);
 }

 public void bytesWriteKey(ByteBuffer data, string key)
 {
     if (key != null)
     {
         byte[] b = StringKit.DefaultToUTF8Byte(key);
         data.writeByte(b.Length);
         data.writeBytes(b);
     }
     else
     {
         data.writeByte(0);
     }
 }

    public void parseMessage(ByteBuffer socketbuffer)
    {
        int num = socketbuffer.readByte ();
        bool flag = (num & 8) != 0;
        bool flag2 = (num & 4) != 0;
        bool flag3 = (num & 2) != 0;
        ByteBuffer data = new ByteBuffer (this.length - 1);
        data.write (socketbuffer.toArray (), 0, this.length - 1);
        if (base.socket.Available >= 2) {
            byte[] buffer = new byte[2];
            base.socket.Receive (buffer, SocketFlags.None);
            this.length = ByteKit.readUnsignedShort (buffer, 0);
        } else {
            this.length = 0;
        }
        if (flag) {
            data = this.encryptionCode (data, this._receiveChallengeCode);
        }
        if (flag3) {
            data = new ByteBuffer (ZIPUtil.Decompress (data.toArray ()));
        }
        if (flag2) {
            int num2 = data.readInt ();
            ByteBuffer buffer4 = new ByteBuffer ();
            buffer4.writeBytes (data.toArray (), 0, data.top - data.position);
            int num3 = (int)ChecksumUtil.Adler32 (buffer4);
            if (num2 != num3) {
                //MonoBehaviour.print(string.Concat(new object[] { "crc is err,crcValue", num2, ",nowCrc=", num3 }));
                // Log.info
                return;
            }
        }
        ErlKVMessage message = new ErlKVMessage (null);

        message.bytesRead (data);

        if (base._portHandler != null) {
            base._portHandler.erlReceive (this, message);
        }
    }

 protected override ByteBuffer createDataByHead(ByteBuffer head)
 {
     ByteBuffer buffer = new ByteBuffer ();
     int b = (((0 | (this._encryption << 3)) | (this._crc << 2)) | (this._compress << 1)) | this._kv;
     buffer.writeShort (head.length () + 1);
     buffer.writeByte (b);
     buffer.writeBytes (head.toArray ());
     return buffer;
 }

    public void TransParseMessage(ByteBuffer socketbuffer , bool isServer , ByteBuffer src)
    {
        try{
        int num = socketbuffer.readByte ();
        bool flag = (num & 8) != 0;
        bool flag2 = (num & 4) != 0;
        bool flag3 = (num & 2) != 0;
        ByteBuffer data = new ByteBuffer (this.length - 1);
        data.write (socketbuffer.toArray (), 0, this.length - 1);
        if ((this.dataBuffer.bytesAvailable) >= 2) {
            byte[] buffer = new byte[2];
            //base.socket.Receive (buffer, SocketFlags.None);
            this.dataBuffer.readBytes(buffer,0,2);
            this.length = ByteKit.readUnsignedShort (buffer, 0);

        } else {
            this.length = 0;
        }
        if (flag) {
            if (this.isServer) {
                data = this.encryptionCode (data, this._sendChallengeCode);
            } else {
                data = this.encryptionCode (data, this._receiveChallengeCode);
            }
        }
        if (flag3) {
            data = new ByteBuffer (ZIPUtil.Decompress (data.toArray ()));
        }
        if (flag2) {
            int num2 = data.readInt ();
            ByteBuffer buffer4 = new ByteBuffer ();
            buffer4.writeBytes (data.toArray (), 0, (int)data.bytesAvailable);
            int num3 = (int)ChecksumUtil.Adler32 (buffer4);
            if (num2 != num3) {
                Log.Error(string.Concat(new object[] { "crc is err,crcValue", num2, ",nowCrc=", num3 }));
                // Log.info
                //if (this.transCallBack != null) {
                //	this.transCallBack.Invoke ();
            //	}
                    int len = (int)this.dataBuffer.bytesAvailable;
                    int pos = this.dataBuffer.position;

                    byte[] tmp = new byte[len];
                    byte[] bak = new byte[pos];

                    this.dataBuffer.position = 0;
                    this.dataBuffer.readBytes (bak, 0, pos);
                    this.dataBuffer.readBytes (tmp, 0, len);
                    this.dataBuffer.clear ();
                    this.dataBuffer = new ByteBuffer (tmp);
                    if(!this.isServer){
                        base.socket.Send (bak);}

                    if (this.dataBuffer.bytesAvailable > 0) {
                        this.TransReceive (null, this.isServer);
                    }

                return;
            }
        }

            ErlKVMessage message = new ErlKVMessage (null);
            this.tmpBuffer = data;
            message.bytesRead (data);
            Log.Debug(string.Concat( data.getArray())+"++++++");
            this.myLen = this.dataBuffer.top;

            if (base._portHandler != null) {
                base._portHandler.erlReceive (this, message);

        }
        }
        catch(Exception e) {
            Log.Error (e.Message);
            if (this.dataBuffer.bytesAvailable > 0) {
                this.TransReceive (null, this.isServer);
            } else {
                int len = (int)this.dataBuffer.bytesAvailable;
                int pos = this.dataBuffer.position;

                byte[] tmp = new byte[len];
                byte[] bak = new byte[pos];

                this.dataBuffer.position = 0;
                this.dataBuffer.readBytes (bak, 0, pos);
                this.dataBuffer.readBytes (tmp, 0, len);
                this.dataBuffer.clear ();
                this.dataBuffer = new ByteBuffer (tmp);
                if (!this.isServer) {
                    base.socket.Send (bak);
                }

                if (this.dataBuffer.bytesAvailable > 0) {
                    this.TransReceive (null, this.isServer);
                }

            }
        }
    }

    public void sendErl(ByteBuffer data, int encryption, int crc, int compress, int kv)
    {
        if ((this._sendChallengeCode != null) && (this._sendChallengeCode.Length >= 0)) {
            this._encryption = encryption;
            this._crc = crc;
            this._compress = compress;
            this._kv = kv;
            int i = 0;
            ByteBuffer buffer = new ByteBuffer ();
            if ((this._compress == 1) && (data.length () >= 0x40)) {
                data = new ByteBuffer (ZIPUtil.Compress (data.toArray ()));
            } else {
                this._compress = 0;
            }
            if ((this._crc == 1) && (this._compress == 0)) {
                i = (int)ChecksumUtil.Adler32 (data);
                buffer.writeInt (i);
            } else {
                this._crc = 0;
            }
            buffer.writeBytes (data.toArray ());
            if (this._encryption == 1) {
                if (!this.isServer) {
                    buffer = this.encryptionCode (buffer, this._receiveChallengeCode);
                    /*string code = "";
                    foreach(int sc in this._receiveChallengeCode)
                    {
                        code = code + sc ;
                    }
                    //Log.Info("---this._receiveChallengeCode="+ code);
                     */
                } else {
                    buffer = this.encryptionCode (buffer, this._sendChallengeCode);
                    /*string code = "";
                    foreach(int sc in this._sendChallengeCode)
                    {
                        code = code + sc ;
                    }
                    Log.Info("---this._sendChallengeCode="+ code);
                     */
                }

                //buffer = this.encryptionCode (buffer, this._receiveChallengeCode);
            }
            base.send (buffer);
            //Log.Info(string.Concat(buffer.getArray()));
            this._encryption = 1;
            this._crc = 1;
            this._compress = 1;
            this._kv = 1;
        }
    }

    public void bytesWriteValue(ByteBuffer sc_data, object value)
    {
        ErlType type = value as ErlType;
        if (type == null)
        {
            type = new ErlNullList();
        }
        ByteBuffer data = new ByteBuffer();

        if (type.GetType ().ToString () == "ErlArray"||type.GetType ().ToString () == "ErlAtom") {
            data.writeByte ((byte)0x83);
            Log.Info (type.GetType ().ToString ());
            type.bytesWriteServer (data);
            sc_data.writeByte (0);
            sc_data.writeByte ((byte)data.bytesAvailable);
            sc_data.writeBytes (data, 0, data.bytesAvailable);
        } else {
            type.bytesWrite (data);
            sc_data.writeBytes (data, 0, data.bytesAvailable);
        }
    }

 protected virtual ByteBuffer createDataByHead(ByteBuffer body)
 {
     int len = body.length();
     ByteBuffer data = new ByteBuffer();
     ByteKit.writeLength(data, len);
     data.writeBytes(body.toArray());
     return data;
 }