C# 我可以在现有进程上执行代码吗？

我有一个在系统托盘图标中连续运行的应用程序。它通过运行一些使用@Global互斥体的代码来确保它是我的应用程序的唯一运行实例

由于第三方供应商的限制，我可以与供应商应用程序的一部分集成的唯一（合理）方法是在配置文件中指定调用任意命令行可执行文件。我关心的参数会自动添加到我指定的可执行文件中

因此，我认为与此集成的大多数人运行一个单独的程序，该程序连接到主程序上的服务器套接字，并发送一个数据包，让主程序知道命令行已被触发

我想知道是否有一种方法可以实现这个伪代码

    static void Main(string[] args)
    {
        if (isrunningcommandLine)
        {
            ConnectToAlreadyRunningProcessAndPassInfo(args); // find already running process by its process name and somehow pass the command line params
            KillProgram();
        }
        else
        {
            CheckGlobalMutexAndStart();
        }
    }

基本上，如果我通过命令行运行，请连接到已经运行的全局进程并向其传递一些数据

---

我控制客户端和服务器的代码，它们实际上是同一个项目。

您可以使用全局命名互斥来检测应用程序是否已经运行

• 如果否运行服务器，接收并管理命令
• 如果yes运行客户机并将命令发送到服务器

然后在本地主机上使用TCP连接来交换消息

    using System;
    using System.Net;
    using System.Net.Sockets;
    using System.Text;
    using System.Threading;

    namespace Test42
    {
        internal static class Program
        {
            private static int PORT = 1337;

            private static void Main()
            {
                bool ok;

                // Try to build a mutex.
                var mutex = new Mutex(true, @"Test42", out ok);

                // If build is ok, we run as a server. 
                // Otherwise, the server is already running, so we run as a client.
                if (ok)
                {
                    var server = new MyServer(PORT);
                    server.Start();
                }
                else
                {
                    var r = new Random();
                    var message = "Ho Hey : " + r.Next(50);

                    var client = new MyClient();
                    client.Send(PORT, message);
                }
            }
        }

        internal class MyClient
        {
            /// <summary>
            /// Send a message to localhost.
            /// </summary>
            /// <param name="port">The port to connect.</param>
            /// <param name="message">The message to send.</param>
            public void Send(int port, string message)
            {
                var client = new TcpClient();
                var serverEndPoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), port);

                client.Connect(serverEndPoint);

                using (var stream = client.GetStream())
                {
                    var messageBuffer = Encoding.Unicode.GetBytes(message);
                    var lengthBuffer = BitConverter.GetBytes(messageBuffer.Length);

                    // Send message length.
                    stream.Write(lengthBuffer, 0, lengthBuffer.Length);

                    // Send message.
                    stream.Write(messageBuffer, 0, messageBuffer.Length);

                    stream.Flush();
                }

                client.Close();
            }
        }

        internal class MyServer
        {
            private readonly int _port;

            public MyServer(int port)
            {
                _port = port;
            }

            public void Start()
            {
                Console.WriteLine("wait for messages");
                var thread = new Thread(ThreadStart);
                thread.Start();
            }

            private void ThreadStart()
            {
                var listener = new TcpListener(IPAddress.Any, _port);
                listener.Start();
                while (true)
                {
                    var client = listener.AcceptTcpClient();
                    var clientThread = new Thread(ClientThreadStart);
                    clientThread.Start(client);
                }
            }

            private void ClientThreadStart(object obj)
            {
                var client = obj as TcpClient;
                if (client == null) return;

                using (var stream = client.GetStream())
                {
                    const int lengthLength = sizeof(int) / sizeof(byte);

                    // Read the message length.
                    var lengthBuffer = new byte[lengthLength];
                    stream.ReadAsync(lengthBuffer, 0, lengthLength).Wait();
                    var messageLength = BitConverter.ToInt32(lengthBuffer, 0);

                    // Read the message.
                    var messageBuffer = new byte[messageLength];
                    stream.ReadAsync(messageBuffer, 0, messageLength).Wait();
                    var message = Encoding.Unicode.GetString(messageBuffer);

                    Console.WriteLine("Client says: " + message);
                }

                client.Close();
            }
        }
    }

使用系统；
Net系统；
使用System.Net.Sockets；
使用系统文本；
使用系统线程；
名称空间Test42
{
内部静态类程序
{
专用静态int端口=1337；
私有静态void Main（）
{
布尔ok；
//尝试构建互斥体。
var mutex=新的mutex（true，@“Test42”，out ok）；
//如果构建正常，我们将作为服务器运行。
//否则，服务器已经在运行，所以我们作为客户机运行。
如果（确定）
{
var server=新的MyServer（端口）；
server.Start（）；
}
其他的
{
var r=新的随机变量（）；
var message=“hohey:”+r.Next（50）；
var client=new MyClient（）；
发送（端口、消息）；
}
}
}
内部类MyClient
{
/// 
///向本地主机发送消息。
/// 
///要连接的端口。
///要发送的消息。
公共void发送（int端口，字符串消息）
{
var client=new TcpClient（）；
var serverEndPoint=newipendpoint（IPAddress.Parse（“127.0.0.1”），端口）；
Connect（serverEndPoint）；
使用（var stream=client.GetStream（））
{
var messageBuffer=Encoding.Unicode.GetBytes（消息）；
var lengthBuffer=BitConverter.GetBytes（messageBuffer.Length）；
//发送消息长度。
写入（lengthBuffer，0，lengthBuffer.Length）；
//发送消息。
stream.Write（messageBuffer，0，messageBuffer.Length）；
stream.Flush（）；
}
client.Close（）；
}
}
内部类MyServer
{
专用只读int_端口；
公共MyServer（int端口）
{
_端口=端口；
}
公开作废开始（）
{
Console.WriteLine（“等待消息”）；
var thread=新线程（ThreadStart）；
thread.Start（）；
}
私有void ThreadStart（）
{
var listener=new TcpListener（IPAddress.Any，_port）；
listener.Start（）；
while（true）
{
var client=listener.AcceptTcpClient（）；
var clientThread=新线程（ClientThreadStart）；
clientThread.Start（客户端）；
}
}
私有void ClientThreadStart（对象obj）
{
var客户端=作为TCP客户端的obj；
if（client==null）返回；
使用（var stream=client.GetStream（））
{
常量int lengthLength=sizeof（int）/sizeof（字节）；
//阅读信息长度。
var lengthBuffer=新字节[lengthLength]；
ReadAsync（lengthBuffer，0，lengthLength）.Wait（）；
var messageLength=BitConverter.ToInt32（lengthBuffer，0）；
//阅读信息。
var messageBuffer=新字节[messageLength]；
ReadAsync（messageBuffer，0，messageLength.Wait（）；
var message=Encoding.Unicode.GetString（messageBuffer）；
Console.WriteLine（“客户说：”+消息）；
}
client.Close（）；
}
}
}

将行为注入到另一个进程/窗口通常是被禁止的，但并非不可能，因为我们一直在使用此处找到的UITesting命名空间：还有其他方法，但正如您所提到的，我所知道的所有方法都要求对该进程进行操作，以了解改变其行为的某些情况。尤其是C++中有一组类，称为IPC（进程间通信）类，它正好符合您的需要。问题是客户端和其他pgm。必须准备好接收消息。您编写了一个托盘图标应用程序，需要通过命令行与另一个应用程序通信？服务器套接字与它有什么关系？到底是什么问题？是的，有可能。您所需要的只是运行实例的一个众所周知的端点，它的命令行调用可以连接到该端点。有亩