How to emulate statically the C bitfields in c#?

Question

I have to define a communication protocol and I want to use a bitfield to store some logic values.

I'm working on the both systems: the sender: a device and a .Net software as receiver.

On the firmware side, I defined as usually a bitfield struct like:

struct __attribute__((__packed__)) BitsField 
{
  // Logic values
  uint8_t vesselPresenceSw: 1;
  uint8_t drawerPresenceSw: 1;
  uint8_t pumpState: 1;
  uint8_t waterValveState: 1;
  uint8_t steamValveState: 1;
  uint8_t motorDriverState: 1;
    // Unused
  uint8_t unused_0: 1;
  uint8_t unused_1: 1;
};

How I can define a same structure on the software side that support a bytes deserialization to build the struct itself?

Answer 1

In the meantime, I had a similar idea @Dmitry. I found the following solution using FieldOffset attribute. Working well without additional code. I think it's acceptable.

[Serializable]
[StructLayout(LayoutKind.Sequential)]
public struct LiveDataBitField
{
    // Where the values are effectively stored
    public byte WholeField { get; private set; }

    public bool VesselPresenceSw
    {
        get => (WholeField & 0x1) > 0;
        set
        {
            if (value)
            {
                WholeField |= 1;
            }
            else
            {
                WholeField &= 0xfE;
            }
        }
    }

    public bool DrawerPresenceSw
    {
        get => (WholeField & 0x2) >> 1 > 0;
        set
        {
            if (value)
            {
                WholeField |= (1 << 1);
            }
            else
            {
                WholeField &= 0xFD;
            }
        }
    }
    public bool PumpState
    {
        get => (WholeField & 0x4) >> 2 > 0;
        set
        {
            if (value)
            {
                WholeField |= (1 << 2);
            }
            else
            {
                WholeField &= 0xFB;
            }
        }
    }
    public bool WaterValveState
    {
        get => (WholeField & 0x8) >> 3 > 0;
        set
        {
            if (value)
            {
                WholeField |= (1 << 3);
            }
            else
            {
                WholeField &= 0xF7;
            }
        }
    }
    public bool SteamValveState
    {
        get => (WholeField & 0x10) >> 4 > 0;
        set
        {
            if (value)
            {
                WholeField |= (1 << 4);
            }
            else
            {
                WholeField &= 0xEF;
            }
        }
    }
    public bool MotorDriverState
    {
        get => (WholeField & 0x20) >> 5 > 0;
        set
        {
            if (value)
            {
                WholeField |= (1 << 5);
            }
            else
            {
                WholeField &= 0xDF;
            }
        }
    }
}

To deserialize a byte array to struct you can use:

    public static object ReadStruct(byte[] data, Type type)
    {
        var pinnedPacket = GCHandle.Alloc(data, GCHandleType.Pinned);
        var obj = Marshal.PtrToStructure(pinnedPacket.AddrOfPinnedObject(), type); 
        pinnedPacket.Free();
        return obj;
    }

Answer 2

Please see an example,

C code,

struct example_bit_field
{
unsigned char bit1 : 1;
unsigned char bit2 : 1;
unsigned char two_bits : 2;
unsigned char four_bits : 4;
}

and C# equivalent,

[BitFieldNumberOfBitsAttribute(8)]
struct ExampleBitField : IBitField
{
[BitFieldInfo(0, 1)]
public bool Bit1 { get; set; }
[BitFieldInfo(1, 1)]
public byte Bit2 { get; set; }
[BitFieldInfo(2, 2)]
public byte TwoBits { get; set; }
[BitFieldInfo(4, 4)]
public byte FourBits { get; set; }
}

Source :- https://www.codeproject.com/Articles/1095576/Bit-Field-in-Csharp-using-struct

Answer 3

I'm afraid there is no direct C# equivalent to C-style bitfield structs.

C# is capable, to a limited extent, of approximating C-style unions by using FieldOffset attributes. These explicit layout attributes allow you to specify exact and potentially overlapping field offsets. Unfortunately, that doesn't even get you halfway there: the offsets must be specified in bytes rather than bits, and you cannot enforce a specific width when reading or writing overlapping fields.

The closest C# comes to natively supporting bitfields is probably flag-based enum types. You may find this sufficient, provided you don't need more than 64 bits. Start by declaring an enum based on the smallest unsigned type that will fit all your flags:

[Flags]
public enum BitFields : byte {
    None             =      0,
    VesselPresenceSw = 1 << 0,
    DrawerPresenceSw = 1 << 1,
    PumpState        = 1 << 2,
    WaterValveState  = 1 << 3,
    SteamValveState  = 1 << 4,
    MotorDriverState = 1 << 5
}

The named items can have any value assigned to them that fits within the underlying type (byte in this case), so one item could represent multiple bits if you wanted it to. Note that if you want to interop directly with a C-style bitfield, your first value should start at the most significant bit rather than the least.

To use your flags, just declare a variable or field of your new type and perform whatever bitwise operations you need:

BitFields bits = BitFields.None;

bits |= BitFields.VesselPresenceSw | BitFields.PumpState;
bits &= ~BitFields.VesselPresenceSw;

// etc.

On the upside, enums declared with [Flags] are nicely formatted when displayed in the debugger or converted to strings. For example, if you were to print the expression BitFields.VesselPresenceSw | BitFields.PumpState, you would get the text DrawerPresenceSw, PumpState.

There is a caveat: the storage for an enum will accept any value that fits within the underlying type. It would be perfectly legal to write:

BitFields badBits = (BitFields)0xFF;

This sets all 8 bits of the byte-sized enumeration, but our named values only cover 6 bits. Depending on your requirements, you may want to declare a constant that encompasses only the 'legal' flags, which you could & against.

If you need anything richer than that, there is a framework-level 'bitfield' data structure called BitArray. However, BitArray is a reference type that uses a managed int[] for storage. It's not going to help you if want a struct that you could use for interop purposes or any kind of memory mapping.

Answer 4

You can try mimic such a struct. It seems, that you want to use it in the interop (say, C routine exchange data with C# program). Since you have logic values, let expose them as bool:

  using System.Runtime.InteropServices;

  ...

  [StructLayout(LayoutKind.Sequential, Pack = 1)]
  public struct MyBitsField {
    private Byte m_Data; // We actually store Byte

    public MyBitsField(Byte data) {
      m_Data = data;
    }

    private bool GetBit(int index) {
      return (m_Data & (1 << index)) != 0;
    }

    private void SetBit(int index, bool value) {
      byte v = (byte)(1 << index);

      if (value)
        m_Data |= v;
      else
        m_Data = (byte) ((m_Data | v) ^ v);
    }

    public bool vesselPresenceSw {
      get { return GetBit(0); }
      set { SetBit(0, value); }
    }

    ...

    public bool motorDriverState {
      get { return GetBit(5); }
      set { SetBit(5, value); }
    }
  }

Usage:

  var itemToSend = new MyBitsField() {
    vesselPresenceSw = false,
    motorDriverState = true,
  };