1

我遇到了一个 C# 2008 Windows 应用程序未完成执行的问题,我正在尝试确定如何解决该问题。最初,C# 2010 控制台应用程序被编写为调用 C# 2008 控制台应用程序,后者又调用 Web 服务。我将这两个应用程序都更改为 windows 应用程序,因为我不希望 dos 弹出窗口。

问题是被调用的 C# 2008 windows 应用程序永远不会完成执行。该过程保留在内存中。

下面列出的代码是 C# 2010 应用程序代码的一部分。

private static Logger logger = LogManager.GetCurrentClassLogger(); 
try
{
    Process eProcess = new Process();
    strConsoleAppLocation = ConfigurationManager.AppSettings["client_location"];
    String Process_Arguments = null;
    eRPT_Process.StartInfo.UseShellExecute = false;
    eRPT_Process.StartInfo.FileName = strConsoleAppLocation;
    Process_Arguments = " 1 CLI";
    eProcess.StartInfo.Arguments = Process_Arguments;
    eProcess.Start();
    eProcess.WaitForExit(1800);
    Process_Arguments = null;
    eProcess.StartInfo.UseShellExecute = false;
    Process_Arguments = " 2 TIM";
    eProcess.StartInfo.Arguments = Process_Arguments;
    eProcess.Start();
    eProcess.WaitForExit(1800);
    eProcess.Dispose();
    Process_Arguments = null;
}
catch (Exception e)
{
    logger.Error(e.Message + "\n" + e.StackTrace);
} 

我知道 C# 2008 应用程序永远不会通过查看内存中的进程来完成。此外,如果我将代码行更改为以下:eProcess.WaitForExit();,应用程序永远不会返回到被调用的程序。

在 C# 2008 调用的应用程序中,执行的最后一行代码如下:

Environment.Exit(1);   

因此,为了解决这个问题,我有以下问题:

  1. 如果您对如何更改我上面列出的代码有建议,请告诉我您的建议是什么?

  2. 由于这两个程序现在正在生产中,我想知道您是否有关于如何解决此问题以进行“创可贴”修复的建议?有没有办法让我在 C# 2010 程序完成执行时停止正在运行的 C# 2008 进程?有没有办法让 C# 2008 应用程序在完成执行后杀死自己的进程?如果是这样,你能告诉我如何解决这个问题的代码吗?

  3. 对于长期修复,您能告诉我如何确定为什么 C# 2008 进程不会停止以及如何修复它?我会使用分析器,但是我的公司只有 Visual Studio 2010 的专业版。所以你能告诉我你的建议是什么吗?

4

4 回答 4

3

WaitForExit(),即无限期地等待它等待结束的进程,而WaitForExit(int milliseconds)等待指定的持续时间然后超时。

根据您编写的内容,您从 C# 2010 程序启动的 C# 2008 程序永远不会终止。这可能是由于几个原因。

  • 它可能正在等待用户输入。

  • 它可能会陷入无限循环。

  • 如果它是多线程的,则其中一个线程可能尚未完成执行,这会使进程保持活动状态(以防线程未设置为后台线程)。

尝试直接从命令行运行它,看看它在做什么。

如果从命令行执行时 C# 2008 程序的行为是正确的/符合预期,但从 C# 2010 程序执行时行为不同,则验证两种情况下的参数是否匹配。

您可以使用pskill杀死正在运行的进程。您可以执行以下操作:

if (!process.WaitForExit(1800))
{
    // launch a process for pskill to kill the C# 2008 program
}

最后,您可以通过打开 C# 解决方案/项目然后使用Attach to Process命令来调试正在运行的程序,您可以Debug在 Visual Studio 的菜单栏项下找到该命令。

于 2013-02-16T11:04:21.093 回答
0
  1. 不,您不能直接在代码中键入 pskill。您将不得不启动一个进程,就像您目前使用 System.Diagnostics.Process 类为 C# 2008 程序所做的那样。

  2. 您是对的,您将使用 Visual Studio 附加到该过程,无论项目是在哪个版本中创建的。打开程序的解决方案后,单击Debug\Attach to Process。它将显示您机器上正在运行的进程的列表。其中一列(通常是第一列)显示可执行文件的名称,它将与您的 C# 2008 应用程序的名称相匹配。Attach在列表中选择 C# 2008 程序,然后在可疑代码行上放置断点后单击按钮。

  3. 我不确定你的意思。

  4. 调试几乎是您能够弄清楚发生了什么的唯一方法。

我刚刚在重新阅读您的问题时注意到的最后一件事。您已将 C# 2008 应用程序转换为 Windows 应用程序,对吗?那不是你想要的。Windows 应用程序必须以某种方式终止并需要交互。您应该将这两个应用程序转换回控制台应用程序,并确保在创建Process对象以启动 C# 2008 应用程序时,将构造函数的参数CreateNoWindow属性设置为 true。ProcessStartInfoProcess

所以,像:

public class Processor
{
    private static Logger logger = LogManager.GetCurrentClassLogger();

    private ProcessStartInfo MakeProcessStartInfo(string fileName, string arguments)
    {
        return new ProcessStartInfo
        {
            CreateNoWindow = true,
            UseShellExecute = false,
            FileName = fileName,
            Arguments = appArguments
        };
    }

    public void CallExternalApplications()
    {
        try
        {
            var fileName = ConfigurationManager.AppSettings["client_location"];

            using (var process = new Process { StartInfo = MakeProcessStartInfo(fileName, " 1 CLI") })
            {
                process.Start();

                if (!process.WaitForExit(1800))
                {
                    // create a Process here for pskill to kill the "process" using process.Id.
                }
            }

            using (var process = new Process { StartInfo = MakeProcessStartInfo(fileName, " 2 TIM") })
            {
                process.Start();

                if (!process.WaitForExit(1800))
                {
                    // create a Process here for pskill to kill the "process" using process.Id.
                }
            }
        }
        catch (Exception e)
        {
            // you really should be using logger.ErrorException(e.Message, e) here
            // and be using the ${exception} layoutrenderer in the layout in the NLog.config file
            logger.Error(e.Message + "\n" + e.StackTrace);
        }
    }
}

您可能可以进一步重构此代码,因为我正在重复创建process对象的代码。我使用了一个using块来隐式调用Dispose对象process;这使代码更清晰,更具可读性。

关键是设置对象的CreateNoWindow属性ProcessStartInfo,一旦您将应用程序从 Windows 应用程序转换回控制台应用程序,这将阻止控制台窗口弹出。

于 2013-02-16T23:13:29.237 回答
0

这是我将 ctrl-c 发送到进程的解决方案。仅供参考,我从来没有process.WaitForExit工作过。

不是使用 GenerateConsoleCtrlEvent,而是我发现将 CTRL-C 发送到进程的方法。仅供参考,在这种情况下,我不需要找到组进程 ID。

using System;
using System.Diagnostics;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

public class ConsoleAppManager
{
    private readonly string appName;
    private readonly Process process = new Process();
    private readonly object theLock = new object();
    private SynchronizationContext context;
    private string pendingWriteData;

    public ConsoleAppManager(string appName)
    {
        this.appName = appName;

        this.process.StartInfo.FileName = this.appName;
        this.process.StartInfo.RedirectStandardError = true;
        this.process.StartInfo.StandardErrorEncoding = Encoding.UTF8;

        this.process.StartInfo.RedirectStandardInput = true;
        this.process.StartInfo.RedirectStandardOutput = true;
        this.process.EnableRaisingEvents = true;
        this.process.StartInfo.CreateNoWindow = true;

        this.process.StartInfo.UseShellExecute = false;

        this.process.StartInfo.StandardOutputEncoding = Encoding.UTF8;

        this.process.Exited += this.ProcessOnExited;
    }

    public event EventHandler<string> ErrorTextReceived;
    public event EventHandler ProcessExited;
    public event EventHandler<string> StandartTextReceived;

    public int ExitCode
    {
        get { return this.process.ExitCode; }
    }

    public bool Running
    {
        get; private set;
    }

    public void ExecuteAsync(params string[] args)
    {
        if (this.Running)
        {
            throw new InvalidOperationException(
                "Process is still Running. Please wait for the process to complete.");
        }

        string arguments = string.Join(" ", args);

        this.process.StartInfo.Arguments = arguments;

        this.context = SynchronizationContext.Current;

        this.process.Start();
        this.Running = true;

        new Task(this.ReadOutputAsync).Start();
        new Task(this.WriteInputTask).Start();
        new Task(this.ReadOutputErrorAsync).Start();
    }

    public void Write(string data)
    {
        if (data == null)
        {
            return;
        }

        lock (this.theLock)
        {
            this.pendingWriteData = data;
        }
    }

    public void WriteLine(string data)
    {
        this.Write(data + Environment.NewLine);
    }

    protected virtual void OnErrorTextReceived(string e)
    {
        EventHandler<string> handler = this.ErrorTextReceived;

        if (handler != null)
        {
            if (this.context != null)
            {
                this.context.Post(delegate { handler(this, e); }, null);
            }
            else
            {
                handler(this, e);
            }
        }
    }

    protected virtual void OnProcessExited()
    {
        EventHandler handler = this.ProcessExited;
        if (handler != null)
        {
            handler(this, EventArgs.Empty);
        }
    }

    protected virtual void OnStandartTextReceived(string e)
    {
        EventHandler<string> handler = this.StandartTextReceived;

        if (handler != null)
        {
            if (this.context != null)
            {
                this.context.Post(delegate { handler(this, e); }, null);
            }
            else
            {
                handler(this, e);
            }
        }
    }

    private void ProcessOnExited(object sender, EventArgs eventArgs)
    {
        this.OnProcessExited();
    }

    private async void ReadOutputAsync()
    {
        var standart = new StringBuilder();
        var buff = new char[1024];
        int length;

        while (this.process.HasExited == false)
        {
            standart.Clear();

            length = await this.process.StandardOutput.ReadAsync(buff, 0, buff.Length);
            standart.Append(buff.SubArray(0, length));
            this.OnStandartTextReceived(standart.ToString());
            Thread.Sleep(1);
        }

        this.Running = false;
    }

    private async void ReadOutputErrorAsync()
    {
        var sb = new StringBuilder();

        do
        {
            sb.Clear();
            var buff = new char[1024];
            int length = await this.process.StandardError.ReadAsync(buff, 0, buff.Length);
            sb.Append(buff.SubArray(0, length));
            this.OnErrorTextReceived(sb.ToString());
            Thread.Sleep(1);
        }
        while (this.process.HasExited == false);
    }

    private async void WriteInputTask()
    {
        while (this.process.HasExited == false)
        {
            Thread.Sleep(1);

            if (this.pendingWriteData != null)
            {
                await this.process.StandardInput.WriteLineAsync(this.pendingWriteData);
                await this.process.StandardInput.FlushAsync();

                lock (this.theLock)
                {
                    this.pendingWriteData = null;
                }
            }
        }
    }
}

然后,在我的主应用程序中实际运行进程并发送 CTRL-C:

            DateTime maxStartDateTime = //... some date time;
            DateTime maxEndDateTime = //... some later date time
            var duration = maxEndDateTime.Subtract(maxStartDateTime);
            ConsoleAppManager appManager = new ConsoleAppManager("myapp.exe");
            string[] args = new string[] { "args here" };
            appManager.ExecuteAsync(args);
            await Task.Delay(Convert.ToInt32(duration.TotalSeconds * 1000) + 20000);

            if (appManager.Running)
            {
                // If stilll running, send CTRL-C
                appManager.Write("\x3");
            }

详情请参见重定向控制台应用程序的标准输入Windows如何获取已经在运行的进程的进程组?

于 2018-05-12T22:54:03.760 回答
-1

这就像一个魅力

而不是process.WaitForExit()我使用这种方法:

while (!process.StandardOutput.EndOfStream)
{
    Console.WriteLine(process.StandardOutput.ReadLine());
}
于 2017-06-27T00:53:07.607 回答