C#适时监听IP端口

[miaoxiao423]

移动终端（POS机）发送数据（例如客户名）到服务器指定的端口上（假设服务器IP为：192.168.10.123,端口号为1200）。通过C#，socket编程来适时监听这个端口，当端口接收到数据时，对数据做相应处理（如判断数据合法性，完整性，然后更新数据），返回一条数据(如返回客户地址）给移动终端（POS机）。并且，服务器控制台上要适时可视化的看到数据包的接收，发送情况。（也就是通过一个ListBox或其他控件进行数据接收与发送的适时显示：如：

成功接收一条查询信息，终端号为A001 时间：16：30：30
成功发出一条查询结果信息，查询类型：客户资料查询。终端号为A001 时间：16：40：30
发送结果到移动终端失败，原因：连接超时 时间16：50：30
……

）
现求一windows窗口应用程序的后台代码，以实现上诉效果。
分数确实太少，但已是本人全部家当。不甚感激！

[满衣兄]

强烈建议自己写，能写多少算多少，这么简单的东西别人帮你写了真是害了你。

[miaoxiao423]

[Quote=引用 2 楼 yfqvip 的回复:]
强烈建议自己写，能写多少算多少，这么简单的东西别人帮你写了真是害了你。
[/Quote]
3天的时间，我已经用了两天，还剩明天一天了！
书到用时方恨少啊。

[我不懂电脑]

命名空间： System.Net.Sockets
程序集： System（在 System.dll 中）

语法
Visual Basic（声明）
Public Class Socket _
Implements IDisposable

Visual Basic（用法）
Dim instance As Socket

C#
public class Socket : IDisposable

Visual C++
public ref class Socket : IDisposable

J#
public class Socket implements IDisposable

JScript
public class Socket implements IDisposable


备注
Socket 类为网络通信提供了一套丰富的方法和属性。Socket 类允许您使用 ProtocolType 枚举中所列出的任何一种协议执行异步和同步数据传输。

Socket 类对异步方法遵循 .NET Framework 命名模式。例如，同步的 Receive 方法对应于异步的 BeginReceive 和 EndReceive 方法。

如果应用程序在执行期间只需要一个线程，请使用下面的方法，这些方法适用于同步操作模式。

如果当前使用的是面向连接的协议（如 TCP），则服务器可以使用 Listen 方法侦听连接。Accept 方法处理任何传入的连接请求，并返回可用于与远程主机进行数据通信的 Socket。可以使用此返回的 Socket 来调用 Send 或 Receive 方法。如果要指定本地 IP 地址和端口号，请在调用 Listen 方法之前先调用 Bind 方法。如果您希望基础服务提供程序为您分配可用端口，请使用端口号 0。如果希望连接到侦听主机，请调用 Connect 方法。若要进行数据通信，请调用 Send 或 Receive 方法。

如果当前使用的是无连接协议（如 UDP），则根本不需要侦听连接。调用 ReceiveFrom 方法可接受任何传入的数据报。使用 SendTo 方法可将数据报发送到远程主机。

若要在执行过程中使用单独的线程处理通信，请使用下面的方法，这些方法适用于异步操作模式。

如果当前使用的是面向连接的协议（如 TCP），则可使用 Socket、BeginConnect 和 EndConnect 方法来连接侦听主机。通过使用 BeginSend 和 EndSend 方法，或者使用 BeginReceive 和 EndReceive 方法，可以进行异步数据通信。可以使用 BeginAccept 和 EndAccept 处理传入的连接请求。

如果您使用的是 UDP 等无连接协议，则可以使用 BeginSendTo 和 EndSendTo 来发送数据报，而使用 BeginReceiveFrom 和 EndReceiveFrom 来接收数据报。

如果对一个套接字执行多个异步操作，它们不一定按启动时的顺序完成。

当数据发送和数据接收完成之后，可使用 Shutdown 方法来禁用 Socket。在调用 Shutdown 之后，可调用 Close 方法来释放与 Socket 关联的所有资源。

通过 Socket 类，您可以使用 SetSocketOption 方法来配置 Socket。可以使用 GetSocketOption 方法来检索这些设置。

注意：
如果要编写相对简单的应用程序，而且不需要最高的性能，则可以考虑使用 TcpClient、TcpListener 和 UdpClient。这些类为 Socket 通信提供了更简单、对用户更友好的接口。


Windows Mobile for Pocket PC, Windows Mobile for Smartphone, Windows CE 平台说明：

并非所有设备的操作系统会支持全部的套接字选项。


示例
下面的代码示例演示如何使用 Socket 类向 HTTP 服务器发送数据和接收响应。接收到整个页前，此示例将一直处于阻止状态。

Visual Basic 复制代码
Imports System
Imports System.Text
Imports System.IO
Imports System.Net
Imports System.Net.Sockets
Imports Microsoft.VisualBasic

Public Class GetSocket

Private Shared Function ConnectSocket(server As String, port As Integer) As Socket
Dim s As Socket = Nothing
Dim hostEntry As IPHostEntry = Nothing

' Get host related information.
hostEntry = Dns.GetHostEntry(server)

' Loop through the AddressList to obtain the supported AddressFamily. This is to avoid
' an exception that occurs when the host host IP Address is not compatible with the address family
' (typical in the IPv6 case).
Dim address As IPAddress

For Each address In hostEntry.AddressList
Dim endPoint As New IPEndPoint(address, port)
Dim tempSocket As New Socket(endPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp)

tempSocket.Connect(endPoint)

If tempSocket.Connected Then
s = tempSocket
Exit For
End If

Next address

Return s
End Function


' This method requests the home page content for the specified server.

Private Shared Function SocketSendReceive(server As String, port As Integer) As String
'Set up variables and String to write to the server.
Dim ascii As Encoding = Encoding.ASCII
Dim request As String = "GET / HTTP/1.1" + ControlChars.Cr + ControlChars.Lf + "Host: " + server + ControlChars.Cr + ControlChars.Lf + "Connection: Close" + ControlChars.Cr + ControlChars.Lf + ControlChars.Cr + ControlChars.Lf
Dim bytesSent As [Byte]() = ascii.GetBytes(request)
Dim bytesReceived(255) As [Byte]

' Create a socket connection with the specified server and port.
Dim s As Socket = ConnectSocket(server, port)

If s Is Nothing Then
Return "Connection failed"
End If
' Send request to the server.
s.Send(bytesSent, bytesSent.Length, 0)

' Receive the server home page content.
Dim bytes As Int32

' Read the first 256 bytes.
Dim page as [String] = "Default HTML page on " + server + ":" + ControlChars.Cr + ControlChars.Lf

' The following will block until the page is transmitted.
Do
bytes = s.Receive(bytesReceived, bytesReceived.Length, 0)
page = page + Encoding.ASCII.GetString(bytesReceived, 0, bytes)
Loop While bytes > 0

Return page
End Function

'Entry point which delegates to C-style main Private Function
Public Overloads Shared Sub Main()
Main(System.Environment.GetCommandLineArgs())
End Sub


Overloads Private Shared Sub Main(args() As String)
Dim host As String
Dim port As Integer = 80

If args.Length = 1 Then
' If no server name is passed as argument to this program,
' use the current host name as default.
host = Dns.GetHostName()
Else
host = args(1)
End If

Dim result As String = SocketSendReceive(host, port)

Console.WriteLine(result)
End Sub 'Main
End Class




C# 复制代码
using System;
using System.Text;
using System.IO;
using System.Net;
using System.Net.Sockets;

public class GetSocket
{
private static Socket ConnectSocket(string server, int port)
{
Socket s = null;
IPHostEntry hostEntry = null;

// Get host related information.
hostEntry = Dns.GetHostEntry(server);

// Loop through the AddressList to obtain the supported AddressFamily. This is to avoid
// an exception that occurs when the host IP Address is not compatible with the address family
// (typical in the IPv6 case).
foreach(IPAddress address in hostEntry.AddressList)
{
IPEndPoint ipe = new IPEndPoint(address, port);
Socket tempSocket =
new Socket(ipe.AddressFamily, SocketType.Stream, ProtocolType.Tcp);

tempSocket.Connect(ipe);

if(tempSocket.Connected)
{
s = tempSocket;
break;
}
else
{
continue;
}
}
return s;
}

// This method requests the home page content for the specified server.
private static string SocketSendReceive(string server, int port)
{
string request = "GET / HTTP/1.1\r\nHost: " + server +
"\r\nConnection: Close\r\n\r\n";
Byte[] bytesSent = Encoding.ASCII.GetBytes(request);
Byte[] bytesReceived = new Byte[256];

// Create a socket connection with the specified server and port.
Socket s = ConnectSocket(server, port);

if (s == null)
return ("Connection failed");

// Send request to the server.
s.Send(bytesSent, bytesSent.Length, 0);

// Receive the server home page content.
int bytes = 0;
string page = "Default HTML page on " + server + ":\r\n";

// The following will block until te page is transmitted.
do {
bytes = s.Receive(bytesReceived, bytesReceived.Length, 0);
page = page + Encoding.ASCII.GetString(bytesReceived, 0, bytes);
}
while (bytes > 0);

return page;
}

public static void Main(string[] args)
{
string host;
int port = 80;

if (args.Length == 0)
// If no server name is passed as argument to this program,
// use the current host name as the default.
host = Dns.GetHostName();
else
host = args[0];

string result = SocketSendReceive(host, port);
Console.WriteLine(result);
}
}

[miaoxiao423]

[Quote=引用 4 楼 songhtao 的回复:]
命名空间： System.Net.Sockets
程序集： System（在 System.dll 中）

语法
Visual Basic（声明）
Public Class Socket _
Implements IDisposable

Visual Basic（用法）
Dim instance As Socket

C#
public class Socket : IDisposable

Visual C++
public ref class Socket : IDisposable

J#
public class Socket implements IDisposable

JScript
public class Socket implements ID…
[/Quote]
MSDN上也有这个，但是弄了半天没搬过来。

[liudanking]

lz看一下mcdn里面的socket就知道怎么写了。
加油！不要被时间吓到了

[miaoxiao423]

[Quote=引用 6 楼 liudanking 的回复:]
lz看一下mcdn里面的socket就知道怎么写了。
加油！不要被时间吓到了
[/Quote]
3Q!

[蓝海D鱼]

server端
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Net.Sockets;
using System.Net;
using System.Threading;


namespace se
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
      
        private IPEndPoint MyServer;
        private Socket sock;
        private Socket handler;
        private bool bb = true;

        private void Form1_Load(object sender, EventArgs e)
        {
            try
            {
                MyServer = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 999);
                sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                sock.Bind(MyServer);
                sock.Listen(50);
                toolStripStatusLabel1.Text = "开始监听 ．．．";
                sock.BeginAccept(new AsyncCallback(AcceptCallback), sock);
            }
            catch (Exception ee) { toolStripStatusLabel1.Text = ee.Message; }

            Control.CheckForIllegalCrossThreadCalls = false;

        }

        private void targett()
        {
            if (handler.Connected)
            {
                toolStripStatusLabel1.Text = "与客户建立连接。";
                while (bb)
                {
                    Byte[] bbb = new Byte[640];
                    handler.Receive(bbb, bbb.Length, 0);
                    string ccc = System.Text.Encoding.UTF8.GetString(bbb);
                    string x = "w";
                    int i = ccc.IndexOf(x);
                    if (i > 0)
                    {
                        saveUser(ccc);
                    }
                    richTextBox1.AppendText(ccc + "\r\n");
                }
            }
        }
        private void saveUser(string str) 
        { 
           
        }
        private void AcceptCallback(IAsyncResult ar)
        {
            toolStripStatusLabel1.Text = "与客户建立连接!";
            handler = ((Socket)ar.AsyncState).EndAccept(ar);
            Thread thread = new Thread(new ThreadStart(targett));
            thread.Start();
        } 

    }
}

客户端：
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Net.Sockets;
using System.Net;
using System.Threading;


namespace Client
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
  
    private IPEndPoint MyServer; 
        private Socket sock; 
        private bool bb = true; 
                
        private void Form1_Load(object sender, EventArgs e) 
        { 


            Control.CheckForIllegalCrossThreadCalls = false; 
        } 
        
        private void targett() 
        { 
            while (bb) 
            { 
                Byte[] bbb = new Byte[640]; 
                sock.Receive(bbb, bbb.Length, 0); 
                string aaaaa = System.Text.Encoding.BigEndianUnicode.GetString(bbb);
                this.richTextBox1.AppendText(aaaaa); 
            } 
        } 
        
        private void button2_Click(object sender, EventArgs e) 
        { 
            try 
            { 
                Byte[] bytee = new Byte[640];
                string send = this.richTextBox2.Text + "\r\n"; 
                bytee = System.Text.Encoding.BigEndianUnicode.GetBytes(send.ToCharArray()); 
                sock.Send(bytee, bytee.Length, 0); 
            } 
            catch { MessageBox.Show("连接尚未建立! 无法发送!"); } 
        }

        private void richTextBox1_TextChanged(object sender, EventArgs e)
        {

        }

        private void button1_Click(object sender, EventArgs e)
        {
            try
            {
                Byte[] bytee = new Byte[640];
                string send = this.richTextBox2.Text + "\r\n";
                bytee = System.Text.Encoding.UTF8.GetBytes(send.ToCharArray());
                sock.Send(bytee, bytee.Length, 0);
            }
            catch { MessageBox.Show("连接尚未建立! 无法发送!"); } 
        }

        private void button2_Click_1(object sender, EventArgs e)
        {
            try
            {
                MyServer = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 999);
                sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                sock.Connect(MyServer);
                this.label1.Text = "连接成功!";
                Thread thread = new Thread(new ThreadStart(targett));
                thread.Start();
            }
            catch (Exception ee) { MessageBox.Show(ee.Message); } 
        }
    }
}

[蓝海D鱼]

Socket网络编程学习笔记（2）：面向连接的Socket
在上一篇中，我列了一些常用的方法，可以说这些方法是一些辅助性的方法，对于分析网络中的主机属性非常有用。在这篇中，我将会介绍一下面向连接（TCP）socket编程，其中辅以实例，代码可供下载。
对于TCP的Socket编程，主要分二部分：
一、服务端Socket侦听：
服务端Socket侦听主要分以下几个步骤，按照以下几个步骤我们可以很方便的建立起一个Socket侦听服务，来侦听尝试连接到该服务器的客户Socket，从而建立起连接进行相关通讯。
1、创建IPEndPoint实例，用于Socket侦听时绑定

1IPEndPoint ipep = new IPEndPoint(IPAddress.Any, 6001);
2、创建套接字实例
1//创建一个套接字
2 serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
这里创建的时候用ProtocolType.Tcp，表示建立一个面向连接(TCP)的Socket。

3、将所创建的套接字与IPEndPoint绑定

1 //将所创建的套接字与IPEndPoint绑定
2 serverSocket.Bind(ipep);
4、设置套接字为收听模式
1//设置套接字为收听模式
2 serverSocket.Listen(10);
以上这四步，我们已经建立了Socket的侦听模式，下面我们就来设置怎么样来获取客户Socket连接的实例，以及连接后的信息发送。

5、在套接字上接收接入的连接
1while (true)
2 {
3 try
4 {
5 //在套接字上接收接入的连接
6 clientSocket = serverSocket.Accept();
7 clientThread = new Thread(new ThreadStart(ReceiveData));
8 clientThread.Start();
9 }
10 catch (Exception ex)
11 {
12 MessageBox.Show("listening Error: " + ex.Message);
13 }
14 }
通过serverSocket.Accept()来接收客户Socket的连接请求，在这里用循环可以实现该线程实时侦听，而不是只侦听一次。当程序运行serverSocket.Accept()时，会等待，直到有客户端Socket发起连接请求时，获取该客户Socket，如上面的clientSocket。在这里我用多线程来实现与多个客户端Socket的连接和通信，一旦接收到一个连接后，就新建一个线程，执行ReceiveData功能来实现信息的发送和接收。

6、 在套接字上接收客户端发送的信息和发送信息
1private void ReceiveData()
2 {
3 bool keepalive = true;
4 Socket s = clientSocket;
5 Byte[] buffer = new Byte[1024];
6
7 //根据收听到的客户端套接字向客户端发送信息
8 IPEndPoint clientep = (IPEndPoint)s.RemoteEndPoint;
9 lstServer.Items.Add("Client：" + clientep.Address + "("+clientep.Port+")");
10 string welcome = "Welcome to my test sever ";
11 byte[] data = new byte[1024];
12 data = Encoding.ASCII.GetBytes(welcome);
13 s.Send(data, data.Length, SocketFlags.None);
14
15 while (keepalive)
16 {
17 //在套接字上接收客户端发送的信息
18 int bufLen = 0;
19 try
20 {
21 bufLen = s.Available;
22
23 s.Receive(buffer, 0, bufLen, SocketFlags.None);
24 if (bufLen == 0)
25 continue;
26 }
27 catch (Exception ex)
28 {
29 MessageBox.Show("Receive Error:" + ex.Message);
30 return;
31 }
32 clientep = (IPEndPoint)s.RemoteEndPoint;
33 string clientcommand = System.Text.Encoding.ASCII.GetString(buffer).Substring(0, bufLen);
34
35 lstServer.Items.Add(clientcommand + "("+clientep.Address + ":"+clientep.Port+")");
36
37 }
38
39 }

通过IPEndPoint clientep = (IPEndPoint)s.RemoteEndPoint;我们可以获取连接上的远程主机的端口和IP地址，如果想查询该主机的其它属性如主机名等，可用于上一篇讲的Dns.GetHostByAddress(string ipAddress)来返回一个IPHostEntry对象，就可以得到。另外我们要注意的是，通过Socket发送信息，必须要先把发送的信息转化成二进字进行传输，收到信息后也要把收到的二进字信息转化成字符形式，这里可以通过Encoding.ASCII.GetBytes(welcome);和Encoding.ASCII.GetString(buffer).Substring(0, bufLen);来实现。

以上就是服务端Socket侦听模式的实现，只要有远程客户端Socket连接上后，就可以轻松的发送信息和接收信息了。下面我们来看看客户端Socket是怎么连接上服务器的。

二、客户端连接

客户端Socket连接相对来说比较简单了，另外说明一下，在执行客户端连接前，服务端Socket侦听必须先启动，不然会提示服务器拒绝连接的信息。

1、创建IPEndPoint实例和套接字

1 //创建一个套接字
2 IPEndPoint ipep = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 6001);
3 clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
这个跟服务端Socket侦听差不多，下面一步由服务端Socket的侦听模式变成连接模式。

2、将套接字连接到远程服务器

1//将套接字与远程服务器地址相连
2 try
3 {
4 clientSocket.Connect(ipep);
5 }
6 catch (SocketException ex)
7 {
8 MessageBox.Show("connect error: " + ex.Message);
9 return;
10 }
前面已说明，如果在执行Socket连接时，服务器的Socket侦听没有开启的话，会产生一个SocketException异常，如果没有异常发生，那恭喜你，你已经与服务器连接上了，接下来就可以跟服务器通信了。

3、接收信息

1while (true)
2 {
3 //接收服务器信息
4 int bufLen = 0;
5 try
6 {
7 bufLen = clientSocket.Available;
8
9 clientSocket.Receive(data, 0, bufLen, SocketFlags.None);
10 if (bufLen == 0)
11 {
12 continue;
13 }
14 }
15 catch (Exception ex)
16 {
17 MessageBox.Show("Receive Error:" + ex.Message);
18 return;
19 }
20
21 string clientcommand = System.Text.Encoding.ASCII.GetString(data).Substring(0, bufLen);
22
23 lstClient.Items.Add(clientcommand);
24
25 }
4、发送信息

1//向服务器发送信息
2
3 byte[] data = new byte[1024];
4 data = Encoding.ASCII.GetBytes(txtClient.Text);
5 clientSocket.Send(data, data.Length, SocketFlags.None);
客户端的发送信息和接收信息跟服务器的接收发送是一样的，只不过一个是侦听模式而另一个是连接模式。

以下是程序的运行界面，这些在源码下载里都可以看到：

1、服务端界面：


2、客户端界面：


好了，关于面向连接的Socket就讲到这里了，以实例为主，希望对那些派得上用场的朋友能够看得明白。另外提一下，这里服务端开启侦听服务、客户端连接服务端都采用线程方式来实现，这样服务端能够跟多个客户端同时通信，不用等候，当然还有另外一种方式可以实现那就是异步socket，关于这些可以搜索博客园上的相关文章，已经有好多了。

[miaoxiao423]

[Quote=引用 8 楼 jingshuaizh 的回复:]
C# code
server端
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Net.Sockets;
using System.Net;
using System.Threading;


namespace se
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();…
[/Quote]
差不多明白了，但是好像没有数据回发的处理！谢谢！

[miaoxiao423]

继续等待~

[zjs1109]

百度一下《C#网络编程》

[这个还能被注册？]

帮顶下

[sanfrontgfl]

学习

[sjlianan]

好复杂啊

[qlzf11140820]

学习

[miaoxiao423]

坚持！

[CeleryZeng]

[Quote=引用 2 楼 yfqvip 的回复:]
强烈建议自己写，能写多少算多少，这么简单的东西别人帮你写了真是害了你。
[/Quote]

我个人根本不知道怎么写
你至少给LZ一点提示撒~~~

[jdhlowforever]

[Quote=引用 8 楼 jingshuaizh 的回复:]
C# codeserver端usingSystem;usingSystem.Collections.Generic;usingSystem.ComponentModel;usingSystem.Data;usingSystem.Drawing;usingSystem.Text;usingSystem.Windows.Forms;usingSystem.Net.Sockets;usingSystem.Net;usingSystem.Threading;namespacese
{publicpartialclassForm1 : Form
{publicForm1()
{
InitializeComponent();
}privateIPEndPoint MyServer;privateSocket sock;private…
[/Quote]

不错。顶好的一段代码。。

[gxj760998]

我手头上倒是有一个，可惜直接不能给你啊。帖点你参考吧：
//端口监听
localServer = new TcpListener((Dns.GetHostAddresses(Dns.GetHostName()))[0], port);
localServer.Start();
while (isListener)
{
System.Threading.Thread.Sleep(100);
isRun = true;
if (localServer.Pending())
{
Socket currentSocket = localServer.AcceptSocket();

Server485 current485 = new Server485(currPoint.Address.ToString(), currPoint.Port, currentSocket);
//更新界面，需要执行者和委托或者封装支持跨线程的方法
if (currentForm != null && delegt485 != null)
{
currentForm.Invoke(delegt485, currPoint.Address.ToString(), true);
}
}
}
isRun = false;

//SOCKET 接收
private void RecvInfo()
{
while (IsContinue && currSocket != null)
{
//尝试接收数据
Thread.Sleep(100);
if (currSocket == null)
Stop();
byte[] tempInfo = new byte[1500];
int count =0,recvCount = 0;

try
{

if (currSocket.Available > 0)
{
//传递数据出去，进行处理
count = currSocket.Receive(tempInfo, tempInfo.Length, 0);
//通讯心跳更新
check = DateTime.Now;
}

}
catch (SocketException erSocket)
{
if (erSocket.ErrorCode == 10054)
{
Stop();
}
}
catch (Exception er)
{
LogWrite.WriteExceptionLog(er);
isContinue = false;
//表示接收出现问题，此时为SOCKET出现问题
//currSocket.Close();

}
}
}

[LIMINLY520]

路过
看看