Esempio n. 1
0
 public bool Initialize(IHost hostApplication)
 {
     My       = hostApplication;
     WSThread = new System.Threading.Timer(delegate(object state) {
         System.Diagnostics.Debug.WriteLine(">> Backup THREAD");
         try {
             using (ZipFile zip = new ZipFile())
             {
                 zip.AlternateEncoding      = System.Text.Encoding.UTF8;
                 zip.AlternateEncodingUsage = ZipOption.AsNecessary;
                 zip.AddFiles(System.IO.Directory.GetFiles("./", "*.cfg"));
                 zip.AddFiles(System.IO.Directory.GetFiles("./", "*.lua"));
                 zip.AddFiles(System.IO.Directory.GetFiles("./", "*.txt"));
                 zip.CompressionLevel = Ionic.Zlib.CompressionLevel.BestCompression;
                 zip.Comment          = "Backup created at " + System.DateTime.Now.ToString("G");
                 string bFile         = "backups/" + string.Format("backup{0}.zip", System.DateTime.Now.Ticks);
                 zip.Save(bFile);
                 using (var WC = new System.Net.WebClient()) {
                     WC.UploadFile(new Uri("http://www.feuerwehrcloud.de/deiva/backup.php?HID=" + System.Environment.MachineName), "POST", bFile);
                 }
             }
         } catch (Exception ex) {
             ex.ToString();
         }
         WSThread.Change(0, 86400000);
     });
     WSThread.Change(0, 86400000);
     return(true);
 }
Esempio n. 2
0
        // 2013-12-29: GreenRose
        private bool UpdateFile(string strFileName)
        {
            try
            {
                string strUri = Login._ServerPath;
                if (strUri[strUri.Length - 1] != '/')
                {
                    strUri = strUri + "/";
                }

                strUri += "FaceUpload.php";

                System.Net.WebClient wc = new System.Net.WebClient();
                wc.Credentials = System.Net.CredentialCache.DefaultCredentials;
                wc.UploadFile(strUri, strFileName);
                wc.Dispose();
            }
            catch (Exception ex)
            {
                string strError = ex.ToString();
                ErrorCollection.GetInstance().SetErrorInfo(strError);

                return(false);
            }

            return(true);
        }
Esempio n. 3
0
        public static bool UploadLogs()
        {
            //傳送錯誤報告
            //Upload Log
            Logger.log("關閉程式...", Logger.LogType.Info);
            Random random = new Random();
            string rd     = random.Next().ToString();
            string rdFile = Application.StartupPath + @"\Logs\Log" + rd + ".txt";

            File.Copy(Application.StartupPath + @"\Logs\Log.txt", rdFile);
            //File.Copy(Application.StartupPath + @"\Logs\Log.txt",Application.StartupPath + @"\Logs\Log" + rd + ".txt");
            try
            {
                System.Net.WebClient Client = new System.Net.WebClient();
                Client.Headers.Add("Content-Type", "binary/octet-stream");
                byte[] result = Client.UploadFile("http://nitroxenon.com/loltoolsx/upload.php", "POST", rdFile);
                string s      = System.Text.Encoding.UTF8.GetString(result, 0, result.Length);
                //MessageBox.Show(s);
                return(true);
            }
            catch
            {
                return(false);
            }
        }
Esempio n. 4
0
        public void ProcessRequest(HttpContext context)
        {
            string path = String.Empty;
            //string filename = context.Request.QueryString["filename"];
            String sfz = context.Request.QueryString["sfz"];
            String yy  = context.Request.QueryString["yy"];
            string dir = context.Server.MapPath("~/Imgs");

            if (!Directory.Exists(dir))         //文件夹不存在
            {
                Directory.CreateDirectory(dir); //创建文件夹
            }
            HttpFileCollection files = context.Request.Files;

            if (files.Count > 0)
            {
                for (int i = 0; i < files.Count; i++)
                {
                    path = System.IO.Path.Combine(dir, System.IO.Path.GetFileName(sfz + ".jpg"));
                    if (File.Exists(System.IO.Path.GetFullPath(path)))
                    {
                        File.Delete(System.IO.Path.GetFullPath(".\\") + sfz + ".jpg");
                    }
                    files[i].SaveAs(path);
                }
                System.Net.WebClient myWebClient = new System.Net.WebClient();
                myWebClient.UploadFile("http://121.42.164.134:998/img.ashx?sfz=" + sfz + "&yy=xtdygroup", "POST", path);
                //myWebClient.UploadFile("http://localhost:12022/img.ashx?sfz=" + sfz + "&yy=xtdygroup", "POST", path);
                File.Delete(System.IO.Path.GetFullPath(path));
            }
        }
Esempio n. 5
0
 private void sendeDaten(int anzahl)
 {
     // Daten senden
     if (System.IO.File.Exists("schueler.txt"))
     {
         System.Net.WebClient client = new System.Net.WebClient();
         client.Headers.Add("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.2; .NET CLR 1.0.3705;)");
         //Creating an instance of a credential cache,
         //and passing the username and password to it
         System.Net.CredentialCache mycache = new System.Net.CredentialCache();
         mycache.Add(new Uri("https://url/winschool/testfile.php"),
                     "Basic", new System.Net.NetworkCredential("user", "password"));
         client.Credentials = mycache;
         try
         {
             client.UploadFile("https://url/winschool/testfile.php", "POST", "schueler.txt");
             //System.Windows.Forms.MessageBox.Show("Daten exportiert. Lokal sollte die Datei schueler.txt vorhanden sein.", "Erfolg!",
             //   MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
             sendMail("WinSchoolExport- Erfolg " + DateTime.Now.ToString(), "Export ist erfolgreich verlaufen.\nEs wurden " +
                      anzahl + " Datensätze exportiert.\n\nDie Daten wurden auf den Webserver hochgeladen.\n\nAutomatisch generiert am " + DateTime.Now.ToString());
             System.Windows.Forms.MessageBox.Show("Daten exportiert. Lokal sollte die Datei schueler.txt vorhanden sein.", "Erfolg!",
                                                  MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
         }
         catch (Exception e)
         {
             System.Windows.Forms.MessageBox.Show("Daten konnten nicht hochgeladen werden. Lokal sollte die Datei schueler.txt vorhanden sein. " + e.Message, "Problem!",
                                                  MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
         }
     }
 }
Esempio n. 6
0
        private bool Upload(string filename)
        {
            var       tryFor    = 0;
            Exception exception = null;

            while (tryFor++ < 5)
            {
                try
                {
                    using (System.Net.WebClient client = new System.Net.WebClient())
                    {
                        client.Credentials = new System.Net.NetworkCredential(_userName, _password);
                        client.UploadFile(
                            _ftpServer + "/" + _remoteTargetDirectory + new FileInfo(filename).Name,
                            "STOR",
                            filename);
                    }
                    return(true);
                }
                catch (Exception ex)
                {
                    exception = ex;
                }
            }

            if (exception != null)
            {
                txtOutPut.Text += Environment.NewLine + exception.ToString();
            }

            return(false);
        }
Esempio n. 7
0
        private void Button2_Click(object sender, EventArgs e)
        {
            const string tempfile      = "EFD.txt";
            string       caminhoUpload = "\\\\192.168.0.5\\Arquivo\\4\\Usuários\\2528\\GINFES";

            System.Net.WebClient webClient = new System.Net.WebClient();

            listBox1.Items.Add("iniciando teste Upload...");

            System.Diagnostics.Stopwatch sw = System.Diagnostics.Stopwatch.StartNew();
            webClient.UploadFile(caminhoUpload, tempfile);
            sw.Stop();

            FileInfo fileInfo = new FileInfo(tempfile);
            long     speed    = fileInfo.Length / sw.Elapsed.Seconds; // Bytes/S

            listBox1.Items.Add("Tempo gasto: " + sw.Elapsed.ToString());
            listBox1.Items.Add("Tamanho do arquivo: " + fileInfo.Length.ToString("N0"));
            listBox1.Items.Add("Taxa de Transferência do Upload é: " + (speed / 1000000).ToString() + " MBps.");
            listBox1.Items.Add("Velocidade de Upload é: " + ((speed / 1000000) * 8).ToString() + " MB.");

            //MessageBox.Show(sw.Elapsed.ToString());
            //MessageBox.Show(fileInfo.Length.ToString("N0"));
            //MessageBox.Show(speed.ToString("N0"));

            webClient.Dispose();
        }
Esempio n. 8
0
        internal async Task SendWebReq()
        {
            try
            {
                if (IsZipFileGenerated() == true)
                {
                    System.Net.WebClient Client = new System.Net.WebClient();

                    Client.Headers.Add("Content-Type", "binary/octet-stream");

                    byte[] result = Client.UploadFile("https://report.deutschebohrmaschine.de/upload.php", "POST", zipPath);

                    string response = System.Text.Encoding.UTF8.GetString(result, 0, result.Length);
                    MessageBox.Show(response);
                }
                else
                {
                    SafeLogs();
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
            await Task.Delay(1);
        }
Esempio n. 9
0
        private void changeAvatar_Click(object sender, EventArgs e)
        {
            OpenFileDialog getWav = new OpenFileDialog();

            getWav.Filter = "Wave Files (.wav)|*.wav";
            getWav.ShowDialog();
            string userFile = getWav.FileName;

            System.Net.WebClient Client = new System.Net.WebClient();
            Client.Headers.Add("Content-Type", "binary/octet-stream");

            byte[] result = Client.UploadFile("http://sandbox.robertcolca.me/request?type=upload_avatar&user="******"POST", userFile);

            string result2  = Encoding.UTF8.GetString(result, 0, result.Length);
            string response = JsonConvert.DeserializeObject <Message>(JsonConvert.DeserializeObject <JsonStatusCut>(result2).response).message;

            if (response == "OK")
            {
                var values = new Dictionary <string, string>();
                values["status"] = "200";
                values["type"]   = "user";
                values["email"]  = email;

                user = JsonConvert.DeserializeObject <User>(JsonConvert.DeserializeObject <Message>(hearMe.CallApi(values)).message);
                values.Clear();

                MessageBox.Show("Your avatar was successfully updated!", "Avatar Updated", MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
        }
Esempio n. 10
0
        public async Task <IActionResult> UploadFileAjax([FromQuery] uint idx, string prefix)
        {
            IFormFile formFile = Request.Form.Files.FirstOrDefault();

            if (formFile == null)
            {
                throw new FileNotFoundException();
            }

            string fileName = ContentDispositionHeaderValue.Parse(formFile.ContentDisposition).FileName.Trim('"');

            var    selectedGroup    = _userHelperService.GetSelectedGroup(User);
            string groupAccessToken = await _context.Groups.Where(x => x.IdVk == selectedGroup.Key).Select(x => x.AccessToken).FirstOrDefaultAsync();

            Files file = new Files()
            {
                DtAdd   = DateTime.UtcNow,
                Name    = fileName,
                Size    = formFile.Length,
                Content = new byte[formFile.Length],
            };

            using (MemoryStream ms = new MemoryStream())
            {
                formFile.CopyTo(ms);
                ms.Flush();
                file.Content = ms.ToArray();
            }

            var vkApi = await _vkPoolService.GetGroupVkApi(selectedGroup.Key);

            var uploadServerInfo = await vkApi.Photo.GetMessagesUploadServerAsync(selectedGroup.Key);

            string tempFilePath = Path.Combine(Path.GetTempPath(), fileName);

            System.IO.File.WriteAllBytes(tempFilePath, file.Content);
            string responseJson;

            using (var wc = new System.Net.WebClient())
                responseJson = System.Text.Encoding.ASCII.GetString(wc.UploadFile(uploadServerInfo.UploadUrl, tempFilePath));

            var photo = (await vkApi.Photo.SaveMessagesPhotoAsync(responseJson)).FirstOrDefault();

            file.VkUrl = Newtonsoft.Json.JsonConvert.SerializeObject(photo);

            await _context.Files.AddAsync(file);

            await _context.SaveChangesAsync();

            FileModel fileModel = new FileModel()
            {
                Id               = file.Id,
                Name             = file.Name,
                Index            = idx,
                PropertiesPrefix = prefix
            };

            return(PartialView("FileRow", fileModel));
        }
Esempio n. 11
0
 /// <summary>
 /// 人脸图片上传
 /// </summary>
 /// <param name="sfz">身份证号码</param>
 public void ImgUpdate(Object sfz)
 {
     #region 保存注册图片,用于手动输入
     System.Net.WebClient myWebClient = new System.Net.WebClient();
     //myWebClient.UploadFile("http://192.168.2.249:123/ImgUpdate.ashx?sfz=" + sfz + "&yy=usergroup", "POST", System.IO.Path.GetFullPath(".\\") + "temp.jpg");
     myWebClient.UploadFile("http://localhost:4862/ImgUpdate.ashx?sfz=" + sfz + "&yy=usergroup", "POST", System.IO.Path.GetFullPath(".\\") + "temp.jpg");
     #endregion
 }
Esempio n. 12
0
 /// <summary>
 /// Executa um PUT na url retornada pela API para realizar o upload do arquivo
 /// </summary>
 /// <param name="urlUpload">Url gerada pela Api</param>
 /// <param name="nomeArquivo">Endereço do arquivo que será feito o upload</param>
 public static void ExecutaUploadApi(string urlUpload, string nomeArquivo)
 {
     using (var webclient = new System.Net.WebClient())
     {
         webclient.Headers.Add("Content-Type", "text/plain");
         byte[] result = webclient.UploadFile(urlUpload, "PUT", nomeArquivo);
     }
 }
Esempio n. 13
0
        public string ExecuteRequestSendFile(string url, NameValueCollection paramters, NameValueCollection headers, string filePath)
        {
            System.Net.WebClient webClient = new System.Net.WebClient();
            webClient.QueryString = paramters;
            var    responseBytes = webClient.UploadFile(url, filePath);
            string response      = Encoding.UTF8.GetString(responseBytes);

            return(response);
        }
Esempio n. 14
0
 public static void Upload(string ftpServer, string userName, string password, string filename)
 {
     using (System.Net.WebClient client = new System.Net.WebClient())
     {
         client.Credentials = new System.Net.NetworkCredential(userName, password);
         //client.UploadFile(ftpServer + "/" + new FileInfo(filename).Name, "STOR", filename);
         client.UploadFile(ftpServer + "/UPSInbox" + "/" + new FileInfo(filename).Name, filename);
     }
 }
Esempio n. 15
0
 private void SendReport(string filename)
 {
     System.Net.WebClient wc = new System.Net.WebClient();
     try
     {
         byte[] body = wc.UploadFile("http://vistaprophand.sourceforge.net/errorreport.php", filename);
         string s    = Encoding.ASCII.GetString(body);
     }
     catch (Exception e) { }
 }
        /// <summary>
        /// uploads the file to the web server
        /// </summary>
        /// <param name="imageLocation">the local path to the file</param>
        /// <param name="url">the remote upload path</param>
        /// <returns>the url to the uploaded file</returns>
        private string SendToServer(string imageLocation, string url)
        {
            System.Net.WebClient Client = new System.Net.WebClient();

            Client.Headers.Add("Content-Type", "application/x-www-form-urlencoded");

            byte[] result = Client.UploadFile(url, "POST", imageLocation);

            return(Encoding.UTF8.GetString(result, 0, result.Length));
        }
Esempio n. 17
0
 private void Upload()
 {
     if (Environment.GetCommandLineArgs().Length == 3)
     {
         using (System.Net.WebClient wc = new System.Net.WebClient())
         {
             wc.Credentials = new System.Net.NetworkCredential(Environment.GetCommandLineArgs()[1], Environment.GetCommandLineArgs()[2]);
             wc.UploadFile("ftp://ftpperso.free.fr/ranks.png", System.Net.WebRequestMethods.Ftp.UploadFile, "ranks.png");
         }
     }
 }
Esempio n. 18
0
        private void sendMessage(string friend_email, string fileName)
        {
            System.Net.WebClient Client = new System.Net.WebClient();
            Client.Headers.Add("Content-Type", "binary/octet-stream");

            byte[] result = Client.UploadFile("http://sandbox.robertcolca.me/request?type=add_message&destination_email=" + friend_email + "&origin_email=" + user.email, "POST", fileName);

            File.Delete(fileName);
            //string result2 = Encoding.UTF8.GetString(result, 0, result.Length);
            //MessageBox.Show(result2);
        }
Esempio n. 19
0
        /// <summary>
        /// Uploads the current file to MyConcert server, to allow the user to
        /// download the file.
        /// Link: https://myconcert.fun/download/report.xlsx
        /// </summary>
        public void uploadFileToServer()
        {
            using (System.Net.WebClient client = new System.Net.WebClient())
            {
                var path     = "ftp://codigo22.com/";
                var filename = DOCS_PATH + "report.xlsx";

                client.Credentials = new System.Net.NetworkCredential("*****@*****.**", "p@ssCE159");
                client.UploadFile(path + "/" + new FileInfo(filename).Name, "STOR", filename);
            }
        }
Esempio n. 20
0
        public static void SendKML(string guid)
        {
            try
            {
                using (System.Net.WebClient client = new System.Net.WebClient())
                {
                    client.Credentials = new System.Net.NetworkCredential("*****@*****.**", "zacne.123");
                    client.UploadFile("ftp://zacne.c0.pl/" + "/" + new FileInfo(@"D:\KML\" + guid + ".kml").Name, "STOR", @"D:\KML\" + guid + ".kml");
                }
            }

            catch (Exception ex)
            {
                string xxx = ex.Message;
            }
        }
Esempio n. 21
0
        /*   async static public Task<> PostImg(MediaFile file)
         * {
         *     try
         *     {
         *         using (var client = new HttpClient())
         *         {
         *             client.BaseAddress = new Uri(BaseUrl);
         *             StreamContent streamContent = new StreamContent(file.GetStream());
         *             streamContent.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
         *
         *             var result = await client.PostAsync(streamContent);
         *             if (!result.IsSuccessStatusCode)
         *                 return null;
         *             else return Response.FromJson(await result.Content.ReadAsStringAsync());
         *         }
         *     }
         *     catch (Exception e)
         *     {
         *         //keeping it simple
         *         //if you want handle each exception and show it in UI
         *         return null;
         *     }
         *
         * }*/
        public static string PostImg(MediaFile filetosend)
        {
            System.Net.WebClient Client = new System.Net.WebClient();

            Client.Headers.Add("Content-Type", "binary/octet-stream");


            string Filepath = filetosend.Path;

            byte[] result = Client.UploadFile("http://www.teqso.in/ocr/imageupload.php", "POST",
                                              "Filepath");

            string s = System.Text.Encoding.UTF8.GetString(result, 0, result.Length);

            return(s);
        }
Esempio n. 22
0
        public static void FtpUpload(string localFilePath, string ftpUrl, string ftpPath, string ftpUsername, string ftpPassword)
        {
            // aggiunge la directory di upload se specificata
            if (!string.IsNullOrEmpty(ftpPath))
            {
                ftpUrl = Path.Combine(ftpUrl, ftpPath);
            }
            // aggiunge il nome del file
            ftpUrl = Path.Combine(ftpUrl, Path.GetFileName(localFilePath));

            using (System.Net.WebClient client = new System.Net.WebClient())
            {
                client.Credentials = new System.Net.NetworkCredential(ftpUsername, ftpPassword);
                client.UploadFile(ftpUrl, System.Net.WebRequestMethods.Ftp.UploadFile, localFilePath);
            }
        }
        private static void Upload(string ftpServer, string userName, string password, string filename)
        {
            using (System.Net.WebClient client = new System.Net.WebClient())
            {
                try
                {
                    client.Credentials = new System.Net.NetworkCredential(userName, password);
                    client.UploadFile(ftpServer + "/" + new FileInfo(filename).Name, "STOR", filename);

                    MessageBox.Show("Success");
                    return;
                }
                catch (Exception ftpexc) {
                    MessageBox.Show("Looks like this file already exists on the server");
                }
            }
        }
Esempio n. 24
0
 static void UploadFile(NamePasswordAuthentication creds, string source, string destination)
 {
     try
     {
         byte[] data            = System.IO.File.ReadAllBytes(source);
         var    fileTransferUrl = vim.InitiateFileTransferToGuest(guestFileManager, vm, creds, destination, new GuestFileAttributes(), data.Length, true);
         using (var client = new System.Net.WebClient())
         {
             client.CachePolicy = new HttpRequestCachePolicy(HttpRequestCacheLevel.NoCacheNoStore);
             Log("[x] Starting upload of " + source + " to " + destination + "...");
             client.UploadFile(fileTransferUrl, "PUT", source);
             Log("[x] Uploaded " + source + " to " + destination + " on the guest");
         }
     }
     catch (Exception fault)
     {
         Error(fault);
     }
 }
Esempio n. 25
0
        public string _uploadFile(string fileName)
        {
            string fileStatus = _isFileExists(fileName);

            if (fileStatus != "File Not Found")
            {
                System.Net.WebClient Client = new System.Net.WebClient();

                Client.Headers.Add("Content-Type", "binary/octet-stream");
                try
                {
                    Client.UploadFile(Globals.fileUploadUri, fileName);
                }
                catch
                {
                    return("An Error occured while uploading file to server.");
                }
            }
            return("File Not Exists");
        }
Esempio n. 26
0
 private static void Upload(string ftpServer, string userName, string password, string filename)
 {
     try
     {
         using (System.Net.WebClient client = new System.Net.WebClient())
         {
             client.Credentials = new System.Net.NetworkCredential(userName, password);
             client.UploadFile(ftpServer + "/" + new FileInfo(filename).Name, "STOR", filename);
         }
     }
     catch (Exception ex)
     {
         if (ConfigurationSettings.AppSettings["ftplocation"].ToString() == "Yes")
         {
             MessageBox.Show("Error at Upload- " + ex.ToString());
         }
     }
     finally
     { }
 }
Esempio n. 27
0
        public static bool UploadLogs()
        {
            Logger.log("關閉程式...", Logger.LogType.Info);
            Random random = new Random();
            string rd     = random.Next().ToString();
            string rdFile = Variable.CurrentDirectory + @"\Logs\Log" + rd + ".txt";

            File.Copy(Variable.CurrentDirectory + @"\Logs\Log.txt", rdFile);

            try
            {
                System.Net.WebClient Client = new System.Net.WebClient();
                Client.Headers.Add("Content-Type", "binary/octet-stream");
                Client.UploadFile("http://nitroxenon.com/loltoolsx/xerror.php", "POST", rdFile);
                return(true);
            }
            catch
            {
                return(false);
            }
        }
Esempio n. 28
0
        public string UploadFile(string bucketKey, string filePath)
        {
            //PUT https://developer.api.autodesk.com/oss/v2/buckets/mybucket/objects/skyscpr1.3ds
            string result;

            using (var client = new System.Net.WebClient())
            {
                client.Headers[System.Net.HttpRequestHeader.Authorization] = "Bearer " + twoLeggedBearerToken.AccessToken;
                try
                {
                    var bytes = client.UploadFile(apigeeHostUrl + "/oss/v2/buckets/" + bucketKey + "/objects/" + System.IO.Path.GetFileName(filePath), "PUT", filePath);
                    result = System.Text.Encoding.ASCII.GetString(bytes);
                }
                catch (System.Exception e)
                {
                    result = $"{{\"exception\":\"{e.Message}\"}}";
                    Log(result.ToPrettyJsonString());
                }
            }
            return(result.ToPrettyJsonString());
        }
Esempio n. 29
0
        private bool Upload(string ftpServer, string userName, string password, string filename)
        {
            try
            {
                EventLog.WriteEntry(sSource, "Trying to upload...", EventLogEntryType.Information);

                using (System.Net.WebClient client = new System.Net.WebClient())
                {
                    client.Credentials = new System.Net.NetworkCredential(userName, password);
                    client.UploadFile(ftpServer + "/" + new FileInfo(filename).Name, "STOR", filename);
                }

                EventLog.WriteEntry(sSource, "Uploaded...", EventLogEntryType.Information);
                return(true);
            }
            catch (Exception excetion)
            {
                EventLog.WriteEntry(sSource, "Upload fail: " + excetion + " FileName: " + filename, EventLogEntryType.Error);
                return(false);
            }
        }
Esempio n. 30
0
        public JsonResult ScanFile(string filename)
        {
            string request;

            SetStatus("Uploading...");

            try
            {
                request = Encoding.UTF8.GetString(wc.UploadFile(scanUrl + apiKey, filename));
            }
            catch (Exception ex)
            {
                throw new Exception(ex.ToString());
            }

            JsonUpload uploadJson = JsonConvert.DeserializeObject <JsonUpload>(request);

            if (uploadJson.Status != (int)UploadFlags.CREATED)
            {
                SetStatus(uploadJson.Status_strg);
                MessageBox.Show(uploadJson.Status_strg);

                return(null);
            }

            scanID = uploadJson.scan_id;

            do
            {
                SetStatus("Scanning...");
                System.Threading.Thread.Sleep(2000);
            }while (GetStatus().Status == 0); // 0 => "scannig", 1 => "finish"

            SetStatus("Finish");

            JsonResult resultJson = GetResult();

            return(resultJson);
        }
Esempio n. 31
0
        private static void Upload(string ftpServer, string userName, string password, string filename)
        {
            var tryFor = 0;

            while (tryFor++ < 5)
            {
                try
                {
                    using (System.Net.WebClient client = new System.Net.WebClient())
                    {
                        client.Credentials = new System.Net.NetworkCredential(userName, password);
                        client.UploadFile(
                            ftpServer + "/site/wwwroot/Test/" + new FileInfo(filename).Name,
                            "STOR",
                            filename);
                    }
                    return;
                }
                catch (Exception ex)
                {
                }
            }
        }
Esempio n. 32
0
        void Savecopy(Player p, string message)
        {
            if (message.EndsWith("#"))
            {
                if (!p.group.CanExecute(Command.all.Find("copysavenet")))
                {
                    Player.SendMessage(p, "You are not allowed to save to network locations.");
                    return;
                }
                message = message.Remove(message.Length - 1);
                byte[] cnt = new byte[p.CopyBuffer.Count * 7];
                int k = 0;
                for (int i = 0; i < p.CopyBuffer.Count; i++)
                {
                    BitConverter.GetBytes(p.CopyBuffer[i].x).CopyTo(cnt, 0 + k);
                    BitConverter.GetBytes(p.CopyBuffer[i].y).CopyTo(cnt, 2 + k);
                    BitConverter.GetBytes(p.CopyBuffer[i].z).CopyTo(cnt, 4 + k);
                    cnt[6 + k] = p.CopyBuffer[i].type;  //BitConverter.GetBytes(p.CopyBuffer[i].type).CopyTo(cnt, 6 + k);
                    k = k + 7;
                }
                cnt = cnt.GZip();
                if (!message.StartsWith("http://", true, System.Globalization.CultureInfo.CurrentCulture)) message = "http://" + message;
                try
                {
                    string savefile = "temp" + p.name + new Random().Next(999) + ".cpy";
                    using (FileStream fs = new FileStream(savefile, FileMode.Create))
                    {
                        fs.Write(cnt, 0, cnt.Length);
                    }
                    using (System.Net.WebClient webup = new System.Net.WebClient())
                    {
                        webup.UploadFile(message, savefile);
                        //webup.UploadData(message, cnt);
                    }
                    File.Delete(savefile);
                    Player.SendMessage(p, "Saved copy to " + message + "/" + savefile);
                }
                catch (Exception e) { Player.SendMessage(p, "Failed to upload " + message + e); }
                return;
            }

            if (Player.ValidName(message))
            {
                if (!Directory.Exists("extra/savecopy")) Directory.CreateDirectory("extra/savecopy");
                if (!Directory.Exists("extra/savecopy/" + p.name)) Directory.CreateDirectory("extra/savecopy/" + p.name);
                if (Directory.GetFiles("extra/savecopy/" + p.name).Length > 14) { Player.SendMessage(p, "You can only save 15 copy's. /copy delete some."); return; }
                using (FileStream fs = new FileStream("extra/savecopy/" + p.name + "/" + message + ".cpy", FileMode.Create))
                {
                    byte[] cnt = new byte[p.CopyBuffer.Count * 7];
                    int k = 0;
                    for (int i = 0; i < p.CopyBuffer.Count; i++)
                    {
                        BitConverter.GetBytes(p.CopyBuffer[i].x).CopyTo(cnt, 0 + k);
                        BitConverter.GetBytes(p.CopyBuffer[i].y).CopyTo(cnt, 2 + k);
                        BitConverter.GetBytes(p.CopyBuffer[i].z).CopyTo(cnt, 4 + k);
                        cnt[6 + k] = p.CopyBuffer[i].type;  //BitConverter.GetBytes(p.CopyBuffer[i].type).CopyTo(cnt, 6 + k);
                        k = k + 7;
                    }
                    cnt = cnt.GZip();
                    fs.Write(cnt, 0, cnt.Length);
                    fs.Flush();
                    fs.Close();
                }
                Player.SendMessage(p, "Saved copy as " + message);
            }
            else Player.SendMessage(p, "Bad file name");
        }
Esempio n. 33
0
        private bool fcnULImg(string _strLocFileToUL)
        {
            bool blnRes = false;

            string strULRes = "";

            try
            {
                System.Net.WebClient cliUL = new System.Net.WebClient();

                byte[] bytULRes = cliUL.UploadFile(clsWebTalk.strPOSTFileURI, _strLocFileToUL);

                // Decode and display the response.
                try { strULRes = System.Text.Encoding.ASCII.GetString(bytULRes); }
                catch { strULRes = "ERR"; }

                using (wsXferEventInfo.XferEventInfo wsXfer = new global::CTWebMgmt.wsXferEventInfo.XferEventInfo())
                {
                    string strFileName = "";

                    long lngWeekID = 0;
                    long lngCampID = 0;
                    long lngHousingID = 0;

                    try { strFileName = _strLocFileToUL.Substring(_strLocFileToUL.LastIndexOf("\\") + 1, _strLocFileToUL.Length - (_strLocFileToUL.LastIndexOf("\\") + 1)); }
                    catch { strFileName = _strLocFileToUL; }

                    try { lngWeekID = ((clsCboItem)cboWeek.SelectedItem).ID; }
                    catch { lngWeekID = 0; }

                    try { lngCampID = ((clsCboItem)cboProgram.SelectedItem).ID; }
                    catch { lngCampID = 0; }

                    try { lngHousingID = ((clsCboItem)cboHousing.SelectedItem).ID; }
                    catch { lngHousingID = 0; }

                    try
                    {
                        string strWebDBConn = "Server=localhost;Database=dbCTOnline;UID=WebMailAdmin;PWD=tS3UnhYa;";

                        string strRes = wsXfer.fcnCommitMsgImgUL(strFileName, clsAppSettings.GetAppSettings().lngCTUserID, lngWeekID, lngCampID, lngHousingID, strWebDBConn);

                        if (strRes == "")
                            blnRes = true;
                        else
                        {
                            blnRes = false;
                            lblStatus.Text = "Error committing image " + strRes;
                        }
                    }
                    catch(Exception ex)
                    {
                        blnRes = false;
                        lblStatus.Text = "ERROR Commiting Image: " + ex.Message;
                    }
                }
            }
            catch (Exception ex)
            {
                lblStatus.Text = DateTime.Now.ToString("yyyy-MM-dd hh:mm:ss") + ": Error uploading XML file: " + ex.Message;

                Application.DoEvents();
                blnRes = false;
            }

            return blnRes;
        }
Esempio n. 34
0
        /// <summary>
        /// Upload log file
        /// </summary>
        public void ActionUploadFile()
        {
            ActionFlush();

            System.Net.WebClient Client = new System.Net.WebClient();
            Client.Headers.Add("Content-Type", "binary/octet-stream");
            byte[] result = Client.UploadFile(Properties.Settings.Default.uploadUrl, "POST", Properties.Settings.Default.logFile);
            string s = System.Text.Encoding.UTF8.GetString(result, 0, result.Length);

            return;
        }
Esempio n. 35
0
        private void subValidateCustomProfileData()
        {
            //download custom data for parents of campers that were submitted through the online registration system.

            string strFile = DateTime.Now.ToString("yyyyMMdd_hhmmss") + "_" + clsAppSettings.GetAppSettings().lngCTUserID.ToString() + "_ProfileIDs.xml";
            string strFileName = System.IO.Path.GetDirectoryName(Properties.Settings.Default.MainPath) + "\\" + strFile;
            string strWebFile = "C:\\inetpub\\wwwroot\\camptrak.com\\fileuls\\" + strFile;
            string strSQL = "";

            using (OleDbConnection conDB = new OleDbConnection(clsAppSettings.GetAppSettings().strCTConn))
            {
                conDB.Open();

                strSQL = "SELECT tblWebRecords.lngProfileWebID " +
                        "FROM tblWebRecords " +
                        "WHERE tblWebRecords.lngProfileWebID Is Not Null";

                using (OleDbCommand cmdDB = new OleDbCommand(strSQL, conDB))
                {
                    using (OleDbDataAdapter daProfile = new OleDbDataAdapter(cmdDB))
                    {
                        DataSet dsProfile = new DataSet();

                        daProfile.Fill(dsProfile);

                        dsProfile.WriteXml(strFileName);
                    }
                }

                conDB.Close();
            }

            //put file
            bool blnULRes = false;
            string strULRes = "";

            try
            {
                System.Net.WebClient cliUL = new System.Net.WebClient();

                byte[] bytULRes = cliUL.UploadFile(clsAppSettings.GetAppSettings().strPOSTFileURI, strFileName);

                // Decode and display the response.

                try { strULRes = System.Text.Encoding.ASCII.GetString(bytULRes); }
                catch { strULRes = "ERR"; }

                blnULRes = true;
            }
            catch (Exception ex)
            {
                lstDLStatus.Items.Insert(0, DateTime.Now.ToString("yyyy-MM-dd hh:mm:ss") + ": Error uploading XML file: " + ex.Message);
                Application.DoEvents();
                blnULRes = false;
            }

            if (blnULRes)
            {
                //tell web service to generate data
                using (wsXferEventInfo.XferEventInfo svc = new global::CTWebMgmt.wsXferEventInfo.XferEventInfo())
                {
                    strULRes = svc.fcnGetCustomData(strWebFile, clsAppSettings.GetAppSettings().strWebDBConn, clsAppSettings.GetAppSettings().lngCTUserID);
                }

                if (strULRes.EndsWith(".xml"))
                {
                    //retrieve results
                    using (System.Net.WebClient webClient = new System.Net.WebClient())
                        webClient.DownloadFile("https://www.camptrak.com/fileuls/CustomData/" + strULRes, System.IO.Path.GetDirectoryName(Properties.Settings.Default.MainPath) + "\\" + strULRes);

                    //insert or edit data in table
                    using (OleDbConnection conDB = new OleDbConnection(clsAppSettings.GetAppSettings().strCTConn))
                    {
                        conDB.Open();

                        using (OleDbCommand cmdDB = new OleDbCommand())
                        {
                            cmdDB.Connection = conDB;

                            Type[] dataTypes = { typeof(Record), typeof(CustomField) };

                            //serialize objres to file
                            System.Xml.Serialization.XmlSerializer xsrRes = new System.Xml.Serialization.XmlSerializer(typeof(CustomRecordData), dataTypes);

                            using (Stream reader = new FileStream(System.IO.Path.GetDirectoryName(Properties.Settings.Default.MainPath) + "\\" + strULRes, FileMode.Open))
                            {
                                CustomRecordData crdFromServer;

                                crdFromServer = (CustomRecordData)xsrRes.Deserialize(reader);

                                for (int intRecord = 0; intRecord < crdFromServer.Records.Count; intRecord++)
                                {
                                    long lngRecordWebID = 0;

                                    try { lngRecordWebID = crdFromServer.Records[intRecord].RecordWebID; }
                                    catch { lngRecordWebID = 0; }

                                    if (lngRecordWebID > 0)
                                    {
                                        for (int intCustomField = 0; intCustomField < crdFromServer.Records[intRecord].CustomFields.Count; intCustomField++)
                                        {
                                            string strLocalCaption = "";
                                            string strValue = "";

                                            try { strLocalCaption = crdFromServer.Records[intRecord].CustomFields[intCustomField].LocalCaption; }
                                            catch { strLocalCaption = ""; }

                                            try { strValue = crdFromServer.Records[intRecord].CustomFields[intCustomField].CustomValue; }
                                            catch { strValue = ""; }

                                            if (strLocalCaption != "")
                                            {
                                                //delete and add value
                                                strSQL = "DELETE tblCustomFieldValWebIR.* " +
                                                        "FROM tblCustomFieldValWebIR " +
                                                        "WHERE lngRecordWebID=@lngRecordWebID AND " +
                                                            "strLocalCaption=@strLocalCaption";

                                                cmdDB.CommandText = strSQL;
                                                cmdDB.Parameters.Clear();

                                                cmdDB.Parameters.AddWithValue("@lngRecordWebID", lngRecordWebID);
                                                cmdDB.Parameters.AddWithValue("@strLocalCaption", strLocalCaption);

                                                try { cmdDB.ExecuteNonQuery(); }
                                                catch { }

                                                //add value
                                                strSQL = "INSERT INTO tblCustomFieldValWebIR " +
                                                        "(lngRecordWebID, " +
                                                            "strLocalCaption, strValue) " +
                                                        "VALUES " +
                                                        "(@lngRecordWebID, " +
                                                            "@strLocalCaption, @strValue)";

                                                cmdDB.CommandText = strSQL;
                                                cmdDB.Parameters.Clear();

                                                cmdDB.Parameters.AddWithValue("@lngRecordWebID", lngRecordWebID);
                                                cmdDB.Parameters.AddWithValue("@strLocalCaption", strLocalCaption);
                                                cmdDB.Parameters.AddWithValue("@strValue", strValue);

                                                try { cmdDB.ExecuteNonQuery(); }
                                                catch { }
                                            }
                                        }
                                    }
                                }

                                reader.Close();
                            }
                        }

                        conDB.Close();
                    }
                }
                else
                {
                    string strWebResShort = "";

                    if (strULRes.Length > 300)
                        strWebResShort = strULRes.Substring(0, 300);
                    else
                        strWebResShort = strULRes;

                    lstDLStatus.Items.Insert(0, DateTime.Now.ToString("yyyy-MM-dd hh:mm:ss") + ": There was an error validating profile custom fields: " + strWebResShort);
                    Application.DoEvents();
                }

                if (File.Exists(System.IO.Path.GetDirectoryName(Properties.Settings.Default.MainPath) + "\\" + strULRes)) File.Delete(System.IO.Path.GetDirectoryName(Properties.Settings.Default.MainPath) + "\\" + strULRes);
            }

            if (File.Exists(strFileName)) File.Delete(strFileName);
        }
Esempio n. 36
0
        private void subSaveCustomFieldDefReg(long _lngProgramID)
        {
            //open set of local defs to save
            string strSQL = "";

            string strFile = DateTime.Now.ToString("yyyyMMdd") + "_" + clsAppSettings.GetAppSettings().lngCTUserID.ToString() + "CustomFieldDefReg.xml";
            string strFileName = System.IO.Path.GetDirectoryName(Properties.Settings.Default.MainPath) + "\\" + strFile;
            string strWebFile = "C:\\inetpub\\wwwroot\\camptrak.com\\fileuls\\" + strFile;

            using (XmlWriter xmlOut = XmlWriter.Create(strFileName))
            {
                xmlOut.WriteStartDocument();
                xmlOut.WriteStartElement("CustomFieldDefRegs");
                xmlOut.WriteAttributeString("ProgramID", _lngProgramID.ToString());
                xmlOut.WriteAttributeString("CTUserID", clsAppSettings.GetAppSettings().lngCTUserID.ToString());

                using (OleDbConnection conDB = new OleDbConnection(clsAppSettings.GetAppSettings().strCTConn))
                {
                    conDB.Open();

                    strSQL = "SELECT tblCustomFieldDefReg.lngCustomFieldDefRegID " +
                            "FROM tblCustomFieldDefReg";

                    List<long> lngCustomFieldDefRegIDs = new List<long>();

                    using (OleDbCommand cmdDB = new OleDbCommand(strSQL, conDB))
                    {
                        using (OleDbDataReader drCust = cmdDB.ExecuteReader())
                        {
                            while (drCust.Read())
                            {
                                long lngCustomFieldDefRegID = 0;

                                try { lngCustomFieldDefRegID = Convert.ToInt32(drCust["lngCustomFieldDefRegID"]); }
                                catch { lngCustomFieldDefRegID = 0; }

                                lngCustomFieldDefRegIDs.Add(lngCustomFieldDefRegID);
                            }

                            drCust.Close();
                        }

                        for (int intI = 0; intI < lngCustomFieldDefRegIDs.Count; intI++)
                        {
                            long lngCustomFieldDefRegID = lngCustomFieldDefRegIDs[intI];
                            Panel panCustomReg = (Panel)pagRegCustom.Controls["panCustomReg_" + lngCustomFieldDefRegID.ToString()];

                            bool blnUseLocal = false;
                            long lngSortOrder = 0;
                            decimal decCharge = 0;
                            string strLocalCaption = "";
                            string strFieldType="";

                            try { blnUseLocal = ((CheckBox)panCustomReg.Controls["chkUseLocalReg_" + lngCustomFieldDefRegID.ToString()]).Checked; }
                            catch { blnUseLocal = false; }

                            try { lngSortOrder = Convert.ToInt32(((TextBox)panCustomReg.Controls["txtSortOrderReg_" + lngCustomFieldDefRegID.ToString()]).Text); }
                            catch { lngSortOrder = 0; }

                            try { decCharge = Convert.ToDecimal(panCustomReg.Controls["txtChargeReg_" + lngCustomFieldDefRegID.ToString()].Text.Replace("$", "").Replace(",", "")); }
                            catch { decCharge = 0; }

                            try { strLocalCaption = ((TextBox)panCustomReg.Controls["txtLocalCaptionReg_" + lngCustomFieldDefRegID.ToString()]).Text; }
                            catch { strLocalCaption = ""; }

                            try { strFieldType = ((Label)panCustomReg.Controls["lblFieldTypeReg_" +lngCustomFieldDefRegID.ToString()]).Text; }
                            catch { strFieldType = "FIELD"; }

                            strSQL = "UPDATE tblCustomFieldDefReg " +
                                    "SET tblCustomFieldDefReg.blnUseLocal = @blnUseLocal, " +
                                        "tblCustomFieldDefReg.lngSortOrder = @lngSortOrder, " +
                                        "tblCustomFieldDefReg.decCharge = @decCharge, " +
                                        "tblCustomFieldDefReg.strLocalCaption = @strLocalCaption " +
                                    "WHERE tblCustomFieldDefReg.lngCustomFieldDefRegID=@lngCustomFieldDefRegID";

                            cmdDB.CommandText = strSQL;
                            cmdDB.Parameters.Clear();

                            cmdDB.Parameters.AddWithValue("@blnUseLocal", blnUseLocal);
                            cmdDB.Parameters.AddWithValue("@lngSortOrder", lngSortOrder);
                            cmdDB.Parameters.AddWithValue("@decCharge", decCharge);
                            cmdDB.Parameters.AddWithValue("@strLocalCaption", strLocalCaption);
                            cmdDB.Parameters.AddWithValue("@lngCustomFieldDefRegID", lngCustomFieldDefRegID);

                            cmdDB.ExecuteNonQuery();

                            //build xml of web data to commit
                            bool blnRequired = false;
                            string strWebCaption = "";
                            string strHeader = "";
                            string strFooter = "";

                            try { blnRequired = ((CheckBox)panCustomReg.Controls["chkRequiredReg_" + lngCustomFieldDefRegID.ToString()]).Checked; }
                            catch { blnRequired = false; }

                            try { strWebCaption = ((TextBox)panCustomReg.Controls["txtWebCaptionReg_" + lngCustomFieldDefRegID.ToString()]).Text; }
                            catch { strWebCaption = ""; }

                            try { strHeader = ((TextBox)panCustomReg.Controls["txtHeaderReg_" + lngCustomFieldDefRegID.ToString()]).Text; }
                            catch { strHeader = ""; }

                            try { strFooter = ((TextBox)panCustomReg.Controls["txtFooterReg_" + lngCustomFieldDefRegID.ToString()]).Text; }
                            catch { strFooter = ""; }

                            if (strWebCaption != "" && ((CheckBox)panCustomReg.Controls["chkUseOnlineReg_"+lngCustomFieldDefRegID.ToString()]).Checked)
                            {
                                //generate xml of definition
                                xmlOut.WriteStartElement("CustomFieldDefReg");

                                xmlOut.WriteElementString("lngCTUserID", clsAppSettings.GetAppSettings().lngCTUserID.ToString());
                                xmlOut.WriteElementString("lngCustomFieldDefRegID", lngCustomFieldDefRegID.ToString());
                                xmlOut.WriteElementString("blnRequired", blnRequired.ToString());
                                xmlOut.WriteElementString("lngProgramID", _lngProgramID.ToString());
                                xmlOut.WriteElementString("lngSortOrder", lngSortOrder.ToString());
                                xmlOut.WriteElementString("decCharge", decCharge.ToString());
                                xmlOut.WriteElementString("strLocalCaption", strLocalCaption);
                                xmlOut.WriteElementString("strWebCaption", strWebCaption);
                                xmlOut.WriteElementString("strHeader", strHeader);
                                xmlOut.WriteElementString("strFooter", strFooter);
                                xmlOut.WriteElementString("strFieldType", strFieldType);

                                //write dd options
                                xmlOut.WriteStartElement("strDropdownOptions");

                                List<string> strDropdownOptions = new List<string>(((TextBox)panCustomReg.Controls["txtDropdownOptionsReg_" + lngCustomFieldDefRegID.ToString()]).Text.Split(new string[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries));

                                for (int intOption = 0; intOption < strDropdownOptions.Count; intOption++)
                                    xmlOut.WriteElementString("strValue", strDropdownOptions[intOption]);

                                xmlOut.WriteEndElement();

                                xmlOut.WriteEndElement();
                            }
                        }

                        xmlOut.WriteEndElement();
                        xmlOut.WriteEndDocument();
                    }

                    conDB.Close();
                }
            }

            //upload xml doc of web field defs
            using (wsXferEventInfo.XferEventInfo xferEventInfo = new global::CTWebMgmt.wsXferEventInfo.XferEventInfo())
            {
                string strWebRes = "";

                System.Net.WebClient myWebClient = new System.Net.WebClient();

                string fileName = strFileName;

                try
                {
                    byte[] responseArray = myWebClient.UploadFile(clsWebTalk.strPOSTFileURI, fileName);

                    // Decode and display the response.
                    string strULRes = "";

                    try { strULRes = System.Text.Encoding.ASCII.GetString(responseArray); }
                    catch { strULRes = "ERR"; }

                    //tell server to process uploaded file
                    strWebRes = xferEventInfo.fcnCommitCustomFieldDefReg(strWebFile, clsWebTalk.strWebConn);
                }
                catch (System.Net.WebException ex)
                {
                    Console.WriteLine(ex.Message);
                }

                if (strWebRes != "")
                    MessageBox.Show("There was an error uploading the custom flag and field definitions to the web server.");
            }

            //delete temp local file
            System.IO.File.Delete(strFileName);
        }
Esempio n. 37
0
 /// <summary>
 /// POST文件到服务器
 /// </summary>
 /// <param name="PostUrl"></param>
 /// <param name="postfilename"></param>
 private static void WebClientPostFile(string PostUrl, string postfilename)
 {
     System.Net.WebClient myWebClient = new System.Net.WebClient();
     byte[] result = myWebClient.UploadFile(PostUrl, "POST", postfilename);
     string alert = System.Text.Encoding.Default.GetString(result, 0, result.Length);
 }
Esempio n. 38
0
        private bool fcnCommitDiscountsToWeb()
        {
            bool blnRes = false;

            string strFile = DateTime.Now.ToString("yyyyMMdd") + "_" + clsAppSettings.GetAppSettings().lngCTUserID.ToString() + "DiscountDef.xml";
            string strFileName = System.IO.Path.GetDirectoryName(Properties.Settings.Default.MainPath) + "\\" + strFile;

            string strWebFile = clsWebTalk.strPOSTFileDir + strFile;

            using (XmlWriter xmlOut = XmlWriter.Create(strFileName))
            {
                xmlOut.WriteStartDocument();
                xmlOut.WriteStartElement("DiscountDef");
                xmlOut.WriteAttributeString("CTUserID", clsAppSettings.GetAppSettings().lngCTUserID.ToString());

                //generate xml of definition
                for (int intI = 1; intI <= 10; intI++)
                {
                    xmlOut.WriteStartElement("Discount");
                    xmlOut.WriteElementString("DiscountID", intI.ToString());
                    xmlOut.WriteElementString("Description", ((TextBox)Controls["txtDiscount" + intI.ToString()]).Text);
                    xmlOut.WriteElementString("PromoCode", ((TextBox)Controls["txtPromoCode" + intI.ToString()]).Text);
                    xmlOut.WriteElementString("Amount", ((TextBox)Controls["txtDiscountAmt" + intI.ToString()]).Text.Replace("$", ""));
                    xmlOut.WriteElementString("Display", ((CheckBox)Controls["chkDisplayOnline" + intI.ToString()]).Checked.ToString());
                    xmlOut.WriteEndElement();
                }

                xmlOut.WriteEndElement();
                xmlOut.WriteEndDocument();
            }

            using (wsXferEventInfo.XferEventInfo xferEventInfo = new global::CTWebMgmt.wsXferEventInfo.XferEventInfo())
            {
                string strWebRes = "";

                //upload file

                // Create a new WebClient instance.
                System.Net.WebClient myWebClient = new System.Net.WebClient();

                // Upload the file to the URI.
                // The 'UploadFile(uriString,fileName)' method implicitly uses HTTP POST method.

                try
                {
                    byte[] responseArray = myWebClient.UploadFile(clsWebTalk.strPOSTFileURI, strFileName);

                    // Decode and display the response.
                    string strULRes = "";

                    try { strULRes = System.Text.Encoding.ASCII.GetString(responseArray); }
                    catch { strULRes = "ERR"; }

                    strWebRes = xferEventInfo.fcnCommitDiscountDefs(strWebFile, clsWebTalk.strWebConn);
                }
                catch (System.Net.WebException ex)
                {
                    Console.WriteLine(ex.Message);
                }
                //upload xml definition file...web server will process it and return result.
                if (strWebRes != "")
                    MessageBox.Show("There was an error uploading the discount definitions to the web server.");
                else
                    blnRes = true;
            }

            //delete temp file
            System.IO.File.Delete(strFileName);

            return blnRes;
        }
Esempio n. 39
-1
        static void Main(string[] args)
        {
            string tempPath = System.Environment.GetEnvironmentVariable ("TEMP");
            if (tempPath == null) {
                tempPath = System.Environment.GetEnvironmentVariable ("TMP");
            }
            if (tempPath == null) {
                tempPath = "..\\..";
            }

            Exception exc = null;
            System.DateTime now = System.DateTime.Now;
            System.Security.Cryptography.X509Certificates.X509Certificate xc = null;
            System.IO.StreamWriter sw = null;
            System.IO.StreamReader sr = null;
            System.IO.DirectoryInfo di = null;
            bool b = false;
            System.DateTime dt = InicDateTime ();
            string[] sL = null;
            System.IO.FileInfo[] fiL = null;
            System.IO.DirectoryInfo[] diL = null;
            System.IO.FileSystemInfo[] fsiL = null;
            System.IO.FileStream fs = null;
            System.IO.FileInfo fi = null;
            System.IAsyncResult asr = null;
            int i = 0;
            long l = 0;
            string s = null;
            System.IO.IsolatedStorage.IsolatedStorageFile isf = null;
            System.IO.IsolatedStorage.IsolatedStorageFileStream isfs = null;
            byte[] bL = null;
            System.Diagnostics.Process p = null;

            System.IO.FileInfo fileInfo = new System.IO.FileInfo (tempPath + "\\resources4file.txt");
            fileInfo.Create ().Close ();
            System.IO.StreamWriter outFile = fileInfo.AppendText ();
            System.Console.WriteLine (tempPath + "\\resources4file.txt");

            try {
                exc = null;
                xc = null;
                now = System.DateTime.Now;
                xc = System.Security.Cryptography.X509Certificates.X509Certificate.CreateFromCertFile (tempPath + "\\dummyFile1.txt");
            } catch (Exception e) {
                exc = e;
            } finally {
                outFile.WriteLine ("Name: " + tempPath + "\\dummyFile1.txt");
                outFile.WriteLine ("Func: " + "System.Security.Cryptography.X509Certificates.X509Certificate.CreateFromCertFile(String)");
                outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                outFile.WriteLine ("Time: " + GetTime (now));
                outFile.WriteLine ("Retv: " + toString (xc));
                outFile.WriteLine ("Errc: " + "");
                outFile.WriteLine ("Exce: " + GetException (exc));
            }
            try {
                exc = null;
                xc = null;
                now = System.DateTime.Now;
                xc = System.Security.Cryptography.X509Certificates.X509Certificate.CreateFromSignedFile (tempPath + "\\dummyFile2.txt");
            } catch (Exception e) {
                exc = e;
            } finally {
                outFile.WriteLine ("Name: " + tempPath + "\\dummyFile2.txt");
                outFile.WriteLine ("Func: " + "System.Security.Cryptography.X509Certificates.X509Certificate.CreateFromSignedFile(String)");
                outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                outFile.WriteLine ("Time: " + GetTime (now));
                outFile.WriteLine ("Retv: " + toString (xc));
                outFile.WriteLine ("Errc: " + "");
                outFile.WriteLine ("Exce: " + GetException (exc));
            }
            /*
            try {
            System.IO.BinaryWriter.Write ();
            System.IO.BinaryWriter.Seek ();
            System.IO.BinaryWriter.Flush ();
            System.IO.BinaryWriter.Close ();
            System.IO.BinaryWriter bw = new System.IO.BinaryWriter ();
            } catch (Exception e) {
            }

            try {
            System.IO.BufferedStream.WriteByte ();
            System.IO.BufferedStream.Write ();
            System.IO.BufferedStream.ReadByte ();
            System.IO.BufferedStream.Read ();
            System.IO.BufferedStream.SetLength ();
            System.IO.BufferedStream.Seek ();
            System.IO.BufferedStream.EndWrite ();
            System.IO.BufferedStream.BeginWrite ();
            System.IO.BufferedStream.EndRead ();
            System.IO.BufferedStream.BeginRead ();
            System.IO.BufferedStream.Flush ();
            System.IO.BufferedStream.Close ();
            System.IO.BufferedStream bs = new System.IO.BufferedStream ();
            } catch (Exception e) {
            }
            */
            try {
                exc = null;
                try {
                    exc = null;
                    sw = null;
                    now = System.DateTime.Now;
                    sw = new System.IO.StreamWriter (tempPath + "\\dummyFile3.txt");
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile3.txt");
                    outFile.WriteLine ("Func: " + "System.IO.StreamWriter.ctor(String)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (sw));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                    try {
                        exc = null;
                        System.Console.SetOut (sw);
                        try {
                            exc = null;
                            now = System.DateTime.Now;
                            System.Console.WriteLine ();
                        } catch (Exception e) {
                            exc = e;
                        } finally {
                            outFile.WriteLine ("Name: " + tempPath + "\\dummyFile3.txt");
                            outFile.WriteLine ("Func: " + "System.Console.WriteLine()");
                            outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                            outFile.WriteLine ("Time: " + GetTime (now));
                            outFile.WriteLine ("Retv: " + "");
                            outFile.WriteLine ("Errc: " + "");
                            outFile.WriteLine ("Exce: " + GetException (exc));
                        }
                        try {
                            exc = null;
                            now = System.DateTime.Now;
                            System.Console.Out.Write ("hello");
                        } catch (Exception e) {
                            exc = e;
                        } finally {
                            outFile.WriteLine ("Name: " + tempPath + "\\dummyFile3.txt");
                            outFile.WriteLine ("Func: " + "System.IO.TextWriter.Write(String)");
                            outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                            outFile.WriteLine ("Time: " + GetTime (now));
                            outFile.WriteLine ("Retv: " + "");
                            outFile.WriteLine ("Errc: " + "");
                            outFile.WriteLine ("Exce: " + GetException (exc));
                        }
                    } finally {
                        try {
                            sw.Close ();
                        } catch (Exception) {
                        }
                    }
                } catch (Exception) {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile3.txt");
                    outFile.WriteLine ("Func: " + "System.IO.StreamWriter.ctor(String)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (sw));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }

                try {
                    exc = null;
                    sr = null;
                    now = System.DateTime.Now;
                    sr = new System.IO.StreamReader (tempPath + "\\dummyFile4.txt");
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile4.txt");
                    outFile.WriteLine ("Func: " + "System.IO.StreamReader.ctor(String)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (sr));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                    try {
                        System.Console.SetIn (sr);
                        try {
                            exc = null;
                            now = System.DateTime.Now;
                            System.Console.ReadLine ();
                        } catch (Exception e) {
                            exc = e;
                        } finally {
                            outFile.WriteLine ("Name: " + tempPath + "\\dummyFile4.txt");
                            outFile.WriteLine ("Func: " + "System.Console.ReadLine()");
                            outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                            outFile.WriteLine ("Time: " + GetTime (now));
                            outFile.WriteLine ("Retv: " + "");
                            outFile.WriteLine ("Errc: " + "");
                            outFile.WriteLine ("Exce: " + GetException (exc));
                        }
                        try {
                            exc = null;
                            now = System.DateTime.Now;
                            System.Console.In.ReadLine ();
                        } catch (Exception e) {
                            exc = e;
                        } finally {
                            outFile.WriteLine ("Name: " + tempPath + "\\dummyFile4.txt");
                            outFile.WriteLine ("Func: " + "System.IO.TextReader.ReadLine()");
                            outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                            outFile.WriteLine ("Time: " + GetTime (now));
                            outFile.WriteLine ("Retv: " + "");
                            outFile.WriteLine ("Errc: " + "");
                            outFile.WriteLine ("Exce: " + GetException (exc));
                        }
                    } catch (Exception) {
                    } finally {
                        try {
                            sr.Close ();
                        } catch (Exception) {
                        }
                    }
                } catch (Exception e) {
                    exc = e;
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile4.txt");
                    outFile.WriteLine ("Func: " + "System.IO.StreamReader.ctor(String)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (sr));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }

                try {
                    exc = null;
                    sw = null;
                    now = System.DateTime.Now;
                    sw = new System.IO.StreamWriter (tempPath + "\\dummyFile5.txt");
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile.txt");
                    outFile.WriteLine ("Func: " + "System.IO.StreamWriter.ctor(String)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (sw));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                    try {
                        System.Console.SetError (sw);
                        try {
                            exc = null;
                            now = System.DateTime.Now;
                            System.Console.Error.WriteLine ();
                        } catch (Exception e) {
                            exc = e;
                        } finally {
                            outFile.WriteLine ("Name: " + tempPath + "\\dummyFile5.txt");
                            outFile.WriteLine ("Func: " + "System.IO.TextWriter.WriteLine(String)");
                            outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                            outFile.WriteLine ("Time: " + GetTime (now));
                            outFile.WriteLine ("Retv: " + "");
                            outFile.WriteLine ("Errc: " + "");
                            outFile.WriteLine ("Exce: " + GetException (exc));
                        }
                    } finally {
                        try {
                            sw.Close ();
                        } catch (Exception) {
                        }
                    }
                } catch (Exception e) {
                    exc = e;
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile5.txt");
                    outFile.WriteLine ("Func: " + "System.IO.StreamWriter.ctor(String)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (sw));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
            } catch (Exception) {
            }

            try {
                try {
                    exc = null;
                    di = null;
                    now = System.DateTime.Now;
                    di = System.IO.Directory.CreateDirectory (tempPath + "\\TestDir1");
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\TestDir1");
                    outFile.WriteLine ("Func: " + "System.IO.Directory.CreateDirectory(String)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (di));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    di = null;
                    now = System.DateTime.Now;
                    di = System.IO.Directory.GetParent (tempPath + "\\TestDir1");
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath);
                    outFile.WriteLine ("Func: " + "System.IO.Directory.GetParent(String)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (di));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    now = System.DateTime.Now;
                    b = System.IO.Directory.Exists (tempPath + "\\TestDir1");
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\TestDir1");
                    outFile.WriteLine ("Func: " + "System.IO.Directory.Exists(String)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (b));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    now = System.DateTime.Now;
                    System.IO.Directory.SetCreationTime (tempPath + "\\TestDir1", new System.DateTime (2003, 01, 01));
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\TestDir1");
                    outFile.WriteLine ("Func: " + "System.IO.Directory.SetCreationTime(String, DateTime)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + "");
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    dt = InicDateTime ();
                    now = System.DateTime.Now;
                    dt = System.IO.Directory.GetCreationTime (tempPath + "\\TestDir1");
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\TestDir1");
                    outFile.WriteLine ("Func: " + "System.IO.Directory.GetCreationTime(String)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (dt));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    now = System.DateTime.Now;
                    System.IO.Directory.SetLastWriteTime (tempPath + "\\TestDir1", new System.DateTime (2003, 01, 01));
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\TestDir1");
                    outFile.WriteLine ("Func: " + "System.IO.Directory.SetLastWriteTime(String, DateTime)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + "");
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    dt = InicDateTime ();
                    now = System.DateTime.Now;
                    dt = System.IO.Directory.GetLastWriteTime (tempPath + "\\TestDir1");
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\TestDir1");
                    outFile.WriteLine ("Func: " + "System.IO.Directory.GetLastWriteTime(String)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (dt));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    now = System.DateTime.Now;
                    System.IO.Directory.SetLastAccessTime (tempPath + "\\TestDir1", new System.DateTime (2003, 01, 01));
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\TestDir1");
                    outFile.WriteLine ("Func: " + "System.IO.Directory.SetLastAccessTime(String, DateTime)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + "");
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    dt = InicDateTime ();
                    now = System.DateTime.Now;
                    dt = System.IO.Directory.GetLastAccessTime (tempPath + "\\TestDir1");
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\TestDir1");
                    outFile.WriteLine ("Func: " + "System.IO.Directory.GetLastAccessTime(String)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (dt));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    sL = null;
                    now = System.DateTime.Now;
                    sL = System.IO.Directory.GetFiles (tempPath + "\\TestDir1");
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\TestDir1");
                    outFile.WriteLine ("Func: " + "System.IO.Directory.GetFiles(String)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (sL));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    sL = null;
                    now = System.DateTime.Now;
                    sL = System.IO.Directory.GetDirectories (tempPath + "\\TestDir1");
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\TestDir1");
                    outFile.WriteLine ("Func: " + "System.IO.Directory.GetDirectories(String)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (sL));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    now = System.DateTime.Now;
                    System.IO.Directory.GetFileSystemEntries (tempPath + "\\TestDir1");
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\TestDir1");
                    outFile.WriteLine ("Func: " + "System.IO.Directory.GetFileSystemEntries(String)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (sL));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    now = System.DateTime.Now;
                    System.IO.Directory.SetCurrentDirectory (tempPath + "\\TestDir1\\..");
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath);
                    outFile.WriteLine ("Func: " + "System.IO.Directory.SetCurrentDirectory(String)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + "");
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    now = System.DateTime.Now;
                    System.IO.Directory.Move (tempPath + "\\TestDir1", tempPath + "\\TestDir2");
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\TestDir1");
                    outFile.WriteLine ("Func: " + "System.IO.Directory.Move(String, String)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                    //---
                    outFile.WriteLine ("Name: " + tempPath + "\\TestDir2");
                    outFile.WriteLine ("Func: " + "System.IO.Directory.Move(String, String)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + "");
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    now = System.DateTime.Now;
                    System.IO.Directory.Delete (tempPath + "\\TestDir1");
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\TestDir1");
                    outFile.WriteLine ("Func: " + "System.IO.Directory.Delete(String)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + "");
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    now = System.DateTime.Now;
                    System.IO.Directory.Delete (tempPath + "\\TestDir2");
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\TestDir2");
                    outFile.WriteLine ("Func: " + "System.IO.Directory.Delete(String)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + "");
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
            } catch (Exception) {
            }

            try {
                di = null;
                di = new System.IO.DirectoryInfo (tempPath);
                System.IO.DirectoryInfo di2 = null;
                try {
                    try {
                        exc = null;
                        di2 = null;
                        now = System.DateTime.Now;
                        di2 = di.CreateSubdirectory (tempPath + "\\TestDir3");
                        di = di2;
                    } catch (Exception e) {
                        exc = e;
                    } finally {
                        outFile.WriteLine ("Name: " + tempPath + "\\TestDir3");
                        outFile.WriteLine ("Func: " + "System.IO.DirectoryInfo.CreateSubdirectory(String)");
                        outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                        outFile.WriteLine ("Time: " + GetTime (now));
                        outFile.WriteLine ("Retv: " + toString (di2));
                        outFile.WriteLine ("Errc: " + "");
                        outFile.WriteLine ("Exce: " + GetException (exc));
                    }
                    try {
                        exc = null;
                        fiL = null;
                        now = System.DateTime.Now;
                        fiL = di.GetFiles ();
                    } catch (Exception e) {
                        exc = e;
                    } finally {
                        outFile.WriteLine ("Name: " + tempPath + "\\TestDir3");
                        outFile.WriteLine ("Func: " + "System.IO.DirectoryInfo.GetFiles()");
                        outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                        outFile.WriteLine ("Time: " + GetTime (now));
                        outFile.WriteLine ("Retv: " + toString (fiL));
                        outFile.WriteLine ("Errc: " + "");
                        outFile.WriteLine ("Exce: " + GetException (exc));
                    }
                    try {
                        exc = null;
                        diL = null;
                        now = System.DateTime.Now;
                        diL = di.GetDirectories ();
                    } catch (Exception e) {
                        exc = e;
                    } finally {
                        outFile.WriteLine ("Name: " + tempPath + "\\TestDir3");
                        outFile.WriteLine ("Func: " + "System.IO.DirectoryInfo.GetDirectories()");
                        outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                        outFile.WriteLine ("Time: " + GetTime (now));
                        outFile.WriteLine ("Retv: " + toString (diL));
                        outFile.WriteLine ("Errc: " + "");
                        outFile.WriteLine ("Exce: " + GetException (exc));
                    }
                    try {
                        exc = null;
                        fsiL = null;
                        now = System.DateTime.Now;
                        fsiL = di.GetFileSystemInfos ();
                    } catch (Exception e) {
                        exc = e;
                    } finally {
                        outFile.WriteLine ("Name: " + tempPath + "\\TestDir3");
                        outFile.WriteLine ("Func: " + "System.IO.DirectoryInfo.GetFileSystemInfos()");
                        outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                        outFile.WriteLine ("Time: " + GetTime (now));
                        outFile.WriteLine ("Retv: " + toString (fsiL));
                        outFile.WriteLine ("Errc: " + "");
                        outFile.WriteLine ("Exce: " + GetException (exc));
                    }
                    try {
                        exc = null;
                        now = System.DateTime.Now;
                        di.MoveTo (tempPath + "\\TestDir4");
                    } catch (Exception e) {
                        exc = e;
                    } finally {
                        outFile.WriteLine ("Name: " + tempPath + "\\TestDir3");
                        outFile.WriteLine ("Func: " + "System.IO.DirectoryInfo.MoveTo(String)");
                        outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                        outFile.WriteLine ("Time: " + GetTime (now));
                        outFile.WriteLine ("Retv: " + "");
                        outFile.WriteLine ("Errc: " + "");
                        outFile.WriteLine ("Exce: " + GetException (exc));
                        //---
                        outFile.WriteLine ("Name: " + tempPath + "\\TestDir4");
                        outFile.WriteLine ("Func: " + "System.IO.DirectoryInfo.MoveTo(String)");
                        outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                        outFile.WriteLine ("Time: " + GetTime (now));
                        outFile.WriteLine ("Retv: " + "");
                        outFile.WriteLine ("Errc: " + "");
                        outFile.WriteLine ("Exce: " + GetException (exc));
                    }
                } finally {
                    try {
                        exc = null;
                        char[] backSlash = new char[1];
                        backSlash[0] = '\\';
                        outFile.WriteLine ("Name: " + di.FullName.TrimEnd (backSlash));
                        now = System.DateTime.Now;
                        di.Delete ();
                    } catch  (Exception e) {
                        exc = e;
                    } finally {
                        outFile.WriteLine ("Func: " + "System.IO.DirectoryInfo.Delete()");
                        outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                        outFile.WriteLine ("Time: " + GetTime (now));
                        outFile.WriteLine ("Retv: " + "");
                        outFile.WriteLine ("Errc: " + "");
                        outFile.WriteLine ("Exce: " + GetException (exc));
                    }
                }
                try {
                    di = null;
                    di = new System.IO.DirectoryInfo (tempPath + "\\TestDir5");
                    try {
                        exc = null;
                        now = System.DateTime.Now;
                        di.Create ();
                    } catch (Exception e) {
                        exc = e;
                    } finally {
                        outFile.WriteLine ("Name: " + tempPath + "\\TestDir5");
                        outFile.WriteLine ("Func: " + "System.IO.DirectoryInfo.Create()");
                        outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                        outFile.WriteLine ("Time: " + GetTime (now));
                        outFile.WriteLine ("Retv: " + "");
                        outFile.WriteLine ("Errc: " + "");
                        outFile.WriteLine ("Exce: " + GetException (exc));
                    }
                    try {
                        exc = null;
                        now = System.DateTime.Now;
                        di.MoveTo (tempPath + "\\TestDir6");
                    } catch (Exception e) {
                        exc = e;
                    } finally {
                        outFile.WriteLine ("Name: " + tempPath + "\\TestDir5");
                        outFile.WriteLine ("Func: " + "System.IO.DirectoryInfo.MoveTo(String)");
                        outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                        outFile.WriteLine ("Time: " + GetTime (now));
                        outFile.WriteLine ("Retv: " + "");
                        outFile.WriteLine ("Errc: " + "");
                        outFile.WriteLine ("Exce: " + GetException (exc));
                        //---
                        outFile.WriteLine ("Name: " + tempPath + "\\TestDir6");
                        outFile.WriteLine ("Func: " + "System.IO.DirectoryInfo.MoveTo(String)");
                        outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                        outFile.WriteLine ("Time: " + GetTime (now));
                        outFile.WriteLine ("Retv: " + "");
                        outFile.WriteLine ("Errc: " + "");
                        outFile.WriteLine ("Exce: " + GetException (exc));
                    }
                } catch (Exception) {
                } finally {
                    try {
                        exc = null;
                        char[] backSlash = new char[1];
                        backSlash[0] = '\\';
                        outFile.WriteLine ("Name: " + di.FullName.TrimEnd (backSlash));
                        now = System.DateTime.Now;
                        di.Delete ();
                    } catch (Exception e) {
                        exc = e;
                    } finally {
                        outFile.WriteLine ("Func: " + "System.IO.DirectoryInfo.Delete()");
                        outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                        outFile.WriteLine ("Time: " + GetTime (now));
                        outFile.WriteLine ("Retv: " + "");
                        outFile.WriteLine ("Errc: " + "");
                        outFile.WriteLine ("Exce: " + GetException (exc));
                    }
                }
            } catch (Exception) {
            }

            try {
                try {
                    exc = null;
                    sr = null;
                    now = System.DateTime.Now;
                    sr = System.IO.File.OpenText (tempPath + "\\dummyFile6.txt");
                    sr.Close ();
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile6.txt");
                    outFile.WriteLine ("Func: " + "System.IO.File.OpenText(String)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (sr));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    sw = null;
                    now = System.DateTime.Now;
                    sw = System.IO.File.CreateText (tempPath + "\\dummyFile7.txt");
                    sw.Close ();
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile7.txt");
                    outFile.WriteLine ("Func: " + "System.IO.File.CreateText(String)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (sw));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    sw = null;
                    now = System.DateTime.Now;
                    sw = System.IO.File.AppendText (tempPath + "\\dummyFile8.txt");
                    sw.Close ();
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile8.txt");
                    outFile.WriteLine ("Func: " + "System.IO.File.AppendText(String)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (sw));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    fs = null;
                    now = System.DateTime.Now;
                    fs = System.IO.File.Open (tempPath + "\\dummyFile9.txt", System.IO.FileMode.OpenOrCreate);
                    fs.Close ();
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile9.txt");
                    outFile.WriteLine ("Func: " + "System.IO.File.Open(String)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (fs));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    now = System.DateTime.Now;
                    System.IO.File.SetCreationTime (tempPath + "\\dummyFile9.txt", new System.DateTime (2003, 01, 01));
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile9.txt");
                    outFile.WriteLine ("Func: " + "System.IO.File.SetCreationTime(String, DateTime)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + "");
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    dt = InicDateTime ();
                    now = System.DateTime.Now;
                    dt = System.IO.File.GetCreationTime (tempPath + "\\dummyFile9.txt");
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile9.txt");
                    outFile.WriteLine ("Func: " + "System.IO.File.GetCreationTime(String)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (dt));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    now = System.DateTime.Now;
                    System.IO.File.SetLastAccessTime (tempPath + "\\dummyFile9.txt", new System.DateTime (2003, 01, 01));
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile9.txt");
                    outFile.WriteLine ("Func: " + "System.IO.File.SetLastAccessTime(String, DateTime)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + "");
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    now = System.DateTime.Now;
                    dt = System.IO.File.GetLastAccessTime (tempPath + "\\dummyFile9.txt");
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile9.txt");
                    outFile.WriteLine ("Func: " + "System.IO.File.GetLastAccessTime(String)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (dt));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    now = System.DateTime.Now;
                    System.IO.File.SetLastWriteTime (tempPath + "\\dummyFile9.txt", new System.DateTime (2003, 01, 01));
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile9.txt");
                    outFile.WriteLine ("Func: " + "System.IO.File.SetLastWriteTime(String, DateTime)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + "");
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    dt = InicDateTime ();
                    now = System.DateTime.Now;
                    dt = System.IO.File.GetLastWriteTime (tempPath + "\\dummyFile9.txt");
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile9.txt");
                    outFile.WriteLine ("Func: " + "System.IO.File.GetLastWriteTime(String)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (dt));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    fs = null;
                    now = System.DateTime.Now;
                    fs = System.IO.File.OpenRead (tempPath + "\\dummyFile10.txt");
                    fs.Close ();
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile10.txt");
                    outFile.WriteLine ("Func: " + "System.IO.File.OpenRead(String)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (fs));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    fs = null;
                    now = System.DateTime.Now;
                    fs = System.IO.File.OpenWrite (tempPath + "\\dummyFile11.txt");
                    fs.Close ();
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile11.txt");
                    outFile.WriteLine ("Func: " + "System.IO.File.OpenWrite(String)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (fs));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    fs = null;
                    now = System.DateTime.Now;
                    fs = System.IO.File.Create (tempPath + "\\testFile1.txt");
                    fs.Close ();
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\testFile1.txt");
                    outFile.WriteLine ("Func: " + "System.IO.File.Create(String)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (fs));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    fs = null;
                    now = System.DateTime.Now;
                    System.IO.File.Move (tempPath + "\\testFile1.txt", tempPath + "\\testFile2.txt");
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\testFile1.txt");
                    outFile.WriteLine ("Func: " + "System.IO.File.OpenWrite(String)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + "");
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                    //---
                    outFile.WriteLine ("Name: " + tempPath + "\\testFile2.txt");
                    outFile.WriteLine ("Func: " + "System.IO.File.OpenWrite(String)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + "");
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    now = System.DateTime.Now;
                    System.IO.File.Delete (tempPath + "\\testFile2.txt");
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\testFile2.txt");
                    outFile.WriteLine ("Func: " + "System.IO.File.Delete(String)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + "");
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    now = System.DateTime.Now;
                    b = System.IO.File.Exists (tempPath + "\\testFile3.txt");
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\testFile3.txt");
                    outFile.WriteLine ("Func: " + "System.IO.File.Exists(String)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (b));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
            } catch (Exception) {
            }

            try {
                fi = new System.IO.FileInfo (tempPath + "\\testFile4.txt");
                try {
                    exc = null;
                    fs = null;
                    now = System.DateTime.Now;
                    fs = fi.Create ();
                    fs.Close ();
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\testFile4.txt");
                    outFile.WriteLine ("Func: " + "System.IO.FileInfo.Create()");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (fs));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    sr = null;
                    now = System.DateTime.Now;
                    sr = fi.OpenText ();
                    sr.Close ();
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\testFile4.txt");
                    outFile.WriteLine ("Func: " + "System.IO.FileInfo.OpenText()");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (sr));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    sw = null;
                    now = System.DateTime.Now;
                    sw = fi.CreateText ();
                    sw.Close ();
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\testFile4.txt");
                    outFile.WriteLine ("Func: " + "System.IO.FileInfo.CreateText()");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (sw));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    sw = null;
                    now = System.DateTime.Now;
                    sw = fi.AppendText ();
                    sw.Close ();
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\testFile4.txt");
                    outFile.WriteLine ("Func: " + "System.IO.FileInfo.AppendText()");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (sw));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    fs = null;
                    fi = new System.IO.FileInfo (tempPath + "\\testFile5.txt");
                    now = System.DateTime.Now;
                    fs = fi.Open (System.IO.FileMode.Open);
                    fs.Close ();
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\testFile5.txt");
                    outFile.WriteLine ("Func: " + "System.IO.FileInfo.Create(FileMode)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (fs));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    fs = null;
                    now = System.DateTime.Now;
                    fs = fi.OpenWrite ();
                    fs.Close ();
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\testFile5.txt");
                    outFile.WriteLine ("Func: " + "System.IO.FileInfo.OpenWrite()");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (fs));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    now = System.DateTime.Now;
                    fi.MoveTo (tempPath + "\\testFile6.txt");
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\testFile5.txt");
                    outFile.WriteLine ("Func: " + "System.IO.FileInfo.MoveTo(String)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + "");
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                    //---
                    outFile.WriteLine ("Name: " + tempPath + "\\testFile6.txt");
                    outFile.WriteLine ("Func: " + "System.IO.FileInfo.MoveTo(String)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + "");
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    char[] backSlash = new char[1];
                    backSlash[0] = '\\';
                    outFile.WriteLine ("Name: " + fi.FullName.TrimEnd (backSlash));
                    now = System.DateTime.Now;
                    fi.Delete ();
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Func: " + "System.IO.FileInfo.Delete()");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + "");
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
            } catch (Exception) {
            }

            try {
                exc = null;
                byte[] array = new byte[1];
                array[0] = 0;
                fs = null;
                now = System.DateTime.Now;
                fs = System.IO.File.Open (tempPath + "\\dummyFile12.txt", System.IO.FileMode.OpenOrCreate);
                outFile.WriteLine ("Name: " + tempPath + "\\dummyFile12.txt");
                outFile.WriteLine ("Func: " + "System.IO.File.Open(String, FileMode)");
                outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                outFile.WriteLine ("Time: " + GetTime (now));
                outFile.WriteLine ("Retv: " + toString (fs));
                outFile.WriteLine ("Errc: " + "");
                outFile.WriteLine ("Exce: " + GetException (exc));

                try {
                    exc = null;
                    now = System.DateTime.Now;
                    fs.Lock (0, 1);
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile12.txt");
                    outFile.WriteLine ("Func: " + "System.IO.FileStream.Lock(Int64, Int64)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + "");
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    now = System.DateTime.Now;
                    fs.Unlock (0, 1);
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile12.txt");
                    outFile.WriteLine ("Func: " + "System.IO.FileStream.Unlock(Int64, Int64)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + "");
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    now = System.DateTime.Now;
                    fs.WriteByte (0);
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile12.txt");
                    outFile.WriteLine ("Func: " + "System.IO.FileStream.WriteByte(Byte)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + "");
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    now = System.DateTime.Now;
                    fs.Write (array, 0, 1);
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile12.txt");
                    outFile.WriteLine ("Func: " + "System.IO.FileStream.Write(Byte[], Int32, Int32)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + "");
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    asr = null;
                    now = System.DateTime.Now;
                    asr = fs.BeginWrite (array, 0, 1, null, null);
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile12.txt");
                    outFile.WriteLine ("Func: " + "System.IO.FileStream.BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (asr));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));

                    try {
                        exc = null;
                        now = System.DateTime.Now;
                        fs.EndWrite (asr);
                    } catch (Exception e) {
                        exc = e;
                    } finally {
                        outFile.WriteLine ("Name: " + tempPath + "\\dummyFile12.txt");
                        outFile.WriteLine ("Func: " + "System.IO.FileStream.EndWrite(IAsyncResult)");
                        outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                        outFile.WriteLine ("Time: " + GetTime (now));
                        outFile.WriteLine ("Retv: " + "");
                        outFile.WriteLine ("Errc: " + "");
                        outFile.WriteLine ("Exce: " + GetException (exc));
                    }
                } catch (Exception e) {
                    exc = e;
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile12.txt");
                    outFile.WriteLine ("Func: " + "System.IO.FileStream.BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (asr));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    now = System.DateTime.Now;
                    fs.SetLength (2);
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile12.txt");
                    outFile.WriteLine ("Func: " + "System.IO.FileStream.SetLength(Int64)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + "");
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    now = System.DateTime.Now;
                    fs.Flush ();
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile12.txt");
                    outFile.WriteLine ("Func: " + "System.IO.FileStream.Flush()");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + "");
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    i = 0;
                    now = System.DateTime.Now;
                    i = fs.ReadByte ();
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile12.txt");
                    outFile.WriteLine ("Func: " + "System.IO.FileStream.ReadByte()");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (i));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    i = 0;
                    now = System.DateTime.Now;
                    i = fs.Read (array, 0, 1);
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile12.txt");
                    outFile.WriteLine ("Func: " + "System.IO.FileStream.Read(Byte[], Int32, Int32)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (i));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    l = 0;
                    now = System.DateTime.Now;
                    l = fs.Seek (0, System.IO.SeekOrigin.Begin);
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile12.txt");
                    outFile.WriteLine ("Func: " + "System.IO.FileStream.Seek(Int64, SeekOrigin)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (l));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    asr = null;
                    now = System.DateTime.Now;
                    asr = fs.BeginRead (array, 0, 1, null, null);
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile12.txt");
                    outFile.WriteLine ("Func: " + "System.IO.FileStream.BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (asr));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));

                    try {
                        exc = null;
                        i = 0;
                        now = System.DateTime.Now;
                        i = fs.EndRead (asr);
                    } catch (Exception e) {
                        exc = e;
                    } finally {
                        outFile.WriteLine ("Name: " + tempPath + "\\dummyFile12.txt");
                        outFile.WriteLine ("Func: " + "System.IO.FileStream.EndRead(IAsyncResult)");
                        outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                        outFile.WriteLine ("Time: " + GetTime (now));
                        outFile.WriteLine ("Retv: " + toString (i));
                        outFile.WriteLine ("Errc: " + "");
                        outFile.WriteLine ("Exce: " + GetException (exc));
                    }
                } catch (Exception e) {
                    exc = e;
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile12.txt");
                    outFile.WriteLine ("Func: " + "System.IO.FileStream.BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (asr));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    now = System.DateTime.Now;
                    fs.Close ();
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile12.txt");
                    outFile.WriteLine ("Func: " + "System.IO.FileStream.Close(IAsyncResult)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + "");
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
            } catch (Exception e) {
                exc = e;
                outFile.WriteLine ("Name: " + tempPath + "\\dummyFile12.txt");
                outFile.WriteLine ("Func: " + "System.IO.File.Open(String, FileMode)");
                outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                outFile.WriteLine ("Time: " + GetTime (now));
                outFile.WriteLine ("Retv: " + toString (fs));
                outFile.WriteLine ("Errc: " + "");
                outFile.WriteLine ("Exce: " + GetException (exc));
            }

            try {
                System.IO.TextWriter tw = new System.IO.StreamWriter (tempPath + "\\dummyFile13.txt");
                try {
                    exc = null;
                    now = System.DateTime.Now;
                    tw.WriteLine ("hello");
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile13.txt");
                    outFile.WriteLine ("Func: " + "System.IO.TextWriter.WriteLine(String)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + "");
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    now = System.DateTime.Now;
                    tw.Write ("12345678790");
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile13.txt");
                    outFile.WriteLine ("Func: " + "System.IO.TextWriter.Write(String)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + "");
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    now = System.DateTime.Now;
                    tw.Flush ();
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile13.txt");
                    outFile.WriteLine ("Func: " + "System.IO.TextWriter.Flush()");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + "");
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    now = System.DateTime.Now;
                    tw.Close ();
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile13.txt");
                    outFile.WriteLine ("Func: " + "System.IO.TextWriter.Close()");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + "");
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
            } catch (Exception) {
            }

            try {
                char[] array = new char[1];
                array[0] = 'a';
                System.IO.TextReader tr = new System.IO.StreamReader (tempPath + "\\dummyFile13.txt");
                try {
                    exc = null;
                    s = null;
                    now = System.DateTime.Now;
                    s = tr.ReadLine ();
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile13.txt");
                    outFile.WriteLine ("Func: " + "System.IO.TextReader.ReadLine()");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (s));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    i = 0;
                    now = System.DateTime.Now;
                    i = tr.ReadBlock (array, 0, 1);
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile13.txt");
                    outFile.WriteLine ("Func: " + "System.IO.TextReader.ReadBlock(Char[], Int32, Int32)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (i));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    i = 0;
                    now = System.DateTime.Now;
                    i = tr.Read ();
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile13.txt");
                    outFile.WriteLine ("Func: " + "System.IO.TextReader.Read()");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (i));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    i = 0;
                    now = System.DateTime.Now;
                    i = tr.Read (array, 0, 1);
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile13.txt");
                    outFile.WriteLine ("Func: " + "System.IO.TextReader.Read(Char[], Int32, Int32)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (i));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    s = null;
                    now = System.DateTime.Now;
                    s = tr.ReadToEnd ();
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile13.txt");
                    outFile.WriteLine ("Func: " + "System.IO.TextReader.ReadToEnd()");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (s));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    now = System.DateTime.Now;
                    tr.Close ();
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile13.txt");
                    outFile.WriteLine ("Func: " + "System.IO.TextReader.Close()");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + "");
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
            } catch (Exception) {
            }

            try {
                sw = new System.IO.StreamWriter (tempPath + "\\dummyFile14.txt");
                try {
                    exc = null;
                    now = System.DateTime.Now;
                    sw.Write (0);
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile14.txt");
                    outFile.WriteLine ("Func: " + "System.IO.StreamWriter.Write(Int32)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + "");
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    now = System.DateTime.Now;
                    sw.Flush ();
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile14.txt");
                    outFile.WriteLine ("Func: " + "System.IO.StreamWriter.Flush()");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + "");
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    now = System.DateTime.Now;
                    sw.Close ();
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile14.txt");
                    outFile.WriteLine ("Func: " + "System.IO.StreamWriter.Close()");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + "");
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
            } catch (Exception) {
            }

            /*
            try {
                exc = null;
                System.IO.IsolatedStorage.IsolatedStorageScope iss = System.IO.IsolatedStorage.IsolatedStorageScope.User | System.IO.IsolatedStorage.IsolatedStorageScope.Assembly | System.IO.IsolatedStorage.IsolatedStorageScope.Domain;
                isf = null;
                now = System.DateTime.Now;
                isf = System.IO.IsolatedStorage.IsolatedStorageFile.GetStore (iss, null, null);

                try {
                    exc = null;
                    now = System.DateTime.Now;
                    isf.Dispose ();
                } catch (Exception e) {
                    exc = e;
                }
            //			System.IO.IsolatedStorage.IsolatedStorageFile.GetUserStoreForDomain ();
            //			System.IO.IsolatedStorage.IsolatedStorageFile.GetUserStoreForAssembly ();
            //			System.IO.IsolatedStorage.IsolatedStorageFile.GetStore (System.IO.IsolatedStorage.IsolatedStorageScope.User | System.IO.IsolatedStorage.IsolatedStorageScope.Assembly | System.IO.IsolatedStorage.IsolatedStorageScope.Domain, null, null);
                try {
                    exc = null;
                    now = System.DateTime.Now;
                    isf.CreateDirectory ("dummyDir");
                } catch (Exception e) {
                    exc = e;
                }
                try {
                    exc = null;
                    now = System.DateTime.Now;
                    isf.GetDirectoryNames ("*");
                } catch (Exception e) {
                    exc = e;
                }
                try {
                    exc = null;
                    now = System.DateTime.Now;
                    isf.DeleteFile ("dummyFile");
                } catch (Exception e) {
                    exc = e;
                }
                try {
                    exc = null;
                    now = System.DateTime.Now;
                    isf.DeleteDirectory ("dummyDir");
                } catch (Exception e) {
                    exc = e;
                }
                try {
                    exc = null;
                    now = System.DateTime.Now;
                    isf.GetFileNames ("*");
                } catch (Exception e) {
                    exc = e;
                }
                try {
                    exc = null;
                    now = System.DateTime.Now;
                    isf.Close ();
                } catch (Exception e) {
                    exc = e;
                }
                try {
                    exc = null;
                    now = System.DateTime.Now;
                    System.IO.IsolatedStorage.IsolatedStorageFile.Remove (iss);
                } catch (Exception e) {
                    exc = e;
                }
            } catch (Exception e) {
                exc = e;
            }
            */
            try {
                exc = null;
                byte[] array = new byte[1];
                array[0] = 0;
                isfs = null;
                now = System.DateTime.Now;
                isfs = new System.IO.IsolatedStorage.IsolatedStorageFileStream (tempPath + "\\dummyFile15.txt", System.IO.FileMode.OpenOrCreate);
                outFile.WriteLine ("Name: " + tempPath + "\\dummyFile15.txt");
                outFile.WriteLine ("Func: " + "System.IO.IsolatedStorage.IsolatedStorageFileStream.ctor(String, FileMode)");
                outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                outFile.WriteLine ("Time: " + GetTime (now));
                outFile.WriteLine ("Retv: " + toString (isfs));
                outFile.WriteLine ("Errc: " + "");
                outFile.WriteLine ("Exce: " + GetException (exc));

                try {
                    exc = null;
                    now = System.DateTime.Now;
                    isfs.Lock (0, 1);
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile15.txt");
                    outFile.WriteLine ("Func: " + "System.IO.IsolatedStorage.IsolatedStorageFileStream.Lock(Int64, Int64)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + "");
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    now = System.DateTime.Now;
                    isfs.Unlock (0, 1);
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile15.txt");
                    outFile.WriteLine ("Func: " + "System.IO.IsolatedStorage.IsolatedStorageFileStream.Unlock(Int64, Int64)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + "");
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    now = System.DateTime.Now;
                    isfs.WriteByte (0);
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile15.txt");
                    outFile.WriteLine ("Func: " + "System.IO.IsolatedStorage.IsolatedStorageFileStream.WriteByte(Byte)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + "");
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    now = System.DateTime.Now;
                    isfs.Write (array, 0, 1);
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile15.txt");
                    outFile.WriteLine ("Func: " + "System.IO.IsolatedStorage.IsolatedStorageFileStream.Write(Byte[], Int32, Int32)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + "");
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    asr = null;
                    now = System.DateTime.Now;
                    asr = isfs.BeginWrite (array, 0, 1, null, null);
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile15.txt");
                    outFile.WriteLine ("Func: " + "System.IO.IsolatedStorage.IsolatedStorageFileStream.BeginWrite(IAsyncResult, Int32, Int32, AsyncCallback, Object)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (asr));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));

                    try {
                        exc = null;
                        now = System.DateTime.Now;
                        isfs.EndWrite (asr);
                    } catch (Exception e) {
                        exc = e;
                    } finally {
                        outFile.WriteLine ("Name: " + tempPath + "\\dummyFile15.txt");
                        outFile.WriteLine ("Func: " + "System.IO.IsolatedStorage.IsolatedStorageFileStream.EndWrite(IAsyncResult)");
                        outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                        outFile.WriteLine ("Time: " + GetTime (now));
                        outFile.WriteLine ("Retv: " + "");
                        outFile.WriteLine ("Errc: " + "");
                        outFile.WriteLine ("Exce: " + GetException (exc));
                    }
                } catch (Exception e) {
                    exc = e;
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile15.txt");
                    outFile.WriteLine ("Func: " + "System.IO.IsolatedStorage.IsolatedStorageFileStream.BeginWrite(IAsyncResult, Int32, Int32, AsyncCallback, Object)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (asr));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    now = System.DateTime.Now;
                    isfs.SetLength (2);
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile15.txt");
                    outFile.WriteLine ("Func: " + "System.IO.IsolatedStorage.IsolatedStorageFileStream.SetLength(Int64)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + "");
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    now = System.DateTime.Now;
                    isfs.Flush ();
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile15.txt");
                    outFile.WriteLine ("Func: " + "System.IO.IsolatedStorage.IsolatedStorageFileStream.Flush()");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + "");
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    l = 0;
                    now = System.DateTime.Now;
                    l = isfs.Seek (0, System.IO.SeekOrigin.Begin);
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile15.txt");
                    outFile.WriteLine ("Func: " + "System.IO.IsolatedStorage.IsolatedStorageFileStream.Seek(Int64, SeekOrigin)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (l));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    i = 0;
                    now = System.DateTime.Now;
                    i = isfs.ReadByte ();
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile15.txt");
                    outFile.WriteLine ("Func: " + "System.IO.IsolatedStorage.IsolatedStorageFileStream.ReadByte()");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (i));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    i = 0;
                    now = System.DateTime.Now;
                    i = isfs.Read (array, 0, 1);
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile15.txt");
                    outFile.WriteLine ("Func: " + "System.IO.IsolatedStorage.IsolatedStorageFileStream.Read(Byte[], Int32, Int32)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (i));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    asr = null;
                    now = System.DateTime.Now;
                    asr = isfs.BeginRead (array, 0, 1, null, null);
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile15.txt");
                    outFile.WriteLine ("Func: " + "System.IO.IsolatedStorage.IsolatedStorageFileStream.BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (asr));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));

                    try {
                        exc = null;
                        i = 0;
                        now = System.DateTime.Now;
                        i = isfs.EndRead (asr);
                    } catch (Exception e) {
                        exc = e;
                    } finally {
                        outFile.WriteLine ("Name: " + tempPath + "\\dummyFile15.txt");
                        outFile.WriteLine ("Func: " + "System.IO.IsolatedStorage.IsolatedStorageFileStream.EndRead(IAsyncResult)");
                        outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                        outFile.WriteLine ("Time: " + GetTime (now));
                        outFile.WriteLine ("Retv: " + toString (i));
                        outFile.WriteLine ("Errc: " + "");
                        outFile.WriteLine ("Exce: " + GetException (exc));
                    }
                } catch (Exception e) {
                    exc = e;
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile15.txt");
                    outFile.WriteLine ("Func: " + "System.IO.IsolatedStorage.IsolatedStorageFileStream.BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (asr));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    now = System.DateTime.Now;
                    isfs.Close ();
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile15.txt");
                    outFile.WriteLine ("Func: " + "System.IO.IsolatedStorage.IsolatedStorageFileStream.Close()");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + "");
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
            } catch (Exception e) {
                exc = e;
                outFile.WriteLine ("Name: " + tempPath + "\\dummyFile15.txt");
                outFile.WriteLine ("Func: " + "System.IO.IsolatedStorage.IsolatedStorageFileStream.ctor(String, FileMode)");
                outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                outFile.WriteLine ("Time: " + GetTime (now));
                outFile.WriteLine ("Retv: " + toString (isfs));
                outFile.WriteLine ("Errc: " + "");
                outFile.WriteLine ("Exce: " + GetException (exc));
            }

            try {
                System.Net.WebClient wc = new System.Net.WebClient ();
                try {
                    exc = null;
                    now = System.DateTime.Now;
                    wc.DownloadFile ("http://www.google.com", tempPath + "\\dummyFile16.txt");
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile16.txt");
                    outFile.WriteLine ("Func: " + "System.Net.WebClient.DownloadFile(String, String)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + "");
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    bL = null;
                    now = System.DateTime.Now;
                    bL = wc.UploadFile ("http://www.google.com", tempPath + "\\dummyFile16.txt");
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile16.txt");
                    outFile.WriteLine ("Func: " + "System.Net.WebClient.UploadFile(String, String)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + toString (bL));
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
            } catch (Exception) {
            }

            try {
                string processString = null;
                try {
                    exc = null;
                    p = null;
                    now = System.DateTime.Now;
                    p = System.Diagnostics.Process.Start (tempPath + "\\dummyFile16.txt");
                    processString = toString (p);
                    p.Kill ();
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile16.txt");
                    outFile.WriteLine ("Func: " + "System.Diagnostics.Process.Start(String)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + processString);
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
                try {
                    exc = null;
                    System.Diagnostics.ProcessStartInfo psi = new System.Diagnostics.ProcessStartInfo (tempPath + "\\dummyFile16.txt");
                    p = null;
                    now = System.DateTime.Now;
                    p = System.Diagnostics.Process.Start (psi);
                    processString = toString (p);
                    p.Kill ();
                } catch (Exception e) {
                    exc = e;
                } finally {
                    outFile.WriteLine ("Name: " + tempPath + "\\dummyFile16.txt");
                    outFile.WriteLine ("Func: " + "System.Diagnostics.Process.Start(ProcessStartInfo)");
                    outFile.WriteLine ("Proc: " + System.Diagnostics.Process.GetCurrentProcess ().Id);
                    outFile.WriteLine ("Time: " + GetTime (now));
                    outFile.WriteLine ("Retv: " + processString);
                    outFile.WriteLine ("Errc: " + "");
                    outFile.WriteLine ("Exce: " + GetException (exc));
                }
            } catch (Exception) {
            }

            /*
            try {
                now = System.DateTime.Now;
                System.Configuration.AppSettingsReader asr = new System.Configuration.AppSettingsReader ();
                asr.GetValue ("key", System.Type.GetType ("System.Object", false));
            } catch (Exception e) {
            }
            */

            /*
            try {
            System.Xml.XmlDocument.Save ();
            System.Xml.XmlDocument.LoadXml ();
            System.Xml.XmlDocument.WriteContentTo ();
            System.Xml.XmlDocument.WriteTo ();
            System.Xml.XmlDocument xd = new System.Xml.XmlDocument (System.Xml.XmlNameTable);
            System.Xml.XmlDocumentFragment.WriteContentTo ();
            System.Xml.XmlDocumentFragment.WriteTo ();
            System.Xml.XmlDocumentType.WriteContentTo ();
            System.Xml.XmlDocumentType.WriteTo ();
            } catch (Exception e) {
            }

            try {
            System.Xml.XmlWriter.WriteNode ();
            System.Xml.XmlWriter.WriteAttributes ();
            System.Xml.XmlWriter.WriteStartElement ();
            System.Xml.XmlWriter.WriteAttributeString ();
            System.Xml.XmlWriter.WriteStartAttribute ();
            System.Xml.XmlWriter.WriteElementString ();
            } catch (Exception e) {
            }

            try {
            System.Xml.XmlTextWriter xtw = System.Xml.XmlTextWriter (tempPath + "\\dummyFile.txt", System.Text.Encoding.ASCII);
            xtw.WriteNode ();
            xtw.WriteAttributes ();
            xtw.WriteQualifiedName ("localName", );
            xtw.WriteName ();
            xtw.WriteNmToken ();
            xtw.WriteBinHex ();
            xtw.WriteBase64 ();
            xtw.WriteRaw ();
            xtw.WriteChars ();
            xtw.WriteSurrogateCharEntity ();
            xtw.WriteString ();
            xtw.WriteWhitespace ();
            xtw.WriteCharEntity ();
            xtw.WriteEntityRef ();
            xtw.WriteProcessingInstruction ();
            xtw.WriteComment ();
            xtw.WriteCData ();
            xtw.WriteEndAttribute ();
            xtw.WriteStartAttribute ();
            xtw.WriteFullEndElement ();
            xtw.WriteEndElement ();
            xtw.WriteStartElement ();
            xtw.WriteDocType ();
            xtw.WriteEndDocument ();
            xtw.WriteStartDocument ();
            xtw.WriteAttributeString ();
            xtw.WriteElementString ();
            xtw.Flush ();
            xtw.Close ();
            } catch (Exception e) {
            }

            try {
            System.Xml.XmlReader.IsStartElement ();
            System.Xml.XmlReader.ReadEndElement ();
            System.Xml.XmlReader.ReadElementString ();
            System.Xml.XmlReader.ReadStartElement ();
            System.Xml.XmlReader.MoveToContent ();
            System.Xml.XmlReader.Skip ();
            System.Xml.XmlReader.IsName ();
            System.Xml.XmlReader.IsNameToken ();
            } catch (Exception e) {
            }

            try {
            System.Xml.XmlTextReader.ReadAttributeValue ();
            System.Xml.XmlTextReader.ResolveEntity ();
            System.Xml.XmlTextReader.LookupNamespace ();
            System.Xml.XmlTextReader.ReadOuterXml ();
            System.Xml.XmlTextReader.ReadInnerXml ();
            System.Xml.XmlTextReader.IsStartElement ();
            System.Xml.XmlTextReader.ReadEndElement ();
            System.Xml.XmlTextReader.ReadElementString ();
            System.Xml.XmlTextReader.ReadStartElement ();
            System.Xml.XmlTextReader.MoveToContent ();
            System.Xml.XmlTextReader.ReadString ();
            System.Xml.XmlTextReader.Skip ();
            System.Xml.XmlTextReader.Close ();
            System.Xml.XmlTextReader.Read ();
            System.Xml.XmlTextReader.MoveToElement ();
            System.Xml.XmlTextReader.MoveToNextAttribute ();
            System.Xml.XmlTextReader.MoveToFirstAttribute ();
            System.Xml.XmlTextReader.MoveToAttribute ();
            System.Xml.XmlTextReader.GetAttribute ();
            System.Xml.XmlTextReader.GetRemainder ();
            System.Xml.XmlTextReader.ReadChars ();
            System.Xml.XmlTextReader.ReadBase64 ();
            System.Xml.XmlTextReader.ReadBinHex ();
            System.Xml.XmlTextReader.ctor ();
            } catch (Exception e) {
            }

            try {
            System.Xml.XmlEntityReference.WriteContentTo ();
            System.Xml.XmlEntityReference.WriteTo ();
            System.Xml.XmlImplementation.CreateDocument ();
            System.Xml.XmlImplementation.ctor ();
            System.Xml.XmlText.WriteContentTo ();
            System.Xml.XmlText.WriteTo ();
            } catch (Exception e) {
            }
            */
            outFile.Flush ();
            outFile.Close ();

            try {
                sL = System.IO.Directory.GetFiles (tempPath, "tempFile*.txt");
                foreach (string str in sL) {
                    try {
                        System.IO.File.Delete (str);
                    } catch (Exception) {
                    }
                }
                sL = System.IO.Directory.GetFiles (tempPath, "dummyFile*.txt");
                foreach (string str in sL) {
                    try {
                        System.IO.File.Delete (str);
                    } catch (Exception) {
                    }
                }
                sL = System.IO.Directory.GetDirectories (tempPath, "TempDir*");
                foreach (string str in sL) {
                    try {
                        System.IO.Directory.Delete (str);
                    } catch (Exception) {
                    }
                }
            } catch (Exception) {
            }
        }