求服务器程序设计思路：GPRS终端与服务器通信，采用TCP/IP协议，Socket,多线程

Question

我也在做这个方面的。不过现在用的是DELPHI。
如果用C#，线程和委托是分不开的。而且你说的很笼统，似乎你已经把思路说的很清楚了。如果实现上有问题，还是具体问题具体分析吧。我的QQ：16178508。也许可以互相讨论以下。不过我的C#也是菜鸟级别的

Answer 1

看你的介绍思路已经是清晰的啊？再细化的话就是技术实现的细节性问题了。
身份认证看你采取的认证方式，安全性可靠性都和你使用的实际技术有直接关联。严格些的话做CA认证。简单点直接MD5认证就行。
TCP监听就简单了，SOCKET搞定。
事务通讯的话看实际需求。也会用到SOCKET，当然你也可以用其他技术。socket多线程的实际应用MSDN里其实有很多例子。我记得有个wintalk就是用socket通讯的demo.msdn附带的。

Answer 2

我现在做的就是这个，不过是用UDP通信。LZ说得太笼统，不太明白。
愿与LZ交流

Answer 3

hoho，这么多人做这个。我写了一个设备类，处理线程和socket都是成员，还有一些其他信息。每有一个客户端链接，就创建这样一个对象。所有的设备对象放在一个动态数组中，由主线程对这个数组进行管理，如果发现设备掉线，就清理资源。不过我的设备类只处理数据接收，发送还是由主线程检测待发数据然后直接发送的。感觉不是很好，不过没想到什么更合适的办法。

Answer 4

谢谢大家的回复，对，系统设计已经很明确了，就是对Socket和多线程有些不熟悉。
我的MSN：[email protected]
QQ：173318008

Answer 5

欢迎熟悉Socket和多线程的朋友过来交流一下

Answer 6

多看看委托和线程间的通信就可以了。你可以先写个多线程的小程序，再写个多线程间使用委托通信的小程序试试，具体代码可以在网上找找，或者参见msdn上的代码。

Answer 7

这么多人做这个。我写了一个设备类，处理线程和socket都是成员，还有一些其他信息。每有一个客户端链接，就创建这样一个对象。所有的设备对象放在一个动态数组中，由主线程对这个数组进行管理，如果发现设备掉线，就清理资源。不过我的设备类只处理数据接收，发送还是由主线程检测待发数据然后直接发送的。感觉不是很好，不过没想到什么更合适的办法。

Answer 8

欢迎熟悉Socket和多线程的朋友过来交流!

Answer 9

学习中... 欢迎加入ASP.NET(C#)学习交流QQ群号:32801051

Answer 10

1  TCP/TP中的服务器端和客户端要比较清晰
2  .net异步除了
3  GPRS模块一般通过tcp客户传递过来,没有多少关系的

Answer 11

1  TCP/TP中的服务器端和客户端要比较清晰
2  .net异步处理(vwinsock)
3  GPRS模块一般通过tcp客户传递过来,没有多少关系的

Answer 12

在java里是线程池，这种线程由用户控制比较简陋，异步的socket编程便是多线程的，不过这种多线程的声明周期是由系统控制，楼主可以看看我以前给你的代码。下边是使用范例
   class DispatchServer
    {
        private TcpWorkServer server;
        ProtocolResolve resolver;
        string OSIP;
        string ASIP;        public DispatchServer()
        {
            OSIP=ASIP=Dns.GetHostAddresses(Dns.GetHostName())[0].ToString();
            server= new TcpWorkServer(7458);
            resolver = new ProtocolResolve();
            server.OnAccept+=new TcpEvent(inform);
            server.OnError+=new TcpErrorEvent(errorHandle);
            server.OnReceive+=new TcpEvent(rcvHandle);
            server.OnStart += new TcpErrorEvent(server_OnStart);
            server.OnEndSend += new TcpEvent(server_OnSend);
        }        void ConnToOS_OnReceive(object sender, Session session)
        {
            server.Send(session);
        }        void ConnToOS_OnSend(object sender, Session session)
        {
            throw new Exception("The method or operation is not implemented.");
        }        void ConnToOS_OnConnect(object sender, Session session)
        {
            Console.WriteLine("连接上业务服务器！");
        }
    
        static void Main(string[] args)
        {
            DispatchServer s = new DispatchServer();
            s.startJob();
        }
        public void startJob()
        {            Console.WriteLine("服务器开始启动");
            //ProtocolResolve pr = new ProtocolResolve("TST 0.1 CF test,hello%25world END");
            //Console.WriteLine("{0},{1},{2},{3}", pr.Command, pr.Version, pr.CounterFoil,pr.Param.Count);
            //Console.WriteLine(pr.BuildRequest("CHG", "1.0", "CF"));            server.StartListening();
        }        void server_OnSend(object sender, Session state)
        {  
        }        void server_OnStart(object sender, string msg)
        {
            Console.WriteLine(msg);
        }
        public void errorHandle(Object sender,string code)
        {
            Console.WriteLine(code);
        }
        public void inform(object sender,Session session)
        {
            Console.WriteLine("Connect with"+session.WorkSocket.RemoteEndPoint.ToString());
        }
        /// <summary>
        /// 会话接收响应函数
        /// </summary>
        public void rcvHandle(Object sender, Session session)
        {           
            resolver.SetCommand(session.Message.ToString());
            resolver.ProtocolResolving();
            Console.WriteLine("Recive!读取客户端信息::"+resolver.FullCmd);
            MessageResolve(session);//调用消息处理控制台
            //server.SendData(session);//返回处理过的Session到客户端
        }        /// <summary>
        /// 会话处理函数
        /// </summary>
        public void MessageResolve(Session _session)
        {
            ProtocolResolve pr = new ProtocolResolve(_session.Message.ToString());
            switch (pr.Command)
            {
                case "LIN":
                    AuthenticationSender(_session);
                    break;
                default:
                    OperationSender(_session);
                    break;
            }
        }
        /// <summary>
        /// 将消息发送到AS中
        /// </summary>
        public void AuthenticationSender(Session _session)
        {
            TcpClient ConnToAS = new TcpClient(ASIP, 7459);
            string remoteip=_session.WorkSocket.RemoteEndPoint.ToString().Split(':')[0];
            byte[] t = Encoding.UTF8.GetBytes(_session.Message.ToString()+"|"+remoteip);//DS将客户端IP附加在消息后边发送给AS
            NetworkStream ns = ConnToAS.GetStream();
            ns.Write(t, 0, t.Length);            if (ns.CanRead)
            {
                byte[] r = new byte[ConnToAS.ReceiveBufferSize];
                int size = ns.Read(r, 0, ConnToAS.ReceiveBufferSize);
                string cr = Encoding.UTF8.GetString(r, 0, size);
                _session.Message.Remove(0, _session.Message.Length);
                _session.Message.Append(cr);
                Console.WriteLine(cr);
                server.Send(_session);
                //server.ExitSession(_session);
            }
           
        }        void ConnToAS_OnSend(object sender, Session session)
        {
            Console.WriteLine("发送消息{0}到AS",session.Message.ToString());
        }        void client_OnReceive(object sender, Session session)
        {
            Console.WriteLine("接收到{0}送来的消息{1}，送往{2}", session.WorkSocket.RemoteEndPoint, session.WorkSocket.ToString(), session.WorkSocket.RemoteEndPoint);
            //server.SendData(session);
        }        void client_OnConnect(object sender, Session session)
        {
            Console.WriteLine("作为客户端Connect!与AS交互在"+session.WorkSocket.LocalEndPoint.ToString());
        }        /// <summary>
        /// 将消息发送到OS中
        /// </summary>
        public void OperationSender(Session _session)
        {
            TcpClient ConnToOS = new TcpClient(OSIP, 7457);
            byte[] t = Encoding.UTF8.GetBytes(_session.Message.ToString());
            NetworkStream ns = ConnToOS.GetStream();
            ns.Write(t, 0, t.Length);            if (ns.CanRead)
            {
                byte[] r = new byte[ConnToOS.ReceiveBufferSize];
                int size = ns.Read(r, 0, ConnToOS.ReceiveBufferSize);
                string cr = Encoding.UTF8.GetString(r, 0, size);
                _session.Message.Remove(0, _session.Message.Length);
                _session.Message.Append(cr);
                Console.WriteLine("OS返回消息"+cr);
                ConnToOS.Close();
                server.Send(_session);
                //server.ExitSession(_session);
            }
        }
    }

Answer 13

.net异步处理
就是多线程把

Answer 14

可以参考.NET4。0的SocketAsyncEventArgs类，这个类的模型为异步的完成端口模型，而且使用方便简单！

Answer 15

晕。做的人还真多。刚帮一家公司做了一个WINCE的.