Wie können Bitfelder in C# implementiert werden, um eine effiziente Speichernutzung zu erreichen?

Bitfelder in C#

Bitfelder sind eine Datenstruktur in C, die es dem Benutzer ermöglicht, eine Struktur mit Feldern zu definieren, die eine bestimmte Anzahl belegen von Bits. Dies kann nützlich sein, wenn Sie mit begrenztem Speicher arbeiten oder wenn die gespeicherten Daten einem bestimmten Bitmuster entsprechen.

Im bereitgestellten Beispiel verfügt der Benutzer über eine Struktur mit mehreren Bitfeldern:

• reserviert (2 Bits)
• Scrambling_Control (2 Bits)
• Priorität (1 Bit)
• data_alignment_indicator (1 Bit)
• Copyright (1 Bit)
• original_or_copy (1 Bit)

Um auf die einzelnen Bits darin zuzugreifen B. ein Bitfeld in C#, kann der Punktoperator verwendet werden. Allerdings gibt es in C# kein direktes Äquivalent zur in C verwendeten Syntax zum Definieren von Bitfeldern.

Eine mögliche Lösung besteht darin, Attribute zu verwenden, um die Länge jedes Bitfelds anzugeben, und dann eine Konvertierungsklasse zu schreiben, die die Struktur konvertieren kann zu einem Bitfeldprimitiv. Dies kann wie folgt erfolgen:

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

Dieser Code erzeugt das erwartete Ergebnis 000101011. Diese Lösung ist wiederverwendbar und ermöglicht eine einfache Wartung von Strukturen mit Bitfeldern.

Das obige ist der detaillierte Inhalt vonWie können Bitfelder in C# implementiert werden, um eine effiziente Speichernutzung zu erreichen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!