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.qualification,"MCA");

CString fileName = "c:\\testdata.dat";

CFile file;
file.Open(fileName,CFile::modeCreate | CFile::modeWrite |
CFile::typeBinary);
file.Write(&s,sizeof(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.comwrote in
message news:uk**************@TK2MSFTNGP02.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.com

"Nand Kishore Gupta" <Na**************@discussions.microsoft.comwrote in
message news:A0**********************************@microsof t.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.qualification,"MCA");

CString fileName = "c:\\testdata.dat";

CFile file;
file.Open(fileName,CFile::modeCreate | CFile::modeWrite |
CFile::typeBinary);
file.Write(&s,sizeof(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.com

"Nand Kishore Gupta" <Na**************@discussions.microsoft.comwrote in
message news:A0**********************************@microsof t.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.qualification,"MCA");

CString fileName = "c:\\testdata.dat";

CFile file;
file.Open(fileName,CFile::modeCreate | CFile::modeWrite |
CFile::typeBinary);
file.Write(&s,sizeof(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.nospamwrote in message
news:eU***************@TK2MSFTNGP05.phx.gbl...

>
"Nicholas Paldino [.NET/C# MVP]" <mv*@spam.guard.caspershouse.comwrote in message
news:uk**************@TK2MSFTNGP02.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.comwrote :

>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.qualification,"MCA");

CString fileName = "c:\\testdata.dat";

CFile file;
file.Open(fileName,CFile::modeCreate | CFile::modeWrite |
CFile::typeBinary);
file.Write(&s,sizeof(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","PGCE"

though XML is also a possibility.

rossum

[Ben Voigt]

"Willy Denoyette [MVP]" <wi*************@telenet.bewrote in message
news:eD**************@TK2MSFTNGP03.phx.gbl...

"Ben Voigt" <rb*@nospam.nospamwrote in message
news:eU***************@TK2MSFTNGP05.phx.gbl...

>>
"Nicholas Paldino [.NET/C# MVP]" <mv*@spam.guard.caspershouse.comwrote
in message news:uk**************@TK2MSFTNGP02.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.nospamwrote in message
news:ee**************@TK2MSFTNGP05.phx.gbl...

>
"Willy Denoyette [MVP]" <wi*************@telenet.bewrote in message
news:eD**************@TK2MSFTNGP03.phx.gbl...

>"Ben Voigt" <rb*@nospam.nospamwrote in message
news:eU***************@TK2MSFTNGP05.phx.gbl...

>>>
"Nicholas Paldino [.NET/C# MVP]" <mv*@spam.guard.caspershouse.comwrote in message
news:uk**************@TK2MSFTNGP02.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.bewrote in message
news:%2***************@TK2MSFTNGP05.phx.gbl...

"Ben Voigt" <rb*@nospam.nospamwrote in message
news:ee**************@TK2MSFTNGP05.phx.gbl...

>>
"Willy Denoyette [MVP]" <wi*************@telenet.bewrote in message
news:eD**************@TK2MSFTNGP03.phx.gbl...

>>"Ben Voigt" <rb*@nospam.nospamwrote in message
news:eU***************@TK2MSFTNGP05.phx.gbl...

"Nicholas Paldino [.NET/C# MVP]" <mv*@spam.guard.caspershouse.com>
wrote in message news:uk**************@TK2MSFTNGP02.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.nospamwrote in message
news:u4**************@TK2MSFTNGP02.phx.gbl...

>
"Willy Denoyette [MVP]" <wi*************@telenet.bewrote in message
news:%2***************@TK2MSFTNGP05.phx.gbl...

>"Ben Voigt" <rb*@nospam.nospamwrote in message
news:ee**************@TK2MSFTNGP05.phx.gbl...

>>>
"Willy Denoyette [MVP]" <wi*************@telenet.bewrote in message
news:eD**************@TK2MSFTNGP03.phx.gbl...
"Ben Voigt" <rb*@nospam.nospamwrote in message
news:eU***************@TK2MSFTNGP05.phx.gbl.. .
>
"Nicholas Paldino [.NET/C# MVP]" <mv*@spam.guard.caspershouse.comwrote in message
news:uk**************@TK2MSFTNGP02.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.

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 "application 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 "application 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]]

"Ben Voigt" <rb*@nospam.nospamwrote in message
news:%2****************@TK2MSFTNGP03.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 "application 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.