Ich habe ein Formular "fm" , das ein einfaches Infofenster ist, das alle 10 Minuten geöffnet wird ( fm.Show();).

Wie ich das machen kann, wird alle 10 Minuten überprüft, ob das Formular "fm" geöffnet ist und wenn es geöffnet ist, wird es geschlossen und erneut geöffnet!

Jetzt wird das Formular fm immer mit erstellt. form fm = new form();
Wenn ich versuche zu überprüfen, ob das Formular geöffnet ist, ist es immer falsch und öffnet ein neues Fenster, auch wenn es zuvor ein Formular gibt!

Ich brauche ein Tool, um ihm eine eindeutige Identität zu geben und dann zu überprüfen, ob dieses Formular mit eindeutiger Identität geöffnet ist oder nicht!

Ich möchte nicht nur die Daten im Formular (fm) aktualisieren, da ich eine komplizierte Information mit Schaltflächen habe.

Der Formularname lautet "UpdateWindow"

Vielen Dank

vielleicht hilft das:

FormCollection fc = Application.OpenForms;

foreach (Form frm in fc)
{
//iterate through
     if (frm.Name == "YourFormName")
     {
         bFormNameOpen = true;
     }
}

Etwas Code im foreach, um das spezifische Formular zu erkennen, und es könnte getan werden. Ungetestet.

Gefunden auf http://bytes.com/topic/c-sharp/answers/591308-iterating-all-open-forms

Ich weiß, dass ich zu spät komme ... Aber für diejenigen, die neugierig sind ... Dies ist ein anderer Weg

if (Application.OpenForms.OfType<UpdateWindow>().Count() == 1)
    Application.OpenForms.OfType<UpdateWindow>().First().Close();

UpdateWindow frm = new UpdateWindow()
frm.Show();

Angenommen, wir rufen ein Formular aus einem Menü auf und klicken auf MDI-Formular. Dann müssen wir die Instanzdeklaration dieses Formulars auf oberster Ebene wie folgt erstellen:

Form1 fm = null;

Dann müssen wir das Menüklickereignis definieren, um Form1 wie folgt aufzurufen:

private void form1ToolStripMenuItem_Click(object sender, EventArgs e)
{
    if (fm == null|| fm.Text=="")
    {
        fm = new Form1();              
        fm.MdiParent = this;
        fm.Dock = DockStyle.Fill;
        fm.Show();
    }
    else if (CheckOpened(fm.Text))
    {
        fm.WindowState = FormWindowState.Normal;
        fm.Dock = DockStyle.Fill;
        fm.Show();
        fm.Focus();               
    }                   
}

Das zur Überprüfung von Form1 definierte CheckOpened ist bereits geöffnet oder nicht:

private bool CheckOpened(string name)
{
    FormCollection fc = Application.OpenForms;

    foreach (Form frm in fc)
    {
        if (frm.Text == name)
        {
            return true; 
        }
    }
    return false;
}

Ich hoffe, dies löst die Probleme beim Erstellen mehrerer Instanzen eines Formulars, wobei der Fokus auf das Klicken auf das Menü "Formular1" gelegt wird, wenn es bereits geöffnet oder minimiert ist.

Ich bin mir nicht sicher, ob ich die Aussage verstehe. Hoffe das hilft. Wenn Sie nur mit einer Instanz dieses Formulars arbeiten möchten, sollten Sie den Aufruf von Form.Dispose beim Schließen des Benutzers verhindern . Zu diesem Zweck können Sie das Abschlussereignis des untergeordneten Formulars verarbeiten.

private void ChildForm_FormClosing(object sender, FormClosingEventArgs e)
{
    this.Hide();
    e.Cancel = true;
}

Und dann müssen Sie keine neuen Instanzen von erstellen frm. Rufen Sie einfach die Show-Methode für die Instanz auf.

Sie können die Form.Visible-Eigenschaft überprüfen, um zu überprüfen, ob das Formular gerade geöffnet ist.

private ChildForm form = new ChildForm();

private void ReopenChildForm()
{
    if(form.Visible)
    {
        form.Hide();
    }
    //Update form information
    form.Show();
}

Eigentlich verstehe ich immer noch nicht, warum Sie nicht einfach die Daten auf dem Formular aktualisieren.

Form fc = Application.OpenForms["UpdateWindow"]; 

if (fc != null) 
   fc.Close(); 

fc.Show();

Form1 fc = Application.OpenForms["Form1 "] != null ? (Form1 ) Application.OpenForms["Form1 "] : null;
if (fc != null)
{
    fc.Close();
}

Es wird das Formular1 geschlossen. Sie können dieses Formular erneut öffnen, wenn Sie Folgendes möchten:

Form1 frm = New Form1();
frm.show();

if( ((Form1)Application.OpenForms["Form1"]).Visible == true)
    //form is visible
else
    //form is invisible

Wo Form1ist der Name Ihres Formulars?

Versuchen Sie dies, es wird funktionieren:

//inside main class
Form1 Fm1 = new Form1();<br>

//in button click
if (Fm1.IsDisposed)
{
    Fm1 = new Form();
}
Fm1.Show();
Fm1.BringToFront();
Fm1.Activate();

if (Application.OpenForms["Form_NAME"] == null)
{
   new Form_NAME().Show();
}

Wenn die Formularinstanz nicht geöffnet ist, wird sie in die IF-Schleife eingegeben.

Probieren Sie diese MDICHILD- Funktion aus

public void mdiChild(Form mdiParent, Form mdiChild)
{
    foreach (Form frm in mdiParent.MdiChildren)
    {
        // check if name equals
        if (frm.Name == mdiChild.Name)
        {
            //close if found

            frm.Close();

            return;
        }
    }

    mdiChild.MdiParent = mdiParent;

    mdiChild.Show();

    mdiChild.BringToFront();
}

Versuchen Sie, unten zu verdrahten,

private void frmMyForm_Deactivate(object sender, EventArgs e)
    {
        // Raise your flag here.
    }

Wenn Sie das obige Ereignis verkabeln, erfahren Sie, wann immer das Formular minimiert und teilweise / vollständig von einem anderen Formular ausgeblendet wird.

Dies ist, was ich verwendet habe, um alle offenen Formulare zu schließen (mit Ausnahme des Hauptformulars)

    private void CloseOpenForms()
    {

           // Close all open forms - except for the main form.  (This is usually OpenForms[0].
           // Closing a form decrmements the OpenForms count
           while (Application.OpenForms.Count > 1)
           {
               Application.OpenForms[Application.OpenForms.Count-1].Close();
           }
    }

Komisch, ich musste diesen Thread ergänzen.

1) Fügen Sie eine globale Variable in form.show () hinzu und löschen Sie die Variable in form.close ()

2) Fügen Sie im übergeordneten Formular einen Timer hinzu. Lassen Sie das untergeordnete Formular offen und aktualisieren Sie Ihre Daten alle 10 Minuten.

3) Setzen Sie den Timer auf das untergeordnete Formular, um die Daten selbst zu aktualisieren.

* Hoffe das wird für dich funktionieren

System.Windows.Forms.Form f1 = System.Windows.Forms.Application.OpenForms["Order"];
if(((Order)f1)!=null)
{
//open Form
}
else
{
//not open
}

Versuche dies

 bool IsOpen = false;
    foreach (Form f in Application.OpenForms)
    {
        if (f.Text == "Form2")
        {
            IsOpen = true;
            f.Focus();
            break;
        }
    }

    if (IsOpen == false)
    {
        Form2 f2 = new Form2();
        f2.MdiParent = this;
        f2.Show();
    }

 private static Form IsFormAlreadyOpen(Type formType)
 {
     return Application.OpenForms.Cast<Form>().FirstOrDefault(openForm => openForm.GetType() == formType);
 }

Nur einmal bilden

Wenn Ihr Ziel darin besteht, mehrere Instanzen eines Formulars zuzulassen, sollten Sie Folgendes in Betracht ziehen ...

public class MyForm : Form
{
    private static MyForm alreadyOpened = null;

    public MyForm()
    {
        // If the form already exists, and has not been closed
        if (alreadyOpened != null && !alreadyOpened.IsDisposed)
        {
            alreadyOpened.Focus();            // Bring the old one to top
            Shown += (s, e) => this.Close();  // and destroy the new one.
            return;
        }           

        // Otherwise store this one as reference
        alreadyOpened = this;  

        // Initialization
        InitializeComponent();
    }
}

Form user_rpt = Application.OpenForms["frmUesr_reports"];
        if (user_rpt == null)
        {
            /// Do Something here
        }

Versuchen Sie dies Dies ist die kurze Idee, um zu überprüfen, ob das Formular geöffnet oder nicht geöffnet ist

In meiner App hatte ich ein Hauptmenüformular mit Schaltflächen zum Navigieren zu einer Auswahl anderer Formulare (auch Unterformulare genannt). Ich wollte, dass jeweils nur eine Instanz jedes Unterformulars ausgeführt wird. Außerdem wollte ich sicherstellen, dass ein Unterformular, wenn ein Benutzer versucht, ein bereits vorhandenes Unterformular zu starten, gezwungen ist, "front & center" anzuzeigen, wenn es minimiert ist oder sich hinter anderen App-Fenstern befindet. Unter Verwendung der derzeit am besten bewerteten Antworten habe ich ihre Antworten folgendermaßen überarbeitet:

private void btnOpenSubForm_Click(object sender, EventArgs e)
    {

        Form fsf = Application.OpenForms["formSubForm"];

        if (fsf != null)
        {
            fsf.WindowState = FormWindowState.Normal;
            fsf.Show();
            fsf.TopMost = true;
        }
        else
        {
            Form formSubForm = new FormSubForm();
            formSubForm.Show();
            formSubForm.TopMost = true;
        }
    }

Das hat bei mir funktioniert:

public void DetectOpenedForm()
{
    FormCollection AllForms = Application.OpenForms;
    Boolean FormOpen = false;
    Form OpenedForm = new Form();
    foreach (Form form in AllForms)
    {
        if (form.Name == "YourFormName")
        {
            OpenedForm = form;
            FormOpen = true;
        }
    }
    if (FormOpen == true)
    {
        OpenedForm.Close();
    }
}

Ich denke, meine Methode ist die einfachste .

    Form2 form2 = null;
    private void SwitchFormShowClose_Click(object sender, EventArgs e)
    {  
        if(form2 == null){
            form2 = new Form2();
            form2.Show();
        }
        else{
            form2.Close();
            form2 = null;
        }
    }

Das Folgende funktioniert tatsächlich sehr gut.

private void networkInformationToolStripMenuItem_Click(object sender, EventArgs e)
{
    var _open = false;
    FormCollection fc = Application.OpenForms;
    foreach (Form frm in fc)
    {
        if (frm.Name == "FormBrowseNetworkInformation")
        {
            _open = true;
            frm.Select();
            break;
        }
    }
    if (_open == false)
    {
        var formBrowseNetworkInformation = new FormBrowseNetworkInformation();
        formBrowseNetworkInformation.Show();
    }
}

das wird definitiv sagen. Ich benutze diese Funktion auch für mich.

  public static bool isFormOpen(Form formm)
    {

        foreach (Form OpenForm in Application.OpenForms)
        {
            if (OpenForm.Name == formm.Name)
            {
                return true;
            }
        }

        return false;
    }

Ich habe einen früheren Beitrag optimiert. Dies funktioniert einwandfrei, ohne alle offenen Formen durchlaufen zu müssen.

        Form fc = Application.OpenForms["FormBrowse"];
        if (fc != null)
        {
            fc.Select();
        }
        else
        {
            var formBrowse = new FormBrowse();
            formBrowse.Show();
        }

Versuchen Sie dies, ohne die Formulare durchlaufen zu müssen:

if(Application.OpenForms["<your_form_name>"] != null){

   //Your form is already open

}
else {

  //Your form isn't open

}

Dies funktioniert, wenn Sie überprüfen möchten, ob das zweite Formular bereits geöffnet ist, und es beim erneuten Klicken nicht erneut öffnen möchten.

 int formcheck = 0;
    private void button_click()
    {
       Form2Name myForm2 = new Form2Name();
       if(formcheck == 0)
       {
          myForm2.Show(); //Open Form2 only if its not active and formcheck == 0
          // Do Somethin

          formcheck = 1; //Set it to 1 indicating that Form2 have been opened
       {   
    {

Darüber hinaus kann dies helfen

class Helper
    {
        public void disableMultiWindow(Form MdiParent, string formName)
        {
            FormCollection fc = Application.OpenForms;
            try
            {
                foreach (Form form in Application.OpenForms)
                {
                    if (form.Name == formName)
                    {
                        form.BringToFront();
                        return;
                    }
                }

                Assembly thisAssembly = Assembly.GetExecutingAssembly();
                Type typeToCreate = thisAssembly.GetTypes().Where(t => t.Name == formName).First();
                Form myProgram = (Form)Activator.CreateInstance(typeToCreate);
                myProgram.MdiParent = MdiParent;
                myProgram.Show();
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
        }
    }