Comment les champs de bits peuvent-ils être implémentés en C# pour obtenir une utilisation efficace de la mémoire ?

Champs de bits en C#

Les champs de bits sont une structure de données en C qui permet à l'utilisateur de définir une structure avec des champs qui occupent un nombre spécifié de morceaux. Cela peut être utile lorsque vous travaillez avec une mémoire limitée ou lorsque les données stockées sont conformes à un modèle de bits spécifique.

Dans l'exemple fourni, l'utilisateur dispose d'une structure avec plusieurs champs de bits :

• réservé (2 bits)
• scrambling_control (2 bits)
• priorité (1 bit)
• data_alignment_indicator (1 bit)
• copyright (1 bit)
• original_or_copy (1 bit)

Pour accéder aux bits individuels dans un champ de bits en C#, l'opérateur point peut être utilisé. Cependant, il n'existe pas d'équivalent direct à la syntaxe utilisée en C en C# pour définir les champs de bits.

Une solution possible consiste à utiliser des attributs pour spécifier la longueur de chaque champ de bits, puis à écrire une classe de conversion capable de convertir la structure à une primitive de champ de bits. Cela peut être fait comme suit :

using System;

namespace BitfieldTest
{
    [global::System.AttributeUsage(AttributeTargets.Field, AllowMultiple = false)]
    sealed class BitfieldLengthAttribute : Attribute
    {
        uint length;

        public BitfieldLengthAttribute(uint length)
        {
            this.length = length;
        }

        public uint Length { get { return length; } }
    }

    static class PrimitiveConversion
    {
        public static long ToLong<T>(T t) where T : struct
        {
            long r = 0;
            int offset = 0;

            // For every field suitably attributed with a BitfieldLength
            foreach (System.Reflection.FieldInfo f in t.GetType().GetFields())
            {
                object[] attrs = f.GetCustomAttributes(typeof(BitfieldLengthAttribute), false);
                if (attrs.Length == 1)
                {
                    uint fieldLength = ((BitfieldLengthAttribute)attrs[0]).Length;

                    // Calculate a bitmask of the desired length
                    long mask = 0;
                    for (int i = 0; i < fieldLength; i++)
                        mask |= 1 << i;

                    r |= ((UInt32)f.GetValue(t) & mask) << offset;

                    offset += (int)fieldLength;
                }
            }

            return r;
        }
    }

    struct PESHeader
    {
        [BitfieldLength(2)]
        public uint reserved;
        [BitfieldLength(2)]
        public uint scrambling_control;
        [BitfieldLength(1)]
        public uint priority;
        [BitfieldLength(1)]
        public uint data_alignment_indicator;
        [BitfieldLength(1)]
        public uint copyright;
        [BitfieldLength(1)]
        public uint original_or_copy;
    };

    public class MainClass
    {
        public static void Main(string[] args)
        {
            PESHeader p = new PESHeader();

            p.reserved = 3;
            p.scrambling_control = 2;
            p.data_alignment_indicator = 1;

            long l = PrimitiveConversion.ToLong(p);


            for (int i = 63; i >= 0; i--)
            {
                Console.Write(((l & (1l << i)) > 0) ? "1" : "0");
            }

            Console.WriteLine();

            return;
        }
    }
}

Ce code produira le résultat attendu de 000101011. Cette solution est réutilisable et permet une maintenance facile des structures avec des champs de bits.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!