在应用程序之间发送信息

Send information between applications

美好的一天,

我有一个客户端应用程序,它向服务器发送客户端打开的应用程序列表。它特别发送文件路径、文件名和主机名。我的问题是发送的数据在服务器接收时应该进行序列化和反序列化。我是 C# 的新手,所以我对序列化知之甚少。

这是客户端

private List<int> listedProcesses = new List<int>();
        private void SendData()
        {
            String processID = "";
            String processName = "";
            String processPath = "";
            String processFileName = "";
            String processMachinename = "";

            listBox1.BeginUpdate();
            try
            {   
                piis = GetAllProcessInfos();
                for (int i = 0; i < piis.Count; i++)
                {
                    try
                    {
                        if (!listedProcesses.Contains(piis[i].Id)) //placed this on a list to avoid redundancy
                        {
                            listedProcesses.Add(piis[i].Id);
                            processID = piis[i].Id.ToString();
                            processName = piis[i].Name.ToString();
                            processPath = piis[i].Path.ToString();
                            processFileName = piis[i].FileName.ToString();
                            processMachinename = piis[i].Machinename.ToString();
                            output.Text += "\n\nSENT DATA : \n\t" + processFileName + "\n\t" + processMachinename + "\n\t" + processID + "\n\t" + processName + "\n\t" + processPath + "\n";
                        }

                    }
                    catch (Exception ex)
                    {
                        wait.Abort();
                        output.Text += "Error..... " + ex.StackTrace;

                    }

                    NetworkStream ns = tcpclnt.GetStream();
                    String data = "";
                    data = "--++" + "  " + processFileName + " " + processMachinename + " " + processID + " " + processPath;
                    if (ns.CanWrite)
                    {
                        byte[] bf = new ASCIIEncoding().GetBytes(data);
                        ns.Write(bf, 0, bf.Length);
                        ns.Flush();
                    }
                }
            }
            finally
            {
                listBox1.EndUpdate();
            } 
        }

        private void cmd_dis_Click(object sender, EventArgs e)
        {
            if (wait != null)
            {
                wait.Abort();
                //read.Close(2000);
            }

            IPAddress ipclient = Dns.GetHostByName(Dns.GetHostName()).AddressList[0];
            String ipclnt = "+@@+" + ipclient.ToString();
            NetworkStream ns = tcpclnt.GetStream();
            if (ns.CanWrite)
            {
                byte[] bf = new ASCIIEncoding().GetBytes(ipclnt);
                ns.Write(bf, 0, bf.Length);
                ns.Flush();
            }

            tcpclnt.Close();
           // read.Close();
            Application.Exit();
        }

        private void listBox1_SelectedIndexChanged(object sender, EventArgs e)
        {
            ProcessInfoItem pii = piis.FirstOrDefault(x => x.Id == (int)(sender as ListBox).SelectedValue);
            if (pii != null)
            {
                string hostName = System.Net.Dns.GetHostName();

                textBox4.Text = listBox1.SelectedValue.ToString();
                textBox5.Text = (pii.FileName);
                textBox6.Text = (pii.Path);
                textBox7.Text = (pii.Machinename);
            }
        }

        private List<ProcessInfoItem> piis = new List<ProcessInfoItem>();
        private void Form1_Load(object sender, EventArgs e)
        {
            piis = GetAllProcessInfos();
            listBox1.DisplayMember = "Name";
            listBox1.ValueMember = "Id";
            listBox1.DataSource = piis;

        }
        private List<ProcessInfoItem> GetAllProcessInfos()
        {

            List<ProcessInfoItem> result = new List<ProcessInfoItem>();
            Process currentProcess = Process.GetCurrentProcess();
            Process[] processes = Process.GetProcesses();
            foreach (Process p in processes)
            {
                if (!String.IsNullOrEmpty(p.MainWindowTitle))
                {
                    //ProcessInfoItem pii = new ProcessInfoItem(p.Id, p.MainModule.ModuleName, p.MainModule.FileName, p.MainWindowTitle);
                    ProcessInfoItem pii = new ProcessInfoItem(p.Id, p.MainModule.ModuleName, p.MainWindowTitle, p.MainModule.FileName, Environment.MachineName);
                    result.Add(pii);
                }
            }
            return result;
        }
        public class ProcessInfoItem
        {
            public int Id { get; set; }
            public string Name { get; set; }
            public string FileName { get; set; }
            public string Path { get; set; }
            public string Machinename { get; set; }
            public ProcessInfoItem(int id, string name, string filename, string path, string machinename)
            {
                this.Id = id;
                this.Name = name;
                this.FileName = filename;
                this.Path = path;
                this.Machinename = machinename;
            }
        }

这是需要反序列化的服务器

  private void recieveData()
        {
            NetworkStream nStream = tcpClient.GetStream();
            ASCIIEncoding ascii = null;
            while (!stopRecieving)
            {
                if (nStream.CanRead)
                {
                    byte[] buffer = new byte[1024];
                    nStream.Read(buffer, 0, buffer.Length);
                    ascii = new ASCIIEncoding();
                    recvDt = ascii.GetString(buffer);
                    /*Received message checks if it has +@@+ then the ip is disconnected*/
                    bool f = false;
                    f = recvDt.Contains("+@@+");
                    if (f)
                    {
                        string d = "+@@+";
                        recvDt = recvDt.TrimStart(d.ToCharArray());
                        clientDis();
                        stopRecieving = true;
                    }

                    //else if (recvDt.Contains("^^"))
                    //{
                    //    new Transmit_File().transfer_file(file, ipselected);
                    //}
                    /* ++-- shutsdown/restrt/logoff/abort*/
                    else if (recvDt.Contains("++--"))
                    {
                        string d = "++--";
                        recvDt = recvDt.TrimStart(d.ToCharArray());
                        this.Invoke(new rcvData(addToOutput));
                        clientDis();
                    } 
                    /*--++ Normal msg*/
                    else if (recvDt.Contains("--++"))
                    {

                        string d = "--++";
                        recvDt = recvDt.TrimStart(d.ToCharArray());
                        this.Invoke(new rcvData(addToOutput));

                    }
                }
                Thread.Sleep(1000);
            }

        }


public void addToOutput()
        {
            if (recvDt != null && recvDt != "")
            {
                output.Text += "\n Received Data : " + recvDt;
                recvDt = null;



            }

        }

谢谢。

你基本上需要Interprocess Communication.

您可以选择使用 WCF 在客户端和服务器应用程序之间进行通信。

您可以创建一个服务并将其托管在一个应用程序中,该应用程序将从其他应用程序接收数据并使用其他应用程序中的服务来发送数据并显示响应。

这是一个简单的例子。在此示例中,我创建了 2 个应用程序。 Application2 每 10 秒自动向 Application1 发送一次数据,Application1 将响应发送回 Application2,Application2 将显示响应。

到运行示例代码遵循以下步骤:

  1. 使用 2 个控制台应用程序 Application1 和 Application2 创建一个解决方案
  2. 为两个项目添加 System.ServiceModel 引用。
  3. 在每个项目的 program.cs 中粘贴以下代码。
  4. 右键单击解决方案并在属性中,使解决方案多启动项目并设置每个项目的操作'Start'
  5. 按 Ctrl+F5 到 运行 个项目
  6. 在 Application1 window 你会看到一个服务是 运行ning 消息。
  7. Application2 将每 10 秒向应用程序 2 发送 DateTime.Now,并将收到来自应用程序 2 的响应并将其显示给应用程序 1 Window。

应用程序 1 Program.cs

using System;
using System.ServiceModel;

namespace Application1
{
    [ServiceContract]
    public interface IEchoService
    {
        [OperationContract]
        string Echo(string value);
    }

    public class EchoService : IEchoService
    {
        public string Echo(string value)
        {
            return string.Format("You send me data'{0}'", value);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            using (ServiceHost host = new ServiceHost(typeof(EchoService), new Uri[] { new Uri("http://localhost:8000") }))
            {
                host.AddServiceEndpoint(typeof(IEchoService), new BasicHttpBinding(), "Echo");
                host.Open();
                Console.WriteLine("Service is running...");
                Console.WriteLine("Press Enter to exit if you want to close service.");
                Console.ReadLine();
                host.Close();
            }
        }
    }
}

应用程序2 Program.cs

using System;
using System.ServiceModel;
using System.ServiceModel.Channels;

namespace Application2
{
    [ServiceContract]
    public interface IEchoService
    {
        [OperationContract]
        string Echo(string value);
    }

    class Program
    {
        static void Main(string[] args)
        {
            //In real implementation, use server IP instead of localhost
            ChannelFactory<IEchoService> factory = new ChannelFactory<IEchoService>(new BasicHttpBinding(), new EndpointAddress("http://localhost:8000/Echo"));
            IEchoService proxy = factory.CreateChannel();
            int processedSeccond = 0;
            while (true)
            {
                var dateTime = DateTime.Now;
                if (dateTime.Second % 10 == 0 && dateTime.Second!=processedSeccond)
                {
                    processedSeccond = dateTime.Second;
                    string data= dateTime.ToString(); //or Console readLine for manual data entry
                    Console.WriteLine("Recieved Response: " + proxy.Echo(str));
                }
            }
        }
    }
}

结果

就这么简单。您可以根据需要更改代码。

将复杂数据传递给服务的示例:

[DataContract]
public class MyMessageClass
{
    [DataMember]
    public string MyValue1 {get;set;}

    [DataMember]
    public string MyValue2 {get;set;}
}

然后你可以更新服务的接口和实现并简单地使用它而不需要序列化和反序列化任何东西,所有的事情都将由 WCF 在幕后完成。

请注意,您可以将 WCF 服务与 Windows 表单应用程序和控制台应用程序一起使用,并且您可以继续按照与现在相同的方式开发您的项目。您需要做的唯一更改是向将在服务器上 运行 的应用程序添加一项服务,然后在将在客户端 运行 的应用程序中使用该服务。它与您的应用程序的逻辑无关。为了简单起见,我提供的示例位于控制台应用程序中。