I have got the new problem with opening and closing form in C#.
My problem is how to dispose the form after closing .
here is my code :
Program.cs:
static class Program
{
public static Timer timer;
[STAThread]
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
timer = new Timer { Interval = 1000};
timer.Start();
Application.Run(new Form1());
}
}
Form1.cs:
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
Form2 form = new Form2();
form.ShowDialog();
/// I've tried Dispose() method . but didn't work
}
}
Form2.cs:
public partial class Form2 : Form
{
public Form2()
{
InitializeComponent();
}
private void Form2_Load(object sender, EventArgs e)
{
Program.timer.Tick += timer_Tick;
Close();
// I've tried Dispose() method instead of Close() but didn't work
}
private int count = 0;
void timer_Tick(object sender, EventArgs e)
{
count++;
if (count == 5) MessageBox.Show("");
}
}
Edited :
My question is : why the message box shows after 5 seconds when the form2 has closed!
This question turns out to be about Dispose.
Firstly, Dispose has nothing to do with garbage collection. The following happens:
You have a global Timer instance
You create form2
Form2 subscribes to the timer
Form2 is Closed and/or Disposed
The Timer event fires, increments the counter and shows a MessageBox
The Timer event keeps firing until the App closes.
The main point to understand is that Close/Dispose only change the status of the Form, they don't (can't) 'delete' the instance. So the (closed) form is there, the counter field is still there and the Event fires.
OK, part 1:
A using () {} block would be better but this should work:
private void button1_Click(object sender, EventArgs e)
{
Form2 form = new Form2();
form.ShowDialog();
/// I've tried Dispose() method . but didn't work
form.Dispose(); // should work
}
If not, please describe "doesn't work".
private void Form2_Load(object sender, EventArgs e)
{
Program.timer.Tick += timer_Tick;
Close();
/// I've tried Dispose() method instead of Close() . but didn't work
}
This is strange, but I'll assume that it is artifical code for the question.
Your global Program.Timer now stores a reference to your Form2 instance and will keep it from being collected. It does not prevent it from being Disposed/Close so your timer will keep firing for a Closed Form, and that will usually fail and cause other problems.
Don't do this (give Form2 it's own timer)
Use a FormClosed event to unsubscribe: Program.timer.Tick -= timer_Tick;
The simplest and most reliable way to dispose a Form after using is to put the usage inside of a using block
using (Form2 form = new Form2()) {
form.ShowDialog();
}
The using block in C# is a construct that essentially expands the above into the following code.
Form2 form;
try {
form = new Form2();
...
} finally {
if ( form != null ) {
form.Dispose();
}
}
This is an old question but it touches some interesting points about how objects work. A form is, essentially, an object. All objects of the same class share the same methods but each one has their own data. What does this mean? This means that, closing or disposing an object does not free/delete/remove any code from the memory. Only data. All that was about objects in general, no matter the language.
Now, specifically about your code. Let us examine what the line Program.timer.Tick += timer_Tick; does. This gives a pointer to your function in the Form object to the timer object. So, now, no matter what you do to the Form object, the timer object will keep calling that function. The timer object does not care about your Form and is not even aware of the existence of the Form object. It only cares about the function you passed the pointer to. As far as the timer object is concerned, this function is a standalone function.
What does Form.Close() do? Form.Close() disposes the resources used by the form, aka, marks the form's controls for garbage collection unless the form is displayed using ShowDialog. In that case, Dispose() must be called manually. MSDN
Needless to say(or maybe not so needless) that if closing/disposing the form cleared the function from the memory, the timer object would have an invalid pointer and your program would crash after 5 seconds.
Perhaps I am reading the question wrong, but I think the gentlemen needs to know that, to close a form (say form2) opened as Form2.ShowDialog(), you need to set Form2.DialogResult within Form2. Just setting that member is all it takes to close the form and return the result.
form.ShowDialog() shows the form as a modal dialog. This means that the call doesn't return until the Form is closed.
Note that clicking the close X on a modal dialog doesn't close the form, it just hides it. I am guessing that this is what confuses you.
If you want the code in form1 to continue executing rather than blocking, you should call Show() instead of ShowDialog(). Non-modal will close when the X is clicked.
If you do want a blocking modal dialog, you should surround the form with a using block as described in the other answers.
When building a modal dialog you would typically add an "OK" button or similar and set the AcceptButton property of the form to that button to allow the user to close the form by pressing enter. Similarly you can add a "Cancel" button and set the CancelButton property to capture the Esc key.
Add a click handler to the two buttons, set the DialogResult property of the form accordingly and call Close().
Related
I am having a bit of a head scratch moment at the moment.
I have 2 Forms one being a Parent form and other being the child form.
Inside the Parent form am trying to detect the FormClosed event which I have subscribed to a event inside the Parent form to handle some behaviour.
However the FormClosed event never gets subscribed or triggered when I close the child Form? I am not really sure what am doing wrong? I have even tried FormClosing and nothing gets triggered?
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
using (var frm2 = new Form2())
{
frm2.ShowDialog();
frm2.FormClosed += Frm2OnFormClosed;
}
}
private void Frm2OnFormClosed(object sender, FormClosedEventArgs e)
{
// Implement further behaviour handling.
}
}
ShowDialog() will block execution of code in the calling method until the new form is closed. So you are opening and closing frm2 before you've ever even assigned the EventHandler. Switch your two lines around like so and you should be good to go:
frm2.FormClosed += Frm2OnFormClosed;
frm2.ShowDialog();
I have mainVariable.cs that contains delegates for events. Also I have several forms and a worker.cs. My problem is that Login form is starting form and handles some event. After that it hides itself and shows another form. Now the problem starts here, because second form which started after login, cant handle any events. I mean when I raise an event from worker.cs and login form handles the event not the second from even if I dispose the login form. How can I solve this puzzle ?
Apply this to your Programm.cs
Application.Run(loginForm);
if (loginForm.IsLoggedIn == true)
{
ERS_FDData.ERSUser user = loginForm.user;
loginForm.Close();
Application.Run(new frmMain(loginForm.user));
}
else
Application.Exit();
After the login is done, you need to set the Mainf Frame to be the application default window
For any event to be handled you need to assign it a subroutine.
You can do this from any form, given you initialize and show it first.
For example.
Form1
{
FormLoad()
{
mybutton.click += new EventHandler(myfunction);
}
myfunction(object o, EventArgs e) { // Dostuff }
}
So you'd initialize Form1 something like this
Form1 myform = new Form1();
And the event will work as the form expects.
After closing a form, I can't access it anymore, because the object does not exist anymore.
Is there a way to avoid this kind of behaviour, without initiating the object everytime I perform an event?
This is the first Form called status, it's not the only one I need to create, that's why Iam asking.
This does not work: After closing the form and click on the menu item I get an reference error "Object does not exist", and therefor can't be accessed.
public partial class Main : Form
{
StatusForm statusForm = new StatusForm();
public Main()
{
InitializeComponent();
statusForm.MdiParent = this;
}
private void statusToolStripMenuItem_Click(object sender, EventArgs e)
{
statusForm.Show();
}
private void Main_Load(object sender, EventArgs e)
{
statusForm.Show();
}
}
If you use Close to close a form, it is unusable after that point. You have to create a new one.
However, if you want a persistent Form object, just call Form.Hide instead. This hides the form but leaves it "open".
MSDN notes this as well:
When the Close method is called on a Form displayed as a modeless
window, you cannot call the Show method to make the form visible,
because the form's resources have already been released. To hide a
form and then make it visible, use the Control.Hide method.
I have a WinForm that I create that shows a prompt with a button. This is a custom WinForm view, as a message box dialog was not sufficient.
I have a background worker started and running. I also want to exit the while(aBackgroundWorker.IsBusy) loop if the button on myForm was clicked.
//MyProgram.cs
using(CustomForm myForm = new CustomForm())
{
myForm.Show(theFormOwner);
myForm.Refresh();
while(aBackgroundWorker.IsBusy)
{
Thread.Sleep(1);
Application.DoEvents();
}
}
Right now, in the CustomForm the Button_clicked event, I have
//CustomForm.cs
private void theButton_Click(object sender, EventArgs e)
{
this.Close();
}
Do I need to add more code to the CustomForm class, or the location where I declare and initialize the form in order to be able to detect a closure?
To detect when the form is actually closed, you need to hook the FormClosed event:
this.FormClosed += new FormClosedEventHandler(Form1_FormClosed);
void Form1_FormClosed(object sender, FormClosedEventArgs e)
{
// Do something
}
Alternatively:
using(CustomForm myForm = new CustomForm())
{
myForm.FormClosed += new FormClosedEventHandler(MyForm_FormClosed);
...
}
void MyForm_FormClosed(object sender, FormClosedEventArgs e)
{
// Do something
}
You might be going overkill. To show a form like a dialog window and wait for it to exit before returning control back to the calling form, just use:
mySubForm.ShowDialog();
This will "block" the main form until the child is closed.
Make sure your background worker supports cancellation and as others have pointed out use the form closed event handler. This code should point you in the right direction:
using(CustomForm myForm = new CustomForm())
{
myForm.FormClosed += new FormClosedEventHandler(ChildFormClosed);
myForm.Show(theFormOwner);
myForm.Refresh();
while(aBackgroundWorker.IsBusy)
{
Thread.Sleep(1);
Application.DoEvents();
}
}
void ChildFormClosed(object sender, FormClosedEventArgs e)
{
aBackgroundWorker.CancelAsync();
}
Handle the FormClosing event of the form to be notified when the form is closing, so you can perform any cleanup.
You should be able to hook into the FormClosing and FormClosed events.
http://msdn.microsoft.com/en-us/library/system.windows.forms.form.formclosing.aspx
http://msdn.microsoft.com/en-us/library/system.windows.forms.form.formclosed.aspx
Closing is before it's closed.
Closed is after it's closed.
A couple things...
First, it appears that loop is there in order to prevent execution form proceeding while the dialog is open. If that is the case, change you .Show(parent) to .ShowDialog(parent). That will also take care of the rest of your question.
Note that this.Hide(); is not the same as this.Close(); in the actual dialog your overriding the closed event
I am working on a DirectX based simulator.
On which I have to check for a device whether device has been plugged-in or removed from the PC.
I've managed to make classes for device arrival and removal on another thread, which raises an event from the thread itself on device arrival or removal.
The corresponding event method is being called in the main form and there:
Assume Form1 is main window and Form2 is the secondary.
Form2 form2Instance = new Form2();
I want to show another Form (Form2) keeping main Window (Form1) in behind (same as it behaves as form2Instance.ShowDialog(); in general cases.)
After a few tries I have done it by
Applicatin.Run(new Form2());, but the Form2 doesn't behave as'form2Instance.ShowDialog(); in any way.
Just giving the code if it can help in answering:
iARMdetectionThreadClass detection;
InProgram_iARMdetection iARMStatusGUI;
private void Form2_Load(object sender, EventArgs e)
{
iARMStatusGUI = new InProgram_iARMdetection();
detection = new iARMdetectionThreadClass();
detection.IniARM_device_Arrive += new iARMdetectionThreadClass.iARM_device_ArrivedEventHandler(detection_IniARM_device_Arrive);
detection.IniARM_device_Remove += new iARMdetectionThreadClass.iARM_device_RemovedEventHandler(detection_IniARM_device_Remove);
detection.startThread();
}
void detection_IniARM_device_Remove(iARM_deviceInfo senderInfo)
{
detection.StopCheckBeingRemoved();
MethodInvoker act = delegate
{
this.label_iARMStatus.Text = detection.iARM_deviceInf.iARMStatus;
};
this.label_iARMStatus.BeginInvoke(act);
Application.Run(new InProgram_iARMdetection()); //Blocking code
detection.StartCheckBeingRemoved();
}
void detection_IniARM_device_Arrive(iARM_deviceInfo senderInfo)
{
MethodInvoker act = delegate
{
this.label_iARMStatus.Text = detection.iARM_deviceInf.iARMStatus;
};
this.label_iARMStatus.BeginInvoke(act);
//detection.StopCheckArriving();
//detection.StartCheckArriving();
}
I need the code to be Blocking Code. In here:
Application.Run(new InProgram_iARMdetection()); //Blocking code
Perhaps mainform.AddOwnedForm(form2) will do what you want. It will make form2 display in front of mainform and when either one is minimized, the other is also.
You should handle the remove event on form2 rather than form1 and use the ShowDialog() method.
So when on form1 the arrival event will fire it will open up form2 like a dialog. Now when the device will be unplugged, on form2 removal event will fire where you can close the form.