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]

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


"Nicholas Paldino [.NET/C# MVP]" <mvp@spam.guard .caspershouse.c omwrote in
message news:uklz82tcHH A.4260@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]
- mvp@spam.guard. caspershouse.co m
>
"Nand Kishore Gupta" <NandKishoreGup ta@discussions. microsoft.comwr ote in
message news:A07589A4-BD1C-495E-AA5B-ED2BF0C5E91F@mi crosoft.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]]

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

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]
- mvp@spam.guard. caspershouse.co m

"Nand Kishore Gupta" <NandKishoreGup ta@discussions. microsoft.comwr ote in
message news:A07589A4-BD1C-495E-AA5B-ED2BF0C5E91F@mi crosoft.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]]

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

"Ben Voigt" <rbv@nospam.nos pamwrote in message
news:eUJz4%23tc HHA.208@TK2MSFT NGP05.phx.gbl.. .

>
"Nicholas Paldino [.NET/C# MVP]" <mvp@spam.guard .caspershouse.c omwrote in message
news:uklz82tcHH A.4260@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]

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

On Fri, 30 Mar 2007 04:06:00 -0700, Nand Kishore Gupta
<NandKishoreGup ta@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]

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


"Willy Denoyette [MVP]" <willy.denoyett e@telenet.bewro te in message
news:eDerzTucHH A.4632@TK2MSFTN GP03.phx.gbl...

"Ben Voigt" <rbv@nospam.nos pamwrote in message
news:eUJz4%23tc HHA.208@TK2MSFT NGP05.phx.gbl.. .

>>
>"Nicholas Paldino [.NET/C# MVP]" <mvp@spam.guard .caspershouse.c omwrote
>in message news:uklz82tcHH A.4260@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]]

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

"Ben Voigt" <rbv@nospam.nos pamwrote in message
news:ee$9PDwcHH A.1000@TK2MSFTN GP05.phx.gbl...

>
"Willy Denoyette [MVP]" <willy.denoyett e@telenet.bewro te in message
news:eDerzTucHH A.4632@TK2MSFTN GP03.phx.gbl...

>"Ben Voigt" <rbv@nospam.nos pamwrote in message
>news:eUJz4%23t cHHA.208@TK2MSF TNGP05.phx.gbl. ..

>>>
>>"Nicholas Paldino [.NET/C# MVP]" <mvp@spam.guard .caspershouse.c omwrote in message
>>news:uklz82tc HHA.4260@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]

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


"Willy Denoyette [MVP]" <willy.denoyett e@telenet.bewro te in message
news:%23PmPPawc HHA.284@TK2MSFT NGP05.phx.gbl.. .

"Ben Voigt" <rbv@nospam.nos pamwrote in message
news:ee$9PDwcHH A.1000@TK2MSFTN GP05.phx.gbl...

>>
>"Willy Denoyette [MVP]" <willy.denoyett e@telenet.bewro te in message
>news:eDerzTucH HA.4632@TK2MSFT NGP03.phx.gbl.. .

>>"Ben Voigt" <rbv@nospam.nos pamwrote in message
>>news:eUJz4%23 tcHHA.208@TK2MS FTNGP05.phx.gbl ...
>>>>
>>>"Nicholas Paldino [.NET/C# MVP]" <mvp@spam.guard .caspershouse.c om>
>>>wrote in message news:uklz82tcHH A.4260@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]]

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

"Ben Voigt" <rbv@nospam.nos pamwrote in message
news:u4yT6LxcHH A.3632@TK2MSFTN GP02.phx.gbl...

>
"Willy Denoyette [MVP]" <willy.denoyett e@telenet.bewro te in message
news:%23PmPPawc HHA.284@TK2MSFT NGP05.phx.gbl.. .

>"Ben Voigt" <rbv@nospam.nos pamwrote in message
>news:ee$9PDwcH HA.1000@TK2MSFT NGP05.phx.gbl.. .

>>>
>>"Willy Denoyette [MVP]" <willy.denoyett e@telenet.bewro te in message
>>news:eDerzTuc HHA.4632@TK2MSF TNGP03.phx.gbl. ..
>>>"Ben Voigt" <rbv@nospam.nos pamwrote in message
>>>news:eUJz4%2 3tcHHA.208@TK2M SFTNGP05.phx.gb l...
>>>>>
>>>>"Nicholas Paldino [.NET/C# MVP]" <mvp@spam.guard .caspershouse.c omwrote in message
>>>>news:uklz82 tcHHA.4260@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]

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

>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.

[Willy Denoyette [MVP]]

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

"Ben Voigt" <rbv@nospam.nos pamwrote in message
news:%23dglzL7c HHA.4616@TK2MSF TNGP03.phx.gbl. ..

>

>>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.

Oh sure, on Itanium it's definitely something to watch for, but I guess the C/C++ compilers
are watching for this.
I remember that on Alpha it was possible to turn this "feature" off globally, or, on a per
application basis via an API, you can't imagine how many applications that failed with this
turned off, this was a great debugging experience as it allowed us to pinpoint the offending
data structure(s).
Also on Intel (IA32 and X64), a lot of applications still have unaligned data structures,
you can inspect these when running a profiler (like Intel's VTune Performance Analyzer) that
includes the facility to watch the processor core counters, only problem here is that it's a
bit harder to find the offending data structure.
Willy.