c#进程之间对象传递方法

C#中进程间对象传递有多种方式，其中常用的有以下几种：

1. 使用序列化

一种可行的方式是使用序列化将对象转化为二进制并传递到目标进程，再反序列化还原为对象。这个过程需要满足对象继承了Serializable接口并在对象中定义了序列化方法（例如，实现ISerializable接口）。

下面是示例代码：

定义一个包含序列化方法的类：

[Serializable]
class MyData:ISerializable
{
    //属性和方法
    public int num1;
    public int num2;

    public MyData() {}

    //ISerializable接口中定义的方法
    public void GetObjectData(SerializationInfo info, StreamingContext context)
    {
        info.AddValue("num1", num1);
        info.AddValue("num2", num2);
    }

    protected MyData(SerializationInfo info, StreamingContext context)
    {
        num1 = info.GetInt32("num1");
        num2 = info.GetInt32("num2");
    }

    //其它自定义方法
}

发送方：

MyData data = new MyData();
data.num1 = 10;
data.num2 = 20;

//实例化普通的IPC通道
using (var client = new NamedPipeClientStream("testPipe"))
{
    //连接
    client.Connect();

    //将data序列化为二进制
    BinaryFormatter bf = new BinaryFormatter();
    MemoryStream ms = new MemoryStream();
    bf.Serialize(ms, data);
    byte[] buffer = ms.ToArray();

    //将buffer发送到服务器
    using (BinaryWriter writer = new BinaryWriter(client))
    {
        writer.Write(buffer.Length);
        writer.Write(buffer);
    }
}

接收方：

//实例化普通的IPC通道
using (var server = new NamedPipeServerStream("testPipe"))
{
    //等待客户端连接
    server.WaitForConnection();

    //接收客户端发送的数据
    int len;
    using (BinaryReader reader = new BinaryReader(server))
    {
        len = reader.ReadInt32();
        byte[] buffer = reader.ReadBytes(len);

        //将二进制反序列化为MyData类型
        BinaryFormatter bf = new BinaryFormatter();
        MemoryStream ms = new MemoryStream(buffer);
        MyData data = (MyData)bf.Deserialize(ms);

        //处理接收到的数据
        Console.WriteLine(data.num1 + " " + data.num2);
    }
}

2. 使用WCF

另一种进程内通信的方式是使用Windows提供的通信技术：WCF（Windows Communication Foundation）。该技术定义了一系列协议和框架，可用于通过进程、机器、甚至跨域网络通信，使用WCF比使用TCP/IP编程简单得多。

以下是示例代码：

服务端：

[ServiceContract]
public interface IService
{
    [OperationContract]
    void Hello(MyData data);
}

[ServiceBehavior(InstanceContextMode = InstanceContextMode.Single)]
public class Service : IService
{
    public void Hello(MyData data)
    {
        Console.WriteLine(data.num1 + " " + data.num2);
    }
}

class Program
{
    static void Main(string[] args)
    {
        ServiceHost host = new ServiceHost(typeof(Service));
        host.Open();
        Console.ReadLine();
        host.Close();
    }
}

客户端：

//定义代理类
[ServiceContract]
public interface IService
{
    [OperationContract]
    void Hello(MyData data);
}

class Program
{
    static void Main(string[] args)
    {
        //实例化客户端代理
        var client = new ChannelFactory<IService>(new NetNamedPipeBinding(),
            new EndpointAddress("net.pipe://localhost/Service"));
        IService proxy = client.CreateChannel();

        //创建数据对象
        MyData data = new MyData();
        data.num1 = 10;
        data.num2 = 20;

        //调用服务方法
        proxy.Hello(data);

        //销毁代理对象
        ((IClientChannel)proxy).Close();
        client.Close();
    }
}

以上是使用WCF的简单示例，其中服务端和客户端都运行在同一个进程中。使用WCF可使得代码更为简洁，并且通信协议易于扩展和配置。

以上两种方式都能实现进程间对象传递，开发者可以根据不同的场景选取不同的方式。