コード例 #1
0
        /// <summary>
        /// Genera un TCP SocketManager del array de bytes de los datos solicitados
        /// </summary>
        /// <param name="codec">Codec para la obtención</param>
        /// <param name="stream">Stream</param>
        /// <returns>Devuelve la clase TCPSocketMsgManager</returns>
        public static IXPloitSocketMsg Deserialize(Encoding codec, Stream stream)
        {
            List <IXploitMsgHeader> headers = new List <IXploitMsgHeader>();
            byte nheaders = (byte)stream.ReadByte();
            byte type;
            SerializableJSONReference tp;

            if (nheaders > 0)
            {
                // Read headers

                byte[] bl = new byte[3];
                for (int x = 0; x < nheaders; x++)
                {
                    // Read header Length
                    stream.Read(bl, 0, 3);
                    type = bl[2];

                    byte[] data = new byte[BitConverterHelper.ToUInt16(bl, 0) - 1];
                    stream.Read(data, 0, data.Length);

                    if (!_CacheHeaders.TryGetValue(type, out tp))
                    {
                        //no está en cache
                        EXPloitSocketMsgHeader e = (EXPloitSocketMsgHeader)type;
                        tp = e.GetAttribute <SerializableJSONReference>();
                        lock (_CacheHeaders)
                        {
                            _CacheHeaders.Add(type, tp);
                        }
                    }

                    headers.Add(tp.Deserialize <IXploitMsgHeader>(tp.Type, codec, data, 0, data.Length));
                }
            }

            type = (byte)stream.ReadByte();

            if (!_Cache.TryGetValue(type, out tp))
            {
                //no está en cache
                EXPloitSocketMsg e = (EXPloitSocketMsg)type;
                tp = e.GetAttribute <SerializableJSONReference>();
                lock (_Cache)
                {
                    _Cache.Add(type, tp);
                }
            }

            IXPloitSocketMsg ret = tp.Deserialize <IXPloitSocketMsg>(tp.Type, codec, stream);

            if (nheaders > 0)
            {
                ret.Headers.AddRange(headers);
            }
            return(ret);
        }
コード例 #2
0
        /// <summary>
        /// Obtiene el array de bytes de la clase actual
        /// </summary>
        /// <param name="codec">Codec para la obtención</param>
        /// <param name="header">Cabecera del mensaje</param>
        /// <returns>Devuelve el Array de Bytes de la clase actual</returns>
        public byte[] Serialize(Encoding codec, byte[] header)
        {
            SerializableJSONReference tp;
            EXPloitSocketMsg          type = this.Type;

            if (header == null)
            {
                header = new byte[1];
            }
            else
            {
                Array.Resize(ref header, header.Length + 1);
            }

            if (Headers.HaveValidHeaders)
            {
                // Headers length
                byte hay = (byte)Headers.Count;
                header[header.Length - 1] = hay;

                // Headers
                int           l   = 0;
                List <byte[]> ret = new List <byte[]>();
                foreach (IXploitMsgHeader h in Headers)
                {
                    SerializableJSONReference tp2;
                    EXPloitSocketMsgHeader    type2 = h.Type;

                    // Message
                    if (!_CacheHeaders.TryGetValue((byte)type2, out tp2))
                    {
                        //no está en cache
                        tp2 = type2.GetAttribute <SerializableJSONReference>();
                        lock (_CacheHeaders) { _CacheHeaders.Add((byte)type2, tp2); }
                    }

                    byte[] data = tp2.Serialize(codec, (byte)type2, h, null);
                    ret.Add(data);
                    l += data.Length;
                }

                int x = header.Length;
                Array.Resize(ref header, x + l + (hay * 2));

                foreach (byte[] b in ret)
                {
                    ushort lb = (ushort)b.Length;

                    byte[] bl = BitConverterHelper.GetBytesUInt16(lb);
                    Array.Copy(bl, 0, header, x, 2);
                    x += 2;

                    Array.Copy(b, 0, header, x, lb);
                    x += lb;
                }
                ret.Clear();
            }

            // Message
            if (!_Cache.TryGetValue((byte)type, out tp))
            {
                //no está en cache
                tp = type.GetAttribute <SerializableJSONReference>();
                lock (_Cache) { _Cache.Add((byte)type, tp); }
            }

            return(tp.Serialize(codec, (byte)type, this, header));
        }