We Keep Coding

How to close a form launched from Main() without cross-thread errors

I have an Windows form application that can be called from command line or used as a GUI. The command line options are only for scheduling the program to run saved tasks, so I don't want the GUI to launch if the command line options are used.
static void Main()
{
//code to parse the command line options
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
try
{
Application.Run(new MainForm());
}
}
public MainForm()
{
//Loading data from a file into the form.
If (ArgumentList.Length >0)
{
//do command line-requested tasks
this.close();
}
else
{
//do GUI tasks
}
}
How do I close the MainForm window without making a instance of ObjectDisposedException be thrown? If I use anything after
Application.Run(new MainForm());
it doesn't run because that form is opened and nothing runs after that line until the form is closed. I've tried
this.Hide();
instead of
this.Close();
but this.Hide() doesn't seem to do anything in this case, as the form still shows. I know that I shouldn't try to close a form from within the form (cross-threading), but if I don't want the GUI form to show if called from command line.

You should move that code to Main(), and avoid the form entirely if you don't need it.

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.

Beginner's confusion about this.close() function

I was trying to use this.close() function to terminate a window, yes it works, however, Visual Studio did not stop the debugging, I need to manually press the stop button in VS, how to solve this problem? Thanks.

in your program you ll have something like that
[STAThread]
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Form1());
}
You must close the Form passed as an argument in Application.Run in order to close your application. If we are speaking about Winforms.

C# application exits when I dispose

Basically I have a Login window which should close once the user logs in and show another window, for now I've just hid it(Form.Hide()) however I do not wish to take unnescesary system resources and I don't need the login window after I already logged in.
this is the code snippet where I perform the operation:
MainWindow w = new MainWindow();
TimeRegisterApI.Instance.Windows.Add(w.Text,w);
TimeRegisterApI.Instance.Windows[w.Text].Show();
this.Dispose();
Windows is a dictionary that stores references of forms with their title as the key.
TimeRegisterApi is a singleton.
Basically what happens is that my application exits after I login instead of just disposing the login window, when I want it to dispose(close and go to the garbage collector.)
I know that having the title as key might cause duplicate key entries but in my current design it's no problem.

You have to make your window form login as a modal form which parent is your mainform
it will allow you to wait an answer (like a savedialog) and return to your main window form)
this is your main form so you exist

ok I fixed the problem, basically what happens is that when the window that is run from program.cs at application.run(window) gets disposed it closes the program because it's the main window, I think it would be possible to do an e.cancel on the dispose event of this window, however I solved the problem by running the window in a new application.run like this:
from program.cs, relevant lines
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new LoginWindow());
start();
}
public static void start()
{
if (TimeRegisterApI.isLoggedIn())
{
MainWindow w = new MainWindow();
Application.Run(w);
}
}

Threads are still running in C#

I have 2 forms: signin and control_panel. After signin done I'm hiding this form by this.Hide() function and same time I am making new object of control_panel form and showing it by newobj.Show();. But when I am closing directly control_panel form, I am seeing first form thread are still running. I am closing it by stop_debugging button. How will I close every threads or whole program exit simultaneously.

The thread for your first form is still running because you're only calling this.Hide. All that does is hide the form; it doesn't close it. Instead, you need to use this.Close, which will close your original form.
If you want to make sure that your entire application exits, and in the process close any forms that may still be open, you can use the Application.Exit method anywhere in your form's code.
EDIT: To expand on my last comment, you might want something like this in your Program.cs file:
static class Program
{
/// <summary>
/// The main entry point for the application.
/// </summary>
[STAThread]
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
SignInForm frmSignIn = new SignInForm();
if (frmSignIn.ShowDialog() == DialogResult.Yes)
{
//If the sign-in completed successfully, show the main form
//(otherwise, the application will quit because the sign-in failed)
Application.Run(new ControlPanelForm());
}
}
}

Create a FormClosed event in control_panel form property window of control_panel and write the following line as
private void control_panel_FormClosed(object sender, FormClosedEventArgs e)
{
Application.Exit();
}