How C # uses the shared body

It is really convenient to use it to pick up the following:

C # using the FieldOffset property for common and forced type conversions

These two days have been somewhat unaccustomed to the coercion type conversion of C #. That's the way it goes.

In C #, I'm going to read the binary text. The structure of the file is simple, and a series of tightly stored int32 values are stored in binary mode. Now I want to randomly read the I values starting with nth int32 and read them into the array. The result check C # can only read to byte[], or read out a loop int[]. The pursuit of efficiency of course I do not want this, if you can like C + + as the byte[] cast to int[] just fine. For example:

[CPP]View PlainCopyprint?

2. Char tmp[64]; //16 int.  Equivalent to C # byte[] tmp = new int[64];
4. int* dat; //DAT pointer.  Equivalent to C # int[] dat;
6. Ifstream IF (...); //standard file input stream.  Equivalent to C # FileStream FS = new FileStream (...);
8. If.read (TMP, 64);  //Read 64 bytes. Equivalent to C # FS.  Read (tmp,0,64);
10. DAT = (int*) tmp;  //To convert the first address of the TMP array to an int type, the array is converted to an array of type int with 4 bytes.
12. //The data does not change in memory because the data is originally of type int.
14. //The key is that this step cannot be directly implemented in C #.
16. for (int i = 0; i <; i++)
18. cout << Dat[i] << ""; //Output data.  Equivalent to C # console.write (dat[i]+ "");

In C # can not be directly implemented, for this I thought a lot of ways, also looked for a long time, until I saw this code:

[CSharp]View PlainCopyprint?

2. Using System;
4. Using System.IO;
6. Using System.Collections.Generic;
8. Using System.Linq;
10. Using System.Text;
12. Provides a wide variety of members that support COM interop and platform invoke services
14. Using System.Runtime.InteropServices;
18. Namespace test
20. {
22. Class Program
24. {
26. //StructLayout enables designers to control the physical layout of data fields for a class or structure
28. //explicit with FieldOffset to control the precise location of each data member
30. [StructLayout (LAYOUTKIND.EXPLICIT)]
32. public struct S1
34. {
36. //FieldOffset control field has a physical position offset of 0
38. [FieldOffset (0)]
40. public byte[] A;
42. //The same offset is 0, and the starting position overlaps with a.
44. [FieldOffset (0)]
46. public int[] b;
48. }
52. static void Main (string[] args)
54. {
56. S1 s = new S1 (); //To new, otherwise B will report "Use a field that may not be assigned value"
58. s.a=new byte[64];
62. FileStream FS = new FileStream ("E:\\test.txt", FileMode.Open);
64. //S.A. to receive the data of the file
66. Fs. Read (s.a,0,64);
70. //Make sure you don't cross the border when you read B
72. For (int i = 0; i <; i++)
74. Console.Write (s.b[i]+""); //b to use the data
78. Console.readkey ();
80. }
82. }
84. }

The principle is, in fact, like C + +, to point a int[] type variable to the same memory area as the byte[] type variable, which is the same as the first address in C + + where dat points to a char array. Similarly, such structural functions are the same as for C + +, where a structure can be used as a variety of data types, depending on what type is the case.

The files used in the test will not be uploaded, there is a winhex can edit their own, there is no way to write the program will be from 0xF to 0x0 16 numbers in binary mode output to the file. The contents of the file are opened in Winhex with the 16 binary display should be as follows:

How C # uses the shared body