首页 > 代码库 > Delphi的Socket编程步骤(repulish)

Delphi的Socket编程步骤(repulish)

 

转贴自:http://topic.csdn.net/t/20010727/16/212155.html

ClientSocket 和ServerSocket
几个重要的属性:   
1.client和server都有port属性,需要一致才能互相通信   
2.client有Address属性,使用时填写对方(server)的IP地址   
    
几个重要的事件:   
    client:    OnRead事件,当client受到冲击消息时在OnRead事件中可以获得server发送过来消息。   
    Server:     OnClientRead事件,与上述client的作用相同   
    
发送信息:   
    clien使用SocketClient1.Socket.SendBuf(char类型的数组,信息长度);   
    server使用SocketServer1.Socket.Connection[0].SendBuf(char类型的数组,信息长度);   
    
接收信息   
     clien使用SocketClient1.Socket.ReceiveBuf(char类型的数组,信息长度);   
     server使用SocketServer1.Socket.Connection[0].ReceiveBuf(char类型的数组,信息长度);   
    

使用sockets
         Socket 控件让你建立一个利用TCP/IP和有关的协议与其他系统进行通信的应用。使用Sockets,你能够读和写通过它连接的其他机器,而不用担心实际的网络软件的相关细节。Sockets提供基于TCP/IP协议的连接。除此以外还能很好的工作,在其他相关的协议。   
         Delphi 提供你写网络服务器或客户应用程序去读和写其他的系统。一个服务或客户程序通常专注于一个单一的服务如超文本传送协议(HTTP)或文件传输协议(FTP)。使用server           sockets,一个应用程序可以提供这些服务中的一个去连接一个希望使用服务的客户程序。Client           sockets允许一个应用使用这些服务中的一个去连接提供这个服务的服务应用。   
        使用sockets去写应用程序,你必须理解下面这些知识:   
    一、服务工具   
     当你需要写网络服务或客户应用时,Sockets提供一种接合。对于许多服务,象HTTP或    FTP,第三方服务商提供这些服务已经相当有效。有些甚至随着操作系统捆绑而来,以便不用你自己写。然而,当你想更多的控制服务的实现,如想让你的应用程序与网络通信更加紧密,或当没有一个服务能提供你特殊需要的服务时,你可能想建立你自己的服务或客户应用。例如,工作在分布式data            sets时,你可能想为数据库写一层与其他系统通信的应用。想使用Sockets实现一个服务,你必须理解:   
    
      1.服务协议   
     在你写一个网络服务或客户程序前,你必须明白你的应用将提供或使用什么服务。你的网络应用必须支持许多服务的标准协议。如果你为标准的服务例如HTTP,FTP写网络应用,你必须先理解与其他系统通信所使用的协议。特殊服务细节你必须看提供的或使用的文档。   
         如果你的应用程序提供一个新的服务与其他系统通信,第一步是为这个服务的服务端和客户端设计通信协议。什么信息将发送?如何整理这些信息?如何对这些信息进行编码?   
    
      应用程序通信   
       经常的,你的网络服务端或客户端应用程序要提供一层在网络软件和一个应用之间使用的服务。例如,一个HTTP服务站点在INternet与一个Web 服务应用之间为HTTP请求信息提供内容和应答。   
           在你的网络应用(或客户应用)和网络软件之间Sockets 提供一个接口。你必须提供一个接口,在你的应用程序与应用间使用。你可以拷贝第三方服务商提供的标准API(例如ISAPI),或你可以设计和发布你自己的API.   
    
      2.理解服务和端口   
      许多标准服务都有关联的、指定的端口号。当执行服务时,你可以为服务考虑一个端口号。如果你实现一个标准服务,Windows    socket     objects    提供一些方法让你为服务寻找端口号。如果提供一个新的服务,在基于Windows 95    或 NT机器上,你能够在文件Services中为你的服务指定一个相关联的端口号。设置Services文件的更多信息请看微软的Windows    Sockets文档。   
    
      二、Socket连接的类型   
      Socket连接可以分成三个基本的类型,它们反映了如何开始连接和本地Socket 连接是什么。这三个类型是:   
    
     1.客户端连接   
       客户端连接是一个本地系统的客户端socket与一个远程系统上的服务端Socket连接。客户端连接由客户端Socket开始。首先,客户端Socket必须描述它想连接到的服务端Socket.接着客户端socket查找服务端socket,当找到服务器时,就要求连接。服务端socket可能不能完成正确的连接。服务器sockets维持一个客户端请求队列,在他们有时间时完成连接。当服务端socket接受客户端连接,服务端socket将向它想连接的客户socket发送一个完整的描述,客户端的连接完成。   
    
         2.倾听连接   
         服务器 socket不会去定位客户端,代替的,他们形成被动的,"半连接"状态,倾听来自客户端的请求。服务器           sockets形成一个队列,存放它们听到的连接请求。这个队列记录着客户端连接请求就象他们已连接进来一样。当服务器sockets同意客户连接请求时,它形成一个新的socket去连接客户端,因此这个倾听连接能保持开放状态允许其他客户端请求。   
    
         3.服务端连接   
         当倾听socket同意一个客户端请求时,服务器端socket形成一个服务器连接。当服务器端同意连接时,向客户端发送一个服务端socket描述以完成连接,当客户端socket收到这个描述时这个连接得到确认,连接完成。一但连接到客户端的Socket完成,服务端连接就不能识别从一个客户端来的连接。末端双方有同样的能力去接收同样的事件类型。只有倾听(listening)连接是根本不同的,它只有一个单一的末端。   

         三、sockets描述   
         Sockets让你的网络应用软件通过网络与其他系统进行通信。在网络连接中每个socket可以看成一个终端点。它有一个指定的地址。   
    
          *这个系统正在运行   
          *它理解的接口类型   
          *用来连接的端口   
          一个完整的socket连接描述,你必须提供sockets           在连接两端的地址。在你开始一个socket连接前,你必须完整的描述你想得到的连接。有些信息可以从你的应用软件运行的系统平台上得到。例如,你不需要描述一个客户端socket的本地IP地址--这个信息可以从操作系统上获得。你必须提供你工作所依靠的socket的类型的信息。客户端socket必须描述他们想连接的服务器。侦听服务器sockets必须描述他们提供反应的服务器的端口。一个socket           连接终端的完整描述包括两部分:   
    
   1.IP地址   
        主机是这样一个系统,它运行着包含有socket的应用程序。你必须描述主机给socket,通过给出主机的IP地址来完成这个描述。IP地址是一个有四个数字(byte)值的,在标准internet点付内的字符串。   
        例如123.197.1.2   
        一个简单的系统可以支持多于一个的IP地址。IP地址通常难于记忆并且容易打错。一个可供选择的方法是使用主机名。主机名就是IP地址的别名,它就是你常看到的统一资源定位(URLs)。它是一个字符串,包括了域名和服务。   
        例如        http://www.wsite.com   
        许多内部网提供给主机的名字对应的系统IP地址是internetIP地址。在windows95       和NT机器上,如果一个主机名不能用,你可以在HOSTS文件中为你的本地IP地址(这个本地IP地址应该是指你想连接的主机IP地址--zyqsj)建立一个进入的名字。   
        关于HOSTS文件的更多信息请看WINDOWS    SOCKETS的文档。   
        服务器sockets不需要指定主机。本地IP地址可以从系统中读到。如果本地系统支持多于一个的IP地址,服务器sockets将同时在所有的IP地址上侦听客户端请求。当一个服务器socket同意一个连接,客户端提供一个远程IP地址。客户sockets必须指定远程主机通过提供主机名或者IP地址。   
    
         在主机名和IP地址间作一个选择   
         许多应用软件使用一个主机名去指定一个系统。主机名容易记住和容易检查排版错误。进一步讲,服务器能改变系统或与IP地址关联的特殊的主机名。使用一个主机名,能够允许客户端通过主机名描述找到抽象的站点,即使主机使用一个新的IP地址。   
          如果主机名是未知的,客户socket必须指定服务器系统使用的IP地址。通过给一个IP地址来指定服务器将更快。当你提供主机名时,socket在定位服务器系统前,必须搜寻与这个主机名相关的IP地址。   
    
    2.端口号   
         虽然IP得地址提供了足够的信息去找到socket连接中位于另一端的系统,你通常还需要指定那个系统的端口号。没有端口号,一个系统在同一时间只能进行一个单一的连接。端口号是唯一标识那允许一个独立系统连接到支持同时多个连接的主机,每个连接都必须指定一个端口号。   
         在网络应用中,对于服务器工具来说端口号是一个数字代码。有一个习惯就是侦听服务连接到他们自己固定的端口号上,以便他们能找到客户端sockets.服务器socket监听为他们提供服务的相关端口号。当他们允许给予一个客户端socket连接时,他们创建一个独立的socket连接,使用不同的专用的端口号。通过这个方法,能持续的监听相关服务的端口号。   
         客户端socket使用一个专用的本地端口号,就不用其他的socket去寻找它们。他们指定他们想连接的服务器端socket的端口号,这样他们就能找到服务器应用程序。常常的,这个端口号是通过命名想连接的服务来间接指定的。   

 四、使用socket控件   
         Delphi提供两个socket控件,客户端sockets和服务器sockets.他们允许你的网络应用构成连接其他的机器和允许你通过这个连接来读写信息。与每个socket控件相关联的是windows         socket对象,它们在终端的的作用是一个实际的socket连接。socket控件使用windows         socket对象去封装windows    socket     API     调用,所以你的应用不用去关心连接建立的细节或管理socket信息。   
         如果你想利用windows     socket    API调用或自定义连接细节,socket控件提供了便利,你可以使用windows    socket对象的properies,events和方法。   
    
        1.使用客户端sockets   
         添加一个客户端socket控件(TClientSocket)到你的form或data     module    使你的应用成为一个TCP/IP客户。客户sockets允许你指定你想连接的服务器socket和你希望服务器提供的服务。一但你描述你想得到的连接,你可以使用客户socket控件去完成连接服务。   
         每个客户socket控件使用独立的客户windows     socket对象(TClientWinSocket)去应答连接中的客户终端。使用客户sockets去:   
    
         A.指定想得到的服务   
         客户socket控件有一个数字properties,允许你指定想连接的服务器系统和端口。你可以通过主机名来指定服务器系统,使用Host          property。   
         如果你不知道主机名,或者你关心找到服务器的速度,你可以指定服务器系统的IP地址,通过使用 Address    property。你必须指定IP地址和主机名中的一个。   
         如果你两个都指定,客户socket控件将使用主机名。除服务器系统外,你必须指定你的客户socket将连接的在服务器系统上的端口。你能够直接使用Port          property来指定服务端口号。或者直接在Service     property使用想得到的服务的名字。如果你指定端口号和服务名,客户socket控件将使用服务名。   
    
         B.建立连接   
         一旦你在客户socket控件中完成了设置描述你想连接的服务器的属性,你就可以进行连接,通过调用Open方法。如果你想你的应用启动时自动建立连接,在设计时设置Active        property为true,通过使用Object          Inspector来设置。   
    
         C.取得关于连接的信息   
         完成连接到服务器socket后,你可以使用与你的客户socket控件相关的客户windows   socket    object去取得关于连接的信息。使用Socket    property去访问client    windows   socket     object。

         windows    socket    object 有一个properties,它能让你确定在连接的两端客户和服务器使用的地址和端口号。   
         当使用一个windows    socket    API 调用时,你可以使用SocketHandle   property区获得socket连接使用的handle。你可以使用Handle    property去访问windows,以便接收来自socket连接的信息。     
         AsyncStyles      property决定哪种信息类型是windows    handle要接收的。   
    
         D.关闭连接   
         当你完成通讯想关闭socket 连接时,你能够通过调用Close方法来关闭连接。连接可能要由服务器端来关闭。如果是这种情况,你将收到一个OnDisconnect    事件的通知。   
    
     2.使用服务器sockets   
      添加一个服务端socket控件ServerSocket 到你的form或data    module使你的应用成为一个TCP/IP服务器。服务器sockets允许你指定你想提供的服务或你想用来监听客户请求时使用的端口。你可以使用服务器socket控件去监听和允许客户连接请求。每个服务器socket控件使用一个单一的服务器windows   socket    Object(TServerWinSocket)去应答在服务器端监听到的连接。它通常使用一个服务器客户winodws    socket    Object(TServerClientWinSocket)应答在服务器端每个活动的,连接着得到允许服务的客户socket。使用服务器sockets去:   
    
       A.指定端口   
       在你的服务器socket能够监听客户请求之前,你必须指定一个端口给你的监听服务。你可以使用Port     property来指定这个端口。如果你的服务器应用提供一个标准的服务,这个服务使用一个习惯使用的相关联的端口。你能够使用Service     property直接指定端口号。使用Service     property是一个好的主意,能够减少设置端口号时的错误。如果你既指定了Port          property,又指定了Service     property,服务socket将使用服务名。   
    
      B.监听客户请求   
       一旦你在server     socket控件上设置好你的端口号,你就能够通过在运行时通过调用Open方法来监听一个连接。如果你希望你的应用程序能够在启动的时候自动监听连接,在设计的时候通过使用Object     Inspector设置Active 属性为true。   
    
      C.连接到客户端。   
       当监听服务socket控件接收到一个客户端连接请求时他们将自动接受这个请求。当你没次收到通知时,OnClientConnetc事件将发生。   
    
      D.取得关于连接的信息   
      一但你的服务器socket打开了监听连接,你能够使用与你服务器socket控件相关联的服务器windows    socket     object来取得关于连接的信息。使用Socket     property去访问server     windows     socket     object。windows    socket    object有一个属性能够让你找到关于所有活动的客户socket连接这些客户socket是你通过服务器socket控件允许连接的。使用Handle属性去存取windows通过socket连接收到的信息。   
      每个活动的,连接到客户应用是通过服务、客户windows   socket   bject   (TServerClientWinSocket)封装的。你能够通过server    windows   socket   object的连接属性来访问所有的这些。这些server    client   windows    socket    object有些属性让你能够决定哪些地址和端口号给连接的两端--客户和服务器socket使用。当你使用windows   socket   API调用时,可以使用SocketHandle属性去获得socket连接使用的handle。你能够使用Handle属性去访问windows从socket连接处得来的信息。AsyncStyles属性决定windows    handle将接收哪种类型的信息。   
    
      E.关闭连接   
      当你决定关闭监听连接时,调用Close方法。这将关闭所有打开着的,连接到客户应用的连接,取消任何尚未同意的连接,接着关闭监听连接以便你的服务socket控件不在接受任何新的连接。当客户端关闭他们自己独立的连接到你的server          socket的连接时,你可以在OnClientDisconnect事件中得到讯息。   
    
    五、socket事件的应答   
      当使用sockets写应用程序时,大多数工作发生在socket控件的handler事件中。当通过socket连接开始读或写时,OnRead和OnWrite事件在non-blocking    client    sockets中发生从而通知sockets.同样的,服务器sockets(blocking    or    non-blocking)收到OnClientRead和OnClientWrite事件.   
     当服务器结束一个连接时,客户scokets收到一个OnDisconnect事件.当客户端结束一个连接时,服务器socket收到一个OnClientDisconnect事件.   
     另外,客户端Sockets和服务器端socket从连接中收到一个错误信息时,都将产生有个错误事件.   
    
     错误事件:客户sockets和服务器sockets通常会产生一个OnError事件,当他们从连接中收到一个错误信息的时候.你能够写一个OnError事件处理去响应这些错误信息.这个OnError事件处理提供传送关于socket试图做什么的时候这个错误发生的信息,以及错误信息提供的错误代码.你可以在OnError事件处理中对这个错误作出响应,并且把错误代码改为0,以避免socket产生一个例外.   
    
     当开始和完成发生时,socket控件通常会收到一个事件号(number        of       events).如果你的应用程序需要改变socket开始操作的处理过程或通过连接开始读或写操作时,你将写事件handlers去应答这些client     events和server    events.   
    
       A.client     events   
       当一个客户socket打开一个连接时,以下事件发生:   
       1.一个OnLookup事件最先发生,它试图去定位server        socket.在这里你不能改变Host,Address,Port,Service属性去改变你想定位的服务器.你能够使用Socket属性去访问client       windows        socket        object,并且使用它的SocketHandle属性去调用windows       API,以便改变socket的客户属性.例如,如果你想在客户应用软件中设置端口号,你必须在server       client连接前做这件事.   
       2.windows    socket设置和初始化事件通知.   
       3.当找到server       socket 一个OnConnecting事件发生.在这事件中,windows        Socket        object可以利用的是通过socket属性提供关于连接的另一端的服务socket的一些信息.这是获得实际使用来连接的端口和IP地址的第一个机会,它可能不同于从监听socket处同意连接时得到的端口或IP地址.   
       4.服务器同意连接请求,客户端socket完成连接.   
       5.当一个连接得到确定后,一个OnConnect事件发生.如果你的socket立即开始通过连接读或写,就应写一个OnConnect事件Handler去作这件事.   
    
       B.服务器端事件(server        events)   
       服务器socket控件通过两中方式连接:监听连接和连接到客户应用.服务器socket收到这两个连接的所有事件.   
    
       监听时事件   
       当构成监听连接前,OnListen事件发生.在这个时候你能够通过socket属性获得server        windows        socket        object.你能够使用它的SocketHandle属性去改变socket,在socket打开监听之前.例如,如果你想限定监听服务使用的IP地址,你可以在这个OnListen事件Handler中做.   
    
       与客户端连接的事件
       当一个服务器socket同意一个客户连接请求时,接下来的事件发生:   
       1.服务器socket产生一个OnGetSocket事件,通过windows   socket    handle传送给连接的另一端的socket.如果你想提供自己定义的TServerClientWinSocket   of   descendant,你可以在OnGetSocket        事件 handler中建立,将被用来替代TServerClientWinSocket.   

       2.一个OnAccept事件发生,传送新的TServerClientWinSocket对象给事件句柄.这是第一个要点,当你使用TServerClientWinSocket的属性去获得被连接中服务的那端的客户的信息时.   

       3.如果服务类型是stThreadBlocking,一个OnGetThread事件发生。如果你想提供自己定义的TServerClientThread子类,你可以在OnGetThread事件句柄中建立一个,它将替代TServerClientThread.   
       4.如果服务类型是stThreadBlocking,一个ONThreadStart事件发生。当这个线程(thread)开始执行时.如果你想执行任何初始化这个线程,或调用一些windows   socket    API在这线程开始通过连接读和写之前,应该使用OnThreadStart事件句柄.

       5.当客户端完成一个连接时,一个OnClientConnect事件发生.如果是non-blocking服务,你可能想开始通过socket连接在这端进行读或写操作.   
    
    六、通过Socket 连接进行读和写   
        通过socket连接到其他机器的原因是想通过这些连接来读和写信息.什么信息是你要读和写的,或者当你想读和写时是依靠哪些socket连接的相关服务的.   
        通过sockets进行读和写可以是异步的,所以在你的网络应用中不需要阻塞其他代码的执行。这是调用non-blocking       connection.你也同样可以通过blocking       connection,这时你的下一行代码的执行必须等到读或写操作完成.   
    
      A.Non-blocking
      连接,读和写是异步的,   所以在你的网络应用中不需要阻塞其他代码的执行.建立一个Non-blocking连接:   
      1.在客户socket中设置ClientType属性为ctNonBlocking.   
      2.在服务器socket中设置ServerType属性为stNonBlocking.   
      当连接是non-blocking时,连接的另一端企图读或写时读和写事件将把这个信息通知你的socket.   
    
      读和写操作事件   
       Non-blocking   sockets想通过连接读或写时,它会产生一个读和写操作事件通知你的socket.在客户端sockets,你可以在OnRead或OnWrite事件句柄中对这些事件做出反应.在服务器端Scokets,可以在OnClientRead或OnClientWrite事件句柄中对这些事件做出反应.与socket连接相关联的windows      socket       object在事件句柄的读或写中被当作一个参数.Windows   socket   object提供一个方法号(number   of   methods)以允许你通过连接读或写.   

      通过socket连接读,使用ReceiveBuf或ReceiveText方法.在使用ReceiveBuf方法前,使用Receivelength方法去确定在连接的另一端socket准备发送的字节数(number       of      bytes).   
      通过socket连接写,使用SendBuf,SendStream,或SendText方法.如果你通过socket发送信息后不在需要socket连接,你可以使用SendStreamThenDrop方法.   SendStreamThenDrop在写完所有的信息后将关闭Socket连接,它能够从stream读信息.如果你使用SendStream或SendStreamThenDrop方法,不要释放Stream  object,   socket在连接结束后会自动释放这个Stream.   
      注意:SendStreamThenDrop将关闭一个独立的客户连接服务,而不是监听连接.   
    
    B.Blocking       connections   
    当你使用的连接是Blocking时,你的Socket必须通过连接发起读或写操作,胜过被动的等待从socket连接发来的通知.       当你的连接末端的读和写操作发生改变时
    使用Blocking    socket.对于客户端sockets,设置ClientType属性为ctBlocking 以便构成一个blocing       connection.根据你的客户端应用想完成什么,你可能想建立一个执行线程去完成读或写操作,以便你的应用能够继续执行其他的线程,当它在等待通过连接读或写操作的完成.   
    对于服务器sockets,设置ServerType属性为stThreadBlocking 以便构成一个blocking connection.因为blocking      connections在等待通过连接读或写信息完成时挂起了其他代码的执行,服务器socket控件通常产生一个新的执行线程给每一个客户连接,当ServerType设置为stThreadBlocking时.许多使用Blocking连接的应用都写使用线程(using       threads.甚至如果你不使用线程,你可能也想使用 TWinSocketStream 去读和写.   
    1)using       threads   
    当使用一个blocking       connection进行读或写操作时,客户sockets不会自动产生一个新线程.如果你的客户应用程序没有什么事做,直到读或写信息完成,那么这正是你想要的.如果你的应用包括了一个用户界面,它还需要响应用户的操作,那么,你可能想产生一个独立的线程去读写.当服务器sockets形成一个blocking连接时,他们常常产生独立的线程给每一个客户连接,所以没有客户需要等待直到其他客户完成通过连接读或写操作.在默认情况下,服务器sockets使用TServerClientThread对象去实现为每个连接执行不同的线程.   
    TServerClientThread对象模拟发生在non-blocking连接中的OnClientRead和OnClientWrite事件.可是,这些事件发生在监听socket上时,不是本地线程(thread-local).如果客户请求频繁,你将想建立你自己的TServerClientThread子类去提供一个安全线程(Thread-Safe)去完成读和写操作.   
    当写客户线程或写服务器线程时,你能够使用TwinSocketStream去做实际的读写操作.   
      A)写客户端线程   
    为客户端连接写一个线程,定义一个新线程对象,使用新线程对象对话框.你的新线程对象Execute方法的句柄的通过线程连接进行读写操作的细节,可以建立一个TWinSocketStream对象,然后使用它来读或写.   
      使用你自己的线程,在OnConnect事件句柄中建立它.关于建立和运行线程的更多信息,请看Executing       thread       objects.   
    
    B)写服务器线程   
      服务器连接线程由TServerClientThread派生.因为这个,不能使用新线程对象对话框替代的.
    
     注意你将用重载ClientExcute方法替代Execute方法.执行ClientExecute方法必须为客户端连接写一个同样的Execute方法线程.然而,当你从控件栏上放一个客户socket控件到你的应用上时来替代这个方法时.监听服务socket同意一个连接时,服务客户线程必须使用TServerClientWinSocket对象来建立.这可以利用共公共的CientSocket属性.另外,你能够使用HandleException这个protected性的方法,胜过   
    你自己写你的thread-safe例外操作.   
    
    警告:Server   sockets会缓存他们使用到的线程.确信ClientExecute方法执行一些必要的初始化操作,以便它们在最后执行时不致于产生不利的结果.   
    
    当你使用你的线程时,在OnGetThread事件句柄中建立它.当建立线程,设置CreateSuspended参数为false.   
    
      C.使用TwinSocketStream   
    当为一个blocking连接实现一个线程时,你必须确定在连接的另一端的socket是准备写还是读.Blocking连接不会通知socket当它准备好写或读操作的时候.想看看连接是否准备好,使用TWinSocketStream对象.TWinSocketStream提供一个方法去帮助调整读或写操作时间的选择.调用WaitForData方法去等待,直到socket另一端的准备好写操作.当读写操作使用TWinSocketStream时,如果读或写操作在指定的时间期限内未能完成,Stream将发生超时.这个超时被当作一个结果,socket应用不会暂停,而是不断的通过一个dropped    connection试图读或写.   
    
    注意:你不能在non-blocking连接中使用TWinSocketStream

 

实例一:

一、Delphi与Socket
  计算机网络是由一系列网络通信协议组成的,其中的核心协议是传输层的TCP/IP和UDP协议。TCP是面向连接的,通信双方保持一条通路,好比目前的电话线,使用telnet登陆BBS,用的就是TCP协议;UDP是无连接的,通信双方都不保持对方的状态,浏览器访问Internet时使用的HTTP协议就是基于UDP协议的。TCP和UDP协议都非常复杂,尤其是TCP协议,为了保证网络传输的正确性和有效性,必须进行一系列复杂的纠错和排序等处理。
  Socket是建立在传输层协议(主要是TCP和UDP)上的一种套接字规范,最初是由美国加州Berkley大学提出,它定义两台计算机间进行通信的规范(也是一种编程规范),如果说两台计算机是利用一个“通道“进行通信,那么这个“通道“的两端就是两个套接字。套接字屏蔽了底层通信软件和具体操作系统的差异,使得任何两台安装了TCP协议软件和实现了套接字规范的计算机之间的通信成为可能。
  微软的Windows Socket规范(简称winsock)对Berkley的套接字规范进行了扩展,利用标准的Socket的方法,可以同任何平台上的Socket进行通信;利用其扩展,可以更有效地实现在Windows平台上计算机间的通信。在Delphi中,其底层的Socket也应该是Windows的Socket。Socket减轻了编写计算机间通信软件的难度,但总的说来还是相当复杂的(这一点在后面具体会讲到);Inprise在Delphi中对Windows Socket进行了有效的封装,使得用户可以很方便地编写网络通信程序。下面我们实例解读在Delphi中如何利用Socket编写通信程序。
二、利用Delphi编写Socket通信程序。
  下面是一个简单的Socket通信程序,其中客户机和服务机是同一个程序,当客户机(服务器)在一个memo1中输入一段文字然后敲入回车,该段文字就可以显示在服务器(客户机)的memo2中,反之亦成立。具体步骤如下:
  1、新建一个form,任意命名,不妨设之为chatForm;放上一个MainMenu(在Standard栏中),建立ListenItem、ConnectItem、Disconnect和Exit菜单项;在从Internet栏中选择TServerSocket、TClientSocket添加到chatForm中,其中把TClientSocket的名字设为ClientSocket, port设为1025,默认的active为false;把TServerSocket的名字设为ServerSocket,port设为1025,默认的active为false,其他的不变;再放入两个memo,一个命名为memo1,另外一个命名为memo2,其中把memo2的color设置为灰色,因为主要用来显示对方的输入。下面我们一边编写代码一边解释原因。
  2、双击ListemItem。写入如下代码:
procedure TChatForm.ListenItemClick(Sender: TObject);
begin
ListenItem.Checked := not ListenItem.Checked;
if ListenItem.Checked then
begin
ClientSocket.Active := False;
ServerSocket.Active := True;
end
else
begin
if ServerSocket.Active then
ServerSocket.Active := False;
end;
end;
  该程序段的说明如下:当用户选择ListemItem时,该ListenItem取反,如果选中的话,说明处于Listen状态,读者要了解的是:listen是Socket作为Server时一个专有的方法,如果处于listen,则ServerSocket设置为活动状态;否则,取消listen,则关闭ServerSocket。实际上,只有用户一开始选择该菜单项,表明该程序用作Server。反之,如果用户选择ConnectItem,则必然作为Client使用。
  3、双击ConnectItem,敲入以下代码。
procedure TChatForm.ConnectItemClick(Sender: TObject);
begin
if ClientSocket.Active then ClientSocket.Active := False;
if InputQuery(‘Computer to connect to‘, ‘Address Name:‘, Server) then
if Length(Server) > 0 then
with ClientSocket do
begin
Host := Server;
Active := True;
ListenItem.Checked := False;
end;
end;
  这段程序的主要功能就是当用户选择ConnectItem菜单项时,设置应用程序为客户机,弹出input框,让用户输入服务器的地址。这也就是我们不一开始固定ClientSocket的host的原因,这样用户可以动态地连接不同的服务器。读者需要了解的是主机地址只是Socket作为客户机时具有的一个属性,Socket作为服务器时“一般“不用地址,因为它同本机绑定。
  4、在memo1的keydown方法中写入如下代码:
procedure TChatForm.Memo1KeyDown(Sender: TObject; var Key: Word;
Shift: TShiftState);
begin
if Key = VK_Return then
if IsServer then
ServerSocket.Socket.Connections[0].SendText(Memo1.Lines[Memo1.Lines.Count - 1])
else
ClientSocket.Socket.SendText(Memo1.Lines[Memo1.Lines.Count - 1]);
end;
  该段代码的作用很明显,就是开始发消息了。其中如果是Server的话,它只向第一个客户机发消息,由于一个服务器可以连接多个客户机,而同客户机的每一个连接都由一个Socket来维持,因此ServerSocket.Socket.Connnections数组中存储的就是同Client维持连接的Socket。在标准Socket中,服务器方的Socket通过accept()方法的返回值获取维持同客户机连接的Socket,而发送、接受消息的方法分别为send(sendto)和recv(recvfrom), Delphi对此进行了封装。
  5、其余代码的简要介绍。
procedure TChatForm.ServerSocketAccept(Sender: TObject;
Socket: TCustomWinSocket);
begin
IsServer := True;
end;
  ServerSocket的Accept方法,当客户机第一次连接时完成,通过其参数可以认为,它是在标准的accept方法后执行的,因为有TCustomWinSocket这个参数类型,它应该是标准Server方Socket的返回值。

procedure TChatForm.ClientSocketRead(Sender: TObject;
Socket: TCustomWinSocket);
begin
Memo2.Lines.Add(Socket.ReceiveText);
end;

procedure TChatForm.ServerSocketClientRead(Sender: TObject;
Socket: TCustomWinSocket);
begin
Memo2.Lines.Add(Socket.ReceiveText);
end;
  这两段代码分别是服务器方和客户机方在收到对方的消息时,由Delphi触发的,作用是在memo2中显示收到的消息。其中,ClientSocketRead中的Socket实际上就是Socket本身,而在ServerSocketClientRead中的Socket实际上是ServerSocket.Socket.Connection[]中的某个Socket。不过在Delphi中,对服务器方的Socket进行了有效的封装。
procedure TChatForm.ServerSocketClientConnect(Sender: TObject;
Socket: TCustomWinSocket);
begin
Memo2.Lines.Clear;
end;
procedure TChatForm.ClientSocketDisconnect(Sender: TObject;
Socket: TCustomWinSocket);
begin
ListenItemClick(nil);
end;
  这两段比较简单。其中ServerSocketClientConnect在ServerSocket收到一个新的连接时触发。而ClientSocketDisconnect在ClientSocket发出Disconncet时触发。

procedure TChatForm.Exit1Click(Sender: TObject);
begin
ServerSocket.Close;
ClientSocket.Close;
Close;
end;
procedure TChatForm.Disconnect1Click(Sender: TObject);
begin
ClientSocket.Active := False;
ServerSocket.Active := True;
end;
  第一段为关闭应用程序。在标准Socket中,每个Socket在关闭时,必须调用closesocket()方法,否则系统不会释放资源。而在ServerSockt.Close和ClientSocket.Close中,系统内部肯定调用了closesocket()方法。
三、标准Socket与Delphi中的Socket。
标准的Socket的应用程序框架如下:
Server方: Socket()[ 新建一个Socket]--Bind()[ 同服务器地址邦定 ]--Listen() --Accept()--block wait--read()[接受消息,在windows平台中,方法为send(TCP),或者是sendto(UDP)]--处理服务请求--Write()[发送消息,在windows平台中,方法为send(TCP), 或者为sendto(UDP)。
Client方相对简单:Socket()--Connect()[通过一定的port连接特定的服务器,这是与服务器建立连接]--Write()--Read()。
  Socket可以是基于TCP的,也可以是基于UDP,同时Socket甚至建立在其他的协议,比如IPX/SPX,DECNet等。在新建一个Socket时,可以指定新建何类Socket。Bind()用来同服务器的地址邦定,如果一个主机只有一个IP地址,实际上邦定的作用就相对多余了。Listen()开始监听网络,Accept()用于接受连接,其返回值是保持同客户机联系的Socket。
  在Delphi中,对于Windows中的Socket进行了有效的封装。在Delphi中,按其继承关系,可以分层两类:
一、TComponent--TAbstractSocket--TCustomSocket--TCustomServerSocket--TServerSocket
TComponent--TAbstractSocket--TCustomSocket--TClientSocket
二、直接从TObject继承过来:
TObject--TCustomWinSocket--TServerWinSocket
TObject--TCustomWinSocket--TClientWinSocket
TObject--TCustomWinSocket--TServerClientWinSocket
  可以看出第一类建立在TCustomSocket基础上,第二类建立在TCustomWinSocket的基础上。第一类建立在TComponet的基础上,第二类直接构建在TObject基础上。因此如果用户非常熟悉Socket并且想要编写控制台程序时,可以使用TCustomWinScoket类。
  同uses中可以看出,它们都在ScktComp.pas中实现,而在schtComp.pas中,则包含了winsock.pas文件,如果继续深入winsock文件,在其中可以发现所有的Windows Socket的基本方法。

  实际上,如果你了解了标准Socket的应用程序框架,对于使用Delphi编写Socket应用程序也就得心应手了;这不是说你必须了解复杂的Socket中的标准函数,也没有必要,因为Delphi已经为你做了很好的封装了,这也正是Delphi的强势所在,你只要了解那么一点点的基本框架。
  这是我对Delphi中的Socket应用的理解,不足之处希望大家指正。同时也乐于为大家解答Delphi中有关Socket的问题。

 

实例二

 

 

利用Delphi编写Socket通信程序

ClientSocket组件为客户端组件。它是通信的请求方,也就是说,它是主动地与服务器端建立连接。 
ServerSocket组件为服务器端组件。它是通信的响应方,也就是说,它的动作是监听以及被动接受客户端的连接请求,并对请求进行回复。 
ServerSocket组件可以同时接受一个或多个ClientSocket组件的连接请求,并与每个ClientSocket组件建立单独的连接,进行单独的通信。因此,一个服务器端可以为多个客户端服务。 
设计思路 
本例包括一个服务器端程序和一个客户端程序。客户端程序可以放到多个计算机上运行,同时与服务器端进行连接通信。 
本例的重点,一是演示客户端与服务器端如何通信;二是当有多个客户端同时连接到服务器端时,服务器端如何识别每个客户端,并对请求给出相应的回复。为了保证一个客户端断开连接时不影响其它客户端与服务器端的通信,同时保证服务器端能够正确回复客户端的请求,在本例中声明了一个记录类型: 
type 
client_record=record 
CHandle: integer; //客户端套接字句柄 
CSocket:TCustomWinSocket; //客户端套接字 
CName:string; //客户端计算机名称 
CAddress:string; //客户端计算机IP地址 
CUsed: boolean; //客户端联机标志 
end; 
利用这个记录类型数据保存客户端的信息,同时保存当前客户端的连接状态。其中,CHandle保存客户端套接字句柄,以便准确定位每个与服务器端保持连接的客户端;Csocket保存客户端套接字,通过它可以对客户端进行回复。Cused记录当前客户端是否与服务器端保持连接。 
下面对组件ServerSocket和ClientSocket的属性设置简单说明。 
ServerSocket的属性: 
· Port,是通信的端口,必须设置。在本例中设置为1025; 
· ServerTypt,服务器端读写信息类型,设置为stNonBlocking表示异步读写信息,本例中采用这种方式。 
· ThreadCacheSize,客户端的最大连接数,就是服务器端最多允许多少客户端同时连接。本例采用默认值10。 
其它属性采用默认设置即可。 
ClientSocket的属性: 
· Port,是通信的端口,必须与服务器端的设置相同。在本例中设置为1025; 
· ClientType,客户端读写信息类型,应该与服务器端的设置相同,为stNonBlocking表示异步读写信息。 
· Host,客户端要连接的服务器的IP地址。必须设置,当然也可以在代码中动态设置。 
其它属性采用默认设置即可。 
程序源代码: 
· 服务器端源码(uServerMain.pas): 
unit uServerMain; 
interface 
uses 
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs, 
ScktComp, ToolWin, ComCtrls, ExtCtrls, StdCtrls, Buttons; 
const 
CMax=10; //客户端最大连接数 
type 
client_record=record 
CHandle: integer; //客户端套接字句柄 
CSocket:TCustomWinSocket; //客户端套接字 
CName:string; //客户端计算机名称 
CAddress:string; //客户端计算机IP地址 
CUsed: boolean; //客户端联机标志 
end; 
type 
TfrmServerMain = class(TForm) 
ServerSocket: TServerSocket; 
ControlBar1: TControlBar; 
ToolBar1: TToolBar; 
tbConnect: TToolButton; 
tbClose: TToolButton; 
tbDisconnected: TToolButton; 
Edit1: TEdit; 
Memo1: TMemo; 
StatusBar: TStatusBar; 
procedure tbConnectClick(Sender: TObject); 
procedure tbDisconnectedClick(Sender: TObject); 
procedure ServerSocketClientRead(Sender: TObject; 
Socket: TCustomWinSocket); 
procedure ServerSocketListen(Sender: TObject; 
Socket: TCustomWinSocket); 
procedure ServerSocketClientConnect(Sender: TObject; 
Socket: TCustomWinSocket); 
procedure ServerSocketClientDisconnect(Sender: TObject; 
Socket: TCustomWinSocket); 
procedure tbCloseClick(Sender: TObject); 
procedure FormCreate(Sender: TObject); 
procedure FormClose(Sender: TObject; var Action: TCloseAction); 
procedure ServerSocketGetSocket(Sender: TObject; Socket: Integer; 
var ClientSocket: TServerClientWinSocket); 
procedure ServerSocketClientError(Sender: TObject; 
Socket: TCustomWinSocket; ErrorEvent: TErrorEvent; 
var ErrorCode: Integer); 
private 
{ Private declarations } 
public 
{ Public declarations } 
session: array[0..CMax] of client_record; //客户端连接数组 
Sessions: integer; //客户端连接数 
end; 
var 
frmServerMain: TfrmServerMain; 
implementation 
{$R *.DFM} 
//打开套接字连接,并使套接字进入监听状态 
procedure TfrmServerMain.tbConnectClick(Sender: TObject); 
begin 
ServerSocket.Open ; 
end; 
//关闭套接字连接,不再监听客户端的请求 
procedure TfrmServerMain.tbDisconnectedClick(Sender: TObject); 
begin 
ServerSocket.Close; 
StatusBar.Panels[0].Text :=‘服务器套接字连接已经关闭,无法接受客户端的连接请求.‘; 
end; 
//从客户端读取信息 
procedure TfrmServerMain.ServerSocketClientRead(Sender: TObject; 
Socket: TCustomWinSocket); 
var 
i:integer; 
begin 
//将从客户端读取的信息添加到Memo1中 
Memo1.Lines.Add(Socket.ReceiveText); 
for i:=0 to sessions do 
begin 
//取得匹配的客户端 
if session[i].CHandle = Socket.SocketHandle then 
begin 
session[i].CSocket.SendText(‘回复客户端‘+session[i].CAddress+‘ ==> ‘+Edit1.Text); 
end; 
end; 
end; 
//服务器端套接字进入监听状态,以便监听客户端的连接 
procedure TfrmServerMain.ServerSocketListen(Sender: TObject; 
Socket: TCustomWinSocket); 
begin 
StatusBar.Panels[0].Text :=‘等待客户端连接...‘; 
end; 
//当客户端连接到服务器端以后 
procedure TfrmServerMain.ServerSocketClientConnect(Sender: TObject; 
Socket: TCustomWinSocket); 
var 
i,j:integer; 
begin 
j:=-1; 
for i:=0 to sessions do 
begin 
//在原有的客户端连接数组中有中断的客户端连接 
if not session[i].CUsed then 
begin 
session[i].CHandle := Socket.SocketHandle ;//客户端套接字句柄 
session[i].CSocket := Socket; //客户端套接字 
session[i].CName := Socket.RemoteHost ; //客户端计算机名称 
session[i].CAddress := Socket.RemoteAddress ;//客户端计算机IP 
session[i].CUsed := True; //连接数组当前位置已经占用 
Break; 
end; 
j:=i; 
end; 
if j=sessions then 
begin 
inc(sessions); 
session[j].CHandle := Socket.SocketHandle ; 
session[j].CSocket := Socket; 
session[j].CName := Socket.RemoteHost ; 
session[j].CAddress := Socket.RemoteAddress ; 
session[j].CUsed := True; 
end; 
StatusBar.Panels[0].Text := ‘客户端 ‘+Socket.RemoteHost + ‘ 已经连接‘; 
end; 
//当客户端断开连接时 
procedure TfrmServerMain.ServerSocketClientDisconnect(Sender: TObject; 
Socket: TCustomWinSocket); 
var 
i:integer; 
begin 
for i:=0 to sessions do 
begin 
if session[i].CHandle =Socket.SocketHandle then 
begin 
session[i].CHandle :=0; 
session[i].CUsed := False; 
Break; 
end; 
end; 
StatusBar.Panels[0].Text :=‘客户端 ‘+Socket.RemoteHost + ‘ 已经断开‘; 
end; 
//关闭窗口 
procedure TfrmServerMain.tbCloseClick(Sender: TObject); 
begin 
Close; 
end; 
procedure TfrmServerMain.FormCreate(Sender: TObject); 
begin 
sessions := 0; 
end; 
procedure TfrmServerMain.FormClose(Sender: TObject; 
var Action: TCloseAction); 
begin 
ServerSocket.Close ; 
end; 
//当客户端正在与服务器端连接时 
procedure TfrmServerMain.ServerSocketGetSocket(Sender: TObject; 
Socket: Integer; var ClientSocket: TServerClientWinSocket); 
begin 
StatusBar.Panels[0].Text :=‘客户端正在连接...‘; 
end; 
//客户端发生错误 
procedure TfrmServerMain.ServerSocketClientError(Sender: TObject; 
Socket: TCustomWinSocket; ErrorEvent: TErrorEvent; 
var ErrorCode: Integer); 
begin 
StatusBar.Panels[0].Text :=‘客户端‘+Socket.RemoteHost +‘发生错误!‘; 
ErrorCode := 0; 
end; 
end. 
· 客户端源码(uClientMain.pas): 
unit uClientMain; 
interface 
uses 
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs, 
ScktComp, ComCtrls, ToolWin, ExtCtrls, StdCtrls, Buttons; 
const 
SocketHost = ‘172.16.1.6‘; //服务器端地址 
type 
TfrmClientMain = class(TForm) 
ControlBar1: TControlBar; 
ToolBar1: TToolBar; 
tbConnected: TToolButton; 
tbSend: TToolButton; 
tbClose: TToolButton; 
tbDisconnected: TToolButton; 
ClientSocket: TClientSocket; 
Edit1: TEdit; 
Memo1: TMemo; 
StatusBar: TStatusBar; 
btnSend: TBitBtn; 
procedure tbConnectedClick(Sender: TObject); 
procedure tbDisconnectedClick(Sender: TObject); 
procedure ClientSocketRead(Sender: TObject; Socket: TCustomWinSocket); 
procedure tbSendClick(Sender: TObject); 
procedure tbCloseClick(Sender: TObject); 
procedure FormShow(Sender: TObject); 
procedure ClientSocketConnect(Sender: TObject; 
Socket: TCustomWinSocket); 
procedure ClientSocketConnecting(Sender: TObject; 
Socket: TCustomWinSocket); 
procedure ClientSocketDisconnect(Sender: TObject; 
Socket: TCustomWinSocket); 
procedure FormClose(Sender: TObject; var Action: TCloseAction); 
procedure ClientSocketError(Sender: TObject; Socket: TCustomWinSocket; 
ErrorEvent: TErrorEvent; var ErrorCode: Integer); 
private 
{ Private declarations } 
public 
{ Public declarations } 
end; 
var 
frmClientMain: TfrmClientMain; 
implementation 
{$R *.DFM} 
//打开套接字连接 
procedure TfrmClientMain.tbConnectedClick(Sender: TObject); 
begin 
ClientSocket.Open ; 
end; 
//关闭套接字连接 
procedure TfrmClientMain.tbDisconnectedClick(Sender: TObject); 
begin 
ClientSocket.Close; 
end; 
//接受服务器端的回复 
procedure TfrmClientMain.ClientSocketRead(Sender: TObject; 
Socket: TCustomWinSocket); 
begin 
Memo1.Lines.Add(Socket.ReceiveText); 
end; 
//发送信息到服务器端 
procedure TfrmClientMain.tbSendClick(Sender: TObject); 
begin 
ClientSocket.Socket.SendText(Edit1.Text); 
end; 
procedure TfrmClientMain.tbCloseClick(Sender: TObject); 
begin 
Close; 
end; 
//设置要连接的服务器端地址 
procedure TfrmClientMain.FormShow(Sender: TObject); 
begin 
ClientSocket.Host := SocketHost; 
end; 
//已经连接到服务器端 
procedure TfrmClientMain.ClientSocketConnect(Sender: TObject; 
Socket: TCustomWinSocket); 
begin 
tbSend.Enabled := True; 
tbDisconnected.Enabled :=True; 
btnSend.Enabled := True; 
StatusBar.Panels[0].Text := ‘已经连接到 ‘+ Socket.RemoteHost ; 
end; 
//正在连接到服务器端 
procedure TfrmClientMain.ClientSocketConnecting(Sender: TObject; 
Socket: TCustomWinSocket); 
begin 
StatusBar.Panels[0].Text := ‘正在连接到服务器... ‘ ; 
end; 
//当断开与服务器端的连接时发生 
procedure TfrmClientMain.ClientSocketDisconnect(Sender: TObject; 
Socket: TCustomWinSocket); 
begin 
tbSend.Enabled := False; 
btnSend.Enabled := False; 
tbDisconnected.Enabled := False; 
StatusBar.Panels[0].Text := ‘已经断开与 ‘+ Socket.RemoteHost +‘ 的连接‘; 
end; 
procedure TfrmClientMain.FormClose(Sender: TObject; 
var Action: TCloseAction); 
begin 
ClientSocket.Close ; 
end; 
//当与服务器端的连接发生错误时 
procedure TfrmClientMain.ClientSocketError(Sender: TObject; 
Socket: TCustomWinSocket; ErrorEvent: TErrorEvent; 
var ErrorCode: Integer); 
begin 
StatusBar.Panels[0].Text := ‘与服务器端的连接发生错误‘; 
ErrorCode := 0; 
end; 
end. 
小结 
上述方法是比较简单的实现方法,同时也是相对较容易理解的方法。通过这个方法,笔者成功实现了局域网内多个客户端与服务器端进行Socket通信的功能,同时可以保证一个客户端的连接、通信或是断开都不影响其它客户端的正常通信。 
附录: 
服务器端窗体和客户端窗体及组件的属性设置参加相应的DFM文件。 
uServerMain.pas对应的DFM文件(uServerMain.dfm) 
object frmServerMain: TfrmServerMain 
Left = 297 
Top = 258 
BorderIcons = [biSystemMenu, biMinimize] 
BorderStyle = bsSingle 
Caption = ‘ServerSocket‘ 
ClientHeight = 279 
ClientWidth = 476 
Color = clBtnFace 
Font.Charset = DEFAULT_CHARSET 
Font.Color = clWindowText 
Font.Height = -11 
Font.Name = ‘MS Sans Serif‘ 
Font.Style = [] 
OldCreateOrder = False 
OnClose = FormClose 
OnCreate = FormCreate 
PixelsPerInch = 96 
TextHeight = 13 
object ControlBar1: TControlBar 
Left = 0 
Top = 0 
Width = 476 
Height = 30 
Align = alTop 
AutoSize = True 
TabOrder = 0 
object ToolBar1: TToolBar 
Left = 11 
Top = 2 
Width = 459 
Height = 22 
ButtonHeight = 21 
ButtonWidth = 55 
Caption = ‘ToolBar1‘ 
EdgeInner = esNone 
EdgeOuter = esNone 
Flat = True 
ShowCaptions = True 
TabOrder = 0 
object tbConnect: TToolButton 
Left = 0 
Top = 0 
Caption = ‘ 连接 ‘ 
ImageIndex = 0 
OnClick = tbConnectClick 
end 
object tbDisconnected: TToolButton 
Left = 55 
Top = 0 
Caption = ‘断开‘ 
ImageIndex = 4 
OnClick = tbDisconnectedClick 
end 
object tbClose: TToolButton 
Left = 110 
Top = 0 
Caption = ‘关闭‘ 
ImageIndex = 3 
OnClick = tbCloseClick 
end 
end 
end 
object Edit1: TEdit 
Left = 0 
Top = 232 
Width = 473 
Height = 21 
TabOrder = 1 
Text = ‘你好!‘ 
end 
object Memo1: TMemo 
Left = 0 
Top = 30 
Width = 476 
Height = 195 
Align = alTop 
TabOrder = 2 
end 
object StatusBar: TStatusBar 
Left = 0 
Top = 257 
Width = 476 
Height = 22 
Panels = < 
item 
Width = 50 
end> 
SimplePanel = False 
end 
object ServerSocket: TServerSocket 
Active = False 
Port = 1025 
ServerType = stNonBlocking 
OnListen = ServerSocketListen 
OnGetSocket = ServerSocketGetSocket 
OnClientConnect = ServerSocketClientConnect 
OnClientDisconnect = ServerSocketClientDisconnect 
OnClientRead = ServerSocketClientRead 
OnClientError = ServerSocketClientError 
Left = 368 
end 
end 
uClientMain.pas对应的DFM文件(uClientMain.dfm) 
object frmClientMain: TfrmClientMain 
Left = 361 
Top = 290 
BorderIcons = [biSystemMenu, biMinimize] 
BorderStyle = bsSingle 
Caption = ‘ClientSocket‘ 
ClientHeight = 230 
ClientWidth = 402 
Color = clBtnFace 
Font.Charset = DEFAULT_CHARSET 
Font.Color = clWindowText 
Font.Height = -11 
Font.Name = ‘MS Sans Serif‘ 
Font.Style = [] 
OldCreateOrder = False 
Position = poScreenCenter 
OnClose = FormClose 
OnShow = FormShow 
PixelsPerInch = 96 
TextHeight = 13 
object ControlBar1: TControlBar 
Left = 0 
Top = 0 
Width = 402 
Height = 30 
Align = alTop 
AutoSize = True 
TabOrder = 0 
object ToolBar1: TToolBar 
Left = 11 
Top = 2 
Width = 385 
Height = 22 
ButtonHeight = 21 
ButtonWidth = 55 
Caption = ‘ToolBar1‘ 
EdgeInner = esNone 
EdgeOuter = esNone 
Flat = True 
ShowCaptions = True 
TabOrder = 0 
object tbConnected: TToolButton 
Left = 0 
Top = 0 
Caption = ‘ 连接 ‘ 
ImageIndex = 0 
OnClick = tbConnectedClick 
end 
object tbSend: TToolButton 
Left = 55 
Top = 0 
Caption = ‘发送‘ 
Enabled = False 
ImageIndex = 1 
OnClick = tbSendClick 
end 
object tbDisconnected: TToolButton 
Left = 110 
Top = 0 
Caption = ‘断开‘ 
Enabled = False 
ImageIndex = 3 
OnClick = tbDisconnectedClick 
end 
object tbClose: TToolButton 
Left = 165 
Top = 0 
Caption = ‘退出‘ 
ImageIndex = 2 
OnClick = tbCloseClick 
end 
end 
end 
object Edit1: TEdit 
Left = 0 
Top = 184 
Width = 321 
Height = 21 
TabOrder = 1 
Text = ‘问候‘ 
end 
object Memo1: TMemo 
Left = 0 
Top = 30 
Width = 402 
Height = 147 
Align = alTop 
TabOrder = 2 
end 
object StatusBar: TStatusBar 
Left = 0 
Top = 208 
Width = 402 
Height = 22 
Panels = < 
item 
Width = 50 
end> 
SimplePanel = False 
end 
object btnSend: TBitBtn 
Left = 336 
Top = 183 
Width = 60 
Height = 22 
Caption = ‘发送‘ 
Enabled = False 
TabOrder = 4 
OnClick = tbSendClick 
end 
object ClientSocket: TClientSocket 
Active = False 
ClientType = ctNonBlocking 
Port = 1025 
OnConnecting = ClientSocketConnecting 
OnConnect = ClientSocketConnect 
OnDisconnect = ClientSocketDisconnect 
OnRead = ClientSocketRead 
OnError = ClientSocketError 
Left = 320 
end 
end

 
http://blog.sina.com.cn/s/blog_4bb8e2ed01000byp.html
 http://blog.csdn.net/lcq419/article/details/1269938

Delphi的Socket编程步骤(repulish)