Bug molto strano quando si utilizza Mostra finestra di dialogo su Winform C #

Question

Ho creato 2 moduli in VS Studio 2008 Express Edition e li dichiaro con statico pubblico nel file principale program.cs

Voglio solo passare tra i due moduli con ShowDialog e Close ma quando provo a chiudere il secondo modulo e riaprire il primo modulo con showdialog dice che non posso usare showDialog quando il modulo è già visibile, mentre non lo è vero da quando l'ho chiuso prima per mostrare il secondo modulo.

Mi ha chiesto di impostare la proprietà del modulo visibile su false prima di utilizzare showdialog, quindi l'ho fatto

    internal static void CloseSecondForm(FirstForm FirstForm)
    {
        FirstForm .Close();
        SecondForm.Visible = false;
        SecondForm.ShowDialog();
    }

Ma poi dice che non posso usare ShowDialog perché il modulo è già mostrato in modalità Dialog e devo chiuderlo. Quindi ho fatto quello che mi chiedeva

    internal static void CloseSecondForm(FirstForm FirstForm)
    {
        FirstForm .Close();
        SecondForm.Visible = false;
        SecondForm.Close();
        SecondForm.ShowDialog();
    }

Ma fa ancora finta che il modulo sia già aperto con ShowDialog!

È un bug nel mio prog o in Winform?

Aggiornamento: questo è l'intero codice che ho pubblicato nella quinta risposta (voglio usare showdialog e non mostrare perché potrei avere un terzo modulo in Background a cui non voglio che l'utente acceda):

  [STAThread]
  static void Main()
  {
      Application.EnableVisualStyles();
      Application.SetCompatibleTextRenderingDefault(false);
      Form1 = new Form1();
      Form2 = new Form2();
      Form1.ShowDialog();
      Application.Run();

  }

  // called from Form1 BUTTON
  internal static void ShowForm2(Form1 Form1)
  {
      Form1.Hide();
      Form2.ShowDialog();
  }

  // called from Form2 BUTTON
  internal static void ShowForm1(Form2 Form2)
  {
      Form2.Hide();
      Form1.ShowDialog();
  }

---

Ho provato con Nascondi come suggerito ma non funziona neanche. Questo è l'intero programma, quello che voglio fare è molto semplice: ho due moduli inizialmente creati nel programma con un pulsante su ciascun modulo per chiudere me stesso e aprire l'altro. Ho messo tutta la logica in program.cs di seguito:

  using System;
  using System.Windows.Forms;

  namespace twoforms
  {
      static class Program
      {
          /// <summary>
          /// The main entry point for the application.
          /// </summary>
          /// 
          public static Form1 Form1;
          public static Form2 Form2;

          [STAThread]
          static void Main()
          {
              Application.EnableVisualStyles();
              Application.SetCompatibleTextRenderingDefault(false);
              Form1 = new Form1();
              Form2 = new Form2();
              Form1.ShowDialog();
              Application.Run();

          }

          // called from Form1 BUTTON
          internal static void ShowForm2(Form1 Form1)
          {
              Form1.Hide();
              Form2.ShowDialog();
          }

          // called from Form2 BUTTON
          internal static void ShowForm1(Form2 Form2)
          {
              Form2.Hide();
              Form1.ShowDialog();
          }
      }
  }

Answer 1

Questo è da MSDN:

  

Quando un modulo viene visualizzato come modale   finestra di dialogo, facendo clic sul pulsante Chiudi   (il pulsante con una X in corrispondenza del   nell'angolo in alto a destra del modulo)   il modulo da nascondere e il   Proprietà DialogResult su cui impostare   DialogResult.Cancel. A differenza del non modale   moduli, il metodo Close non viene chiamato   da .NET Framework quando l'utente   fa clic sul pulsante del modulo di chiusura di a   finestra di dialogo o imposta il valore di   Proprietà DialogResult. Invece il   il modulo è nascosto e può essere mostrato di nuovo   senza creare una nuova istanza di   la finestra di dialogo. Perché un modulo visualizzato   poiché una finestra di dialogo non è chiusa, tu   deve chiamare il metodo Dispose di   modulo quando il modulo non è più necessario   dalla tua applicazione.

Quindi una volta che mostri un modulo usando ShowDialog e ora vuoi chiuderlo, lascialo restituire DialogResult.Cancel Questo nasconderà (sarà ancora in memoria) il tuo primo modulo. Ora puoi chiamare ShowDialog sul tuo secondo modulo. Ancora una volta, se vuoi passare al primo modulo, lascia che il secondo modulo restituisca DialogResult.Cancel e ora chiama ShowDialog sul primo modulo.

Answer 2

Questo è un bug nel tuo programma. Quando hai due istanze di un modulo (chiamale A e B), ovviamente non puoi mostrare continuamente l'una dall'altra usando ShowDialog. Se potessi farlo, significherebbe che A mostra B in modo modale e B quindi mostra A in modo modale e A quindi mostra B in modo modale ecc. Sarebbe come costruire una casa con due mattoni, dove continui a prendere il mattone inferiore e posizionandolo uno sopra l'altro.

La soluzione migliore è quella di non rendere statici questi moduli e creare semplicemente nuove istanze di ciascun modulo di cui hai bisogno. La tua seconda soluzione migliore è usare Show invece di ShowDialog; se hai comunque uno solo di questi moduli alla volta, ShowDialog non ha scopo.

Le forme statiche sono quasi sempre una cattiva idea (e io sono educato riguardo a "quasi"). Se la creazione dei moduli richiede molto tempo, è necessario identificare quale risorsa impiega così tanto tempo a caricarlo e memorizzarlo nella cache come oggetto statico, invece di provare a memorizzare l'intero modulo come statico.

Answer 3

Prova a usare Nascondi () invece di Chiudi (). Ho avuto un problema simile in passato e Hide () ha funzionato per me.

Answer 4

Penso che dovresti davvero trattare le finestre di dialogo modali come le chiamate di metodo e provare a usare il risultato del Call to ShowDialog per determinare cosa vuoi fare dopo? se hai l'obbligo di passare da una finestra di dialogo all'altra dovresti usare una sorta di risultato (forse semplicemente DialogResult vedi il mio esempio) o una proprietà pubblica della finestra di dialogo per determinare se devi mostrare un'altra finestra di dialogo, se devi chiamare una finestra di dialogo modale da un altro dovresti pensarlo come una pila di forme, che effettivamente (anche se rendi uno invisibile prima di chiamarne un altro) posiziona l'una sull'altra. Vuoi davvero ridurre al minimo questo accatastamento di moduli.

Questo è un esempio un po 'inventato, ma ogni modulo qui ha semplicemente un singolo pulsante con DialogResult impostato su OK.

[STAThread]
    static void Main()
    {
        Application.EnableVisualStyles();
        Application.SetCompatibleTextRenderingDefault(false);

        bool exit = false;
        while (true)
        {
            if (exit) break;
            using (Form1 frm = new Form1())
            {
                switch(frm.ShowDialog())
                {
                    case DialogResult.OK:
                        break;
                    default:
                        exit = true;
                        break;
                }   
            }
            if(exit) break;
            using (Form2 frm = new Form2())
            {
                switch(frm.ShowDialog())
                {
                    case DialogResult.OK:
                        break;
                    default:
                        exit = true;
                        break;
                } 
            }

        }

    }

per uscire è sufficiente fare clic sul pulsante rosso di chiusura (x).

Answer 5

Scopri la differenza tra Chiudi e Nascondi . E la differenza tra Show e ShowDialog .

Non è davvero chiaro per me cosa vuoi ottenere; descrivi solo (parzialmente) ciò che hai fatto nel codice e il sintomo del problema che stai riscontrando. Potresti descrivere cosa stai cercando di fare?

Se il tuo obiettivo è avere due finestre di dialogo che mostrino dalla tua finestra principale dove solo una delle due può essere visibile contemporaneamente, allora ci sono forse soluzioni migliori rispetto all'utilizzo di due statici (= globali) pubblici Form istanze che mostri utilizzando ShowDialog .

Hai mai pensato di usare una finestra di dialogo Form per questo che cambia l'aspetto a seconda della situazione?