c# - para - simplificacion de fracciones algebraicas

¿Cómo se puede simplificar la conversión de orden de bytes de red desde un BinaryReader?

Question

System.IO.BinaryReader lee valores en un formato little-endian.

Tengo una aplicación C # que se conecta a una biblioteca de red propietaria en el lado del servidor. El lado del servidor envía todo en orden de bytes de red, como era de esperar, pero me parece que lidiar con esto en el lado del cliente es incómodo, particularmente para los valores sin firmar.

UInt32 length = (UInt32)IPAddress.NetworkToHostOrder(reader.ReadInt32());

es la única forma en que me he encontrado para obtener un valor correcto sin signo de la transmisión, pero parece incómodo y desagradable, y aún no he probado si eso va a cortar los valores de orden superior para que yo tenga para hacer cosas divertidas con BitConverter.

¿Hay alguna manera en la que me falte escribir un borrador sobre todo para evitar estas feas conversiones en cada lectura? Parece que debería haber una opción de endianidad en el lector para simplificar cosas así, pero no he encontrado nada.

Answer 1

Construí un BinaryReader personalizado para manejar todo esto. Está disponible como parte de mi biblioteca Nextem . También tiene una forma muy fácil de definir estructuras binarias, lo que creo que te ayudará aquí; consulta los ejemplos.

Nota: Está solo en SVN en este momento, pero es muy estable. Si tiene alguna pregunta, envíeme un correo electrónico a cody_dot_brocious_at_gmail_dot_com.

Answer 2

No hay un convertidor incorporado. Aquí está mi envoltorio (como pueden ver, solo implementé la funcionalidad que necesitaba pero la estructura es bastante fácil de cambiar a su gusto):

/// <summary>
/// Utilities for reading big-endian files
/// </summary>
public class BigEndianReader
{
    public BigEndianReader(BinaryReader baseReader)
    {
        mBaseReader = baseReader;
    }

    public short ReadInt16()
    {
        return BitConverter.ToInt16(ReadBigEndianBytes(2), 0);
    }

    public ushort ReadUInt16()
    {
        return BitConverter.ToUInt16(ReadBigEndianBytes(2), 0);
    }

    public uint ReadUInt32()
    {
        return BitConverter.ToUInt32(ReadBigEndianBytes(4), 0);
    }

    public byte[] ReadBigEndianBytes(int count)
    {
        byte[] bytes = new byte[count];
        for (int i = count - 1; i >= 0; i--)
            bytes[i] = mBaseReader.ReadByte();

        return bytes;
    }

    public byte[] ReadBytes(int count)
    {
        return mBaseReader.ReadBytes(count);
    }

    public void Close()
    {
        mBaseReader.Close();
    }

    public Stream BaseStream
    {
        get { return mBaseReader.BaseStream;  }
    }

    private BinaryReader mBaseReader;
}

Básicamente, ReadBigEndianBytes hace que el ronco funcione, y esto se pasa a BitConverter. Habrá un problema definido si lee una gran cantidad de bytes, ya que esto provocará una gran asignación de memoria.