We Keep Coding

How to run multiple modal forms in sequence in C#?

I have a method RunForm() that runs a modal dialog performing some task:
static void RunForm() {
SomeForm form = new SomeForm();
Application.Run( form );
}
I want to call RunForm() multiple times from the STAThread entry point:
[STAThread]
static void Main() {
RunForm(); // Run form once
RunForm(); // Run form twice
RunForm(); // Run form etc.
}
At some point, the form calls "Close()" on itself and unfortunately the application's thread exits and any subsequent call to RunForm() exits immediately...
But if I close the modal dialog manually by clicking the top-right red cross button, the subsequent calls to RunForm() work correctly (i.e. the application's thread is still running somehow).
How can I automatically run multiple modal dialogs in a sequence?
(and what is the difference between a manual close and a programmatic call to Close()?)

Application.Run(ApplicationContext) is more likely a better fit for your usage of multiple forms by running just once this method and by handling the multiple open/closing forms from your application context implementation (as it is described in the link)

Open new windows form window, closes immediately

I am trying to open a new windows form, however it seem to close immediately every time.
it works if i use ShowDialog() instead of Show(), but that is not my intention.
class Forms
{
Main mainForm;
Thread mainThread;
public Forms()
{
}
private void ThreadProc()
{
try
{
mainForm = new Main();
mainForm.Show();
}
catch { }
}
public void startMain()
{
mainThread = new Thread(new ThreadStart(ThreadProc));
mainThread.SetApartmentState(ApartmentState.STA);
mainThread.Start();
}
}

The problem is your mainThread does not run any message loop (that is responsible to react to all the GUI-related messages like resizing, button clicks, etc...), and so after calling mainForm.Show() the thread finishes.
In fact winforms applications usually start like this:
Application.Run(new MainForm());
where, as you can see in the MSDN documentation, Application.Run starts a standard message loop in the current thread and shows the form.
If you use ShowDialog() it works because modal forms run their own message loop internally.
I don't know what you are trying to accomplish but ShowDialog might be the easiest solution; in case you don't like it just replace your mainForm.Show with Application.Run(mainForm) and it should work.

You would need to use Application.Run to start the application message loop, otherwise the program would act like a console app and close once its code has finished executing.
Add using System.Windows.Forms; to the top of the class.
Then change mainForm.Show(); to Application.Run(mainForm); inside ThreadProc.

You should use:
Application.Run(new MainForm());
Begins running a standard application message loop on the current
thread, and makes the specified form visible.

How do I properly exit a C# application?

I have a published application in C#. Whenever I close the main form by clicking on the red exit button, the form closes but not the whole application. I found this out when I tried shutting down the computer and was subsequently bombarded by lots of child windows with MessageBox alerts I added.
I tried Application.Exit but it still calls all the child windows and alerts. I don't know how to use Environment.Exit and which integer to put into it either.
Also, whenever my forms call the FormClosed or FormClosing event, I close the application with a this.Hide() function; does that affect how my application is behaving?

From MSDN:
Application.Exit
Informs all message pumps that they must terminate, and then closes all application windows after the messages have been processed. This is the code to use if you are have called Application.Run (WinForms applications), this method stops all running message loops on all threads and closes all windows of the application.
Environment.Exit
Terminates this process and gives the underlying operating system the specified exit code. This is the code to call when you are using console application.
This article, Application.Exit vs. Environment.Exit, points towards a good tip:
You can determine if System.Windows.Forms.Application.Run has been called by checking the System.Windows.Forms.Application.MessageLoop property. If true, then Run has been called and you can assume that a WinForms application is executing as follows.
if (System.Windows.Forms.Application.MessageLoop)
{
// WinForms app
System.Windows.Forms.Application.Exit();
}
else
{
// Console app
System.Environment.Exit(1);
}
Reference: Why would Application.Exit fail to work?

I know this is not the problem you had, however another reason this could happen is you have a non background thread open in your application.
using System;
using System.Threading;
using System.Windows.Forms;
namespace Sandbox_Form
{
static class Program
{
private static Thread thread;
[STAThread]
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
thread = new Thread(BusyWorkThread);
thread.IsBackground = false;
thread.Start();
Application.Run(new Form());
}
public static void BusyWorkThread()
{
while (true)
{
Thread.Sleep(1000);
}
}
}
}
When IsBackground is false it will keep your program open till the thread completes, if you set IsBackground to true the thread will not keep the program open. Things like BackgroundWoker, ThreadPool, and Task all internally use a thread with IsBackground set to true.

By the way. whenever my forms call the formclosed or form closing event I close the applciation with a this.Hide() function. Does that affect how my application is behaving now?
In short, yes. The entire application will end when the main form (the form started via Application.Run in the Main method) is closed (not hidden).
If your entire application should always fully terminate whenever your main form is closed then you should just remove that form closed handler. By not canceling that event and just letting them form close when the user closes it you will get your desired behavior. As for all of the other forms, if you don't intend to show that same instance of the form again you just just let them close, rather than preventing closure and hiding them. If you are showing them again, then hiding them may be fine.
If you want to be able to have the user click the "x" for your main form, but have another form stay open and, in effect, become the "new" main form, then it's a bit more complicated. In such a case you will need to just hide your main form rather than closing it, but you'll need to add in some sort of mechanism that will actually close the main form when you really do want your app to end. If this is the situation that you're in then you'll need to add more details to your question describing what types of applications should and should not actually end the program.

In this case, the most proper way to exit the application in to override onExit() method in App.xaml.cs:
protected override void OnExit(ExitEventArgs e) {
base.OnExit(e);
}

winform auto close if main form is closed

I have two .net 2 winforms, each has its own project. project 1 is main form and project 2 is a child form. and now I would like to know how to make the child form close it self if main form is no longer active.
killing child form on exit doesnt work, because main form can be killed by task manager.

you need to handle the OnClosing event of main form where you can close any child forms.You need to have a member variable of a child form in main.

If I understand correctly, what you call a 'child form' is actually another WinForms app running in a separate process?
In addition, I take it (from your "because main form can be killed by task manager" comment) that you want the exiting behaviour to be resilient to cases when the main-app is forcefully killed.
One way would be to get the 'child app' to listen to the Process.Exited event of the 'main app', and exit if it fires.
I imagine it would look something like:
public Form1()
{
InitializeComponent();
// You need to figure out how best to do this part.
// Also, what to do if the main-app isn't already running.
var mainAppProcess = Process.GetProcessesByName("MainApp").First();
mainAppProcess.EnableRaisingEvents = true;
// Close the form when the other process exits.
mainAppProcess.Exited +=
delegate { BeginInvoke(new Action(Close)); };
}

Why won't Application.Exit() quit a Windows Forms application?

I am working on learning Windows Forms with C# and have a bare bones application. I am trying to close it when the user selects File->Exit. I have an event handler attached to it and I have tried calling Application.Exit(), Application.ExitThread() and just closing the form. Nothing. It stays there. I'm not creating any other threads of any sort either.
Ideas? Thanks.

Have you tried to put a breakpoint in the event handler to see if it is being hit?
If so, the application won't exit if the window messages aren't being delivered (i.e. the UI thread is blocked). One way to test this is to call Environment.Exit() which is more brutal about forcing a close. If this succeeds, you can then figure out why Application.Exit() isn't working.

Application.Exit isn't the normal way to close a GUI application. Use form.Close instead.
private static void OnMenuClose_Click(object sender, System.EventArgs e)
{
Form dlg = ((Control) sender).FindForm();
//dlg.DialogResult = DialogResult.OK;
dlg.Close();
}