How to emulate statically the C bitfields in c#?

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.

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

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