如何通过Win32事件检测notepad.exe正常退出并实现自动保存？

Alright, let's break down how to make this work—you've got the IntPtr handle to a running notepad.exe process, and you want to run auto-save code only when it's closed normally (not crashed or force-terminated by the OS). Here's a practical, Win32-based approach:

1. Verify Your Process Handle Has the Right Permissions #

First, make sure your process handle includes the SYNCHRONIZE permission—this is required to monitor the process's state. If you didn't request this when you initially got the handle, re-open the process to get a valid handle:

// C# example; adjust syntax for C++/other languages as needed
const uint SYNCHRONIZE = 0x0010;
const uint PROCESS_QUERY_LIMITED_INFORMATION = 0x1000;

IntPtr validProcessHandle = OpenProcess(SYNCHRONIZE | PROCESS_QUERY_LIMITED_INFORMATION, false, targetProcessId);

2. Monitor the Process for Exit #

You have two solid options to detect when the process exits—pick the one that fits your app's threading model:

Option A: Synchronous Wait (For Background Threads) #

Spin up a background thread and use WaitForSingleObject to block until the process exits. This is simple but needs to run off your main thread to avoid blocking the UI:

uint waitResult = WaitForSingleObject(validProcessHandle, INFINITE);
if (waitResult == WAIT_OBJECT_0)
{
    // Process has exited—now check if it was a normal close
    CheckExitReasonAndRunAutoSave(validProcessHandle);
}

Option B: Asynchronous Callback (Non-Blocking) #

Use RegisterWaitForSingleObject to register a callback that triggers automatically when the process exits. This is better for apps that can't afford to block a thread:

WaitHandle processWaitHandle = new SafeWaitHandle(validProcessHandle, false);
ThreadPool.RegisterWaitForSingleObject(
    processWaitHandle,
    (state, timedOut) =>
    {
        if (!timedOut)
        {
            CheckExitReasonAndRunAutoSave(validProcessHandle);
        }
    },
    null,
    INFINITE,
    true // Only trigger once, since the process can't exit twice
);

3. Distinguish Normal Closure From Crashes/Termination #

Once the process exits, you need to confirm it closed normally. Check the exit code—normal exits usually return 0 (or a small non-negative value), while crashes/force-terminations return Windows error codes (like 0xC0000005 for access violations):

void CheckExitReasonAndRunAutoSave(IntPtr processHandle)
{
    if (GetExitCodeProcess(processHandle, out uint exitCode))
    {
        // Adjust this check based on your testing—Notepad normally returns 0 on clean close
        if (exitCode == 0 || (exitCode >= 0 && exitCode <= 0xFF))
        {
            // Execute your auto-save logic here
            PerformNotepadAutoSave();
        }
    }
}

Note: If you need ultra-precise detection (e.g., only trigger when the user clicks the close button, not when Notepad exits via other normal means), you'd need to hook Notepad's window messages (like WM_CLOSE or WM_DESTROY), which requires DLL injection or SetWindowsHookEx—that's more complex, but the exit code check works for most use cases.

4. Implement the Auto-Save Logic #

To save Notepad's content, you'll need to target its internal edit control and extract the text:

void PerformNotepadAutoSave()
{
    // Find Notepad's main window (you could also track this handle when you get the process)
    IntPtr notepadMainWindow = FindWindow("Notepad", null);
    if (notepadMainWindow != IntPtr.Zero)
    {
        // Find the edit control inside Notepad's window
        IntPtr editControl = FindWindowEx(notepadMainWindow, IntPtr.Zero, "Edit", null);
        if (editControl != IntPtr.Zero)
        {
            // Get the length of the text in the edit control
            int textLength = (int)SendMessage(editControl, WM_GETTEXTLENGTH, 0, 0);
            StringBuilder content = new StringBuilder(textLength + 1);
            
            // Extract the text
            SendMessage(editControl, WM_GETTEXT, content.Capacity, content);
            
            // Save to your desired location—e.g., a backup file
            File.WriteAllText(@"C:\temp\notepad_autosave.txt", content.ToString());
        }
    }
}

Critical Housekeeping #

• Don't forget to close the process handle when you're done with it to avoid resource leaks: CloseHandle(validProcessHandle)
• If you're using C#, wrap the handle in a SafeHandle to ensure it's cleaned up automatically
• Permission checks: If Notepad is running as administrator, your app will need admin privileges too to access its process handle

内容的提问来源于stack exchange，提问作者mcintyre321