private void ASyncDataRecive(IAsyncResult asynResult)
        {
            try
            {
                UserSession css = (UserSession)asynResult.AsyncState;

                if (css.AsynSocket == null)
                {
                    return;
                }
                int i = css.AsynSocket.EndReceive(asynResult);

                if (i == 0)
                {
                    return;
                }

                string Unzipdata = UZip.Unzip(System.Text.ASCIIEncoding.ASCII.GetString(css.AsyncBuffer, 0, i));
                css.AsyncData.Append(Unzipdata);

                if (!css.AsyncData.ToString().Contains("\0"))
                {
                    css.AsynSocket.BeginReceive(css.AsyncBuffer, 0, UserSession.BufferSize, SocketFlags.None, new AsyncCallback(ASyncDataRecive), css);
                }
                else
                {
                    css.AsyncData = FilterData(css);
                    css.AsynSocket.BeginReceive(css.AsyncBuffer, 0, UserSession.BufferSize, SocketFlags.None, new AsyncCallback(ASyncDataRecive), css);
                }
            }
            catch (Exception ex)
            {
                OnServerDownError(ex);
            }
        }
Exemple #2
0
        public static void WriteZip(string filePath, string s)
        {
            byte[] b = UZip.ZipString(s);

            FileStream fs = new FileStream(filePath, FileMode.Create);

            fs.Write(b, 0, b.Length);

            fs.Close();
        }
Exemple #3
0
 private void Encrypt(string s)
 {
     try
     {
         rtbFileContent.Text = Encoding.ASCII.GetString(UZip.ZipString(s));
     }
     catch (Exception ex)
     {
         TestDebugger.Instance.WriteError(ex);
         MessageForm.Show(ex);
     }
 }
        private DataSet SyncDataRecive()
        {
            try
            {
                userSession.SyncData = new StringBuilder();

                int i = userSession.SynSocket.Receive(userSession.SyncBuffer);

                while (true)
                {
                    string Unzipdata = UZip.Unzip(System.Text.ASCIIEncoding.ASCII.GetString(userSession.SyncBuffer, 0, i));
                    userSession.SyncData.Append(Unzipdata);

                    if (!userSession.SyncData.ToString().Contains("\0"))
                    {
                        i = userSession.SynSocket.Receive(userSession.SyncBuffer);
                    }
                    else
                    {
                        break;
                    }
                }

                if (UData.IsValidXml(userSession.SyncData.ToString()))
                {
                    return(UData.LoadDataSet(userSession.SyncData.ToString()));
                }
                else
                {
                    DataSet ds = new DataSet();
                    return(ds);
                }
            }
            catch (Exception ex)
            {
                OnServerDownError(ex);

                return(new DataSet());
            }
        }
Exemple #5
0
 public static DataSet UnzipDataSet(string xsd, string ds)
 {
     return(UData.LoadDataSet(xsd, UZip.Unzip(ds)));
 }
Exemple #6
0
 public static string ZipDataSet(DataSet ds)
 {
     return(UZip.Zip(UData.ToString(ds)));
 }
Exemple #7
0
 public static DataTable UnzipDataTable(string xsd, string dt)
 {
     return(UData.LoadDataTable(xsd, UZip.Unzip(dt)));
 }
Exemple #8
0
 public static string ZipDataTable(DataTable dt)
 {
     return(UZip.Zip(UData.ToString(dt)));
 }
Exemple #9
0
 private static void WriteZip(string filePath)
 {
     UZip.WriteZip(filePath, UCrypto.Decrypt(File.ReadAllText(filePath)));
 }
Exemple #10
0
 public string ToZip()
 {
     return(UZip.Zip(this.ToString()));
 }
Exemple #11
0
 public void LoadXml(string dt)
 {
     UData.LoadDataTable(this.DataTable, UZip.Unzip(dt));
 }