यह जांचने के लिए कि क्या विंडोज़ का फॉर्म पहले से खुला है, और अगर है तो उसे बंद कर दें?

Question 1

मेरे पास एक फॉर्म "एफएम" है जो एक साधारण जानकारी विंडो है जो हर 10 मिनट ( fm.Show();) खोलती है ।

मैं कैसे बना सकता हूं कि हर 10 मिनट में यह जांच करेगा कि क्या फॉर्म "एफएम" खुला है और अगर यह खुला है तो इसे बंद कर देता है और फिर से खोलता है!

अब फॉर्म fm हमेशा इस तरह से बनाया जाता form fm = new form();
है, जब मैं यह जांचने की कोशिश करता हूं कि क्या फॉर्म खुला है, यह हमेशा गलत होगा और पहले एक फॉर्म होने पर भी एक नई विंडो खोलेगी!

मुझे इसे एक विशिष्ट पहचान देने के लिए एक उपकरण की आवश्यकता है और फिर जांचें कि क्या यह विशिष्ट पहचान वाला फॉर्म खोला गया है या नहीं!

मैं केवल फॉर्म (एफएम) पर डेटा अपडेट नहीं करना चाहता, क्योंकि मेरे पास बटन के साथ एक जटिल जानकारी है।

रूप नाम है "UpdateWindow"

धन्यवाद

Question 2

शायद यह मदद करता है:

FormCollection fc = Application.OpenForms;

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

विशिष्ट स्वरूप का पता लगाने के लिए कुछ कोड फोरचेक में हैं और यह किया जा सकता है। हालांकि अप्रकाशित

Http://bytes.com/topic/c-sharp/answers/591308-iterating-all-open-forms पर मिला

Question 3

मुझे पता है कि मुझे देर हो गई है ... लेकिन जो उत्सुक हैं उनके लिए ... यह एक और तरीका है

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

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

Question 4

मान लीजिए कि यदि हम किसी मेनू से किसी फॉर्म को एमडीआई फॉर्म पर क्लिक कर रहे हैं, तो हमें उस फॉर्म की घोषणा को इस तरह शीर्ष स्तर पर बनाने की आवश्यकता है:

Form1 fm = null;

फिर हमें फॉर्म 1 पर कॉल करने के लिए मेनू क्लिक इवेंट को परिभाषित करने की आवश्यकता है:

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();               
    }                   
}

CheckOpened Form1 पहले से ही खोला या नहीं है की जाँच करने के लिए परिभाषित:

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

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

आशा है कि यह फॉर्म के कई उदाहरण बनाने पर मुद्दों को हल कर देगा, यह भी मेनू 1 पर फॉर्म 1 पर ध्यान केंद्रित करना है अगर यह पहले से ही खोला या छोटा किया गया है।

Question 5

मुझे यकीन नहीं है कि मैं बयान को समझता हूं। उम्मीद है की यह मदद करेगा। यदि आप इस फ़ॉर्म के केवल एक उदाहरण के साथ काम करना चाहते हैं, तो आपको उपयोगकर्ता के पास फ़ॉर्म कॉल को रोकना चाहिए । ऐसा करने के लिए, आप बच्चे के फॉर्म के समापन कार्यक्रम को संभाल सकते हैं।

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

और फिर आपको नए उदाहरण बनाने की आवश्यकता नहीं है frm। उदाहरण के लिए बस शो विधि को कॉल करें।

आप प्रपत्र की जाँच कर सकते हैं। अदृश्य संपत्ति की जाँच करें कि क्या प्रपत्र इस समय खुला है।

private ChildForm form = new ChildForm();

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

वास्तव में, मुझे अभी भी समझ में नहीं आया है कि आप केवल फॉर्म के डेटा को अपडेट क्यों नहीं करते हैं।

Question 6

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

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

fc.Show();

Question 7

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

यदि आप इसका उपयोग करना चाहते हैं तो यह फॉर्म 1 को फिर से खोल सकता है।

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

Question 8

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

Form1आपके फॉर्म का नाम कहां है

Question 9

यह कोशिश करो, यह काम करेगा:

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

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

Question 10

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

यदि प्रपत्र उदाहरण खुला नहीं है, तो वह IF लूप में प्रवेश करेगा।

Question 11

इस MDICHILD फ़ंक्शन को आज़माएँ

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();
}

Question 12

नीचे तार करने की कोशिश करें,

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

इवेंट के ऊपर वायरिंग करके, यह आपको बताएगा कि जब भी फॉर्म को कम से कम किया जाता है, आंशिक रूप से / पूरी तरह से दूसरे रूप से ठीक किया जाता है।

Question 13

यह वही है जो मैंने सभी खुले रूपों को बंद करने के लिए इस्तेमाल किया (मुख्य रूप को छोड़कर)

    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();
           }
    }

Question 14

मजेदार, मुझे इस धागे को जोड़ना था।

1) form.show () पर एक वैश्विक संस्करण जोड़ें और form.close () पर दिए गए संस्करण को हटा दें।

2) मूल रूप में एक टाइमर जोड़ें। बच्चे के फॉर्म को खुला रखें और हर 10 मिनट में अपना डेटा अपडेट करें।

3) अपने आप को अपडेट डेटा पर जाने के लिए बच्चे के फॉर्म पर टाइमर लगाएं।

Question 15

* आशा है कि यह यू के लिए काम करेगा

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

Question 16

इसे इस्तेमाल करे

 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();
    }

Question 17

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

Question 18

फॉर्म केवल एक बार

यदि आपका लक्ष्य किसी फॉर्म के कई इंस्टेंस को अलग करना है, तो निम्नलिखित पर विचार करें ...

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();
    }
}

Question 19

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

इसे आज़माएं यह फॉर्म ओपन या ओपन न करने की जाँच करने का संक्षिप्त विचार है

Question 20

मेरे ऐप में मेरे पास एक मेनमेनू फॉर्म था जिसमें अन्य रूपों (उर्फ उप-रूपों) के वर्गीकरण पर नेविगेट करने के लिए बटन थे। मैं चाहता था कि प्रत्येक उप-प्रपत्र का केवल एक उदाहरण एक समय में चल रहा हो। इसके अलावा, मैं यह सुनिश्चित करना चाहता था कि यदि कोई उपयोगकर्ता पहले से ही एक उप-प्रपत्र को लॉन्च करने का प्रयास करता है, तो उप-प्रपत्र को "फ्रंट और सेंटर" दिखाने के लिए मजबूर किया जाएगा यदि न्यूनतम या अन्य ऐप विंडोज़ के पीछे। वर्तमान में सबसे अधिक उत्तर दिए गए उत्तरों का उपयोग करते हुए, मैंने उनके उत्तरों को इस में बदल दिया:

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;
        }
    }

Question 21

इसने मुझे काम किया:

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();
    }
}

Question 22

मुझे लगता है कि मेरा तरीका सबसे सरल है ।

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

Question 23

नीचे वास्तव में बहुत अच्छी तरह से काम करता है।

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();
    }
}

Question 24

यह निश्चित रूप से शब्द होगा। मैं इस फ़ंक्शन का उपयोग खुद के लिए भी करता हूं।

  public static bool isFormOpen(Form formm)
    {

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

        return false;
    }

Question 25

मैंने पहले की गई पोस्ट को फिर से बनाया है। यह बिना किसी त्रुटि के काम करता है, हालांकि सभी खुले रूपों में।

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

Question 26

यह कोशिश करो, रूपों के माध्यम से पुनरावृति करने की आवश्यकता नहीं है:

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

   //Your form is already open

}
else {

  //Your form isn't open

}

Question 27

यह काम करता है यदि आप जांचना चाहते हैं कि क्या दूसरा फॉर्म पहले से ही खुला है और इसे फिर से बटन पर क्लिक करने से बचें।

 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
       {   
    {

Question 28

इसके अलावा, यह हो सकता है मदद करेगा


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); }
        }
    }