sslstream binary formater memorystream разминаване

Изпращам данни по ssl по следният начин: client->server

 public byte[] ReadBigData(SslStream sslstr, uint datalenth)
        {
            lock (this)
            {
                int _datalenth = Convert.ToInt32(datalenth);
                byte[] paket = new byte[_datalenth];
                int paketSizes = 15000;// 000;

                if (paket.Length < paketSizes)
                {
                    sslstr.Read(paket, 0, paket.Length);
                    return paket;
                }
                //bool fistRead = true;
                //int dataRead=0;
                int currentRead = 0;

                int ostatyk = _datalenth % paketSizes;
                int broiPaketi = _datalenth / paketSizes;
                if (ostatyk != 0)
                    broiPaketi++;

                byte[] subPaket;
                using (MemoryStream ms = new MemoryStream(paket))
                {
                    while (broiPaketi != 0)
                    {
                        if (sslstr.CanRead)
                        {
                            if (_datalenth > paketSizes)
                            {
                                currentRead = paketSizes;
                                //if (fistRead)
                                //{
                                //    currentRead -= 5;//tip paket i int s razmera =5 byta
                                //}
                                _datalenth -= currentRead;
                            }
                            else
                            {
                                currentRead = _datalenth % paketSizes;
                            }
                            subPaket = new byte[currentRead];
                            sslstr.Read(subPaket, 0, currentRead);
                            broiPaketi--;
                            if (broiPaketi != 0)
                            {
                                if (!sslstr.IsServer)
                                {
                                    sslstr.WriteByte((byte)201);//znachi ok
                                    sslstr.Flush();
                                }
                            }

                            ms.Write(subPaket, 0, currentRead);

                        }
                      
                    }
                  return paket;
                }
            }
            
        }
        public void WriteBigData(SslStream sslstr, byte[] data)
        {    lock(this)
            { 
            int paketSizes = 15000;// 000; 
            byte[] paket = data;
            byte[] subPaket;
            if (data.Length < paketSizes)
            {
                sslstr.Write(paket);
                return;
            }
            int _datalenth = data.Length;
          
            int currentRead = 0;
            
            int ostatyk = _datalenth % paketSizes;
            int broiPaketi = _datalenth / paketSizes;
            if (ostatyk != 0)
                broiPaketi++;
          
            using (MemoryStream ms = new MemoryStream(paket))
            {
                while (broiPaketi != 0)
                {
                    if(sslstr.CanWrite)
                    { 
                        if (_datalenth > paketSizes)
                        {
                            currentRead = paketSizes;
                            _datalenth -= currentRead;
                        }
                        else
                        {
                            currentRead = _datalenth % paketSizes;
                        }
                        subPaket = new byte[currentRead];
                        //sslstr.Read(subPaket, 0, currentRead);
                        //sslstr.WriteByte((byte)201);//znachi ok

                        ms.Read(subPaket, 0, currentRead);
                        sslstr.Write(subPaket,0, currentRead);
                        sslstr.Flush();
                        broiPaketi--;
                        if (broiPaketi != 0)
                            if (sslstr.IsServer)
                            {
                                if (sslstr.ReadByte() != 201)
                                    throw new sslException("WriteBigData != 201");

                            }

                    }
                }
            //    File.WriteAllBytes(@"f:\sendPaket.jpg", paket);

            }
            }
           
        }

WriteBigData се захранва от :

public static T BytesToObject<T>(this byte[] data) where T : DipPacketData
        {
       
            BinaryFormatter bf = new BinaryFormatter();

             using (MemoryStream ms = new MemoryStream(data, 0, data.Length))
            {             
  
                return  (T)bf.Deserialize(ms);
            }
       }

ReadBigData: 1-вия byte е номера на обекта за десериализиране, 2-5 е uint е дължината на данните за десериализиране. - затова има 5 bytе разлика в началото на файловете.

public static byte[] Combine(params byte[][] arrays)
        {
            byte[] rv = new byte[arrays.Sum(a => a.Length)];
            int offset = 0;
            foreach (byte[] array in arrays)
            {
                System.Buffer.BlockCopy(array, 0, rv, offset, array.Length);
                offset += array.Length;
            }
            return rv;
        }
        public static byte[] ObjectToByteArray<T>(this T obj) 
        {
            if (obj == null)
                return null;
            BinaryFormatter bf = new BinaryFormatter();
            using (MemoryStream ms = new MemoryStream())
            {
                bf.Serialize(ms, obj);
                byte[] Data = ms.ToArray();
                bf = null;
                byte[] headerByteDataLenth = BitConverter.GetBytes((uint)Data.Length);
                             //HeaderV                                              //Header Data lent    Data
                return Combine(new byte[1] { obj.GetType().GetDipPacketDataType() }, headerByteDataLenth, Data);
            }
        }

Под  15000 няма проблем. От hhd на hhd големи файлове (вместо sslstream filestream).  Възможно ли е нещо да се случва по мрежата заради изхода от BinaryFormatter-а (възможно ли е нещо да ми реже нуличките - big - little endian ...)? Както виждатe съм разкарал asyn-кове и task-ве пинизите и пак дърво-всичко се изпълнява на 1 thread.

Гърмежа е при сървъра xxx.BytesToObject() (xxx е правилният тип обект - клиента и сървъра използват 1 dll, няма разлика в кода):

client.bac са данните изпратени от клиента а server.bak - Създадени са чрез immediate window на visual studioto, 

System.Runtime.Serialization.SerializationException: Binary stream '178' does
 not contain a valid BinaryHeader. Possible causes are invalid stream or object
version change between serialization and deserialization.
   at System.Runtime.Serialization.Formatters.Binary.__BinaryParser.Run()
   at System.Runtime.Serialization.Formatters.Binary.ObjectReader.Deserialize(He
aderHandler handler, __BinaryParser serParser, Boolean fCheck, Boolean isCrossAp
pDomain, IMethodCallMessage methodCallMessage)
   at System.Runtime.Serialization.Formatters.Binary.BinaryFormatter.Deserialize
(Stream serializationStream, HeaderHandler handler, Boolean fCheck, Boolean isCr
ossAppDomain, IMethodCallMessage methodCallMessage)
   at System.Runtime.Serialization.Formatters.Binary.BinaryFormatter.Deserialize
(Stream serializationStream)

client.bac server.bak