How can I make my C# app erase itself (self-destruct)? Here's two ways that I think might work:
- Supply another program that deletes the main program. How is this deleter program deleted then, though?
- Create a process to CMD that waits a few seconds then deletes your file. During those few seconds, you close your application.
Both of those methods seem inefficient. I have a feeling that there's some built-in flag or something in Windows that allows for such stuff. How should I do it? Also, can you provide some sample code?
UPDATE: Thanks for all your answers! I'm going to try them, and see where that gets me.
First of all, some people have asked why I'd want my app to do this. Here's the answer: a few days ago, I read the Project Aardvark spec that Joel Spolsky posted on his blog, and it mentioned that the client app would delete itself after the remote session. I'm wondering how this works, and how, if I ever need to do this, I can accomplish such a feat.
Here's a little overview of what's been suggested:
- Create a registry entry that tells Windows to delete the file on reboot
- Launch CMD with a ping command to wait a few seconds and then delete the file
Both of those, of course, have their disadvantages, as outlined in the comments.
However, would such a method as outlined below work?
There are two executables: Program.exe and Cleaner.exe. The former is the program itself, the latter is the app that deletes Program.exe and itself (if it's loaded into memory, as I'm about to explain). Is it possible for Program.exe (which has dependencies) to load all of Cleaner.exe, which doesn't have any dependencies, into memory and run it?
If this is possible, could Cleaner.exe be packaged inside Program.exe, loaded into memory, and run?
There's a great CodeProject Article about this topic.
Edit: Basically it's a simple cmd-call which will delete the specified files after some seconds.
There is also
FileOptions.DeleteOnClose
, but that requires the file to be open for writing. You might be able to do it with a sequence like this (untested):Original.exe
, and detects (from its own name) that it needs to trigger the self-destruct function.Original.exe
creates a new fileTemp.exe
withFileOptions.DeleteOnClose
and copies its own content into it, but does not close it yetOriginal.exe
opens a second, read-only handle toTemp.exe
and closes the first write handle. The read-only handle can co-exist with an execute handle, whilst keeping the file open to delay auto-deletion.Original.exe
launchesTemp.exe
.Temp.exe
detects that it has been launched from the temp directory and bypasses the self-destruct sequence and continues normal operation.Original.exe
exits (taking its read-only handle toTemp.exe
with it.)Temp.exe
continues running. When it exits, the fileTemp.exe
will no longer be in use so it will be deleted automatically.Edit #2: Actually I don't think this is possible, because it relies on the kernel opening the file with the
FILE_SHARE_DELETE
flag, which is unlikely.There's a MoveFileEx API, which, when given a
MOVEFILE_DELAY_UNTIL_REBOOT
flag, will delete specified file on next system startup.Since my application (a Windows Service) is installed via the Windows Installer, I self-delete using this:
Sorry--it's in VB, but it should be easily convertible to C#.