Lancer un nouveau fil pour ouvrir une nouvelle fenêtre et la fermer à partir d'un fil différent

Droit maintenant, j'ai le code C# pour pondre une nouvelle fenêtre dans un thread différent, cela fonctionne, mais dès que la nouvelle a engendré fenêtre s'ouvre, se ferme et les extrémités de fil. Comment pourrais-je faire de sorte que le nouveau engendré fenêtre peut être fermée à partir du premier thread?

Ici est un "arbre" de la façon dont le frai travaille actuellement:

Thread principal
--Utilise une fonction dans le thread principal pour démarrer une autre fonction dans un thread séparé pour ouvert w de la fenêtre, provoquant la fenêtre à utiliser ce thread.

Fondamentalement, je veux juste que les deux fenêtres ont chacun leur propre thread. Et être en mesure de contrôler le pondu fenêtre secondaire à partir de la première fenêtre de fil.

source d'informationauteur James T

c#multithreading winforms

27

Je parie que ce que vous faites est quelque chose comme ceci:
```
new Thread(() => new TestForm().Show()).Start();
```
parce que cela rend la fenêtre disparaître immédiatement, comme vous le décrivez.

Essayez plutôt ceci:
```
 new Thread(() => new TestForm().ShowDialog()).Start();
```
ShowDialog tourne son propre message de la pompe, et retourne uniquement lorsque la fenêtre est fermée.

Vous pouvez le faire comme ceci:

Dans Le Programme.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;
using System.Threading;

namespace TwoWindows
{
    static class Program
    {
        public static Form1 form1;
        public static Form2 form2;
        ///<summary>
        ///The main entry point for the application.
        ///</summary>
        [STAThread]
        static void Main()
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false); 

            form1 = new Form1();
            form2 = new Form2();

            form1.Form2Property = form2;
            form2.Form1Property = form1;

            form1.Show();
            form2.Show();

            Application.Run();
        }
    }
}

Dans Form1.cs:

namespace TwoWindows
{
    public partial class Form1 : Form
    {
        public Form2 Form2Property { get; set; }

        public Form1()
        {
            InitializeComponent();
        }

        protected override void OnClosed(EventArgs e)
        {
            if (Form2Property.IsDisposed)
                Application.Exit();
        }
    }
}

Et Form2.cs:

namespace TwoWindows
{
    public partial class Form2 : Form
    {
        public Form1 Form1Property { get; set; }

        public Form2()
        {
            InitializeComponent();
        }

        protected override void OnClosed(EventArgs e)
        {
            if (Form1Property.IsDisposed)
                Application.Exit();
        }
    }
}

De cette façon, vous pouvez obtenir deux formes sur le même fil et utilisez-la pour contrôler l'autre.
Si vous avez besoin d'utiliser des threads, je voudrais suggérer d'utiliser des threads dédiés qui font partie des classes d'une lance pas dans une méthode qui peut être appelé plus d'une fois. Ensuite, utilisez ManualResetEvent ou AutoResetEvent pour contrôler le thread de traitement. J'aime vraiment l'approche de l'aide de quelque chose comme cela, car il est sécurisé et ne passent pas beaucoup de ressources de l'initialisation du fils.

public class MyClassOrForm
{
    Thread myProcessingThread;
    public AutoResetEvent startProcessing = new AutoResetEvent(false);
    public AutoResetEvent processingFinished = new AutoResetEvent(false);
    public AutoResetEvent killProcessingThread = new AutoResetEvent(false);

    public MyClassOrForm()
    {
        myProcessingThread = new Thread(MyProcess);
    }

    private void MyProcess()
    {
        while (true)
        {
            if (startProcessing.WaitOne())
            {
                //Do processing here

                processingFinished.Set();
            }

            if (killProcessingThread.WaitOne(0))
                return;
        }
    }
}

Puis, une fois que vous avez réglé le traitement des données, formulaire d'appel à une autre classe ou d'une méthode

MyClassOrMethodInstance.startProcessing.Set();

Et si vous avez besoin d'attendre pour que la fin du traitement puis insérer:

MyClassOrMethodInstance.processingFinished.WaitOne(time_out_ms);

C'est équivalent à un Fil.Join() de l'appel, mais seulement que vous n'avez pas à allouer un autre thread à chaque fois avec les risques que les threads implique que si elles reposent sur des données locales ou enfant inachevé threads.

1

Comment avez-vous créer la nouvelle fenêtre à partir de la deuxième thread? Et que fait le fil après la fenêtre est créée?

Sans voir le code, je suppose que le problème est que votre deuxième thread ne pompe pas les messages sur le Windows file d'attente de messages.

Faites-vous appel à Application.Run sur votre deuxième thread?

BTW: notez que votre conception a certaines limitations. Le premier thread ne sera pas en mesure de directement de contrôle de la deuxième fenêtre. Chaque fois que vous essayez de manipuler n'importe quel élément de l'INTERFACE utilisateur sur la deuxième fenêtre de la première du fil, vous devrez utiliser Control.Invoke pour s'assurer que la manipulation de l'INTERFACE utilisateur sur le bon thread.
1

Je suis en train d'écrire une application qui est fileté et utilise l'INTERFACE utilisateur sur le thread créé à l'expédition de dessin de la fonctionnalité de la DC.

Lorsque nous avons porté l'exécution de l'application à partir de l'invite de commande, nous avons été naturellement à gauche avec un peu d'un problème comme le répartiteur thread n'a pas été créé ou nécessaire - j'ai donc créé un autre thread de l'application point d'entrée qui a appelé l'essentiel ShowDialog() (la seule façon de tourner le message de la pompe) sur le formulaire principal - avec un overidden OnShown permanente de se cacher et de minimiser le formulaire lors de l'appel. Cela m'a permis de toujours l'expédition de la forme et gérer l'ensemble de mon dessin de l'autre de plusieurs threads.

C'est certainement une approche laide, mais c'était un moyen rapide de le faire, et il fonctionne comme prévu.

Pour un projet que je suis en train de travailler sur j'ai créé un formulaire qui vous pop-up, séjour ouvert alors que la tâche est en cours et fermer par la suite.

Il contient une ProgressBar avec les paramètres suivants:

progressBar1.Style=ProgressBarStyles.Marquee
progressBar1.MarqueeAnimationSpeed = <-- définir votre vitesse personnalisée en millisecondes ici

Si vous le souhaitez, vous pouvez définir la forme du TopMost propriété true.

Voici le code du formulaire:

public partial class BusyForm : Form
{
    public BusyForm(string text = "Busy performing action ...")
    {
        InitializeComponent();
        this.Text = text;
        this.ControlBox = false;
    }

    public void Start()
    {
        System.Threading.Tasks.Task.Run(() =>
        {
            this.ShowDialog();
        });
    }

    public void Stop()
    {
        BeginInvoke((Action)delegate { this.Close(); });
    }

    public void ChangeText(string newText)
    {
        BeginInvoke((Action)delegate { this.Text = newText; });
    }
}

Et voici le code à utiliser le formulaire dans votre code:

        BusyForm busyForm = new BusyForm(text: "Opening database ...");

        busyForm.Start();

        //do your stuff here

        busyForm.Stop();

Mise à JOUR: j'ai couru dans certains sous-jacentes des problèmes avec l'enfilage. Voici une version mise à jour du code. Pour quelques informations de fond, cette forme a une barre de progression qui s'affiche lorsqu'une tâche est occupé. J'ai ajouté le ChangeText commande pour afficher un exemple de la façon dont vous pouvez interagir avec ce formulaire à partir d'un autre formulaire. Devrait probablement aussi mentionner que votre Main dans Program.cs devrait avoir le [STAThread] attribut comme on le voit ci-dessous.

    [STAThread]
    static void Main(string[] args)
    {
        System.Globalization.CultureInfo.DefaultThreadCurrentCulture = System.Globalization.CultureInfo.InvariantCulture;
        Application.EnableVisualStyles();
        Application.SetCompatibleTextRenderingDefault(false);
        Application.Run(new Form1());
    }

Vous devez vous connecter pour publier un commentaire.