सी # एक निर्माता के दौरान एक फॉर्म बंद करना

Question

क्या कन्स्ट्रक्टर निष्पादित करते समय एक फॉर्म बंद करना संभव है (या बस इस चरण में इसे रोकने के लिए)?

public partial class MyForm : Form 
{   
    public MyForm() 
    { 
     if (MyFunc()) 
     { 
      this.Close(); 
     } 
    } 
} 

कौन सा() मुख्य में एक ObjectDisposedException, यहाँ फेंकता है:

:

static void Main() 
    {    
     ... 

     // Following line errors 
     Application.Run(new MyForm()); 
    } 

मैं इस तरह MyForm का परिणाम जाँच की कोशिश की है

मैं निम्नलिखित कोड है

static void Main() 
{    
    ... 

    MyForm frm = new MyForm(); 
    if (frm != null) 
    { 
     // Following line errors 
     Application.Run(frm); 
    } 
} 

लेकिन यह मदद नहीं करता है। क्या कोई मुझे इस के आसपास एक रास्ता बता सकता है, कृपया? शायद यह देखने के लिए फॉर्म देखने का एक तरीका है कि यह अभी भी मौजूद है या नहीं?

Answer 1

कॉलिंग Close फार्म के निर्माता से संभव के रूप में यह एक फार्म अभी तक नहीं बनाया गया है उस पर Dispose फोन करेगा नहीं है,। निर्माण के बाद फार्म को बंद करने के Load event कि आपके प्रपत्र बंद कर देता है इससे पहले कि यह पहली बार के लिए प्रदर्शित किया जाता है के लिए एक गुमनाम ईवेंट हैंडलर आवंटित:

public partial class MyForm : Form 
{ 
    public MyForm() 
    { 
     if (ShouldClose()) 
     { 
      Load += (s, e) => Close(); 
      return; 
     } 

     // ... 
    } 

    // ... 
} 

Answer 2

आपका फॉर्म कन्स्ट्रक्टर से खोला नहीं जाएगा। आप क्या हासिल करने का प्रयास कर रहे हैं?

यदि आप इस फॉर्म को बंद करते हैं तो कोड पथ पूरी तरह से बाहर निकल जाएगा, जिससे आपको कोई स्पष्ट लाभ नहीं मिलेगा (यानी, एप्लिकेशन.रुन बाहर निकल जाएगा)। किसी और ने छिपे हुए फॉर्म को बनाने के बारे में कोड पोस्ट किया है, और अधिक संभावना है।

Answer 3

क्या आप MyFunc static बना सकते हैं? और फिर कुछ ऐसा कार्य करें:

static void Main() 
{    
    ... 
    if (MyForm.MyFunc()) 
    { 
     Application.Run(new MyForm()); 
    } 
} 

इस अनिवार्य रूप से आप फार्म या निर्माण नहीं किया जा रहा है या नहीं इस पर एक ही नियंत्रण देना होगा?

Answer 4

जब आप किसी फॉर्म पर बंद() को कॉल करते हैं, आंतरिक रूप से यह फ़ॉर्म का निपटान कर रहा है और किसी भी प्रबंधित संसाधन को जारी कर रहा है। जब आप ऐसा करते हैं:

Application.Run(new MyForm()); 

आपको ऑब्जेक्ट डिस्प्ले अपवाद प्राप्त होगा। आपको बस इतना करना एक संपत्ति के माध्यम से फार्म की दृश्यता सेट किया गया है की जरूरत है:

Application.Run(new MyForm() { Visible = false }); 

बस आप बंद करने के लिए कॉल अवश्य निकाल दें() निर्माता में, या यहाँ तक कि संपत्ति काम वहाँ भी चलते हैं।

Answer 5

एकमात्र चीज जो आप इसे कर सकते हैं, इसे कन्स्ट्रक्टर में बंद करने के लिए ध्वज सेट करें, और फिर इसे Shown ईवेंट में बंद कर दें। बेशक, यदि आप ऐसा कर रहे हैं, तो यह निर्धारित करने के लिए कोड को स्थानांतरित करना समझ में आता है कि इसे पहले स्थान पर बंद किया जाना चाहिए या नहीं।

Answer 6

अच्छी तरह से निम्नलिखित काम करता है:

public partial class MyForm : Form 
{   
    public MyForm() 
    { 
     if (MyFunc()) 
     { 
      this.Shown += new EventHandler(MyForm_CloseOnStart); 
     } 
    } 

    private void MyForm_CloseOnStart(object sender, EventArgs e) 
    { 
     this.Close(); 
    } 
} 

Answer 7

मैं 'लोड' घटना के लिए कोई हैंडलर जोड़ने पाया इस के रूप में बेहतर है जिस तरह से संवाद कभी भी प्रदर्शित नहीं होता है। 'दिखाया गया है' घटना के साथ आप कुछ समय के लिए संवाद खुला और फिर करीब भ्रमित हो सकता है जो देख सकते हैं:

public partial class MyForm : Form 
{   
    public MyForm() 
    { 
     if (MyFunc()) 
     { 
      this.Load += MyForm_CloseOnStart; 
     } 
    } 

    private void MyForm_CloseOnStart(object sender, EventArgs e) 
    { 
     this.Close(); 
    } 
} 

Answer 8

मुझे लगता है कि निर्माता में एक फार्म बंद करने के लिए समझदारी नहीं है।यदि आप ऐसा करते हैं, तो आपके फॉर्म के उपयोगकर्ता यह नहीं जान पाएंगे कि ShowDialog या नहीं।

// in the parent form: 
public void ShowMyForm() 
{ 
    MyForm form = new MyForm(); 
    form.propertyA = ...; 
    from.propertyB = ...; 
    DialogResult dlgResult = form.ShowDialog(this); 
    ProcessDialogResult(dlgResult); 
} 

आप ShowDialog और संवाद परिणाम प्रक्रिया के लिए कि क्या तय करने के लिए विशेष कोड जोड़ना होगा:

निम्नलिखित कोड काफी सामान्य उपयोग होगा।

इसके अलावा आप सुनिश्चित हैं कि गुण कभी प्रभावित नहीं होंगे कि फ़ॉर्म दिखाया जाना है या नहीं? भविष्य में बदलाव के बाद भी?

निर्माण के दौरान फॉर्म अभी तक नहीं दिखाया/खोला गया है। तो मुझे डर है बंद() जो आप उम्मीद करते हैं वह नहीं करता है।

साफ-सुथरा तरीका Form_Load में आपके चेक करना है। फॉर्म लोड इवेंट हैंडलर जोड़ें और उस पल में अपने चेक करें। यह संकेत करने के लिए कि आपने फॉर्म को न दिखाने का निर्णय लिया है, संवाद संवाद का उपयोग करें। ,

// in the parent form: 
public void ShowMyForm() 
{ 
    MyForm form = new MyForm(); 
    form.propertyA = ...; 
    from.propertyB = ...; 
    DialogResult dlgResult = form.ShowDialog(this); 
    switch (dlgResult) 
    { 
     case System.Windows.Forms.DialogResult.Cancel: 
      ... 
      break; 
     case System.Windows.Forms.DialogResult.OK: 
      ... 
      break; 
     // etc. 
    } 
} 

हालांकि इस काम नहीं करेगा क्योंकि बंद केवल ठीक कहा जा सकता है लोड पूर्ण होने के बाद:

private void FormMain_Load (object sender, EventArgs e) 
{ 
    if (FormShouldNotLoad()) 
    { 
     this.DialogResult = System.Windows.Forms.DialogResult.Cancel; 
     Close(); 
    } 
} 

कोड के उपयोगकर्ता संवाद का परिणाम की जांच कर सकता। तो बजाय बंद बुला() की है, तो आप BeginInvoke बंद() फ़ंक्शन, तो बंद समारोह लोड हो रहा है के बाद बुलाया जाएगा किया जाना चाहिए है:

कोड बंद() लोड हो रहा है हो जाएगा समाप्त हो गया है के बाद कॉल करने के लिए इस प्रकार की तरह:

private void FormMain_Load (object sender, EventArgs e) 
{ 
    if (MyFunc()) 
    { 
     CancelLoading(); 
    } 
} 

private delegate void InvokeDelegate(); 

private void CancelLoading() 
{ // will cancel loading this form 
    this.DialogResult = System.Windows.Forms.DialogResult.Cancel; 
    this.BeginInvoke(new InvokeDelegate(CloseThisForm)); 
} 

private void CloseThisForm() 
{ 
    this.Close(); 
} 

अच्छी बात यह है कि ऑनफॉर्म क्लोजिंग और ऑनफॉर्म के दौरान आप वास्तव में फॉर्म की स्थिति जानते हैं: यह पूरी तरह से लोड हो गया है, इसलिए आप जानते हैं कि बंद होने पर क्या करना है।

Answer 9

यदि आप करने के लिए अपने खिड़की
(कोई झिलमिलाते खिड़कियों कि एक पल के लिए खोलने के लिए और फिर गायब हो) कभी नहीं देखा जा हैं:

public new void Show() 
{ 
    if (MyFunc()) 
     base.Show(); 
    else 
     ; // dispose or whatever 
} 

हालांकि Show(...) 2 भार के है और ShowDialog(...) भी 2 है।
Application.Run() के माध्यम से खोले गए मुख्य रूप के लिए काम नहीं करता है। लेकिन वैसे भी ऐसा कौन करेगा? Application.Run() का उपयोग किये बिना मुख्य फॉर्म खोलने का एक तरीका भी छोड़कर।