We Keep Coding

How to stop windows form from closing but hide upon clicking the X?

I'm trying to have a click event that will open another form. I don't want the user to be able to close this window because I get the following exception when the click event is executed again.
System.ObjectDisposedException: 'Cannot access a disposed object.
Object name: 'Form2'.'
I'm not sure if I'm implementing this correctly or there's a better way of doing this.
Form1
public Form2 f = new Form2();
private void Btnsearch_Click(object sender, EventArgs e)
{
f.Show();
}
Form2
private bool allowClose = false;
private void Btnclose_Click(object sender, EventArgs e)
{
allowClose = true;
this.Hide();
}
private void Form2_FormClosing(object sender, FormClosingEventArgs e)
{
if (!allowClose)
e.Cancel = true;
}

Subscribe to Form.OnClosing and set the Cancel property on the event args that are passed to the handler. This will tell the runtime to cancel the close event.
Since the event is getting canceled, you'll have to hide the form yourself (using Hide(), of course).
private void Form1_Closing(Object sender, CancelEventArgs e)
{
this.Hide();
e.Cancel = true;
}

The instance of form2 should be created within the event
private void Btnsearch_Click(object sender, EventArgs e)
{
Form2 f = new Form2();
f.Show();
}

There are a couple of ways to approach this.
It's generally more efficient, in the FormClosing event, to hide the form and cancel the event, but this can require extra logic.
Unless you have some expensive code that needs to run when the form is created, this probably doesn't matter, and it'll be easier to simply allow the form to close normally.
Either way, all you particularly need to do, is throw some safeguards into the btnSearch handler, so that it can appropriately respond to the state of form f;
public Form2 f;
public void BtnSearch_Click(object sender, EventArgs e)
{
if (f == null || f.IsDisposed || f.Disposing) f = new Form2(...);
f.Show();
}

How to show Notification Message on Shutdown of Application WPF

I made application in which when user will click on close button of MainWindow whole application will shutdown. I want to show a Notification after closing of application. How to show a toast message as application shuts'down?
Here Code is :
private void Close(object sender, EventArgs e)
{
base.OnClosed(e);
Application.Current.Shutdown();
}
Can any one answer my question?
Feel Free to ask if my question is not clear!

Try implementing a handler for the Window.Closing event:
private void MainWindow_Closing(object sender, System.ComponentModel.CancelEventArgs e)
{
MessageBox.Show("Hi, I'm closing!");
}
This will occur before the Window.Closed event.
UPDATE >>>
#Andy and Tameen, please take a look at the Window.Closing Event page at MSDN to see when this event really occurs.
Occurs directly after Close is called, and can be handled to cancel window closure.
UPDATE 2 >>>
Your question does not state that you want to cancel the Close event. However, that is exactly what the Closing event is for:
private void MainWindow_Closing(object sender, System.ComponentModel.CancelEventArgs e)
{
MessageBox.Show("Hi, I'm closing!");
e.Cancel = true;
}

Your application shutdowns by default when the mainwindow closes. Allow the button to signal the window close and handle the toast in the Closed event.
<Window ... Closed="Window_Closed" />
private void Button_Click(object sender, RoutedEventArgs e)
{
this.Close();
}
private void Window_Closed(object sender, EventArgs e)
{
MessageBox.Show("Cya");
}

Activate tool strip click event from another form

I need to send a click event to refreshToolStripMenuItem from another form. Here is what I have, for some reason it doesn't work. Help please.
Menu item click:
public void refreshToolStripMenuItem_Click(object sender, EventArgs e)
{
noteslist.Items.Clear();
idlist.Items.Clear();
setnotes();
}
Code used to send event:
frmnotes notes = new frmnotes();
notes.refreshToolStripMenuItem_Click(this, e);
this.Close();

Dont call the event itself.
It's bad code.
Put the create an own protected void updateMyList() Method.
internal void updateMyList()
{
noteslist.Items.Clear();
idlist.Items.Clear();
setnotes();
}
Then call the update-method from within your event.
private void refreshToolStripMenuItem_Click(object sender, EventArgs e)
{
updateMyList();
}
Then simply call the update-method from your form:
frmnotes notes = new frmnotes();
notes.updateMyList();
this.Close();
Btw.: Set the modifier of your Click events i.e. refreshToolStripMenuItem_Click to private.
You never should call them from outside the form.
Take a look at the MVC pattern for more info. It really helps.

Trigger control's event programmatically

Assume that I have a WinFoms project. There is just one button (e.g. button1).
The question is: is it possible to trigger the ButtonClicked event via code without really clicking it?

Button controls have a PerformClick() method that you can call.
button1.PerformClick();

The .NET framework uses a pattern where for every event X there is a method protected void OnX(EventArgs e) {} that raises event X. See this Msdn article. To raise an event from outside the declaring class you will have to derive the class and add a public wrapper method. In the case of Button it would look like this:
class MyButton : System.Windows.Forms.Button
{
public void ProgrammaticClick(EventArgs e)
{
base.OnClick(e);
}
}

You can just call the event handler function directly and specify null for the sender and EventArgs.Empty for the arguments.
void ButtonClicked(object sender, EventArgs e)
{
// do stuff
}
// Somewhere else in your code:
button1.Click += new EventHandler(ButtonClicked);
// call the event handler directly:
ButtonClicked(button1, EventArgs.Empty);
Or, rather, you'd move the logic out of the ButtonClicked event into its own function, and then your event handler and the other code you have would in turn call the new function.
void StuffThatHappensOnButtonClick()
{
// do stuff
}
void ButtonClicked(object sender, EventArgs e)
{
StuffThatHappensOnButtonClick();
}
// Somewhere else in your code:
button1.Click += new EventHandler(ButtonClicked);
// Simulate the button click:
StuffThatHappensOnButtonClick();
The latter method has the advantage of letting you separate your business and UI logic. You really should never have any business logic in your control event handlers.

Yes, just call the method the way you would call any other. For example:
private void btnSayHello_Click(object sender, EventArgs e)
{
MessageBox.Show("Hello World!");
}
private void btnTriggerHello_Click(object sender, EventArgs e)
{
btnSayHello_Click(null, null);
}

button1.PerformClick();
But if you have to do something like this maybe it's better to move the code you have under the event on a new method ?

Why don't you just put your event code into a Method. Then have the Event execute the method. This way if you need to execute the same code that the Event rises, you can, but simply just calling the "Method".
void Event_Method()
{
//Put Event code here.
MessageBox.Show("Hello!");
}
void _btnSend_Click(object sender, EventArgs e)
{
Event_Method();
}
void AnotherMethod()
{
Event_Method();
}
Make sense? Now the "Click" event AND anywhere in code you can trigger the same code as the "Click" event.
Don't trigger the event, call the method that the event calls. ;)

In most cases you would not need to do that. Simply wrap your functionality in functions related to a specific purpose (task). You call this function inside your event and anywhere else it's needed.
Overthink your approach.

I recently had this problem where I wanted to programatically click a button that had multiple event handlers assigned to it (think UserControl or derived classes).
For example:
myButton.Click += ButtonClicked1
myButton.Click += ButtonClicked2;
void ButtonClicked1(object sender, EventArgs e)
{
Console.WriteLine("ButtonClicked1");
}
void ButtonClicked2(object sender, EventArgs e)
{
Console.WriteLine("ButtonClicked1");
}
When you click the button, both functions will get called. In the instances where you want to programmatically fire an event handler for a function from a form (for example, when a user presses enter in a Text field then call the InvokeOnClick method passing through the control you. For example
this.InvokeOnClick(myButton, EventArgs.Empty);
Where this is the Form instance you are in.

use a for loop to call the button_click event
private void btnadd_Click(object sender, RoutedEventArgs e)
{
for (int i = 0; i <= 2; i++)
StuffThatHappensOnButtonClick();
}
void StuffThatHappensOnButtonClick()
{
........do stuff
}
we assume at least one time you need click the button

c# trying to get an event to fire when a different window closes

I have one form that has an option to open another (dialogue). I want an event to fire when the second window closes. The first form is named frmMain() the other is frmAddEmployee(). Heres what I have:
in frmMain()
//create and open the second window
public void (object sender, EventArgs e)
{
frmAddEmployee addEmp = new frmAddEmployee();
addEmp.ShowDialogue();
}
//create event to handle addEmp being closed
public void addEmp_Closing(object sender, EventArgs e)
{
PopulateEmployeeList();
}
I'm not sure the event is being recognized as an event. What am I doing wrong?

Events in C# have to be registered manually - the C# compiler will not automatically register method as an event handler based just on the name of the method. You need:
frmAddEmployee addEmp = new frmAddEmployee();
addEmp.Closing += addEmp_Closing; // Register event handler explicitly
addEmp.ShowDialogue();
Automatic registration of events is done in ASP.NET and Visual Basic has Handles clause, but in C#, you need to use the += operator to specify that some method should be called when an event occurs.

Assuming ShowDialogue means ShowDialog, then it shows the form modally and you don't need an event handler:
//create and open the second window
public void (object sender, EventArgs e)
{
frmAddEmployee addEmp = new frmAddEmployee();
addEmp.ShowDialog();
PopulateEmployeeList();
}
If you don't show the second form modally, then you can hook up the event handler before showing the form like this:
public void (object sender, EventArgs e)
{
frmAddEmployee addEmp = new frmAddEmployee();
addEmp.FormClosed += AddEmpClosed;
addEmp.Show();
}
private void AddEmpClosed(object sender, FormClosedEventArgs e)
{
PopluateEmployeeList();
}

There is Closing and Closed events which you can register for on the Form. You are registered for neither, unless your registration is taking place somehwere else?

Before you call addEmp.ShowDialog() you need to set your method to handle the Closing event:
frmAddEmployee addEmp = new frmAddEmployee();
addEmp.Closing += addEmp_Closing;
addEmp.ShowDialogue();