Qual è l'equivalente di “ByteBuffer.flip” & “ByteBuffer.slice” in .NET?

Question

Ho bisogno di codice del porto da Java a C #. Nel codice Java, i metodi "ByteBuffer.flip ()" e "ByteBuffer.slice" è usato, e non so come tradurre questo.

Ho letto questa domanda ( un equivalente di javax .nio.Buffer.flip () in C # ), ma anche se viene data una risposta, non posso capire come applicare. Secondo Tom Hawtin, devo "Impostare il limite alla posizione corrente e quindi impostare la posizione a zero" nella matrice sottostante. Sono incerto quanto di come cambiare questi valori. (Se si potesse spiegare la logica sottostante, mi avrebbe aiutato molto:)

Per quanto riguarda il ByteBuffer.slice, non ho idea su come tradurlo.

EDIT: Se può essere più chiaro con il codice vero e proprio, vi posterò che:

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);

Finora, la mia traduzione in 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

Grazie!

EDIT:. Cambiato b.BaseStream.SetLength(b.BaseStream.Length); a b.BaseStream.SetLength(b.BaseStream.Position);, sulla base dei documenti Java

Answer 1

(vedere vedere http://java.sun.com/javase/6/docs/api/java/nio/ByteBuffer.html#slice%28%29 e http://java.sun.com/javase/6/docs/api/java/ NIO / Buffer.html # capovolgere% 28% 29 per le chiamate di Java)

Flip è un modo rapido per ripristinare il buffer. Così, per esempio (Pseudocodice)

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

Permette di impostare rapidamente il buffer si presumibilmente appena scritto per per la lettura fin dall'inizio.

Aggiornamento: Splice è un po 'più complicato a causa del requisito che "modifiche ai contenuti del buffer di questa saranno visibili nel nuovo buffer, e viceversa; posizione delle due buffers', limitare e contrassegnare i valori saranno indipendenti". Sfortunatamente non c'è il concetto di una parte condivisa di tampone (che io sappia - c'è sempre utilizzando gli array, illustrati qui di seguito) senza fare la propria classe. La cosa più vicina che potreste fare è questo:

vecchio Codice:

ByteBuffer b = buff.slice();

Nuovo Codice (assumendo una lista)

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

L'aspetto negativo di codice di cui sopra è che non esiste un modo per C # per tenere il nuovo punto di partenza del nuovo buffer ed ancora condividerlo. Dovrete usare manualmente il nuovo punto di partenza ogni volta di fare qualsiasi cosa, da cicli for (i = per BAvviare; ...) per l'indicizzazione (newList [i + BAvviare] ...)

L'altra opzione è quella di fare uso byte [] array, invece, e fare qualcosa di simile a questo:

Byte[] b = &buff[buffPos];

... tuttavia, che richiede operazioni non sicure da abilitare, e non posso garantire per la sua saftey, a causa del garbage collector e la mia evasione delle caratteristiche "non sicuri".

Al di fuori di questo, c'è sempre fare la propria classe ByteBuffer.

Answer 2

Non testato, ma se ho capito bene i bit java, questo darebbe un'idea su come implementare.

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);
    }
}