C-Sharp Bit Fields

Como Implementar `Campos de Bits` em C#: Um Guia Abrangente

Gerenciar estruturas de dados compactas de maneira eficiente é um desafio comum na programação, especialmente ao trabalhar com comunicação de dados ou estruturas de arquivos de baixo nível. Em C#, embora não haja suporte nativo para campos de bits como em C, podemos alcançar uma funcionalidade similar através do uso inteligente de atributos e reflexão. Este post no blog irá guiá-lo por um método eficaz de implementar e gerenciar campos de bits em C#.

O Problema

Suponha que você tenha uma série de estruturas que precisam representar dados com várias flags booleanas (ou bits). Usar abordagens convencionais do C# pode se tornar complicado e levar a um código menos legível. Pegue, por exemplo, os seguintes bits que precisam ser representados:

bit0 - original_ou_copia
bit1 - direito_autoral
bit2 - indicador_alinhamento_dados
bit3 - prioridade_PES
bit4-bit5 - controle_scrambling_PES
bit6-bit7 - reservado

O objetivo é capturar essa estrutura de uma maneira limpa e fácil de manter, sem recorrer à manipulação manual de bits a cada vez.

A Solução

Etapa 1: Criar um Atributo de Comprimento de Campo de Bits

Primeiro, definiremos um atributo personalizado chamado BitfieldLengthAttribute. Este atributo irá armazenar o comprimento de cada campo de bits. Aqui está como você pode configurá-lo:

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

Etapa 2: Definir uma Classe de Conversão Primitiva

Em seguida, precisamos de uma forma de converter nossos atributos em representações reais de campos de bits. Podemos criar uma classe estática para a lógica de conversão:

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

        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;
                long mask = (1 << (int)fieldLength) - 1;

                r |= ((UInt32)f.GetValue(t) & mask) << offset;
                offset += (int)fieldLength;
            }
        }

        return r;
    }
}

Etapa 3: Criar Sua Estrutura de Dados

Agora você pode criar uma estrutura representando seus campos de bits. Aqui está um exemplo:

struct PESHeader
{
    [BitfieldLength(2)]
    public uint reservado;

    [BitfieldLength(2)]
    public uint controle_scrambling;

    [BitfieldLength(1)]
    public uint prioridade;

    [BitfieldLength(1)]
    public uint indicador_alinhamento_dados;

    [BitfieldLength(1)]
    public uint direito_autoral;

    [BitfieldLength(1)]
    public uint original_ou_copia;
}

Etapa 4: Exemplo de Uso

Vamos juntar tudo em um programa simples que utiliza a estrutura e o método de conversão acima:

public class MainClass
{
    public static void Main(string[] args)
    {
        PESHeader p = new PESHeader
        {
            reservado = 3,
            controle_scrambling = 2,
            indicador_alinhamento_dados = 1
        };

        long l = PrimitiveConversion.ToLong(p);

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

        Console.WriteLine();
    }
}

Considerações Finais

Ao usar atributos personalizados e reflexão em C#, você pode imitar o comportamento de campos de bits do C enquanto mantém seu código legível e fácil de manter. Esta abordagem não apenas reduz a complexidade do código, mas também facilita o suporte a várias estruturas sem duplicação significativa de esforço.

Portanto, da próxima vez que você precisar trabalhar com representações de dados compactas, considere usar este método para uma solução eficiente e elegante!

Como Implementar Campos de Bits em C#: Um Guia Abrangente