Quel est l'équivalent de "ByteBuffer.flip" & "ByteBuffer.slice" dans .NET?

Question

J'ai besoin de porter le code de Java en C#. Dans le code Java, les méthodes "ByteBuffer.flip()" et "ByteBuffer.slice" sont utilisées, et je ne sais pas comment traduire cela.

J'ai lu cette question (An equivalent of javax.nio.Buffer.flip() in c#), mais même si une réponse est donnée, je n'arrive pas à comprendre comment l'appliquer. Selon Tom Hawtin, je devrais "Définir la limite à la position actuelle, puis mettre la position à zéro" dans le tableau sous-jacent. Je ne suis pas sûr de la façon de changer ces valeurs. (Si vous pouviez expliquer la logique sous-jacente, cela m'aiderait beaucoup :)

Comme pour le ByteBuffer.slice, je n'ai aucune idée sur la façon de le traduire.

EDIT: S'il 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: modification de b.BaseStream.SetLength(b.BaseStream.Length); en b.BaseStream.SetLength(b.BaseStream.Position);, en fonction des documents 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#flip%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 depuis 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 les valeurs marque sera indépendant". Il n'y a malheureusement pas de concept de partie partagée de buffer (que je connaisse - utilisant toujours des tableaux, détaillés ci-dessous) sans faire votre propre classe. La chose la plus proche que vous pourriez 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# pour conserver le nouveau point de départ du nouveau tampon et le partager. Vous devrez utiliser manuellement le nouveau point de départ quand vous faites n'importe quoi, des boucles for (pour i = bStart; ...) à l'indexation (newList [i + bStart] ...)

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

Byte[] b = &buff[buffPos]; 

... mais qui nécessite des opérations dangereuses pour être activé, et je ne peux pas se porter garant pour son saftey, en raison du collecteur des ordures et mon évasion des fonctionnalités "dangereuses".En dehors de cela, il ya toujours votre propre classe ByteBuffer.

Answer 2

Non testé, mais si je comprends bien les bits java, cela vous donnera 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); 
    } 
}