1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:

 
        static public void setTelStructureByArray<T>(byte[] arr, ref T data)
        {
            data=(T)RawDeserialize(arr, typeof(T));
        }

        private static object RawDeserialize(byte[] rawdatas, Type anytype)
        {
            int rawsize = Marshal.SizeOf(anytype);
            if (rawsize > rawdatas.Length)
                return null;
            GCHandle handle = GCHandle.Alloc(rawdatas, GCHandleType.Pinned);
            IntPtr buffer = handle.AddrOfPinnedObject();
            object retobj = Marshal.PtrToStructure(buffer, anytype);
            handle.Free();
            return retobj;
        }					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:

      static public void setTelStructureByArray<T>(byte[] arr, ref T data)
        {
            using (MemoryStream memStream = new MemoryStream(arr.Length))
            {
                memStream.Write(arr, 0, arr.Length);

                BinaryFormatter formatter = new BinaryFormatter();
                try
                {
                    data = (T)formatter.Deserialize(memStream);
                }
                catch (SerializationException e)
                {
                    Console.WriteLine("Failed to serialize. Reason: " + e.Message);
                    throw;
                }
                finally
                {
                    memStream.Close();
                }
            }
        }					

1:
2:
3:
4:
5:
6:
7:

    [Serializable]
    public struct TelInitResponseData 
    {
        public ushort encodedLength;
        //...
        public byte[] versNums;
    }					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:

    public static T RawDeserialize<T>(byte[] rawdata)
    {
      if (Marshal.SizeOf(typeof(T)) > rawdata.Length)
        throw new ArgumentException("...");

      GCHandle handle = GCHandle.Alloc(rawdata, GCHandleType.Pinned);
      try {
        IntPtr buffer = handle.AddrOfPinnedObject();
        return (T)Marshal.PtrToStructure(buffer, typeof(T));
      }
      finally {
        handle.Free();
      }
    }					

1:

[MarshalAs(UnmanagedType.ByValArray, ArraySubType = UnmanagedType.U1, SizeConst = 2)]