Question

in this case a binary file is written with the file format based on a struct

    struct fileformat
    {
         struct mask
         {
                bool mem1present
                bool mem2present
                bool mem3present
                //5 bits unused
          }
          //member only written in file if mem1present is true
          byte mem1present
          //member only written in file if mem2present is true
          byte mem1present
          //member only written in file if mem3present is true
          byte mem1present
    }

is this possible to be implemented in c#

Answer 1

Sure – you have to implement the serialization yourself to some extent, but you can do that easily enough.

It’s unclear what sort of serialization you’re using – if you’re using the “raw” binary serialization from .NET, you want to override GetObjectData to only add the relevant data on serialization, and then in the protected constructor taking a SerializationInfo and a StreamingContext, populate your struct from the same data in reverse. See this MSDN article for some details.

I don’t know what happens if you’re using XML serialization.

If you’re writing your own serialization (i.e. you’ve got a method such as WriteToStream) then you can choose to represent it however you want, of course.

EDIT: It sounds like you’ve probably got an existing file format you need to read in, but you can define your own types. It’s easy to have a class or struct with multiple members and possibly a mask to say what’s set, although without knowing more it may not be the best design. While you can use explicit layout to make this efficient in memory, it’s probably easiest just to have separate members:

struct Foo
{
    // Bit-set to determine which fields are actually used
    private readonly byte mask;

    private readonly int value1;
    private readonly int value2;
    private readonly int value3;

    public Foo(byte mask, int value1, int value2, int value3)
    {
        this.mask = mask;
        this.value1 = value1;
        this.value2 = value2;
        this.value3 = value3;
    }
}

Then somewhere (either in the data type or not), something like:

Foo ReadFoo(Stream stream)
{
    byte mask = stream.ReadByte();
    int value1 = 0, value2 = 0, value3 = 0;
    if ((mask & 1) == 1)
    {
       // However you do that, depending on your file format
        value1 = ReadInt32FromStream(stream); 
    }
    if ((mask & 2) == 2)
    {
       // However you do that, depending on your file format
        value2 = ReadInt32FromStream(stream); 
    }
    if ((mask & 4) == 4)
    {
       // However you do that, depending on your file format
        value3 = ReadInt32FromStream(stream); 
    }
    return new Foo(mask, value1, value2, value3);
}

By the way, I would seriously consider whether a struct is really the best approach here – consider using a class instead. I very rarely create my own structs.