序列化操作 反序列化

在网络传送中，需要将一个对象进行序列化来保存这个对象运行时的状态，或者序列化一些要传送的数据，因为在网络传送中只能传送字节流。同时，序列化还会在保存一个对象的运行时状态，或者将一个对象保存在数据库中使用到。

 

我简单的写了一个网络通讯程序，包括客户端和服务器，服务器可以同时接收多个客户端的连接。客户端把用户输入的数据进行序列化，然后传送到服务器，服务器端需要对用户传送来的数据进行反序列化，显示出用户输入信息。这里只是简单的模拟了对数据的序列化，如果有需要的话还可以对运行时的对象进行序列化。

 

序列化的代码：

 

 // 进行序列化
            IFormatter serialize = new BinaryFormatter();
            MemoryStream ms = new MemoryStream();
            // 将文字序列化
            serialize.Serialize(ms, text);
            byte[] info = ms.ToArray();
            ms.Close();

 

 

服务器端代码：

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.IO;

namespace Server
{
    public partial class Server : Form
    {
        private IPAddress server_IP = IPAddress.Parse("10.108.13.27");
        private const int PORT = 8888;
        private TcpListener server_listener = null; 

        public Server()
        {
            InitializeComponent();
        }

        private void Server_Load(object sender, EventArgs e)
        {
            server_listener = new TcpListener(server_IP,PORT);
            Thread thread_listener = new Thread(new ThreadStart(listening));
            // 开始监听线程
            thread_listener.Start();
        }

        private void listening()
        {
            try
            {
                // 开始监听端口
                server_listener.Start();

                while (true)
                {
                    Socket socket = server_listener.AcceptSocket();
                    // 接收一个用户连接后就给这个用户连接创建一个专用的线程来调度
                    Thread newSocket = new Thread(new ParameterizedThreadStart(clientThread));
                    // 开始和用户通信的新线程
                    newSocket.Start(socket);
                }
            }
            catch (ThreadAbortException)
            {
                //
            }
            finally
            { 
                //
            }
        }

        private void clientThread(object socket_o)
        {
            try
            {
                try
                {
                    Socket socket = socket_o as Socket;
                    // 循环和客户端通信
                    while (true)
                    {
                        byte[] cmdBuffer = new byte[4];
                        socket.Receive(cmdBuffer);
                        string cmd = string.Concat(cmdBuffer[0].ToString(), cmdBuffer[1].ToString());
                        switch (cmd)
                        {
                            case "11":
                                {
                                    // 用户请求上传消息
                                    //
                                    byte[] info=new byte[512];
                                    socket.Receive(info);
                                    // 对用户传来的数据进行反序列化
                                    IFormatter deserialize = new BinaryFormatter();
                                    MemoryStream ms = new MemoryStream();
                                    ms.Write(info, 0, info.Length);
                                    ms.Position = 0;
                                    string user_info = (string)deserialize.Deserialize(ms);
                                    user_info = user_info.TrimEnd('\0');
                                    ms.Close();
                                    this.richTextBox1.Text = user_info;
                                    break; 
                                }
                        }

                    }
                }
                catch(SocketException)
                {
                    //
                }
            }
            catch (SocketException)
            {
                //
            }
            finally
            {
                //
            }
        }

        private void Server_FormClosed(object sender, FormClosedEventArgs e)
        {
            server_listener.Stop();
        }
    }
}

 

客户端代码：

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.IO;

namespace Client
{
    public partial class Form1 : Form
    {
        private IPAddress serverIP = IPAddress.Parse("10.108.13.27");
        private const int PORT = 8888;
        private TcpClient client = null;
        NetworkStream netStream = null;

        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            client = new TcpClient();
            // 连接远程服务器
            try
            {
                client.Connect(serverIP, PORT);
                // 获取网络数据流
                netStream = client.GetStream();
                Thread thread = new Thread(new ThreadStart(exchange));
                thread.SetApartmentState(ApartmentState.STA);
                thread.Start();
            }
            catch (SocketException)
            {
                //
            }
            finally
            {
                //
            }
        }

        private void exchange()
        {
            while (true)
            {
                //
            }
        }

        private void button1_Click(object sender, EventArgs e)
        {
            string text = richTextBox1.Text.ToString().TrimEnd('\0');
            // 进行序列化
            IFormatter serialize = new BinaryFormatter();
            MemoryStream ms = new MemoryStream();
            // 将文字序列化
            serialize.Serialize(ms, text);
            byte[] info = ms.ToArray();
            ms.Close();
            // 给服务器发送请求
            netStream.Write(new byte[] { 1, 1 }, 0, 2);
            netStream.Flush();
            // 发送序列化以后的消息
            netStream.Write(info, 0, info.Length);
            netStream.Flush();
        }
    }
}