Convert Vector3 array (vector3[]) to byte array (byte[])

What I did when I had to serialize values (like Vector3) over network, was using serialization with MemoryStream (which you can convert into a byte array).

I had three classes, one for arrays, one for ushort and one for the actual Vector3.

The array class requires a type T input which is the type you want to convert (in this case it's Vector3). It also takes an Action, which is either a serialize- or deserialize function from the Vector3Proxy class.

The UShort class is just for converting the array length; I was using ushort instead of ints since the type contains less data to send.

This all relies on a system type called MemoryStream. Values from types are written in there, and can be afterwards converted into a byte array using ToArray().

(If you want to access the MemoryStream or the Stream class, you need to add the using System.IO tag)

An example of doing the conversion:

If you want to convert a Vector3 array to a byte array, this is how you do it with these three classes:

 using (MemoryStream memoryStream = new MemoryStream())
 {
     ArrayProxy<Vector3>.Serialize(
                memoryStream, 
                yourVector3Variable, 
                Vector3Proxy.Serialize);
 
         //Here is the result
         bytes[] conversionArray = memoryStream.ToArray();
 }

This converts the Vector3 array into a byte array. However, if you want to serialize it back from the byte array to a Vector3 array, it's done like this:

 byte[] conversionArray = yourConvertedByteArray;
 
 using (MemoryStream memoryStream = new MemoryStream(conversionArray))
 {
          //Here is the result
     Vector3[] data = ArrayProxy<Vector3>.Deserialize(memoryStream, Vector3Proxy.Deserialize);
 }

The Proxy Classes:

The array proxy class of a type T:

 public static class ArrayProxy<T>
 {
     public static void Serialize(Stream bytes, T[] instance, Action<Stream, T> serialization)
     {
         UShortProxy.Serialize(bytes, (ushort)instance.Length);
         foreach (T arg in instance)
         {
             serialization(bytes, arg);
         }
     }
 
     public static T[] Deserialize(Stream bytes, ArrayProxy<T>.Deserializer<T> serialization)
     {
         ushort num = UShortProxy.Deserialize(bytes);
         T[] array = new T[(int)num];
         for (int i = 0; i < (int)num; i++)
         {
             array[i] = serialization(bytes);
         }
         return array;
     }
 
     public delegate void Serializer<U>(Stream stream, U instance);
 
     public delegate U Deserializer<U>(Stream stream);
 }

The UShort proxy class:

 public static class UShortProxy
 {
     public static void Serialize(Stream bytes, ushort instance)
     {
         byte[] bytes2 = BitConverter.GetBytes(instance);
         bytes.Write(bytes2, 0, bytes2.Length);
     }
 
     public static ushort Deserialize(Stream bytes)
     {
         byte[] array = new byte[2];
         bytes.Read(array, 0, 2);
         return BitConverter.ToUInt16(array, 0);
     }
 }

The Vector3 Proxy class:

 public static class Vector3Proxy
 {
     public static void Serialize(Stream bytes, Vector3 instance)
     {
         bytes.Write(BitConverter.GetBytes(instance.x), 0, 4);
         bytes.Write(BitConverter.GetBytes(instance.y), 0, 4);
         bytes.Write(BitConverter.GetBytes(instance.z), 0, 4);
     }
 
     public static Vector3 Deserialize(Stream bytes)
     {
         byte[] array = new byte[12];
         bytes.Read(array, 0, 12);
         return new Vector3(BitConverter.ToSingle(array, 0), BitConverter.ToSingle(array, 4), 
             BitConverter.ToSingle(array, 8));
     }
 }

Make sure to comment if there any errors or something you'd like to know!