Comment implémenter efficacement des champs de bits en C# à l'aide des attributs et du déréférencement de structure ?

Implémentation des champs de bits en C

Les champs de bits sont un moyen utile de regrouper plusieurs valeurs booléennes dans un seul octet ou un seul mot, permettant un stockage et une manipulation efficaces des indicateurs et d'autres données de type booléen. En C, les champs de bits sont définis à l'aide du mot-clé struct, suivi d'une série de membres de champ de bits, chacun spécifiant le nombre de bits à allouer à ce membre.

Dans cette question StackOverflow, un utilisateur s'enquiert de un moyen d'implémenter des champs de bits en C# qui permettraient d'accéder aux bits à l'aide de l'opérateur point de déréférencement de structure. La question découle de la nécessité de gérer plusieurs structures avec des membres de champ de bits.

Une solution suggérée consiste à utiliser des attributs et une classe de conversion pour traduire les structures attribuées de manière appropriée en primitives de champ de bits. Les attributs sont utilisés pour spécifier la longueur de chaque membre de champ de bits, et la classe de conversion est chargée de convertir les structures annotées en représentation de champ de bits appropriée.

Voici un exemple de ce à quoi pourrait ressembler une telle implémentation :

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

Cette approche offre une lisibilité accrue du code et une écriture plus rapide, ce qui la rend plus efficace dans la gestion de nombreuses structures avec des membres de champ 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!