Au niveau du bit endian swap de différents types
Avec l'aide de diverses sources, j'ai écrit quelques SwapBytes
méthodes dans mon binaire classe de lecteur que swap-boutiste dans ushort
, uint
, et ulong
, tout en utilisant des opérations bit à bit tout en raw, C#, sans avoir besoin de unsafe
code.
public ushort SwapBytes(ushort x)
{
return (ushort)((ushort)((x & 0xff) << 8) | ((x >> 8) & 0xff));
}
public uint SwapBytes(uint x)
{
return ((x & 0x000000ff) << 24) +
((x & 0x0000ff00) << 8) +
((x & 0x00ff0000) >> 8) +
((x & 0xff000000) >> 24);
}
public ulong SwapBytes(ulong value)
{
ulong uvalue = value;
ulong swapped =
((0x00000000000000FF) & (uvalue >> 56)
| (0x000000000000FF00) & (uvalue >> 40)
| (0x0000000000FF0000) & (uvalue >> 24)
| (0x00000000FF000000) & (uvalue >> 8)
| (0x000000FF00000000) & (uvalue << 8)
| (0x0000FF0000000000) & (uvalue << 24)
| (0x00FF000000000000) & (uvalue << 40)
| (0xFF00000000000000) & (uvalue << 56));
return swapped;
}
Comment pourrais-je aller sur la création de la même méthode, mais pour les versions signées de chacun de ces types, tels que le short, int et long, en Utilisant les mêmes méthodes que ci-dessus, et quelles améliorations pourraient être apportées aux méthodes ci-dessus?
- Pourquoi avez-vous besoin de swap en premier lieu? Ne pourrait-on pas lire directement à l'aide souhaitée endianness à partir du tableau d'octets d'entrée? Dans mon expérience qui conduit à la plus rapide, la plus facile à lire et plus facile à un code de test.
Vous devez vous connecter pour publier un commentaire.
Au lieu de conceptuellement la déconstruction de séparer les octets et les réassembler ensuite dans l'autre sens, vous pouvez conceptuellement swap groupes d'octets, comme ceci: (pas testé)
N'aide pas beaucoup (ou pas du tout) pour 32 bits, mais pour le 64 bits c'est le cas (pas testé)
Pour les types signés, les jeter non signé, le faire, puis jeté en arrière.
Vous devriez jeter un oeil à msdn à l'adresse suivante page : http://msdn.microsoft.com/en-us/library/system.bitconverter.aspx
Vous suffit d'utiliser la Matrice.Inverse et bitConverter:
BitConverter
utilise natif endianness, est lent et leArray.Reverse
spams inutiles instance rendant encore plus lent.Il suffit d'ajouter une fonte non signé au départ et retour à signé à la fin.
Il pourrait être nécessaire d'manuellement inline l'appel à
SwapBytes
pour la performance maximale.Sur une note différente, vous voudrez peut-être éviter de permutation, en faveur d'une lecture directe de données à partir de l'original du tableau d'octets dans la boutisme. Voir Moyen efficace pour lire big endian de données en C# pour plus de détails.
C'est probablement la méthode la plus simple et la manière paresseuse pour remplacer les bits d'un entier: