Estructuras para Byte Arrays para enviar sockets

Question

¿Cuál es la mejor manera de obtener una matriz de bytes de una estructura para enviar a través de sockets TCP? Estoy usando .Net (VB o C #).

Answer 1

Si está utilizando C #, también puede ordenarlo en un búfer nativo, para tener un mejor control sobre la serialización.

Debería agregar el atributo apropiado a su estructura,

  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack=1)]

Entonces puede serializarlo usando:

    /// <summary>
    /// Serializes the specified object into a byte array.
    /// </summary>
    /// <param name="nativeObject">The object to serialize.</param>
    /// <returns></returns>
    public static byte[] Serialize(object obj)
    {
        Type objectType = obj.GetType();
        int objectSize = Marshal.SizeOf(obj);
        IntPtr buffer = Marshal.AllocHGlobal(objectSize);
        Marshal.StructureToPtr(obj, buffer, false);
        byte[] array = new byte[objectSize];
        Marshal.Copy(buffer, array , 0, objectSize);
        Marshal.FreeHGlobal(buffer);
        return array;
    }

Answer 2

Debería buscar Serialización . Hay varias opciones disponibles para usted, desde Protocolo Buffers (implementaciones de los usuarios SO 1º y 2º clasificados) a Xml al BinaryFormatter .

Answer 3

Si está dispuesto a cuidar el endian (para comunicarse en una red heterogénea), la única forma de hacerlo es campo por campo.

Answer 4

¿Por qué no solo usar un lector binario para llenar los campos de la estructura y leerlos nuevamente? Todo lo que necesita saber es el tamaño de los campos en la estructura y su posición en la secuencia, sin necesidad de soluciones no administradas. Aquí hay un ejemplo de un jugador de onda que escribí ...

    /// <summary>Copies header to a stream</summary>
    /// <param name="waveData">Wav data stream</param>
    /// <param name="format">WAVEFORMATEX wav format</param>
    /// <returns>Stream</returns>
    public Stream CreateStream(Stream waveData, WAVEFORMATEX format)
    {
        MemoryStream stream = new MemoryStream();
        BinaryWriter writer = new BinaryWriter(stream);

        writer.Write(System.Text.Encoding.ASCII.GetBytes("RIFF".ToCharArray()));
        writer.Write((Int32)(waveData.Length + 36)); //File length minus first 8 bytes of RIFF description
        writer.Write(System.Text.Encoding.ASCII.GetBytes("WAVEfmt ".ToCharArray()));
        writer.Write((Int32)16); //length of following chunk: 16
        writer.Write((Int16)format.wFormatTag);
        writer.Write((Int16)format.nChannels);
        writer.Write((Int32)format.nSamplesPerSec);
        writer.Write((Int32)format.nAvgBytesPerSec);
        writer.Write((Int16)format.nBlockAlign);
        writer.Write((Int16)format.wBitsPerSample);
        writer.Write(System.Text.Encoding.ASCII.GetBytes("data".ToCharArray()));
        writer.Write((Int32)waveData.Length);

        waveData.Seek(0, SeekOrigin.Begin);
        byte[] b = new byte[waveData.Length];
        waveData.Read(b, 0, (int)waveData.Length);
        writer.Write(b);
        writer.Seek(0, SeekOrigin.Begin);
        return stream;
    }

Answer 5

Debe ser más específico y decirnos su idioma.

Para muchos idiomas, hay marcos ya preparados, o incluso partes del entorno estándar del idioma, para hacer este tipo de cosas.

Answer 6

Asumo el lenguaje C ya que dices " struct "

puedes usar una función llamada

  

ssize_t write (int fd, const void * buf,   size_t count);

donde FD es el descriptor de archivo del socket el búfer es la dirección de la estructura, y el recuento es el tamaño en bytes

lo usarías como:

  

escribir (socket, & amp; struct_var, sizeof (struct_var));