Comment continuer à exécuter du code après avoir appelé ShowDialog ()

la Forme.ShowDialog (), méthode provoque le code pour être arrêtée jusqu'à ce que le nouveau formulaire est fermé. J'ai besoin du code pour continuer à courir après le ShowDialog() la méthode est appelée. J'ai googlé et lu sur l'utilisation de backgroundworker? Mais c'est la première fois que j'ai entendu parler de ça et n'a jamais été utilisé avant.

Form2 form2this = new Form2();
form2this.ShowDialog();
MessageBox.Show("Something");

Ce code est exécuté après avoir cliqué sur un bouton, comment puis-je encore appeler ShowDialog pour empêcher l'utilisateur d'interagir avec le formulaire principal, mais toujours la principale forme de poursuivre ses travaux?

Désolé si sa été discutées, mais tout ce que j'ai trouvé semble extrêmement difficile d'effectuer une telle tâche simple. Je suis d'ailleurs surpris que ses pas inclus dans la méthode SHowDialog. par exemple ShowDialog().Continuer serait cool.

source d'informationauteur Seth

c#continue forms

15
- Si vous voulez juste le code pour continuer sur la place du blocage jusqu'à ce que le pop-up est fermé envisager d'utiliser Show au lieu de ShowDialog.
- Si vous avez un peu d'action que vous voulez avoir le formulaire parent pendant que l'enfant est en place, alors oui, il pourrait être approprié d'utiliser un BackgroundWorker (ou juste de la lancer manuellement un nouveau sujet/Tâche). Il serait utile d'en savoir plus sur ce que la tâche est bien. Si vous avez besoin d'interagir avec le formulaire principal, ou l'enfant à la forme, alors que semble que de mal pour moi; si vous avez juste besoin de faire quelques tâches d'arrière-plan sans interaction de l'INTERFACE utilisateur, alors c'est la droite ligne de la pensée.
- Une autre possibilité est que ce que vous voulez faire vraiment devrait juste être quelque chose à l'enfant, plutôt que le formulaire parent.
5

Tant que vous ne les opérations asynchrones pendant le temps que la boîte de dialogue modale est ouvert, vous pouvez le faire aussi simplement comme illustré ci-dessous, en supposant que button1_Click() est le gestionnaire d'événement pour un bouton.
```
private async void button1_Click(object sender, EventArgs e)
{
    //create and display modal form
    Form2 modalForm = new Form2();
    BeginInvoke((Action)(() => modalForm.ShowDialog()));

    //do your async background operation
    await DoSomethingAsync();

    //close the modal form
    modalForm.Close();
}


private async Task DoSomethingAsync()
{
    //example of some async operation....could be anything
    await Task.Delay(10000);
}
```
J'ai constaté que lorsque j'ai utilisé la solution qui m'a suggéré d'utiliser Show(), j'ai pu retrouver dans les cas où la boîte de dialogue je voulais être modale finirait derrière le formulaire principal, après des allers-retours entre les applications. Qui n'arrive jamais quand j'utilise la solution ci-dessus.
0

Est-il une raison pourquoi vous ne pouvez pas avoir ce code dans le cadre de la Form2 classe? Ou utiliser un dialogue non modale? Vous pourriez utiliser un arrière-plan travailleur ou même quelque chose de simple comme un chronomètre, mais semble exagéré?

Exécuter un appel asynchrone de montrer modal. Voici un exemple dans le wpf:

private Window waitView;

///<summary>
///Closes a displayed WaitView from code.
///</summary>
public void CloseWaitView()
{
  if(waitView != null)
  {
     //Work on the gui Thread of waitView.
     waitView.Dispatcher.Invoke(new Action(() => close()));
  }
}

///<summary>
///Closes a displayed WaitView and releases waitView-Instance.
///</summary>    
private void close()
{
   waitView.Close();
   waitView = null;
}   

///<summary>
///Showes a modal WaitView (Window).
///</summary>
public void ShowWaitView()
{
  //instance a new WaitViewWindow --> your Window extends Window-Class
  waitView = new WaitViewWindow();

  //prepare a operation to call it async --> your ShowDialog-call
  var asyncCall = new Action(() => waitView.Dispatcher.Invoke(
                                   new Action(() => waitView.ShowDialog())
                             ));

  //call the operation async

  //Argument 1 ar:
  //ar means IAsyncResult (what should be done, when come back from ShowDialog -->     
  //remove view memory with set waitView to null or ... dispose

  //the second argument is an custom parameter you can set to use in ar.AsyncState
  asyncCall.BeginInvoke(ar => waitView = null, null);

  //all from here is done during ShowDialog ...
}

C'est ma voie, si laid, mais je n'ai pas de meilleure idée.

private void AppUiMain_Shown(object sender, EventArgs e)
{
    var loading = new AppUiLoading();
    loading.Shown += (o, args) =>
    {
        bool isLoading = true;
        loading.Top = (int)(loading.Top * 1.16);

        Application.DoEvents();//refresh ui

        EventHandler ehr = null;
        EventHandler ehe = null;
        ehr = (ss, ee) =>
        {
            App.Instance.Ready -= ehr;
            App.Instance.Error -= ehe;
            isLoading = false;
        };
        ehe = (ss, ee) =>
        {
            loading.Text = "Error";
            loading.ShowAbortButton("Error occur");
        };
        App.Instance.Error += ehe;
        App.Instance.Ready += ehr;
        InitApp();

        //HACK: find a better way to `refresh' main form
        Application.DoEvents();
        this.Height++;
        this.Height--;

        //HACK: find a better way to keep message looping on ShowDialog
        while (isLoading)
            Application.DoEvents();

        loading.Close();
    };
    loading.ShowDialog(this);
}

0

De poursuivre l'exécution de code sans fermer la boîte de dialogue modale WindowsFormsSynchronizationContext.Actuel.Post(-=> {"Votre code"}, null); peut être utilisé. Ici vous pouvez trouver plus de détails -

http://newapputil.blogspot.in/2015/05/continue-executing-code-after-calling.html

-1

Je suppose que la prochaine solution pour async ShowDialog:

public bool DialogResultAsync
{
    get;
    private set;
}

public async Task<bool> ShowDialogAsync()
{
    var cts = new CancellationTokenSource();
    //Attach token cancellation on form closing.
    Closed += (object sender, EventArgs e) =>
    {
        cts.Cancel();
    };
    Show(); //Show message without GUI freezing.
    try
    {
        //await for user button click.
        await Task.Delay(Timeout.Infinite, cts.Token);
    }
    catch (TaskCanceledException)
    { } 
}

public void ButtonOkClick()
{
    DialogResultAsync = true;
    Close();
}

public void ButtonCancelClick()
{
    DialogResultAsync = false;
    Close();
}

Et dans le formulaire principal, vous devez utiliser ce code:

public async void ShowDialogAsyncSample()
{
    var msg = new Message();
    if (await msg.ShowDialogAsync())
    {
        //Now you can use DialogResultAsync as you need.
        System.Diagnostics.Debug.Write(msg.DialogResultAsync);
    }
}

Vous devez vous connecter pour publier un commentaire.