¿Cuál es el equivalente de “ByteBuffer.flip” y “ByteBuffer.slice” en .NET?

Question

Necesito código de puerto de Java a C #. En el código de Java, los métodos "ByteBuffer.flip ()" y "ByteBuffer.slice" se utiliza, y no sé cómo traducir esto.

He leído esta pregunta ( un equivalente de javax .nio.Buffer.flip () en C # ), pero aunque se da una respuesta, no puedo imaginar cómo aplicarlo. De acuerdo con Tom Hawtin, que debería "Establecer el límite de la posición actual y luego ajustar la posición a cero" en la matriz subyacente. Estoy seguro de que la forma de cambiar estos valores. (Si pudiera explicar la lógica subyacente, me ayudaría mucho:)

En cuanto a la ByteBuffer.slice, no tengo idea de cómo traducirlo.

EDIT: Si puede ser más claro con el código real, lo posteo:

Java:

ByteBuffer buff;
buff.putShort((short) 0);
buff.put(customArray);
buff.flip();
buff.putShort((short) 0);
ByteBuffer b = buff.slice();

short size = (short) (customFunction(b) + 2);
buff.putShort(0, size);
buff.position(0).limit(size);

Hasta ahora, mi traducción en C # .NET:

BinaryWriter b = new BinaryWriter(); //ByteBuffer buff;
b.Write((short)0); // buff.putShort((short) 0);
b.Write(paramStream.ToArray()); // buff.put(customArray);
b.BaseStream.SetLength(b.BaseStream.Position); // buff.flip; (not sure)
b.BaseStream.Position = 0; // buff.flip; too (not sure)
b.Write((short)0); // buff.putShort((short) 0)
??? // ByteBuffer b = buff.slice();

// Not done but I can do it, short size = (short) (customFunction(b) + 2);
??? // How do I write at a particular position?
??? // buff.position(0).limit(size); I don't know how to do this

Gracias!

EDIT:. b.BaseStream.SetLength(b.BaseStream.Length); cambiado a b.BaseStream.SetLength(b.BaseStream.Position);, basado en los documentos de Java

Answer 1

(Ver Ver http://java.sun.com/javase/6/docs/api/java/nio/ByteBuffer.html#slice%28%29 y http://java.sun.com/javase/6/docs/api/java/ nio / Buffer.html # flip% 28% 29 para llamadas de Java)

Flip es una forma rápida de restablecer la memoria intermedia. Así por ejemplo (Pseudocódigo)

void flip()
{
   Length = currentPos;
   currentPos = 0;
}

Le permite configurar rápidamente el buffer que supuestamente acaba de escribir a la lectura desde el principio.

Actualización: Splice es un poco más complicado debido a la exigencia de que "Cambios en el contenido de esta memoria intermedia serán visibles en el nuevo buffer, y viceversa; la posición de los dos buffers', límite, y marca los valores serán independientes". Hay por desgracia, existe el concepto de una porción compartida de tampón (que yo sepa - siempre hay que utilizan matrices, se detalla a continuación) sin hacer que su propia clase. Lo más parecido que podría hacer es la siguiente:

Código antiguo:

ByteBuffer b = buff.slice();

Nuevo Código (suponiendo una lista)

List<Byte> b= buff;
int bStart = buffPos; // buffPos is your way of tracking your mark

la desventaja de que el código anterior es que no hay forma de C # para sostener el nuevo punto de partida de la nueva memoria intermedia y aún comparten. Vas a tener que utilizar manualmente el nuevo punto de partida cada vez que haces algo, a partir de bucles (para i = BInicie; ...) a la indexación (newList [i + BInicie] ...)

Su otra opción es hacer uso byte [] matrices lugar, y hacer algo como esto:

Byte[] b = &buff[buffPos];

... sin embargo, que requiere operaciones inseguras a estar habilitado, y no puedo dar fe de su saftey, debido al recolector de basura y mi evitación de las características "inseguros".

Fuera de eso, siempre hay hacer su propia clase ByteBuffer.

Answer 2

No probado, pero si entiendo los bits de Java correctamente, esto le dará una idea sobre cómo poner en práctica.

public class ByteBuffer {

    private int _Position;
    private int _Capacity;
    private byte[] _Buffer;

    private int _Start;


    private ByteBuffer(int capacity, int position, int start, byte[] buffer) {
        _Capacity = capacity;
        _Position = position;
        _Start = start;
        _Buffer = buffer;
    }

    public ByteBuffer(int capacity) : this(capacity, 0 , 0, new byte[capacity]) {
    }


    public void Write(byte item) {

        if (_Position >= _Capacity) {
            throw new InvalidOperationException();
        }
        _Buffer[_Start + _Position++] = item;
    }

    public byte Read() {

        if (_Position >= _Capacity) {
            throw new InvalidOperationException();
        }

        return _Buffer[_Start + _Position++];
    }

    public void Flip() {

        _Capacity = _Position;
        _Position = _Start;
    }

    public ByteBuffer Slice() {
        return new ByteBuffer(_Capacity-_Position, 0, _Position, _Buffer);
    }
}