socket编程实例_socket编程函数

JAVA编程中的服务端和客户端的Socket实例是不是同一个

// The DNS name of the comr

实例当然不是一个动态DLL文件 Ws2_32.dll了

socket编程实例_socket编程函数

socket编程实例_socket编程函数

如果在同一个函数里，是哪一块在先呢？

服务端在先，肯定阻塞到accept就不会往下执行了；

客户端在先，connect肯定返回失败后才会往下执行。

TCP是这样，肯定不行。

UDP应该也不行,客户端sendto后立刻服务端调用recvfrom，接收不到。

不过你如果在同一个函数里启动两个线程，一个是一个是客户端，那是可以的。

(⊙o⊙)…

都不在一台机器上怎么能是同一个实例呢。

在windows下用C语言如何实现socket网络编程，需要用到哪些头文件或者库？

在windows下用C语言如何实现socket网络编程，需要用到以下头文件和库：

1、头文件 winsock2.h，

2、静态库文件 Ws2_32.l{if (components != null)ib

3、动态DLL文件 Ws2_32.dll

我们可以简单的把Socket理解为一个可以连通网络上不同计算机程序之间的管道，把一堆数据从管道的A端扔进去，则会从管道的B端（也许同时还可以从C、D、E、F……端冒出来）。管道的端口由两个因素来确认，即机器的IP地址和程序所使用的端口号。

扩展资料：

Socket可以支持数据的发送和接收，它会定义一种称为套接字的变量，发送数据时首先创建套接字，然后使用该套接字的sendto等方法对准某个IP/端口进行数据发送；接收端也首先创建套接字，然后将该套接字绑定到一个IP/端口上，所有发向此端口的数据会被该套接字的recv等函数读出。如同读出文件中的数据一样。

参考资料来源：

在windows下用C语言如何实现socket网络编程，需要用到以下头文件和库：

头文件 winsock2.h，

静态库文件 Ws2_32.lib

写一个UDP发送程序的步骤如下：

1. 用WSAStartup函数初始化Socket环境；

2. 用socket函数创建一个套//检查网络流是否可读接字；

3. 用setsockopt函数设置套接字的属性，例如设置为广播类型；很多时候该步骤可以省略；

4. 创建一个sockaddr_in，并指定其IP地址和端口号；

5. 用sendto函数向指定地址发送数据，这里的目标地址就是广播地址；注意这里不需要绑定，即使绑定了，其地址也会被sendto中的参数覆盖；若使用send函数则会出错，因为send是面向连接的，而UDP是非连接的，只能使用sendto发送数据；

6. 用closesocket函数关闭套接字；

7. 用WSACleanup函数关闭Socket环境。

与之类似，一个UDP接收程序的步骤如下，注意接收方一定要bind套接字：

1. 用WSAStartup函数初始化Socket环境；

2. 用socket函数创建一个套接字；

3. 用setsockopt函数设置套接字的属性，例如设置为广播类型；

4. 创建一个sockaddr_in，并指定其IP地址和端口号；

5. 用bind函数将套接字与接收的地址绑定起来，然后调用recvfrom函数或者recv接收数据； 注意这里一定要绑定，因为接收报文的套接字必须在网络上有一个绑定的名称才能保证正确接收数据；

6. 用closesocket函数关闭套接字；

7. 用WSACleanup函数关闭Socket环境。

参考资料地址：

主要是看采取什么样的协议。是tcp还是udp使用的头文件是不一样的。不过别都不大。winscok2.h就够用了。不过往深了走其实还是要涉及到其他的，这个普通的套接字编程主要是winscok2.h里面的。

那就是控制台应用程序喽

看孙鑫VC6视频教程网络编程部分

很详细，VC6只是个平台，可以随便用什么来写

主要用到winscok2.h

C语言socket编程怎么实现2个客户端之间通信

private NetworkStream nsStream; //创建接收的基本数据流

如果只是两个客户端和一个，可通过转发即可，两个客户端连接到，把从A接收到的发给B，把从B接收到的发给A即可，如果要做成多个客户端的，则要给各个客户端分配ID，服务端好根据各个客户端和消息要转发送给客户端的ID来确}}定消息发送对象。

通过Socket实现网络编程的主要过程是什么?

即时通讯？ 太大了吧 聊天还不多

socket——套接字~网络间的进程是靠这个套接字进行通信~

在编程时会用到的函数：socket（）

b{客户端等待一段时间后重试ind（）

listen（）

read() / write()

close()

这是一套完整的流程~具体各函数的定义以及用法可以再百度百科里找到~

先去看书吧孩子，《unix网络编程（卷1：套接字）（卷2：进程间通信）》

解释一下C# socket编程。解释详细我给100分

{//还原传入的原始套接字

因为这里必须是一个 AsyncCallback 委托，这个是BeginReceive的构造参数。

buffer

public IAsyncResult BeginReceive (

byte[] buffer,

int offset,

int size,

SocketFlags socketFlags,

AsyncCallback callback,

Object state

)参数：

Byte 类型的数组，它是存储接收到的数据的位置。

offset

buffer 参数中存储所接收数据的位置，该位置从零开始计数。

size

要接收的字节数。

socketFlags

SocketFlags 值的按位组合。

callback

一个 AsyncCallback 委托，它引用作完成时要调用的方法。

state

一个用户定义对象，其中包含接收作的相关信息。当作完成时，此对象会被传递给 EndReceive 委托。

也就是new AsyncCallback（receivecallback）后又会执行receivecallback（）这个方法。

o(∩_∩)o...哈哈100分拿来！！

网络编程 socket

除了采用上述方法建立连接之后，也可以采用TcpListener类里面的方法进行连接建立。下面是端对关于TcpListener类使用BeginAccetpTcp方法处理一个传入的连接尝试。以下是使用BeginAccetpTcp方法和EndAccetpTcp方法的代码：

没有对recvbuf做清空设置啊。

public static void StartListening()

char recvbuf[100];

memset(recvbuf, 0x00, 100);

recv(stockcon,recvbuf,100,0);

printf("%sn",recvbuf);

closesocket(stockcon);

这个语言很怪，不像c语言，哎，我也不晓得

C语言中socket编程中客户端如何等待服务端作结束,再继续执行下面的作。请写出具体实例。

{Console.WriteLine(e.ToString());

端建立全局变量 bool lock = false;

if lock==false

{lock = true;

作以上是建立连接的两种方法。可根据需要选择使用。...

}else

}

socket编程端接收数据

IPEndPoint iep = new IPEndPoint(local,13000);

//服务端：

using System.Net;

using System.Text;

using System.Threading;

Thread mythread ;

Socket socket;

// 清理所有正在使用的资源。

protected override void Dise( bool dising )

{try

{

socket.Close();//释放资源

mythread.Abort ( ) ;//中止线程

}catch{ }

if( dising )

{components.Dise();

base.Dise( dising );

}public static IPAddress GetIP()

{IPHostEntry ieh=Dns.GetHostByName(Dns.GetHostName());

return ieh.AddressList[0];

}private void BeginListen()

{IPAddress Ip=GetIP();

IPEndPoint iep=new IPEndPoint(Ip,8000);

socket=new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);

byte[] byteMessage=new byte[100];

socket.Bind(iep);

// do

while(true)

{try

{socket.Listen(5);

Socket newSocket=socket.Accept();

newSocket.Receive(byteMessage);

string sTime = DateTime.Now.ToShortTimeString ( ) ;

string msg=sTime+":"+"Message from:";

msg+=newSocket.RemoteEndPoint.ToString()+Encoding.Default.GetString(byteMessage);

this.listBox1.Items.Add(msg);

}catch(SocketException ex)

{this.label1.Text+=ex.ToString();

}} // while(byteMessage!=null);

}//开始

private void button1_Click(object sender, System.EventArgs e)

{try

{mythread = new Thread(new ThreadStart(BeginListen));

mythread.Start();

}catch(System.Exception er)

{MessageBox.Show(er.Message,"完成",MessageBoxButtons.OK,MessageBoxIcon.Stop);

//客户端：

using System.Net;

using System.Text;

private void button1_Click(object sender, System.EventArgs e)

{BeginSend();

}private void BeginSend()

string port=this.txtport.Text;

IPAddress serverIp=IPAddress.Parse(ip);

int serverPort=Convert.ToInt32(port);

IPEndPoint iep=new IPEndPoint(serverIp,serverPort);

byte[] byteMessage;

Socket socket=new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);

socket.Connect(iep);

byteMessage=Encoding.ASCII.GetBytes(textBox1.Text);

socket.Send(byteMessage);

socket.Shutdown(SocketShutdown.Both);

socket.Close();

}//基于TCP协议的发送和接收端

//TCP协议的接收端

using System.Net.Sockets ; //使用到TcpListen类

using System.Threading ; //使用到线程

using System.IO ; //使用到StreamReader类

int port = 8000; //定义侦听端口号

private Thread thThreadRead; //创建线程，用以侦听端口号，接收信息

private TcpListener tlTcpListen; //侦听端口号

private bool blistener = true; //设定标示位，判断侦听状态

private StreamReader srRead;

private System.Windows.Forms.StatusBar statusBar1;

private System.Windows.Forms.Button button1;

private System.Windows.Forms.ListBox listBox1; //从网络基础数据流中读取数据

private Tcp tc ;

private void Listen ( )

{try

{tlTcpListen = new TcpListener ( port ) ; //以8000端口号来初始化TcpListener实例

tlTcpListen.Start ( ) ; //开始

statusBar1.Text = "正在" ;

tc = tlTcpListen.AcceptTcp ( ) ; //通过TCP连接请求

nsStream = tc.GetStream ( ) ; //获取用以发送、接收数据的网络基础数据流

srRead=new StreamReader(nsStream);//以得到的网络基础数据流来初始化StreamReader实例

statusBar1.Text = "已经连接！";

while( blistener ) //循环侦听

{string sMessage = srRead.ReadLine();//从网络基础数据流中读取一行数据

if ( sMessage == "STOP" ) //判断是否为断开TCP连接控制码

{tlTcpListen.Stop(); //关闭侦听

nsStream.Close(); //释放资源

srRead.Close();

statusBar1.Text = "连接已经关闭！" ;

thThreadRead.Abort(); //中止线程

return;

}string sTime = DateTime.Now.ToShortTimeString ( ) ; //获取接收数据时的时间

catch ( System.Security.SecurityException )

{MessageBox.Show ( "侦听失败！" , "错误" ) ;

//开始

private void button1_Click(object sender, System.EventArgs e)

{thThreadRead = new Thread ( new ThreadStart ( Listen ) );

thThreadRead.Start();//启动线程

button1.Enabled=false;

}// 清理所有正在使用的资源。

protected override void Dise( bool dising )

{try

{tlTcpListen.Stop(); //关闭侦听

nsStream.Close();

srRead.Close();//释放资源

thThreadRead.Abort();//中止线程

}catch{}

if( dising )

{components.Dise();

base.Dise( dising );

}//TCP协议的发送端

using System.Net.Sockets; //使用到TcpListen类

using System.Threading; //使用到线程

using System.Net; //使用IPAddress类、IPHostEntry类等

private StreamWriter swWriter; //用以向网络基础数据流传送数据

private NetworkStream nsStream; //创建发送数据的网络基础数据流

private Tcp tcp;

private System.Windows.Forms.Button button1;

private System.Windows.Forms.TextBox textBox1;

private System.Windows.Forms.Button button2;

private System.Windows.Forms.TextBox textBox2;

private System.Windows.Forms.StatusBar statusBar1;

private System.Windows.Forms.Label label2; //通过它实现向远程主机提出TCP连接申请

private bool tcpConnect = false; //定义标识符，用以表示TCP连接是否建立

//连接

private void button1_Click(object sender, System.EventArgs e)

{IPAddress ipRemote ;

try

{ipRemote = IPAddress.Parse ( textBox1.Text ) ;

{MessageBox.Show ( "输入的IP地址不合法！" , "错误提示！" ) ;

return ;

}IPHostEntry ipHost ;

try

{ipHost = Dns.Resolve ( textBox1.Text ) ;

}catch //判断IP地址对应主机是否在线

{MessageBox.Show ("远程主机不在线！" , "错误提示！" ) ;

return ;

}string sHostName = ipHost.HostName ;

try

{Tcp tcp = new Tcp(sHostName,8000);//对远程主机的8000端口提出TCP连接申请

nsStream = tcp.GetStream();//通过申请，并获取传送数据的网络基础数据流

swWriter = new StreamWriter(nsStream);//使用获取的网络基础数据流来初始化StreamWriter实例

button1.Enabled = false ;

button2.Enabled = true ;

tcpConnect = true ;

statusBar1.Text = "已经连接！" ;

}catch

{MessageBox.Show ( "无法和远程主000端口建立连接！" , "错误提示！" ) ;

return ;

//发(2)在端口上侦听是否有新的连接请求；送

private void button2_Click(object sender, System.EventArgs e)

{if (textBox2.Text !="")

{swWriter.WriteLine(textBox2.Text);//刷新当前数据流中的数据

swWriter.Flush();

}else

{MessageBox.Show("发送信息不能为空！","错误提示！");

// 清理所有正在使用的资源。

protected override void Dise( bool dising )

{if ( tcpConnect )

{swWriter.WriteLine ( "STOP" ) ; //发送控制码

swWriter.Flush (); //刷新当前数据流中的数据

nsStream.Close (); //清除资源

swWriter.Close ();

}if( dising )

{components.Dise();

base.Dise( dising );

如何用socket实现TcpListener.pending的功能

}catch(Exception e)

基于C#的socket编程的TCP异步实现

一、摘要

本篇博文阐述基于TCP通信协议的异步实现。

二、实验平台

Visual Studio 2010

三、异步通信实现原理及常用方法

3.1 建立连接

在同步模式中，在上使用Accept方法接入连接请求，而在客户端则使用Connect方法来连接。相对地，在异步模式下，可以使用BeginAccept方法和EndAccept方法来完成连接到客户端的任务，在客户端则通过BeginConnect方法和EndConnect方法来实现与的连接。

BeginAccept在异步方式下传入的连接尝试，它允许其他动作而不必等待连接建立才继续执行后面程序。在调用BeginAccept之前，必须使用Listen方法来侦听是否有连接请求，BeginAccept的函数原型为：

BeginAccept(AsyncCallback AsyncCallback, Ojbect state)

参数：

AsyncCallBack：代表回调函数

state：表示状态信息，必须保证state中包含socket的句柄

使用BeginAccept的基本流程是：

(1)创建本地终，并新建套接字与本地终进行绑定；

(3)请求开始接入新的连接，传入Socket的实例或者StateOjbect的实例。

参考代码：

代码

//定义IP地址

//创建的socket对象

Socket server = new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);

server.Bind(iep);

server.Listen(20);

server.BeginAccecpt(new AsyncCallback(Accept),server);

代码

当BeginAccept()方法调用结束后，一旦新的连接发生，将调用回调函数，而该回调函数必须包括用来结束接入连接作的EndAccept()方法。

该方法参数列表为 Socket EndAccept(IAsyncResult iar)

下面为回调函数的实例：

代码

void Accept(IAsyncResult iar)

//在原始套接字上调用EndAccept方法，返回新的套接字

Socket serv = My.EndAccept(iar);

}代码

至此，端已经准备好了。客户端应通过BeginConnect方法和EndConnect来远程连接主机。在调用BeginConnect方法时必须注册相应的回调函数并且至少传递一个Socket的实例给state参数，以保证EndConnect方法中能使用原始的套接字。下面是一段是BeginConnect的调用：

Socket socket=new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp)

IPAddress ip=IPAddress.Parse("127.0.0.1");

IPEndPoint iep=new IPEndPoint(ip,13000);

socket.BeginConnect(iep, new AsyncCallback(Connect),socket);

EndConnect是一种阻塞方法，用于完成BeginConnect方法的异步连接诶远程主机的请求。在注册了回调函数后必须接收BeginConnect方法返回的IASynccReuslt作为参数。下面为代码演示：

代码

void Connect(IAsyncResult iar)

{Socket client=(Socket)iar.AsyncState;

try

{client.EndConnect(iar);

}finally

{}

}代码

代码

public static void DoBeginAccept(TcpListener listner)

{//开始从客户端连接

Console.WriteLine("Waitting for a connection");

//接收连接

//开始准备接入新的连接，一旦有新连接尝试则调用回调函数DoAcceptTcpCliet

listSocket My = (Socket)iar.AsyncState;ner.BeginAcceptTcp(new AsyncCallback(DoAcceptTcpCliet), listner);

}//处理客户端的连接

public static void DoAcceptTcpCliet(IAsyncResult iar)

{//还原原始的TcpListner对象

TcpListener listener = (TcpListener)iar.AsyncState;

//完成连接的动作，并返回新的Tcp

Tcp client = listener.EndAcceptTcp(iar);

Console.WriteLine("连接成功");

}代码

代码的处理逻辑为：

(1)调用BeginAccetpTcp方法开开始连接新的连接，当连接视图发生时，回调函数被调用以完成连接作；

(2)上面DoAcceptTcpCliet方法通过AsyncState属性获得由BeginAcceptTcp传入的listner实例；

(3)在得到listener对象后，用它调用EndAcceptTcp方法，该方法返回新的包含客户端信息的Tcp。

BeginConnect方法和EndConnect方法可用于客户端尝试建立与服务端的连接，这里和种方法并无区别。下面看实例：

代码

public void doBeginConnect(IAsyncResult iar)

{Socket client=(Socket)iar.AsyncState;

//开始与远程主机进行连接

client.BeginConnect(serverIP[0],13000,requestCallBack,client);

Console.WriteLine("开始与进行连接");

}private void requestCallBack(IAsyncResult iar)

{try

{//还原原始的Tcp对象

Tcp client=(Tcp)iar.AsyncState;

//

client.EndConnect(iar);

Console.WriteLine("与{0}连接成功",client..RemoteEndPoint);

}finally

{}

}代码

在建立了套接字的连接后，就可以端和客户端之间进行数据通信了。异步套接字用BeginSend和EndSend方法来负责数据的发送。注意在调用BeginSend方法前要确保双方都已经建立连接，否则会出异常。下面演示代码：

代码

private static void Send(Socket handler, String data)

{// Convert the string data to byte data using ASCII encoding.

byte[] byteData = Encoding.ASCII.GetBytes(data);

// Begin sending the data to the remote dev.

handler.BeginSend(byteData, 0, byteData.Length, 0, new AsyncCallback(SendCallback), handler);

}private static void SendCallback(IAsyncResult ar)

{try

{// Retri the socket from the state object.

Socket handler = (Socket)ar.AsyncState;

// Complete sending the data to the remote dev.

int bytesSent = handler.EndSend(ar);

Console.WriteLine("Sent {0} bytes to client.", bytesSent);

handler.Shutdown(SocketShutdown.Both);

handler.Close();

代码

接收数据是通过BeginReceive和EndReceive方法：

代码

private static void Receive(Socket client)

{try

{// Create the state object.

StateObject state = new StateObject();

state.workSocket = client;

// Begin receiving the data from the remote dev.

client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReceiveCallback), state);

private static void ReceiveCallback(IAsyncResult ar)

{try

{// Retri the state object and the client socket

// from the asynchronous state object.

StateObject state = (StateObject)ar.AsyncState;

Socket client = state.workSocket;

// Read data from the remote dev.

int bytesRead = client.EndReceive(ar);

{// There might be more data, so store the data received so far.

state..Append(Encoding.ASCII.GetString(state.buffer, 0, bytesRead));

// Get the rest of the data.

client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReceiveCallback), state);

}else

{// All the data has arrived; put it in response.

if (state..Length > 1)

{response = state..ToString();

}// Signal that all bytes he been received.

receiveDone.Set();

catch (Exception e)

代码

上述代码的处理逻辑为：

(1)首先处理连接的回调函数里得到的通讯套接字client，接着开始接收数据；

(2)当数据发送到缓冲区中，BeginReceive方法试图从buffer数组中读取长度为buffer.length的数据块，并返回接收到的数据量bytesRead。接收并打印数据。

除了上述方法外，还可以使用基于NetworkStream相关的异步发送和接收方法，下面是基于NetworkStream相关的异步发送和接收方法的使用介绍。

NetworkStream使用BeginRead和EndRead方法进行读作，使用BeginWreite和EndWrete方法进行写作，下面看实例：

代码

static void DataHandle(Tcp client)

{Tcp tcp = client;

//使用Tcp的GetStream方法获取网络流

NetworkStream ns = tcp.GetStream();

if(ns.CanRead)

{//定义缓冲区

byte[] read = new byte[1024];

ns.BeginRead(read,0,read.Length,new AsyncCallback(myReadCallBack),ns);

}else

{Console.WriteLine("无法从网络中读取流数据");

public static void myReadCallBack(IAsyncResult iar)

{NetworkStream ns = (NetworkStream)iar.AsyncState;

byte[] read = new byte[1024];

String data = "";

int recv;

recv = ns.EndRead(iar);

data = String.Concat(data, Encoding.ASCII.GetString(read, 0, recv));

//接收到的消息长度可能大于缓冲区总大小，反复循环直到读完为止

while (ns.DataAvailable)

{ns.BeginRead(read, 0, read.Length, new AsyncCallback(myReadCallBack), ns);

}//打印

Console.WriteLine("您收到的信息是" + data);

}代码

3.3 程序阻塞与异步中的同步问题

.Net里提供了EventWaitHandle类来表示一个线程的同步。EventWaitHandle即等待句柄，他允许线程通过作系统互发信号和等待彼此的信号来达到线程同步的目的。这个类有2个子类，分别为AutoRestEevnt(自动重置)和ManualRestEvent(手动重置)。下面是线程同步的几个方法：

(1)Rset方法：将状态设为非终止状态，导致线程阻塞。这里的线程阻塞是指允许其他需要等待的线程进行阻塞即让含WaitOne()方法的线程阻塞；

(3)WaitOne方法：阻塞当前线程，直到当前的等待句柄收到信号。此方法将一直使本线程处于阻塞状态直到收到信号为止，即当其他非阻塞进程调用set方法时可以继续执行。

代码

{// Data buffer for incoming data.

byte[] bytes = new Byte[1024];

// Establish the local endpoint for the socket.

// running the listener is "host.contoso".

//IPAddress ipAddress = ipHostInfo.AddressList[0];

IPAddress ipAddress = IPAddress.Parse("127.0.0.1");

IPEndPoint localEndPoint = new IPEndPoint(ipAddress, 11000);

// Create a TCP/IP socket.

Socket listener = new Socket(AddressFamily.InterNetwork,SocketType.Stream, ProtocolType.Tcp);

// Bind the socket to the local

//endpoint and listen for incoming connections.

try

{listener.Bind(localEndPoint);

listener.Listen(100);

while (true)

{// Set the nt to nonsignaled state.

allDone.Reset();

// Start an asynchronous socket to listen for connections.

Console.WriteLine("Waiting for a connection...");

listener.BeginAccept(new AsyncCallback(AcceptCallback),listener);

// Wait until a connection is made before continuing.

allDone.WaitOne();

catch (Exception e)

}Console.WriteLine("nPress ENTER to continue...");

Console.Read();

}代码

上述代码的逻辑为：

(1)试用了ManualRestEvent对象创建一个等待句柄，在调用BeginAccept方法前使用Rest方法允许其他线程阻塞；

(2)为了防止在连接完成之前对套接字进行读写作，务必要在BeginAccept方法后调用WaitOne来让线程进入阻塞状态。

当有连接接入后系统会自动调用会调用回调函数，所以当代码执行到回调函数时说明连接已经成功，并在函数的句就调用Set方法让处于等待的线程可以继续执行

求linux socket网络编程代码

IPAddreusing System.Net.Sockets;ss local = IPAddress.Parse("127.0,0,1");

我呢，在C,C++,SOCKET网络编程，数据库，网页，LINUX下写过一些模块，汇编（IBM 和 AT&T),这些方面有些经验，对了，winSDK,还有程序界面。 如果您仔细考虑之后觉得合着我的这样经验可以闯出那么一片天地，而且您...