Блог

Я застрял и прошу вашей помощи, пытаясь создать программное обеспечение, которое проверяет файл txt этого формата с информацией CRC и загружает файлы внутри этого txt. Это всего лишь пример с одним и тем же хэшем, но на самом деле у них другое имя, хэш и размер.

 [FOLDER/FILE]               [HASH]   [FILESIZE]       

./file1.dat                 f926038f 54 
./Folder/file2.dat          f926038f 54
./Folder/Subfolder/file3.dat f926038f 54
 

после того, как я сгенерирую этот тип информации, я использую этот код, чтобы прочитать, где находится файл…

 private static void backgroundWorker_DoWork(object sender, DoWorkEventArgs e)
        {
            StreamReader streamReader = new StreamReader(new WebClient().OpenRead(Import.ServerURL   Import.PatchlistName));
            while (!streamReader.EndOfStream)
                ListProcessor.AddFile(streamReader.ReadLine());
        }
 

и этот код, чтобы проверить список этого файла и записать их в текущую папку

 internal class ListProcessor
    {
        public static void AddFile(string File) => Import.Files.Add(new Import.File()
        {
            Name = File.Split(' ')[0],
            Hash = File.Split(' ')[1],
            Size = Convert.ToInt64(File.Split(' ')[2])
        });
    }
 

проблема в том, что файлы вне любых папок или вложенных папок они загружают идеально, но внутри любой папки или вложенной папки загрузка не работает.

PS: Это порядок, с которого все начинается:

Main.cs

 private void Btn_Run_Click(object sender, EventArgs e)
{
    if (!this.Btn_Run.Enabled)
        return;
    ListDownloader.DownloadList();
}
 

ListDownloader.cs

 internal class ListDownloader
    {
        public static void DownloadList()
        {
            Common.ChangeStatus("LISTDOWNLOAD");
            Common.DisableStart();
            BackgroundWorker backgroundWorker = new BackgroundWorker();
            backgroundWorker.DoWork  = new DoWorkEventHandler(ListDownloader.backgroundWorker_DoWork);
            backgroundWorker.RunWorkerCompleted  = new RunWorkerCompletedEventHandler(ListDownloader.backgroundWorker_RunWorkerCompleted);
            
            if (backgroundWorker.IsBusy)
            {
                int num = (int) MessageBox.Show(Texts.GetText("UNKNOWNERROR", (object) "DownloadList isBusy"));
                Application.Exit();
            }
            else
                backgroundWorker.RunWorkerAsync();
        }

        private static void backgroundWorker_DoWork(object sender, DoWorkEventArgs e)
        {
            StreamReader streamReader = new StreamReader(new WebClient().OpenRead(Import.ServerURL   Import.PatchlistName));
            while (!streamReader.EndOfStream)
                ListProcessor.AddFile(streamReader.ReadLine());
        }

        private static void backgroundWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
          FileChecker.CheckFiles();
        }
    }
 

FileChecker.cs

 internal class FileChecker
    {
        private static BackgroundWorker backgroundWorker = new BackgroundWorker();

        public static void CheckFiles()
        {
            FileChecker.backgroundWorker.WorkerReportsProgress = true;
            FileChecker.backgroundWorker.DoWork  = new DoWorkEventHandler(FileChecker.backgroundWorker_DoWork);
            FileChecker.backgroundWorker.ProgressChanged  = new ProgressChangedEventHandler(FileChecker.backgroundWorker_ProgressChanged);
            FileChecker.backgroundWorker.RunWorkerCompleted  = new RunWorkerCompletedEventHandler(FileChecker.backgroundWorker_RunWorkerCompleted);
            
            if (FileChecker.backgroundWorker.IsBusy)
            {
                int num = (int) MessageBox.Show(Texts.GetText("UNKNOWNERROR", (object) "CheckFiles isBusy"));
                Application.Exit();
            }
            else
                FileChecker.backgroundWorker.RunWorkerAsync();
        }

        private static void backgroundWorker_DoWork(object sender, DoWorkEventArgs e)
        {
            foreach (Import.File file in Import.Files)
            {
                Import.fullSize  = file.Size;
                FileChecker.backgroundWorker.ReportProgress(0, (object) Path.GetFileName(file.Name));
                
                if (!System.IO.File.Exists(file.Name) || string.Compare(Common.GetHash(file.Name), file.Hash) != 0)
                {
                    Import.OldFiles.Add(file.Name);
                }
                else
                {
                    Import.completeSize  = file.Size;
                    FileChecker.backgroundWorker.ReportProgress(1);
                }
            }
        }

        private static void backgroundWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            if (e.ProgressPercentage == 0)
            {
                Common.ChangeStatus("CHECKFILE", e.UserState.ToString());
            }
            else
            {
                Common.UpdateCompleteProgress(Computer.Compute(Import.completeSize));
                Common.UpdateCurrentProgress(Computer.Compute(Import.completeSize), 0.0);
            }
        }

        private static void backgroundWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            FileDownloader.DownloadFile();
        }

        private enum State
        {
            REPORT_NAME,
            REPORT_PROGRESS,
        }
    }
 

и файл <url>

 internal class FileDownloader
    {
        private static int curFile;
        private static long lastBytes;
        private static long currentBytes;
        private static Stopwatch stopWatch = new Stopwatch();

        public static void DownloadFile()
        {
            if (Import.OldFiles.Count <= 0)
            {
                Common.ChangeStatus("CHECKCOMPLETE");
                Common.UpdateCurrentProgress(100L, 0.0);
                Common.UpdateCompleteProgress(100L);
                Starter.Start();
            }
            else if (FileDownloader.curFile >= Import.OldFiles.Count)
            {
                Common.ChangeStatus("DOWNLOADCOMPLETE");
                Common.UpdateCurrentProgress(100L, 0.0);
                Common.UpdateCompleteProgress(100L);
                Starter.Start();
            }
            else
            {
                if (Import.OldFiles[FileDownloader.curFile].Contains("/"))
                    Directory.CreateDirectory(Path.GetDirectoryName(Import.OldFiles[FileDownloader.curFile]));
                
                WebClient webClient = new WebClient();
                webClient.DownloadProgressChanged  = new DownloadProgressChangedEventHandler(FileDownloader.webClient_DownloadProgressChanged);
                webClient.DownloadFileCompleted  = new AsyncCompletedEventHandler(FileDownloader.webClient_DownloadFileCompleted);
                FileDownloader.stopWatch.Start();
                Common.ChangeStatus("DOWNLOADFILE", Import.OldFiles[FileDownloader.curFile]);
                webClient.DownloadFileAsync(new Uri(Import.ServerURL   Import.OldFiles[FileDownloader.curFile]), Import.OldFiles[FileDownloader.curFile]);
            }
        }

        private static void webClient_DownloadProgressChanged(object sender, DownloadProgressChangedEventArgs e)
        {
            FileDownloader.currentBytes = FileDownloader.lastBytes   e.BytesReceived;
            Common.UpdateCompleteProgress(Computer.Compute(Import.completeSize   FileDownloader.currentBytes));
            Common.UpdateCurrentProgress((long) e.ProgressPercentage, Computer.ComputeDownloadSpeed((double) e.BytesReceived, FileDownloader.stopWatch));
        }

        private static void webClient_DownloadFileCompleted(object sender, AsyncCompletedEventArgs e)
        {
            FileDownloader.lastBytes = FileDownloader.currentBytes;
            Common.UpdateCurrentProgress(100L, 0.0);
              FileDownloader.curFile;
            FileDownloader.stopWatch.Reset();
            FileDownloader.DownloadFile();
        }
    }