reading a C++ structure from a binary file using C#

[=?Utf-8?B?TmFuZCBLaXNob3JlIEd1cHRh?=]

I have a binary file created using C++ that contains an object of the
structure:

struct student
{
int roll_no;
char name[20];
char qualification[50];
};

the following code is used to create and write to the file:

void WriteToFile()
{
student s;
s.roll_no=1;
strcpy(s.name," nand");
strcpy(s.qualif ication,"MCA");

CString fileName = "c:\\testdata.d at";

CFile file;
file.Open(fileN ame,CFile::mode Create | CFile::modeWrit e |
CFile::typeBina ry);
file.Write(&s,s izeof(s));
}

Now, I want to read the contents of this binary file (testdata.dat) using a
C# program and store that in a C# structure. Can any body suggest me how to
do this. Sample code would be highly appreciated.

Thanks

--
Nand Kishore Gupta

[Ben Voigt]

"Nicholas Paldino [.NET/C# MVP]" <mv*@spam.guard .caspershouse.c omwrote in
message news:uk******** ******@TK2MSFTN GP02.phx.gbl...

Nand,

In order to do this in .NET, I would read from the file in 74 byte
blocks (4 + 20 + 50). Then, I would call the static ToInt32 method on the

The C++ code used sizeof(s)... you must print this value out from C++. It
is unlikely to be 74, since the structure contains an int member which
prefers 4-byte alignment... so I think two bytes of padding is added by the
C++ compiler and the record spacing will be 76 bytes. But check it, because
it pragma pack was used several different values would be possible.

BitConverter class to get the roll_no field. Then you can use the
Encoding instance returned by the static ASCII property on the Encoding
class to get an encoding which you can use to convert the remaning 70
bytes into strings (by calling the GetString method).

Hope this helps.
--
- Nicholas Paldino [.NET/C# MVP]
- mv*@spam.guard. caspershouse.co m

"Nand Kishore Gupta" <Na************ **@discussions. microsoft.comwr ote in
message news:A0******** *************** ***********@mic rosoft.com...

>>I have a binary file created using C++ that contains an object of the
structure:

struct student
{
int roll_no;
char name[20];
char qualification[50];
};

the following code is used to create and write to the file:

void WriteToFile()
{
student s;
s.roll_no=1;
strcpy(s.name," nand");
strcpy(s.qualif ication,"MCA");

CString fileName = "c:\\testdata.d at";

CFile file;
file.Open(fileN ame,CFile::mode Create | CFile::modeWrit e |
CFile::typeBin ary);
file.Write(&s,s izeof(s));
}

Now, I want to read the contents of this binary file (testdata.dat) using
a
C# program and store that in a C# structure. Can any body suggest me how
to
do this. Sample code would be highly appreciated.

Thanks

--
Nand Kishore Gupta

[Nicholas Paldino [.NET/C# MVP]]

Nand,

In order to do this in .NET, I would read from the file in 74 byte
blocks (4 + 20 + 50). Then, I would call the static ToInt32 method on the
BitConverter class to get the roll_no field. Then you can use the Encoding
instance returned by the static ASCII property on the Encoding class to get
an encoding which you can use to convert the remaning 70 bytes into strings
(by calling the GetString method).

Hope this helps.
--
- Nicholas Paldino [.NET/C# MVP]
- mv*@spam.guard. caspershouse.co m

"Nand Kishore Gupta" <Na************ **@discussions. microsoft.comwr ote in
message news:A0******** *************** ***********@mic rosoft.com...

>I have a binary file created using C++ that contains an object of the
structure:

struct student
{
int roll_no;
char name[20];
char qualification[50];
};

the following code is used to create and write to the file:

void WriteToFile()
{
student s;
s.roll_no=1;
strcpy(s.name," nand");
strcpy(s.qualif ication,"MCA");

CString fileName = "c:\\testdata.d at";

CFile file;
file.Open(fileN ame,CFile::mode Create | CFile::modeWrit e |
CFile::typeBina ry);
file.Write(&s,s izeof(s));
}

Now, I want to read the contents of this binary file (testdata.dat) using
a
C# program and store that in a C# structure. Can any body suggest me how
to
do this. Sample code would be highly appreciated.

Thanks

--
Nand Kishore Gupta

[Willy Denoyette [MVP]]

"Ben Voigt" <rb*@nospam.nos pamwrote in message
news:eU******** *******@TK2MSFT NGP05.phx.gbl.. .

>
"Nicholas Paldino [.NET/C# MVP]" <mv*@spam.guard .caspershouse.c omwrote in message
news:uk******** ******@TK2MSFTN GP02.phx.gbl...

>Nand,

In order to do this in .NET, I would read from the file in 74 byte blocks (4 + 20 +
50). Then, I would call the static ToInt32 method on the

The C++ code used sizeof(s)... you must print this value out from C++. It is unlikely to
be 74, since the structure contains an int member which prefers 4-byte alignment... so I
think two bytes of padding is added by the C++ compiler and the record spacing will be 76
bytes. But check it, because it pragma pack was used several different values would be
possible.

Why? The int is the first field of the struct, the second is a char array which has no
alignment restriction, so, whatever the packing, the length written on disk will be 74.

Willy.

[rossum]

On Fri, 30 Mar 2007 04:06:00 -0700, Nand Kishore Gupta
<Na************ **@discussions. microsoft.comwr ote:

>I have a binary file created using C++ that contains an object of the
structure:

struct student
{
int roll_no;
char name[20];
char qualification[50];
};

the following code is used to create and write to the file:

void WriteToFile()
{
student s;
s.roll_no=1;
strcpy(s.name," nand");
strcpy(s.qualif ication,"MCA");

CString fileName = "c:\\testdata.d at";

CFile file;
file.Open(fileN ame,CFile::mode Create | CFile::modeWrit e |
CFile::typeBin ary);
file.Write(&s,s izeof(s));
}

Now, I want to read the contents of this binary file (testdata.dat) using a
C# program and store that in a C# structure. Can any body suggest me how to
do this. Sample code would be highly appreciated.

Thanks

Two points:

- you need to know what endinness and size of integer the C++
compiler is using. There is no guarantee that they will be the same
for C#.

- depending on what characters are allowed in names you may also need
to pay attention to what character encoding is used at the C++ end.
For instance, Étienne has an accented character which might not
translate correctly.

If you have control over the C++ end I would suggest modifying the C++
code to write a text file, rather than a binary file. That will solve
the endianness problem and just leave you with the character encoding
problem. For simplicity a CSV file is probably best:

"1","nand","MCA "
"2","martin","P GCE"

though XML is also a possibility.

rossum

[Ben Voigt]

"Willy Denoyette [MVP]" <wi************ *@telenet.bewro te in message
news:eD******** ******@TK2MSFTN GP03.phx.gbl...

"Ben Voigt" <rb*@nospam.nos pamwrote in message
news:eU******** *******@TK2MSFT NGP05.phx.gbl.. .

>>
"Nicholas Paldino [.NET/C# MVP]" <mv*@spam.guard .caspershouse.c omwrote
in message news:uk******** ******@TK2MSFTN GP02.phx.gbl...

>>Nand,

In order to do this in .NET, I would read from the file in 74 byte
blocks (4 + 20 + 50). Then, I would call the static ToInt32 method on
the

The C++ code used sizeof(s)... you must print this value out from C++.
It is unlikely to be 74, since the structure contains an int member which
prefers 4-byte alignment... so I think two bytes of padding is added by
the C++ compiler and the record spacing will be 76 bytes. But check it,
because it pragma pack was used several different values would be
possible.

Why? The int is the first field of the struct, the second is a char array
which has no alignment restriction, so, whatever the packing, the length
written on disk will be 74.

As I said, the OP's C code writes sizeof(s) bytes to disk. Padding is
included in sizeof, because sizeof is the separation between adjacent array
elements which must both be properly aligned.

If there's only one record in the file, it's a non-issue. But I was
responding to a post mentioning "read the file in 74 byte blocks".

[Willy Denoyette [MVP]]

"Ben Voigt" <rb*@nospam.nos pamwrote in message
news:ee******** ******@TK2MSFTN GP05.phx.gbl...

>
"Willy Denoyette [MVP]" <wi************ *@telenet.bewro te in message
news:eD******** ******@TK2MSFTN GP03.phx.gbl...

>"Ben Voigt" <rb*@nospam.nos pamwrote in message
news:eU******* ********@TK2MSF TNGP05.phx.gbl. ..

>>>
"Nicholas Paldino [.NET/C# MVP]" <mv*@spam.guard .caspershouse.c omwrote in message
news:uk****** ********@TK2MSF TNGP02.phx.gbl. ..
Nand,

In order to do this in .NET, I would read from the file in 74 byte blocks (4 + 20 +
50). Then, I would call the static ToInt32 method on the

The C++ code used sizeof(s)... you must print this value out from C++. It is unlikely to
be 74, since the structure contains an int member which prefers 4-byte alignment... so I
think two bytes of padding is added by the C++ compiler and the record spacing will be
76 bytes. But check it, because it pragma pack was used several different values would
be possible.

Why? The int is the first field of the struct, the second is a char array which has no
alignment restriction, so, whatever the packing, the length written on disk will be 74.

As I said, the OP's C code writes sizeof(s) bytes to disk. Padding is included in sizeof,
because sizeof is the separation between adjacent array elements which must both be
properly aligned.

If there's only one record in the file, it's a non-issue. But I was responding to a post
mentioning "read the file in 74 byte blocks".

Oh, I see what you mean, but here the sizeof depends on the packing specified (or the
default packing). This is why I'm always trying to define my structs like this;
#pragma pack(show)
struct student
{
int roll_no;
char name[20];
char qualification[50];
};
#pragma pack(pop)
#pragma pack(show)

when writing to disk, especially when these files have to be read by "foreign" applications.
No surprises here, the size is exactly the sum of all it's elements.

Willy.

[Ben Voigt]

"Willy Denoyette [MVP]" <wi************ *@telenet.bewro te in message
news:%2******** *******@TK2MSFT NGP05.phx.gbl.. .

"Ben Voigt" <rb*@nospam.nos pamwrote in message
news:ee******** ******@TK2MSFTN GP05.phx.gbl...

>>
"Willy Denoyette [MVP]" <wi************ *@telenet.bewro te in message
news:eD******* *******@TK2MSFT NGP03.phx.gbl.. .

>>"Ben Voigt" <rb*@nospam.nos pamwrote in message
news:eU****** *********@TK2MS FTNGP05.phx.gbl ...

"Nicholas Paldino [.NET/C# MVP]" <mv*@spam.guard .caspershouse.c om>
wrote in message news:uk******** ******@TK2MSFTN GP02.phx.gbl...
Nand,
>
In order to do this in .NET, I would read from the file in 74 byte
blocks (4 + 20 + 50). Then, I would call the static ToInt32 method on
the

The C++ code used sizeof(s)... you must print this value out from C++.
It is unlikely to be 74, since the structure contains an int member
which prefers 4-byte alignment... so I think two bytes of padding is
added by the C++ compiler and the record spacing will be 76 bytes. But
check it, because it pragma pack was used several different values
would be possible.
Why? The int is the first field of the struct, the second is a char
array which has no alignment restriction, so, whatever the packing, the
length written on disk will be 74.

As I said, the OP's C code writes sizeof(s) bytes to disk. Padding is
included in sizeof, because sizeof is the separation between adjacent
array elements which must both be properly aligned.

If there's only one record in the file, it's a non-issue. But I was
responding to a post mentioning "read the file in 74 byte blocks".

Oh, I see what you mean, but here the sizeof depends on the packing
specified (or the default packing). This is why I'm always trying to
define my structs like this;
#pragma pack(show)

Did you mean to add here:
#pragma pack(push, 1)

?

struct student
{
int roll_no;
char name[20];
char qualification[50];
};
#pragma pack(pop)
#pragma pack(show)

when writing to disk, especially when these files have to be read by
"foreign" applications. No surprises here, the size is exactly the sum of
all it's elements.

That's very non-portable though, many CPUs will generate hard exceptions if
you use unaligned data. Also the compiler is allowed to reorder the
members. So it's best to serialize each element individually.

>
Willy.

[Willy Denoyette [MVP]]

"Ben Voigt" <rb*@nospam.nos pamwrote in message
news:u4******** ******@TK2MSFTN GP02.phx.gbl...

>
"Willy Denoyette [MVP]" <wi************ *@telenet.bewro te in message
news:%2******** *******@TK2MSFT NGP05.phx.gbl.. .

>"Ben Voigt" <rb*@nospam.nos pamwrote in message
news:ee******* *******@TK2MSFT NGP05.phx.gbl.. .

>>>
"Willy Denoyette [MVP]" <wi************ *@telenet.bewro te in message
news:eD****** ********@TK2MSF TNGP03.phx.gbl. ..
"Ben Voigt" <rb*@nospam.nos pamwrote in message
news:eU***** **********@TK2M SFTNGP05.phx.gb l...
>
"Nicholas Paldino [.NET/C# MVP]" <mv*@spam.guard .caspershouse.c omwrote in message
news:uk**** **********@TK2M SFTNGP02.phx.gb l...
>Nand,
>>
> In order to do this in .NET, I would read from the file in 74 byte blocks (4 + 20
>+ 50). Then, I would call the static ToInt32 method on the
>
The C++ code used sizeof(s)... you must print this value out from C++. It is unlikely
to be 74, since the structure contains an int member which prefers 4-byte alignment...
so I think two bytes of padding is added by the C++ compiler and the record spacing
will be 76 bytes. But check it, because it pragma pack was used several different
values would be possible.
>

Why? The int is the first field of the struct, the second is a char array which has no
alignment restriction, so, whatever the packing, the length written on disk will be 74.

As I said, the OP's C code writes sizeof(s) bytes to disk. Padding is included in
sizeof, because sizeof is the separation between adjacent array elements which must both
be properly aligned.

If there's only one record in the file, it's a non-issue. But I was responding to a
post mentioning "read the file in 74 byte blocks".

Oh, I see what you mean, but here the sizeof depends on the packing specified (or the
default packing). This is why I'm always trying to define my structs like this;
#pragma pack(show)

Did you mean to add here:
#pragma pack(push, 1)

?

>struct student
{
int roll_no;
char name[20];
char qualification[50];
};
#pragma pack(pop)
#pragma pack(show)

when writing to disk, especially when these files have to be read by "foreign"
applications . No surprises here, the size is exactly the sum of all it's elements.

That's very non-portable though, many CPUs will generate hard exceptions if you use
unaligned data. Also the compiler is allowed to reorder the members. So it's best to
serialize each element individually.

Agreed, you can have portability issues doing this, but this is also true when relying on
the default packing.
Note also that such issues are quite common when passing data from one platform (HW and OS)
to another, I would never use this kind of packing for "applicatio n data structures" only
when I need to pass binary data across program boundaries, and I'm never using this to pass
data across non "compatible " (HW and OS) systems.
Anyway, the only CPU I know that will generate hard exceptions is Intel's Itanium, others
like Intel's IA32, Intel 64 (X64 EM), AMD 32 and 64, all handle alignment issues in µcode
(taking a small performance hit). The Alpha CPU raises an alignment exception, which the OS
can correct or just ignore, on a per application basis, I thought Intel's Itanium did
exactly the same.
Willy.

[Ben Voigt]

>That's very non-portable though, many CPUs will generate hard exceptions
if you use
unaligned data. Also the compiler is allowed to reorder the members. So
it's best to serialize each element individually.

Agreed, you can have portability issues doing this, but this is also true
when relying on the default packing.
Note also that such issues are quite common when passing data from one
platform (HW and OS) to another, I would never use this kind of packing
for "applicatio n data structures" only when I need to pass binary data
across program boundaries, and I'm never using this to pass data across
non "compatible " (HW and OS) systems.
Anyway, the only CPU I know that will generate hard exceptions is Intel's
Itanium, others like Intel's IA32, Intel 64 (X64 EM), AMD 32 and 64, all
handle alignment issues in µcode (taking a small performance hit). The
Alpha CPU raises an alignment exception, which the OS can correct or just
ignore, on a per application basis, I thought Intel's Itanium did exactly
the same.

Ok, maybe not a hard exception, but the performance hit from having the OS
trap the unaligned access and emulate proper alignment is quite high.