एक कोड लोड होने के बाद मैं कोड को कैसे निष्पादित करूं?

Question

.NET में, विंडोज फॉर्म में एक ऐसी घटना होती है, जो फॉर्म लोड होने से पहले फायर करती है (फॉर्म.लॉड), लेकिन फॉर्म लोड होने के बाद फायर करने के लिए कोई संबंधित ईवेंट नहीं है। फॉर्म लोड होने के बाद मैं कुछ तर्क निष्पादित करना चाहूंगा।

क्या कोई समाधान की सलाह दे सकता है?

Comments

हालाँकि इस प्रश्न के बहुत अच्छे उत्तर हैं, लेकिन यह ध्यान देने योग्य हो सकता है: docs.microsoft.com/en-us/dotnet/framework/winforms/…

— ऋषव

Answer 1

आप "दिखाया गया" घटना का उपयोग कर सकते हैं: MSDN - फ़ॉर्म

"दिखाया गया इवेंट केवल पहली बार एक फॉर्म प्रदर्शित होने के बाद उठाया जाता है; बाद में कम से कम करना, अधिकतम करना, पुनर्स्थापित करना, छिपाना, दिखाना या अमान्य करना और फिर से दिखाना इस घटना को नहीं बढ़ाएगा।"

Comments

मेरे लिए ऐसा लगता है जैसे दिखाया गया हैंडलर निष्पादित हो गया है जब फॉर्म लोड हो रहा है ... क्या मैं गलत हूं?

— ckonig

पुराना लेकिन सोना ... जी हां, आप गलत हैं। जीयूआई समानांतर कार्यों को नहीं चला सकता है, कुछ करने के लिए क्या महत्वपूर्ण है जब एक और निष्पादन किया जाता है।

— डेनिस ज़िकोल्स्की

यदि लोड ईवेंट हैंडलर में एक कोड है जो Application.DoEvents () को कॉल करता है, तो लोड ईवेंट हैंडलर्स द्वारा उनके निष्पादन को समाप्त करने से पहले दिखाया गया शो फायर। ऐसा इसलिए है क्योंकि दिखाया गया इवेंट वास्तव में Form.BeginInvoke (ShownEvent) और DoEvents () का उपयोग करते हुए एक संदेश कतार में रखा जाता है, यह लोड खत्म होने से पहले इसे आग लगाने के लिए मजबूर करता है।

— आर्टेमिक्स

यह मेरे लिए पर्याप्त नहीं था, सी # में। मुझे एक और सूत्रShown += Form1_Shown; में सुझाव के रूप में जोड़ना था

— समुद्रमंथन

आपको यह जोड़ना चाहिए। रीफ्रेश (); आपके तर्क से पहले सबसे पहले दिखाया गया घटना के अंदर और यह आपके तर्क के चलने से पहले पूरी तरह से लोड होने के लिए फॉर्म को रीफ्रेश और रीफ्रेश करेगा

— Aylian Craspa

Answer 2

मैं कभी-कभी (लोड में) का उपयोग करता हूं

this.BeginInvoke((MethodInvoker) delegate {
  // some code
});

या

this.BeginInvoke((MethodInvoker) this.SomeMethod);

(यदि आप "इस" के अलावा किसी अन्य घटना पर घटना को संभाल रहे हैं, तो इसे अपने "" रूप में बदलें।)

यह विंडो-फॉर्म्स लूप पर इनवॉइस को आगे बढ़ाता है, इसलिए यह उस समय प्रोसेस हो जाता है जब फॉर्म मैसेज कतार को प्रोसेस कर रहा होता है।

[अनुरोध पर अद्यतन]

Control.Invoke / Control.BeginInvoke विधियों का उपयोग थ्रेडिंग के साथ उपयोग करने के लिए किया जाता है, और UI थ्रेड पर काम को आगे बढ़ाने के लिए एक तंत्र है। आम तौर पर इसका इस्तेमाल वर्कर थ्रेड्स आदि द्वारा किया जाता है। Control.Inoke एक सिंक्रोनस कॉल करता है, जहां-as Control.BeginInvoke एक एसिंक्रोनस कॉल करता है।

आम तौर पर, इनका उपयोग इस प्रकार किया जाएगा:

SomeCodeOrEventHandlerOnAWorkerThread()
{
  // this code running on a worker thread...
  string newText = ExpensiveMethod(); // perhaps a DB/web call

  // now ask the UI thread to update itself
  this.Invoke((MethodInvoker) delegate {
      // this code runs on the UI thread!
      this.Text = newText;
  });
}

यह विंडोज़ संदेश कतार पर एक संदेश को धक्का देकर करता है; यूआई थ्रेड (कुछ बिंदु पर) संदेश को डी-क्यू करता है, प्रतिनिधि को संसाधित करता है, और कार्यकर्ता को संकेत देता है कि यह पूरा हो गया ... अब तक बहुत अच्छा; - पीपी

ठीक है; यदि हम UI. थ्रेड पर Control.Invoke / Control.BeginInvoke का उपयोग करते हैं तो क्या होगा? यह कॉपी करता है ... अगर आप कंट्रोल कहते हैं। इंवोक, यह जानने के लिए पर्याप्त समझदार है कि संदेश कतार पर ब्लॉक करने से तत्काल गतिरोध पैदा होगा - इसलिए यदि आप पहले से ही यूआई थ्रेड पर हैं तो यह बस तुरंत कोड चलाता है ... ताकि हमारी मदद नहीं करता है ...

लेकिन Control.BeginInvoke अलग तरीके से काम करता है: यह हमेशा कतार पर काम करता है, यहां तक ​​कि यह हम पहले से ही यूआई थ्रेड पर हैं। यह वास्तव में "एक पल में" कहने का एक तरीका है, लेकिन टाइमर आदि की असुविधा के बिना (जो अभी भी वैसे ही काम करना होगा!)।

Comments

पूरी तरह से समझ में नहीं आया कि एक। क्या आप थोड़ा और समझा सकते हैं?

— Torbjørn 15

हाय मार्क, क्या फॉर्म को उत्तरदायी बनाना संभव है जबकि प्रक्रिया पूरी हो गई है जिसे BeginInvoke में कहा जाता है ??

— huMpty डुम्टी

WPF में यह किसके समकक्ष है?

— 14

Answer 3

पहली बार जब यह "आफ्टरलाईडिंग" शुरू नहीं होगा, तो
यह केवल NEXT लोड शुरू करने के लिए इसे पंजीकृत करेगा।

private void Main_Load(object sender, System.EventArgs e)
{
    //Register it to Start in Load 
    //Starting from the Next time.
    this.Activated += AfterLoading;
}

private void AfterLoading(object sender, EventArgs e)
{
    this.Activated -= AfterLoading;
    //Write your code here.
}

Answer 4

मेरे पास एक ही समस्या थी, और इसे इस प्रकार हल किया:

वास्तव में मैं संदेश दिखाना चाहता हूं और 2 सेकंड के बाद इसे स्वचालित रूप से बंद कर दूंगा। उसके लिए मुझे (गतिशील रूप से) सरल फॉर्म और एक लेबल संदेश दिखाना था, 1500 एमएस के लिए संदेश रोकें ताकि उपयोगकर्ता इसे पढ़ें। और गतिशील रूप से बनाए गए फॉर्म को बंद करें। लोड घटना के बाद दिखाया घटना। तो कोड है

Form MessageForm = new Form();
MessageForm.Shown += (s, e1) => { 
    Thread t = new Thread(() => Thread.Sleep(1500)); 
    t.Start(); 
    t.Join(); 
    MessageForm.Close(); 
};

Answer 5

आप अपने कोड को फ़ॉर्म की सक्रिय घटना में डालने का प्रयास कर सकते हैं, यदि आप चाहते हैं कि यह तब हो, जब फ़ॉर्म सक्रिय हो। आपको एक बूलियन में डाल देना होगा "निष्पादित किया गया है" चेक हालांकि अगर यह केवल पहले सक्रियण पर चलने वाला है।

Answer 6

यह एक पुराना प्रश्न है और यह तब निर्भर करता है जब आपको अपनी दिनचर्या शुरू करने की आवश्यकता होती है। चूँकि कोई भी अशक्त संदर्भ अपवाद नहीं चाहता है, इसलिए अशक्त के लिए जाँच करना हमेशा सबसे अच्छा है, फिर आवश्यकतानुसार उपयोग करें; यह अकेला आपको बहुत दुःख से बचा सकता है।

इस प्रकार के प्रश्न का सबसे आम कारण यह है कि जब कोई कंटेनर या कस्टम नियंत्रण प्रकार किसी कस्टम वर्ग के बाहर आरम्भिक गुणों तक पहुँचने का प्रयास करता है, जहाँ उन गुणों को अभी तक आरंभीकृत नहीं किया गया है, जिससे संभावित रूप से अशक्त मानों में वृद्धि हो सकती है और यहाँ तक कि अशक्त संदर्भ अपवाद भी हो सकते हैं। वस्तु प्रकारों पर। इसका मतलब है कि आपकी कक्षा पूरी तरह से शुरू होने से पहले ही चल रही है - इससे पहले कि आप अपने गुणों को सेट करना शुरू करें आदि इस प्रकार के प्रश्न का एक और संभावित कारण कस्टम ग्राफिक्स का प्रदर्शन करना है।

फॉर्म लोड ईवेंट के बाद कोड को निष्पादित करना कब शुरू करना है, इस सवाल का सबसे अच्छा जवाब देने के लिए, सीधे WM_Paint संदेश या हुक को पेंट इवेंट में ही मॉनिटर करना है। क्यों? पेंट ईवेंट केवल तभी फायर करता है जब सभी मॉड्यूल आपके फॉर्म लोड इवेंट के संबंध में पूरी तरह से लोड हो गए हों। नोट: यह। अदृश्य == सच हमेशा सच नहीं होता है जब इसे सही किया जाता है, इसलिए इसका उपयोग इस उद्देश्य के लिए बिल्कुल नहीं किया जाता है, सिवाय एक रूप को छिपाने के लिए।

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

using System.Windows.Forms;

नामस्थान MyProgramStartingPlaceExample {

/// <summary>
/// Main UI form object
/// </summary>
public class Form1 : Form
{

    /// <summary>
    /// Main form load event handler
    /// </summary>
    public Form1()
    {
        // Initialize ONLY. Setup your controls and form parameters here. Custom controls should wait for "FormReady" before starting up too.
        this.Text = "My Program title before form loaded";
        // Size need to see text. lol
        this.Width = 420;

        // Setup the sub or fucntion that will handle your "start up" routine
        this.StartUpEvent += StartUPRoutine;

        // Optional: Custom control simulation startup sequence:
        // Define your class or control in variable. ie. var MyControlClass new CustomControl;
        // Setup your parameters only. ie. CustomControl.size = new size(420, 966); Do not validate during initialization wait until "FormReady" is set to avoid possible null values etc. 
        // Inside your control or class have a property and assign it as bool FormReady - do not validate anything until it is true and you'll be good! 
    }

    /// <summary>
    /// The main entry point for the application which sets security permissions when set.
    /// </summary>
    static void Main()
    {
        Application.EnableVisualStyles();
        Application.SetCompatibleTextRenderingDefault(false);
        Application.Run(new Form1());
    }


    #region "WM_Paint event hooking with StartUpEvent"            
    //
    // Create a delegate for our "StartUpEvent"
    public delegate void StartUpHandler();
    //
    // Create our event handle "StartUpEvent"
    public event StartUpHandler StartUpEvent;
    //
    // Our FormReady will only be set once just he way we intendded
    // Since it is a global variable we can poll it else where as well to determine if we should begin code execution !!
    bool FormReady;
    //
    // The WM_Paint message handler: Used mostly to paint nice things to controls and screen
    protected override void OnPaint(PaintEventArgs e)
    {
        // Check if Form is ready for our code ?
        if (FormReady == false) // Place a break point here to see the initialized version of the title on the form window
        {
            // We only want this to occur once for our purpose here.
            FormReady = true;
            //
            // Fire the start up event which then will call our "StartUPRoutine" below.
            StartUpEvent();
        }
        //
        // Always call base methods unless overriding the entire fucntion
        base.OnPaint(e);
    }
    #endregion


    #region "Your StartUp event Entry point"
    //
    // Begin executuing your code here to validate properties etc. and to run your program. Enjoy!
    // Entry point is just following the very first WM_Paint message - an ideal starting place following form load
    void StartUPRoutine()
    {
        // Replace the initialized text with the following
        this.Text = "Your Code has executed after the form's load event";
        //
        // Anyway this is the momment when the form is fully loaded and ready to go - you can also use these methods for your classes to synchronize excecution using easy modifications yet here is a good starting point. 
        // Option: Set FormReady to your controls manulaly ie. CustomControl.FormReady = true; or subscribe to the StartUpEvent event inside your class and use that as your entry point for validating and unleashing its code.
        //
        // Many options: The rest is up to you!
    }
    #endregion

}

}

Comments

यह अविश्वसनीय रूप से लंबे समय से घुमावदार लगता है, और क्या यह केवल शोव इवेंट को पकड़ने पर कोई लाभ है?

— स्टीव स्मिथ

Answer 7

मुझे पता है यह एक पुरानी पोस्ट है। लेकिन यहाँ है कि मैं यह कैसे किया है:

    public Form1(string myFile)
    {
        InitializeComponent();
        this.Show();
        if (myFile != null)
        {
            OpenFile(myFile);
        }
    }

    private void OpenFile(string myFile = null)
    {
            MessageBox.Show(myFile);
    }

Answer 8

आप कुछ निष्पादन के बाद अपना फॉर्म बंद कर सकते हैं।

//YourForm.ActiveForm.Close ();

    LoadingForm.ActiveForm.Close();