Quel est l'équivalent de « ByteBuffer.flip » et « ByteBuffer.slice » dans .NET?

Question

Je dois le code du port de Java à C #. Dans le code Java, les méthodes « ByteBuffer.flip () » et « ByteBuffer.slice » est utilisé, et je ne sais pas comment traduire cela.

J'ai lu cette question ( Un équivalent de javax .nio.Buffer.flip () en C # ), mais bien une réponse est donnée, je ne peux pas comprendre comment l'appliquer. Selon Tom Hawtin, je « Régler la limite à la position actuelle et définir la position à zéro » dans le tableau sous-jacent. Je ne suis pas sûr que la façon de modifier ces valeurs. (Si vous pouviez expliquer la logique sous-jacente, cela me aiderait beaucoup:)

Quant au ByteBuffer.slice, je n'ai pas la moindre idée sur la façon de le traduire.

EDIT: Si elle peut être plus clair avec le code actuel, je vais le poster:

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

Jusqu'à présent, ma traduction 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

Merci!

EDIT:. Changé b.BaseStream.SetLength(b.BaseStream.Length); à b.BaseStream.SetLength(b.BaseStream.Position);, sur la base des docs Java

Answer 1

(Voir Voir http://java.sun.com/javase/6/docs/api/java/nio/ByteBuffer.html#slice%28%29 et http://java.sun.com/javase/6/docs/api/java/ nio / Buffer.html # chiquenaude% 28% 29 pour les appels de java)

Flip est un moyen rapide pour réinitialiser le tampon. Ainsi, par exemple (Pseudocode)

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

vous permet de configurer rapidement le tampon que vous venez d'écrire sans doute à la lecture pour le début.

Mise à jour: Splice est un peu plus compliqué en raison de l'exigence que « modifications apportées au contenu de ce tampon seront visibles dans le nouveau tampon, et vice-versa, les deux tampons de position, limite, et marquer les valeurs seront indépendants ». Il n'y a malheureusement pas de concept d'une partie commune de tampon (que je connais - Theres toujours à l'aide de tableaux, détaillés ci-dessous) sans faire votre propre classe. La chose la plus proche que vous pouvez faire est la suivante:

ancien Code:

ByteBuffer b = buff.slice();

Nouveau code (en supposant une liste)

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

l'inconvénient du code ci-dessus est qu'il n'y a aucun moyen pour c # de tenir le nouveau point de départ du nouveau tampon et partager encore. Vous devrez utiliser manuellement le nouveau point de départ à chaque fois que vous faites quoi que ce soit, à partir de boucles (pour i = bDEBUT, ...) à l'indexation (newList [i + bDEBUT] ...)

Votre autre option est de faire usage Byte [] tableaux à la place, et faire quelque chose comme ceci:

Byte[] b = &buff[buffPos];

... mais qui nécessite des opérations dangereuses à activer, et je ne peux pas se porter garant pour son saftey, en raison du garbage collector et mon éviter les caractéristiques « dangereuses ».

En dehors de cela, Theres toujours faire votre propre classe ByteBuffer.

Answer 2

Non testé, mais si je comprends correctement les bits de Java, cela vous donne une idée sur la façon de mettre en œuvre.

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