Develop Reference

Wait until "Write complete"

"simple" question to the "streamer guy's there". My program starts SQL backup processes in single tasks, for any backup per DB.
All the tasks start one by one after the first task finished. But, when the SQL backup command goes to the SQL server, than the process to write the backupfile takes more time then task takes to finish. At this moment, the user can close the program and skip the backupprocess to the big DB files.
Is there a way to block my programm from closing, until every single backupfile is completly written to the HDD?

You can handle the Closing of the Window like this:
private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
{
if (BackupStillRunning)
e.Cancel = true;
else
e.Cancel = false;
}
What you should do though is ask the user if he really wants to quit, something like this:
private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
{
if (BackupStillRunning)
{
if (MessageBox.Show("The backup is still running, if you close the application, the backup will be cancelled. Do you want to proceed?", "Caption", MessageBoxButton.YesNo) == MessageBoxResult.Yes)
e.Cancel = true;
}
else
{
e.Cancel = false;
}
}
Simply not letting the user close the application will quickly get frustrating. If you really dont want the user to close the application, you should at least show a message explaining why.
As Damien_The_Unbeliever pointed out, there is no way to completely prevent the application from shutting down.

C#: Run process and then kill it using a button

I hope that you can help me with this one, my C# is very rusty.
I'm running an executable when the form loads.
private void Form1_Load(object sender, EventArgs e)
{
ProcessStartInfo exe = new ProcessStartInfo();
exe.Arguments = "arguments";
exe.FileName = "file.exe";
Process.Start(exe);
}
And I would like to kill that process using a button, but I don't know how to achieve that.
private void button1_Click(object sender, EventArgs e)
{
}
Thanks.

Process.Start returns an object of type Process. You can save it into variable, then use the method Kill, which Immediately stops the associated process (msdn)
For example declare a field at Form1 level:
class Form1
{
private Process process;
private void Form1_Load(object sender, EventArgs e)
{
//running notepad as an example
process = Process.Start("notepad");
}
//and then at button handler kill that process
private void button1_Click(object sender, EventArgs e)
{
//consider adding check for null
process.Kill();
}
}

You should call Process.CloseMainWindow which performs an orderly termination of the process and closes all windows. As opposed to Process.Kill which causes abnormal termination. CloseMainWindow is preferable for applications with a user interface.
process = Process.Start(exe);//in form load set field
private void button1_Click(object sender, EventArgs e)
{
process.CloseMainWindow();
}
The remarks on MSDN reveals important information regarding the asynchronous behavior and other relevant details.
Kill forces a termination of the process, while CloseMainWindow only
requests a termination. When a process with a graphical interface is
executing, its message loop is in a wait state. The message loop
executes every time a Windows message is sent to the process by the
operating system. Calling CloseMainWindow sends a request to close to
the main window, which, in a well-formed application, closes child
windows and revokes all running message loops for the application. The
request to exit the process by calling CloseMainWindow does not force
the application to quit. The application can ask for user verification
before quitting, or it can refuse to quit. To force the application to
quit, use the Kill method. The behavior of CloseMainWindow is
identical to that of a user closing an application's main window using
the system menu. Therefore, the request to exit the process by closing
the main window does not force the application to quit immediately.
etc...

try this
try
{
Process [] proc Process.GetProcessesByName("notepad");
proc[0].Kill();
}

C# Explicity throw an error on Process.Start()

I'm a C# beginner and I have made a little launcher for a game and to start it, I'm using this button event:
private void button5_MouseClick(object sender, MouseEventArgs e)
{
Process.Start("engine.exe", "/load /config debug");
Application.Exit();
}
As you can see this also uses Application.Exit() to close the launcher when the game starts, because they are separate.
What I want to know is if my method is good to start the game + close launcher and also,
I would like to know how to make a pop up message saying "Engine.exe not found" when I'm clicking the button and engine.exe is missing.
Thanks!

try
{
Process.Start("engine.exe", "/load /config debug");
Application.Exit();
}
catch(FileNotFoundException e)
{
MessageBox.Show(e.Message);
}

Preventing the application from leaving the file operation in the middle and exiting

I'm making something that writes data to a file. Now the problem I'm facing is that the application exits and the file writing operation is left hanging midway. As in I want a set of things to be either written completely or none. But the application exits and only half of it is written sometimes. Any suggestions on what I'm doing wrong here? Thanks.

There isn't much to go on here... but...
Are you properly flushing your file stream?
It could be you're finishing your program just fine, but closing it before you're fully written.

try {
// Open file, start writing...
}
catch (Exception e)
{
// Close file and discard it (if that's what you want), log error with e.ToString()
}
// Close file

Let's take WinForm as an example. When users click the X button in the top-right corner(or some other buttons hence the exit), in the click event(or some other event like Form_Closing), check the status of the File_Operation_Thread(I assume you have such a Thread/BackgroundWorker to operate the file, otherwise your UI will be hanging). If the thread is running, show a dialog with Wait/Cancel button saying "The operation is being processing". The final implementation looks like:
BackgroundWorker worker = new BackgroundWorker();
void WriteButton_Clicked(object sender, EventArgs args)
{
//start writing to the file asynchronously, something like
//worker.DoWork += (s,e) => { /*writing to file*/ };
}
void ExitButton_Clicked(object sender, EventArgs args)
{
if (worker.IsBusy)
{
//show a dialog window
if (CANCEL)
{
worker.CancelAsync();
//but rolling the changes back is a nightmare!!
}
else
{
//exit the applcation when worker.RunWorkerCompleted
}
}
}

You probably have an exception that is caught and "eaten" by a try/catch block. Try to activate the handling of exceptions by the debugger (Debug->Exceptions->Common Language Runtime, and select both the check boxes).

Why would Application.Exit fail to work?

I have an application that has been getting strange errors when canceling out of a dialog box. The application can't continue if the box is cancelled out of, so it exits, but it is not working for some reason, and thus it keeps running and crashes.
I debugged this problem, and somehow the application runs right past the Application.Exit call. I'm running in Debug mode, and this is relevant because of a small amount of code that depends on the RELEASE variable being defined. Here is my app exit code. I have traced the code and it entered the ExitApp method, and keeps on going, returning control to the caller and eventually crashing.
This is an application which provides reports over a remote desktop connection, so that's why the exit code is a bit weird. Its trying to terminate the remote session, but only when running under release because I don't want to shut down my dev machine for every test run.
private void ExitApp()
{
HardTerminalExit();
Application.Exit();
}
// When in Debug mode running on a development computer, this will not run to avoid shutting down the dev computer
// When in release mode the Remote Connection or other computer this is run on will be shut down.
[Conditional("RELEASE")]
private void HardTerminalExit()
{
WTSLogoffSession(WTS_CURRENT_SERVER_HANDLE, WTS_CURRENT_SESSION, false);
}
I've run a debugger right past the Application.Exit line and nothing happens, then control returns to the caller after I step past that line.
What's going on? This is a Windows Forms application.

This is an article which expands on the same train of thought you are going through: http://www.dev102.com/2008/06/24/how-do-you-exit-your-net-application/
Basically:
Environment.Exit - From MSDN: 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.
Application.Exit - From MSDN: 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. There are some more
issues about this method, read about
it in the MSDN page.
Another discussion of this: Link
This article points out 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)
{
// Use this since we are a WinForms app
System.Windows.Forms.Application.Exit();
}
else
{
// Use this since we are a console app
System.Environment.Exit(1);
}

Having had this problem recently (that Application.Exit was failing to correctly terminate message pumps for win-forms with Application.Run(new Form())), I discovered that if you are spawning new threads or starting background workers within the constructor, this will prevent Application.Exit from running.
Move all 'RunWorkerAsync' calls from the constructor to a form Load method:
public Form()
{
this.Worker.RunWorkerAsync();
}
Move to:
public void Form_Load(object sender, EventArgs e)
{
this.Worker.RunWorkerAsync();
}

Try Environment.Exit(exitCode).

I have went though this situation in many cases I use Thread.CurrentThread.Abort()
and the process is closed. It seems that Application.Exit isn't hooking up properly with current thread.

Also ensure any threads running in your application have the IsBackground property set to true. Non-background threads will easily block the application from exiting.

Make sure you have no Console.ReadLine(); in your app and Environment.Exit(1); will work and close your app.

I created the following that will exit the app anywhere. You don't have to worry if the Form is running or not, the test determines that and calls appropriate Exit.
public void exit(int exitCode)
{
if (System.Windows.Forms.Application.MessageLoop)
{
// Use this since we are a WinForms app
System.Windows.Forms.Application.Exit()
}
else
{
// Use this since we are a console app
System.Environment.Exit(exitCode);
}
} //* end exit()

Is this application run (in the Main method) using Application.Run()? Otherwise, Application.Exit() won't work.
If you wrote your own Main method and you want to stop the application, you can only stop by returning from the Main method (or killing the process).

Try this :
in Program.cs file :
after Application.Run(new form());
add Application.Exit();

private void frmLogin_FormClosing(object sender, FormClosingEventArgs e)
{
if (e.CloseReason == CloseReason.UserClosing)
{
DialogResult result = MessageBox.Show("Do you really want to exit?", "Dialog Title", MessageBoxButtons.YesNo);
if (result == DialogResult.Yes)
{
Environment.Exit(0);
}
else
{
e.Cancel = true;
}
}
else
{
e.Cancel = true;
}
}