1. About this article
When transmitting information using the TCP (class TcpClient), UDP (class UdpClient) protocol under C #, you need to convert the information to an array of type byte to send. This article implements two conversions of object and byte arrays and a way to convert a file to a byte array. Data of the underlying type, which can be converted using functions in the Bitconverter class.
2.object and byte[] conversion: Serialization and deserialization using IFormatter serialize and deserialize
To implement this function, you need to refer to three namespaces first: System.IO, System.Runtime.Serialization, System.Runtime.Serialization.Formatters.Binary;
<summary>/// tools: Converting between objects and binary streams/// </summary>class byteconverthelper{ /// <summary> /// convert an object to a byte array /// </summary> /// <param name= "obj" > Converted Object </param > /// <returns> converted byte array </returns> public static byte[] object2bytes (object obj) { byte[] buff; using ( Memorystream ms = new memorystream ()) { iformatter iformatter = new binaryformatter (); Iformatter.serialize (ms, obj); buff = ms. GetBuffer (); } return buff; } /// <summary> /// convert a byte array to an object /// </summary> /// <param name= "Buff" > converted byte array </param> /// <returns> converted to Finished object </returns> public static object bytes2object (Byte[] buff) { object obj; using (Memorystream ms = new memorystream (buff)) { IFormatter iFormatter = new BinaryFormatter (); obj = Iformatter.deserialize (MS); } return obj; }}
Invocation Example:
Suppose there is a structure with the Serializable attribute added:
<summary>/// Test Structure/// </summary>[serializable]struct teststructure{ public string a; //variable a public char b; //variable b public int c; //variable c /// <summary> /// Constructors /// < /summary> /// <param name= "Paraa" ></param> /// <param name= "Parab" ></param> /// <param Name= "Parac" ></param> public teststructure (String paraA, char parab, int parac) { this . A = paraa; this. B = parab; &nbsP; this. c = parac; } /// <summary> /// output content in this structure /// </summary> /// <returns></returns> public string displayinfo () { return string. Format ("a:{0}; B:{1}; C:{2} ", this. A, this. B, this. C); }}
Then call the following code to complete the transformation of this structure
static void Main (string[] args) {teststructure TsA = new Teststructure ("1234", ' 5 ', 6); byte[] byttemp = byteconverthelper.object2bytes (TsA); Console.WriteLine ("Array Length:" + byttemp.length); Teststructure TsB = (teststructure) byteconverthelper.bytes2object (byttemp); Console.WriteLine (Tsb.displayinfo ()); Console.ReadLine ();}
The output is:
It is important to note that, in this way, the transformation between a struct and a byte array must have a serializable attribute on the struct or class. Otherwise there will be an exception (SerializationException): "Assembly" XXX, version=1.0.0.0, culture=neutral, publickeytoken=null "type" xxx.xxx " Not marked as serializable "
In addition, this method produces a large byte array length
3. Convert an object to a byte array using the STRUCTURETOPTR and ptrtostructure functions of the Marshal class
To implement this function, you need to refer to the namespace first: System.Runtime.InteropServices
<summary>/// tools: Converting between objects and binary streams/// </summary>class byteconverthelper{ /// <summary> /// convert an object to a byte array /// </summary> /// <param name= "obj" > Converted Object </param > /// <returns> converted byte array </returns> public static byte[] object2bytes (object obj) { byte[] buff = new byte[marshal.sizeof (obj)]; intptr ptr = marshal.unsafeaddrofpinnedarrayelement (buff, 0) ; marshal.structuretoptr (obj, ptr, true); return buff; } /// <summary> /// convert a byte array to an object /// </summary> /// <param name= "Buff" > converted byte array </param> /// <param Name= "Typ" > Converted to Class name </param> /// <returns> converted to Finished object </returns> public static object bytes2object (Byte[] buff, type typ) { IntPtr ptr = Marshal.unsafeaddrofpinnedarrayelement (buff, 0); return marshal.ptrtostructure (Ptr, typ); }}
Invocation Example:
The existing structure is as follows (which is less characteristic serializable than the structure in the example above):
<summary>/// Test Structure/// </summary>struct teststructure{ public string a; //variable a public char b; / /variable b public int c; //variable c /// <summary> /// Constructors /// </summary> /// <param name= "Paraa" ></param> /// <param name= "Parab" ></param> /// <param name= "ParaC "></param> public teststructure (String paraa, char parab, int parac) { this. A = paraa; this. B = parab; this. C = paraC; } /// <summary> /// output content in this structure /// </summary> /// < Returns></returns> public string displayinfo () { return string. Format ("a:{0}; B:{1}; C:{2} ", this. A, this. B, this. C); }}
Call the following code to complete the conversion:
static void Main (string[] args) {teststructure TsA = new Teststructure ("1234", ' 5 ', 6); byte[] byttemp = byteconverthelper.object2bytes (TsA); Console.WriteLine ("Array Length:" + byttemp.length); Teststructure TsB = (teststructure) byteconverthelper.bytes2object (byttemp, Type.GetType ("ByteConverter2.TestStruct Ure ")); Console.WriteLine (Tsb.displayinfo ()); Console.ReadLine ();}
To run the example:
As you can see, the array length is only 12, which is much shorter than the byte[] array converted in the example above, which is more space-saving
3. Using FileStream to convert a file to a byte array
To implement this feature, you need to reference the namespace first: System.IO
<summary>/// tools: Converting between files and binary streams/// </summary>class filebinaryconverthelper{ /// <summary> /// convert a file to a byte array /// </summary> /// <param name= "Path" > File address </ Param> /// <returns> converted byte array </returns> Public static byte[] file2bytes (String path) { if (! File.exists (path)) { return new byte[0]; } fileinfo fi = new fileinfo (PATH); byte[] buff = new byte[fi. Length]; &nbsP; filestream fs = fi. OpenRead (); fs. Read (Buff, 0, convert.toint32 (fs. Length)); fs. Close (); return buff; } /// <summary> /// convert a byte array to a file and save to the specified address /// </summary> /// <param name= "Buff" >byte array </param > /// <param name= "Savepath" > Save Address </param> public static void bytes2file (Byte[] buff, string savepath) { if (File.exists (savepath)) { File.deleTe (Savepath); } Filestream fs = new filestream (savepath, filemode.createnew); binarywriter bw = new binarywriter (FS); &NBSP;&NBSP;&NBSP;&NBSP;BW. Write (Buff, 0, buff. Length); bw. Close (); fs. Close (); }}
Assuming there is a file Test.txt, call the following code to write test.txt to a byte array and write the contents of the byte array to the file output.txt
static void Main (string[] args) {byte[] byttemp = filebinaryconverthelper.file2bytes ("test.txt"); Console.WriteLine ("Array Length:" + byttemp.length); Filebinaryconverthelper.bytes2file (byttemp, "output.txt"); Console.WriteLine ("Output Complete"); Console.ReadLine ();}
Operation Result:
END
Conversion between C # objects, files, and binary strings (byte arrays)