释放在后台工作程序C＃WPF上使用的资源

Question

好，所以我正在开发游戏启动器。 它检查更新，如果存在，则将其下载并解压缩。 解压缩完成后，将新文件复制到需要的位置，然后删除zip和解压缩的文件。

问题是这样的：如果用户在解压缩时关闭启动器，则下次启动时，我在解压缩时遇到错误-该文件已存在。

所以我想做的是退出时删除Patch文件夹。 但是，如果后台工作程序正在运行，则无法删除该资源，因为该资源正被另一个进程使用。

下载器类：

static void downloader_DoWork(object sender, DoWorkEventArgs e)
    {
        BackgroundWorker worker = sender as BackgroundWorker;

        if (!Directory.Exists(Path.Combine(BASE_DIR, "Patch")))
            Directory.CreateDirectory(Path.Combine(BASE_DIR, "Patch"));

        string sFilePathToWriteFileTo = Path.Combine(BASE_DIR, "Patch", "patch.zip").ToString();

        // first, we need to get the exact size (in bytes) of the file we are downloading
        Uri url = new Uri(sUrlToReadFileFrom);
        System.Net.HttpWebRequest request = (System.Net.HttpWebRequest)System.Net.WebRequest.Create(url);
        System.Net.HttpWebResponse response = (System.Net.HttpWebResponse)request.GetResponse();
        response.Close();
        // gets the size of the file in bytes
        Int64 iSize = response.ContentLength;

        // keeps track of the total bytes downloaded so we can update the progress bar
        Int64 iRunningByteTotal = 0;

        // use the webclient object to download the file
        using (System.Net.WebClient client = new System.Net.WebClient())
        {
            // open the file at the remote URL for reading
            using (System.IO.Stream streamRemote = client.OpenRead(new Uri(sUrlToReadFileFrom)))
            {
                // using the FileStream object, we can write the downloaded bytes to the file system
                using (Stream streamLocal = new FileStream(sFilePathToWriteFileTo, FileMode.Create, FileAccess.Write, FileShare.None))
                {
                    // loop the stream and get the file into the byte buffer
                    int iByteSize = 0;
                    byte[] byteBuffer = new byte[1024];
                    double dTotal = (double)iSize;
                    while ((iByteSize = streamRemote.Read(byteBuffer, 0, byteBuffer.Length)) > 0)
                    {
                        // write the bytes to the file system at the file path specified
                        streamLocal.Write(byteBuffer, 0, iByteSize);
                        iRunningByteTotal += iByteSize;

                        // calculate the progress out of a base "100"
                        double dIndex = (double)(iRunningByteTotal);
                        double dProgressPercentage = (dIndex / dTotal);
                        int iProgressPercentage = (int)(dProgressPercentage * 100);

                        // update the progress bar
                        worker.ReportProgress(iProgressPercentage);
                    }

                    // clean up the file stream
                    streamLocal.Close();
                }
                // close the connection to the remote server
                streamRemote.Close();
            }
        }

    }

然后解压缩：

private void decompresser_DoWork(object sender, DoWorkEventArgs e)
    {
        BackgroundWorker worker = sender as BackgroundWorker;
        #region Unzip files

        if (!Directory.Exists(decompressPath))
            Directory.CreateDirectory(decompressPath);

        using (ZipArchive archive = ZipFile.OpenRead(archiveName))
        {
            int iTotal = archive.Entries.Count();
            int curr = 0;
            foreach (ZipArchiveEntry entry in archive.Entries)
            {
                if (entry.FullName != entry.Name)
                {
                    if (entry.Name == string.Empty)
                    {
                        //create folder here
                        Directory.CreateDirectory(Path.Combine(decompressPath, entry.FullName));
                    }
                    else
                    {
                        //create folder and extract file into it
                        string dirToCreate = entry.FullName.Replace(entry.Name, "");
                        Directory.CreateDirectory(Path.Combine(decompressPath, dirToCreate));
                        entry.ExtractToFile(Path.Combine(decompressPath, entry.FullName));
                    }
                }
                else
                {
                    //just extract file
                    Console.WriteLine(Path.Combine(decompressPath, entry.FullName));
                    entry.ExtractToFile(Path.Combine(decompressPath, entry.FullName));
                }

                curr++;
                var progress = ((double)curr / (double)iTotal) * 60.0;
                worker.ReportProgress((int)progress);
            }
        }

        //delete zip file
        File.Delete(Path.Combine(BASE_DIR, "Patch", "patch.zip"));
        #endregion

        #region Copy files
        string sourceDirName = Path.Combine(BASE_DIR, "Patch");
        string destDirName = BASE_DIR;
        DirectoryInfo dir = new DirectoryInfo(sourceDirName);
        long maxbytes = 0;
        List<FileInfo> files = new List<FileInfo>();
        FileInfo[] folder = dir.GetFiles("*.*", SearchOption.AllDirectories);
        foreach (FileInfo file in folder)
        {
            if ((file.Attributes & FileAttributes.Directory) != 0) continue;
            files.Add(file);
            maxbytes += file.Length;
        }

        // Copy files
        long bytes = 0;
        foreach (FileInfo file in files)
        {
            try
            {
                //where to copy
                string copyPath = file.FullName.Replace("Patch\\", "").Replace(file.Name, "");
                if (!Directory.Exists(copyPath))
                    Directory.CreateDirectory(copyPath);
                File.Copy(file.FullName, Path.Combine(copyPath, file.Name), true);
                var progress = 60 + ((double)bytes / (double)maxbytes) * 30.0;
                worker.ReportProgress((int)progress);
            }
            catch (Exception ex)
            {
            }
            bytes += file.Length;
        }

        #endregion

        #region Clean Up

        foreach (FileInfo file in files)
        {
            try
            {
                var progress = 90 + ((double)(maxbytes - file.Length) / (double)maxbytes) * 9;

                file.Delete();
                worker.ReportProgress((int)progress);
            }
            catch (Exception ex) { }
        }
        try
        {
            string delPath = Path.Combine(BASE_DIR, "Patch");
            Directory.Delete(delPath, true);
        }
        catch (Exception ex) { }

        worker.ReportProgress(100);


        #endregion
    }

我通过调用App.Current.Shutdown();终止应用程序App.Current.Shutdown(); 方法。

Answer 1

如果我什么都不缺，那么有一个非常简单的解决方案。 您可以通过调用workerObject.RequestStop();使用退出时事件停止所有后台工作程序workerObject.RequestStop(); （请注意，它仅向工作人员中的代码发出信号，要求您请求停止，您需要在工作人员的do work循环中进行处理以停止工作）。 然后，您可以清理补丁文件夹。

Answer 2

为了回避这个问题，您是否还不能在启动应用程序时而是在开始下载之前删除补丁程序文件夹？

Answer 3

@GWLlosa-我确实考虑过在启动时删除文件，如果需要的话，但是如果我找不到更好的方法，我将把它保存为万不得已

我尝试过这样的事情

    protected override void OnClosing(System.ComponentModel.CancelEventArgs e)
        {
            updater.CancelAsync();
            while (updater.IsBusy)
            {
                Thread.Sleep(100);
            }
//run code to delete the files after the worked has stopped
}

但这只会使我陷入无限循环:)

Answer 4

如果这样做，我将在启动后立即发现并终止下载过程。

Process[] p = Process.GetProcessesByName("processname");
foreach (var proc in p)
{
     proc.Kill();
}

Answer 5

对于您的问题，我有2个解决方案。

1）不要试图在退出时删除补丁程序文件夹，只需启动并忘记BackgroundWorker，如果用户取消补丁程序并退出，则只需退出应用程序即可。 但是，总是在用户启动您的应用程序时删除补丁文件夹，特别是在您调用unzip之前。

2）如果您仍然想在退出时删除补丁文件夹，请使用CancelAsync（）函数取消BackgroundWorker。 例如

private void btnStart_Click(object sender, EventArgs e)
{
    if (btnStart.Text == "Start")
    {
        ...
    }
    else
    {
        m_bgWorker.CancelAsync();
    }
}


private void SearchFiles(string strPath, string strPattern)
{
    string strMessage = "Parsing directory " + strPath;
    m_bgWorker.ReportProgress(0, strMessage);
    foreach (string strFileName in Directory.GetFiles(strPath, strPattern))
    {
        if (m_bgWorker.CancellationPending)
        {
            return;
        }
        else
        {
            m_lstFiles.Add(strFileName);
        }
    }

    foreach (string strDirName in Directory.GetDirectories(strPath))
    {
        if (m_bgWorker.CancellationPending)
        {
            return;
        }
        else
        {
            SearchFiles(strDirName, strPattern);
        }
    }
}

我从这篇文章中得到了代码。 您可以从该示例中阅读更多内容，以了解作者如何取消其BackgroundWorker。