如何检测是否“按任意键继续。 。 "会显示吗？ [英] How can I detect if "Press any key to continue . . ." will be displayed?

问题描述

在Visual Studio中运行控制台应用程序时，根据您的设置，它会在程序退出后添加提示：

When running a console application in Visual Studio, depending on your settings, it will add a prompt after the program exits:

按任何继续的关键。 。 。

Press any key to continue . . .

我找到了如何检测我是否在调试器下运行（使用 Debugger.IsAttached ），但没有帮助。按 CTRL-F5 到启动而不调试将此标志设置为 false ，但仍显示提示。

I have found how to detect if I am running under the debugger(use Debugger.IsAttached), but it isn't helpful. Press CTRL-F5 to Start Without Debugging sets this flag to false, yet still shows the prompt.

我想检测这个，因为我想显示自己的消息并等待按键，但是不会加倍按键检查。

I want to detect this because I'd like to display my own message and wait for a keypress, but not double up keypress checks.

我不想使用我的常规Visual Studio设置。如果我可以用一种可以检查到源代码管理的方式为这个项目禁用它，那也可以。

I don't want to muck with my general Visual Studio settings. If I can disable it for this project in a way that can be checked into source control, that would also work.

使用什么机制要附加此提示，我该如何检测它？

What mechanism is used to append this prompt, and how do I detect it?

或者我如何为每个项目禁用它，并将此更改检查为源代码管理？

Or how do I disable it per-project, and check this change into source control?

推荐答案

将以下代码添加到控制台应用程序：

Add the following code to the console application:

public static class Extensions {
    [DllImport("kernel32.dll")]
    static extern IntPtr OpenThread(uint dwDesiredAccess, bool bInheritHandle, uint dwThreadId);

    [DllImport("kernel32.dll")]
    static extern bool TerminateThread(IntPtr hThread, uint dwExitCode);

    public static Process GetParentProcess(this Process x) {
        return (
            from it in (new ManagementObjectSearcher("root\\CIMV2", "select * from Win32_Process")).Get().Cast<ManagementObject>()
            where (uint)it["ProcessId"]==x.Id
            select Process.GetProcessById((int)(uint)it["ParentProcessId"])
            ).First();
    }

    public static IEnumerable<Process> GetChildProcesses(this Process x) {
        return (
            from it in (new ManagementObjectSearcher("root\\CIMV2", "select * from Win32_Process")).Get().Cast<ManagementObject>()
            where (uint)it["ParentProcessId"]==x.Id
            select Process.GetProcessById((int)(uint)it["ProcessId"])
            );
    }

    public static void Abort(this ProcessThread x) {
        TerminateThread(OpenThread(1, false, (uint)x.Id), 1);
    }
}

然后修改你的代码：

class Program {
    static void Main(String[] args) {
        // ... (your code might goes here)

        try {
            Process.GetCurrentProcess().GetParentProcess().Threads.Cast<ProcessThread>().Single().Abort();
        }
        catch(InvalidOperationException) {
        }

        Console.Write("Press ONLY key to continue . . . ");
        Console.ReadKey(true);
    }
}

因此，我们所期待的一切都已完成。我认为这是一种解决方案。它可以在 Windows XP SP3 下工作，我猜它可以用于较新的Windows操作系统。在 Visual Studio 下，应用程序始终是 衍生过程 。在较旧的 Visual C ++ 6.0 中，它由IDE通过调用 VCSPAWN.EXE 生成;在 Visual Studio 2010 中，当启动而不调试时，应用程序使用以下命令行运行：

So, everything we are expecting is done now. I consider this as a workaround solution. It works under Windows XP SP3 and I guess that it would work with newer Windows operating systems. Under Visual Studio, applications are always a spawned process. In older Visual C++ 6.0, it spawned by the IDE by calling VCSPAWN.EXE; in Visual Studio 2010, your application runs with following command line when Start Without Debugging:

％comspec％/ c您的应用程序文件名&暂停

"%comspec%" /c ""your application filename" & pause"

因此无法达到完全管理的方式;因为它在应用程序域下是 NOT 。

So it is impossible to reach the goal in fully managed ways; because it was NOT under the application domain.

这里我们使用 WMI 的托管方式来枚举进程，并封装非托管 WINAPI s来终止 ProcessThread ，因为 ProcessThread 不应该是通常流产;它提供了像只读的东西。

Here we use the managed way of WMI to enumerate the processes, and encapsulate the unmanaged WINAPIs to terminate the ProcessThreads, because the ProcessThread is not supposed to be normally aborted; it's provided like something for read-only.

如上所述，应用程序是使用特定的命令行生成的;它会 一个线程创建一个进程 签名，所以我们使用 Single（）方法来检索线程并终止它。

As mentioned above, the application was spawned with the particular command line; it would have a single thread creates a single process signature, so we used the Single() method to retrieve that thread and terminate it.

当我们在现有命令提示符下启动应用程序时，它与启动无调试的情况相同。此外，当开始调试时，应用程序进程由 devenv.exe 创建。它有很多线程，我们知道并且不会中止任何线程，只是提示并等待按键。这种情况类似于双击启动应用程序或从上下文菜单启动应用程序。这样，应用程序进程由系统shell创建，通常是 Explorer.exe ，它也有很多线程。

When we start the application under an existing command prompt, it is just the same scenario of Start Without Debugging. Moreover, when Start Debugging, the application process is created by devenv.exe. It has a lot of threads, we known that and won't abort any thread, just prompt and wait for a key press. This situation is similar to starting application with double-clicking or from context menu. This way, the application process is created by the system shell, usually Explorer.exe and it also has a lots of threads.

事实上，如果我们可以成功中止线程，则意味着我们有权杀死父进程。但我们需要 NOT 。我们只需要中止唯一的线程，当系统没有更多线程时，进程会自动终止。通过识别调用进程％comspec％来杀死父进程是另一种做同样事情的方法，但这是一个危险的过程。因为生成应用程序的进程可能具有其他线程，这些线程具有任意数量的线程，所以创建进程匹配％comspec％。你可能会粗心地杀死一个关键的过程工作，或者只是增加检查过程是否可以安全杀死的复杂性。所以我认为 一个线程创建一个进程 作为我们父进程的签名，可以安全地终止/中止。

In fact, if we can successfully abort the thread it implies that we have the permissions to kill the parent process. But we do NOT need to. We just need to abort the only thread, the process terminates automatically by system when it has no more threads. Killing the parent process by identifying that the calling process is %comspec%, is another way to do the same thing, but it's a dangerous procedure. Because the process spawning the application might have other threads which have any number of threads create a process matches %comspec%. You may kill a critical work of process with carelessness or just growing the complexity of checking whether the process is safe to kill. So I consider a single thread creates a single process as a signature of our parent process which is safe to kill/abort.

WMI 是现代的，一些 WINAPI 可能将来会被弃用。但这种构成的真正原因在于它的简单性。旧的工具帮助库是如此复杂，如将 ProcessThread 转换为的方法System.Threading .Thread 。使用LINQ和扩展方法，我们可以使代码更简单，更具语义。

WMI is modern, some of WINAPIs might become deprecated in the future. But the real reason of this composition is for its simplicity. The old Tool Help Library is such complicated like the ways to convert ProcessThread to System.Threading.Thread. With LINQ and extension methods, we can make the code simpler and more semantical.

这篇关于如何检测是否“按任意键继续。 。 "会显示吗？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！