Pourquoi le même code est-il tellement plus lent dans le fil du travail d'arrière-plan que dans mon fil d'interface graphique?

J'essaie de créer une application C # Winforms qui recherche et met en évidence le texte dans une richtextbox. J'ai créé deux méthodes de recherche: une qui fonctionne dans le fil de l'interface graphique et une qui fonctionne dans un travailleur d'arrière-plan. La logique dans les deux méthodes est essentiellement identique. Cependant, le code dans le BGW fonctionne considérablement plus lentement.

Veuillez voir les résultats ci-dessous: p>

0.25MB fichier texte recherchant un mot clé commun: GUI: 2.9S - BGW: 7.0
Fichier texte de 1 Mo Recherche sur un mot-clé commun: GUI: 14.1S - BGW: 71.4S
Fichier texte de 5 Mo Recherche sur un mot clé commun: GUI: 172s - BGW: 1545S P>

Il me semble étrange que la relation entre le temps pris pour les deux méthodes n'est pas une doublure en ce qui concerne la taille de la recherche. P >

L'application sera utilisée pour rechercher des fichiers jusqu'à 10 Mo de taille de 10 Mo afin qu'il soit important que cela soit rapide. Je voulais utiliser un ouvrier d'arrière-plan afin que l'utilisateur puisse voir les progrès et continuer à lire le fichier pendant la recherche de la recherche. P>

Veuillez consulter le code des deux méthodes ci-dessous: P>

    // background search thread
    private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
    {
        // Get the BackgroundWorker that raised this event.
        BackgroundWorker worker = sender as BackgroundWorker;

        RichTextBox rtb = new RichTextBox();
        RichTextBox results = new RichTextBox();
        rtb.Rtf = e.Argument as string;  //recive text to be searched

        int hits = 0; // track number of hits
        int pos = 0;  // track position in rtb
        int i = 0;    // trach current line number for progress report

        string lowerT = searchTerm.ToLowerInvariant();
        string lowerl = "";
        int n = 0;
        int len = searchTerm.Length;

        foreach (string l in rtb.Lines)
        {
            lowerl = l.ToLowerInvariant();
            n = lowerl.IndexOf(lowerT);
            if (n > -1)
            {
                while (n > -1)   //if found sterm highlight instances
                {
                    hits++;     //incriment hits

                    //hilight term
                    rtb.SelectionStart = pos + n;
                    rtb.SelectionLength = len;
                    rtb.SelectionBackColor = Color.Yellow;
                    rtb.SelectionColor = Color.Black;

                    //find next
                    n = lowerl.IndexOf(lowerT, n + len);
                }
                searchRes.Add(pos); // add positon of hit to results list

                //add rtb formatted text to results rtb
                rtb.SelectionStart = pos;
                rtb.SelectionLength = l.Length;
                results.SelectedRtf = rtb.SelectedRtf;
                results.AppendText(Environment.NewLine);

            }
            pos += l.Length + 1; //incriment position

            //worker.ReportProgress(++i);
        }
        string[] res = {rtb.Rtf,results.Rtf,hits.ToString()};
        e.Result = res;
    }

    // old non threaded search method
    public void OldSearch(string sTerm)
    {
        int hits = 0; // track number of hits
        int pos = 0;  // track position in rtb
        int oldPos = richTextBox1.SelectionStart; //save current positin in rtb
        int oldLen = richTextBox1.SelectionLength;

        string lowerT = sTerm.ToLowerInvariant();

        sTime = 0;
        System.Threading.Timer tmr = new System.Threading.Timer(new TimerCallback(TimerTask), null, 0, 100);

        if (sTerm.Length > 0)
        {
            //clear old search
            ReloadFile();
            richTextBox4.Clear();
            searchRes = new List<int>();

            //open results pane
            label1.Text = "Searching for \"" + sTerm + "\"...";
            splitContainer1.Panel2Collapsed = false;

            frmFind.Focus();
            frmFind.ShowProgress(true);

            foreach (string l in richTextBox1.Lines)
            {
                string lowerl = l.ToLowerInvariant();
                int n = lowerl.IndexOf(lowerT);
                if (n > -1)
                {
                    while (n > -1)   //if found sterm highlight instances
                    {
                        hits++;     //incriment hits
                        //hilight term
                        richTextBox1.SelectionStart = pos + n;
                        richTextBox1.SelectionLength = sTerm.Length;
                        richTextBox1.SelectionBackColor = Color.Yellow;
                        richTextBox1.SelectionColor = Color.Black;
                        //find next
                        n = lowerl.IndexOf(lowerT, n + sTerm.Length);
                    }
                    searchRes.Add(pos);
                    richTextBox1.SelectionStart = pos;
                    richTextBox1.SelectionLength = l.Length;
                    richTextBox4.SelectedRtf = richTextBox1.SelectedRtf;
                    richTextBox4.AppendText(Environment.NewLine);
                }
                pos += l.Length + 1; //incriment position
            }

            tmr.Dispose();

            float time = (float)sTime / 10;

            label1.Text = "Search for \"" + sTerm + "\": Found " + hits + " instances in " + time + " seconds.";
            richTextBox4.SelectionStart = 0;
            richTextBox1.SelectionStart = oldPos;
            richTextBox1.SelectionLength = oldLen;
            richTextBox1.Focus();
            frmFind.ShowProgress(false);
        }
    }

• Je sais que la classe RTB a sa propre méthode de recherche, mais la présente considérablement plus lente que ma propre méthode. li>
• J'ai lu un certain nombre de threads concernant la performance BGW et le plus semblent utiliser l'utilisation des méthodes d'appel comme la cause, mais j'utilise aucun. li>
• Je comprends que l'utilisation de threads multiples le rendra plus lente mais ne s'attendait pas à cette différence. li>
• Le problème n'est pas avec ReportProgress Code> J'ai commenté cette ligne de sortie. La raison pour laquelle je le fais de cette façon plutôt que comme un pourcentage est le calcul pour déterminer le pourcentage de la grande différence. Il est en fait plus rapide de cette façon li>
• this lien fourni par un autre utilisateur décrit comment J'utilise mon RTB dans un fil non influencé. Il semble suggérer que cela ne devrait pas être un problème, mais incitera plus de frais généraux car cela provoquera la création d'une file d'attente de message. Je ne sais pas si cela affectera la performance du code dans ma boucle foreach. Toute commentaires sur la question serait très appréciée. Li> ul> p>