Comment vérifier si un formulaire Windows est déjà ouvert et le fermer s'il l'est?
J'ai un formulaire "fm" qui est une simple fenêtre d'informations qui s'ouvre toutes les 10 minutes (fm.Show();).
Comment je peux faire cela toutes les 10 minutes, il vérifiera si le formulaire "fm" est ouvert et s'il est ouvert, il le ferme et l'ouvre à nouveau!
Maintenant, le formulaire fm est toujours créé avec form fm = new form();
Donc, lorsque j'essaie de vérifier si le formulaire est ouvert, il sera toujours faux et ouvre une nouvelle fenêtre, même s'il existe un formulaire auparavant!
J'ai besoin d'un outil pour lui donner une identité unique et ensuite vérifier si ce formulaire avec une identité unique est ouvert ou non!
Je ne veux pas simplement mettre à jour les données sur le formulaire (fm), car j'ai une information compliquée avec des boutons.
Le nom du formulaire est "UpdateWindow"
Résolu en utilisant ce qui suit:
Form fc = Application.OpenForms["UpdateWindow"];
if (fc != null)
fc.Close();
fc.Show();
peut-être que cela aide:
FormCollection fc = Application.OpenForms;
foreach (Form frm in fc)
{
//iterate through
}
Certains codes dans le foreach pour détecter la forme spécifique et cela pourrait être fait. Non testé cependant.
Trouvé sur http://bytes.com/topic/c-sharp/answers/591308-iterating-all-open-forms
Je sais que je suis en retard ... Mais pour ceux qui sont curieux ... C'est une autre façon
if (Application.OpenForms.OfType<UpdateWindow>().Count() == 1)
Application.OpenForms.OfType<UpdateWindow>().First().Close();
UpdateWindow frm = new UpdateWindow()
frm.Show();
Supposons que si nous appelons un formulaire depuis un menu, cliquez sur le formulaire MDI, nous devons alors créer la déclaration d'instance de ce formulaire au niveau supérieur, comme suit:
Form1 fm = null;
Ensuite, nous devons définir l'événement click du menu pour appeler le Form1 comme suit:
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();
}
}
Le CheckOpened défini pour vérifier que le Form1 est déjà ouvert ou non:
private bool CheckOpened(string name)
{
FormCollection fc = Application.OpenForms;
foreach (Form frm in fc)
{
if (frm.Text == name)
{
return true;
}
}
return false;
}
J'espère que cela résoudra les problèmes liés à la création de plusieurs instances d'un formulaire, ainsi que l'activation de Form1 dans le menu, cliquez sur celui-ci s'il est déjà ouvert ou réduit.
Je ne suis pas sûr de comprendre la déclaration. J'espère que cela vous aidera ... Si vous souhaitez utiliser une seule instance de ce formulaire, vous devez empêcher Form.Dispose appeler à la fermeture de l'utilisateur. Pour ce faire, vous pouvez gérer l'événement Closing du formulaire enfant.
private void ChildForm_FormClosing(object sender, FormClosingEventArgs e)
{
this.Hide();
e.Cancel = true;
}
Et vous n'avez pas besoin de créer de nouvelles instances de frm. Il suffit d'appeler la méthode Show sur l'instance.
Vous pouvez vérifier la propriété Form.Visible pour vérifier si le formulaire est ouvert pour le moment.
private ChildForm form = new ChildForm();
private void ReopenChildForm()
{
if(form.Visible)
{
form.Hide();
}
//Update form information
form.Show();
}
En fait, je ne comprends toujours pas pourquoi ne pas simplement mettre à jour les données du formulaire.
Form1 fc = Application.OpenForms["Form1 "] != null ? (Form1 ) Application.OpenForms["Form1 "] : null;
if (fc != null)
{
fc.Close();
}
Il va fermer le formulaire1, vous pouvez rouvrir ce formulaire si vous le souhaitez en utilisant:
Form1 frm = New Form1();
frm.show();
if( ((Form1)Application.OpenForms["Form1"]).Visible == true)
//form is visible
else
//form is invisible
où Form1 est le nom de votre formulaire.
essayez cette fonctionMDICHILD
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();
}
Form fc = Application.OpenForms["UpdateWindow"];
if (fc != null)
fc.Close();
fc.Show();
Essayez ceci, ça va marcher:
//inside main class
Form1 Fm1 = new Form1();<br>
//in button click
if (Fm1.IsDisposed)
{
Fm1 = new Form();
}
Fm1.Show();
Fm1.BringToFront();
Fm1.Activate();
Ne forme qu'une seule fois
Si votre objectif est d'autoriser plusieurs instances d'une entreprise, envisagez de suivre ...
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();
}
}
Je pense que ma méthode est la la plus simple .
Form2 form2 = null;
private void SwitchFormShowClose_Click(object sender, EventArgs e)
{
if(form2 == null){
form2 = new Form2();
form2.Show();
}
else{
form2.Close();
form2 = null;
}
}
Dans mon application, j'avais un formulaire de menu principal doté de boutons permettant de naviguer dans un assortiment d'autres formulaires (également appelés sous-formulaires). Je voulais qu'une seule instance de chaque sous-formulaire soit en cours d'exécution à la fois. De plus, je voulais m'assurer, si un utilisateur tentait de lancer un sous-formulaire déjà existant, que le sous-formulaire soit obligé de montrer "avant et centre" s'il était réduit ou derrière d'autres fenêtres d'application. En utilisant les réponses actuellement les plus votées, j'ai reformulé leurs réponses dans ceci:
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;
}
}
Form user_rpt = Application.OpenForms["frmUesr_reports"];
if (user_rpt == null)
{
/// Do Something here
}
Essayez ceci C'est la petite idée de vérifier si le formulaire est ouvert ou non ouvert
essaye ça
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);
}
Cela a fonctionné de moi:
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();
}
}
* J'espère que cela fonctionnera pour vous
System.Windows.Forms.Form f1 = System.Windows.Forms.Application.OpenForms["Order"];
if(((Order)f1)!=null)
{
//open Form
}
else
{
//not open
}
Essayez de câbler ci-dessous,
private void frmMyForm_Deactivate(object sender, EventArgs e)
{
// Raise your flag here.
}
En reliant l'événement ci-dessus, il vous dira chaque fois que le formulaire est minimisé, masqué partiellement ou totalement par un autre formulaire.
if (Application.OpenForms["Form_NAME"] == null)
{
new Form_NAME().Show();
}
Si l'instance de formulaire n'est pas ouverte, elle entrera dans la boucle IF.
ce sera Word définitivement. J'utilise cette fonction pour moi aussi.
public static bool isFormOpen(Form formm)
{
foreach (Form OpenForm in Application.OpenForms)
{
if (OpenForm.Name == formm.Name)
{
return true;
}
}
return false;
}
J'ai modifié un post précédent. Cela fonctionne parfaitement sans avoir à parcourir toutes les formes ouvertes.
Form fc = Application.OpenForms["FormBrowse"];
if (fc != null)
{
fc.Select();
}
else
{
var formBrowse = new FormBrowse();
formBrowse.Show();
}
Drôle, j'ai dû ajouter à ce fil.
1) Ajoutez une var globale sur form.show () et effacez la var sur form.close ()
2) Sur le formulaire parent, ajoutez une minuterie. Laissez le formulaire enfant ouvert et mettez à jour vos données toutes les 10 minutes.
3) mettre timer sur le formulaire enfant pour aller mettre à jour les données sur lui-même.
Le ci-dessous fonctionne vraiment très bien.
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();
}
}
C’est ce que j’utilisais pour fermer tous les formulaires ouverts (à l’exception du formulaire principal)
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();
}
}