tnblog
首页

Socket 类

72人阅读 2018/11/23 13:15 评论:0 手机浏览 收藏
分类: Socket

Socket 类

构造函数

 

 


名称

说明

Socket(AddressFamily,?SocketType,?ProtocolType)

新实例初始化 Socket 类使用指定的地址族、 套接字类型和协议。

Socket(SocketInformation)

新实例初始化 Socket 类使用返回值的指定的值 DuplicateAndClose

Socket(SocketType,?ProtocolType)

新实例初始化 Socket 类使用指定的套接字类型和协议。

属性

 

 


名称

说明

AddressFamily

获取的地址族 Socket。

Available

获取已经从网络接收且可供读取的数据量。

Blocking

获取或设置一个值,该值指示是否 Socket 处于阻塞模式。

Connected

获取一个值,该值指示是否 Socket 连接到远程主机从上次以来 Send 或 Receive 操作。

DontFragment

获取或设置 Boolean 值,该值指定是否 Socket 允许 Internet 协议 (IP) 的数据报进行分片。

DualMode

获取或设置一个 Boolean 值,该值指定 Socket 是否是用于 IPv4 和 IPv6 的双模式套接字。

EnableBroadcast

获取或设置 Boolean 值,该值指定是否 Socket 可以发送或接收广播的数据包。

ExclusiveAddressUse

获取或设置 Boolean 值,该值指定是否 Socket 仅允许一个进程绑定到端口。

Handle

获取操作系统句柄 Socket。

IsBound

获取一个值,该值指示是否 Socket 绑定到特定本地端口。

LingerState

获取或设置一个值,指定是否 Socket 将延迟发送所有挂起的数据以尝试关闭套接字。

LocalEndPoint

获取本地终结点。

MulticastLoopback

获取或设置一个值,指定是否传出多播的数据包将传输到发送应用程序。

NoDelay

获取或设置 Boolean 值,该值指定是否流 Socket 使用 Nagle 算法。

OSSupportsIPv4

指示基础操作系统和网络适配器是否支持 Internet 协议版本 4 (IPv4)。

OSSupportsIPv6

指示基础操作系统和网络适配器是否支持 Internet 协议版本 6 (IPv6)。

ProtocolType

获取的协议类型 Socket。

ReceiveBufferSize

获取或设置一个值,指定的接收缓冲区的大小 Socket。

ReceiveTimeout

获取或设置一个值,指定的后的时间量同步 Receive 调用将会超时。

RemoteEndPoint

获取远程终结点。

SendBufferSize

获取或设置一个值,指定发送缓冲区的大小 Socket。

SendTimeout

获取或设置一个值,指定的后的时间量同步 Send 调用将会超时。

SocketType

获取 Socket 的类型。

SupportsIPv4

已过时。 获取一个值,该值指示 IPv4 支持是否可用且已启用当前主机上。

SupportsIPv6

已过时。 获取一个值,该值指示框架是否支持 IPv6 对于某些已过时 Dns 成员。

Ttl

获取或设置一个值,指定发送的 Internet 协议 (IP) 数据包的生存时间 (TTL) 值 Socket。

UseOnlyOverlappedIO

指定套接字是否应仅使用重叠的 I/O 模式。

方法

 

 


名称

说明

Accept()

创建一个新 Socket 为新创建的连接。

AcceptAsync(SocketAsyncEventArgs)

开始一个异步操作以接受传入的连接尝试。

BeginAccept(AsyncCallback,?Object)

开始一个异步操作以接受传入的连接尝试。

BeginAccept(Int32,?AsyncCallback,?Object)

开始异步操作以接受传入的连接尝试并接收第一个客户端应用程序所发送的数据块。

BeginAccept(Socket,?Int32,?AsyncCallback,?Object)

开始异步操作以接受传入的连接尝试从指定的套接字并接收第一个客户端应用程序所发送的数据块。

BeginConnect(EndPoint,?AsyncCallback,?Object)

开始一个对远程主机连接的异步请求。

BeginConnect(IPAddress,?Int32,?AsyncCallback,?Object)

开始一个对远程主机连接的异步请求。 主机由 IPAddress 和端口号指定。

BeginConnect(IPAddress[],?Int32,?AsyncCallback,?Object)

开始一个对远程主机连接的异步请求。 主机由 IPAddress 数组和端口号指定。

BeginConnect(String,?Int32,?AsyncCallback,?Object)

开始一个对远程主机连接的异步请求。 主机由主机名和端口号指定。

BeginDisconnect(Boolean,?AsyncCallback,?Object)

开始一个异步请求来断开与远程终结点的连接。

BeginReceive(Byte[],?Int32,?Int32,?SocketFlags,?AsyncCallback,?Object)

开始异步接收数据从连接 Socket。

BeginReceive(Byte[],?Int32,?Int32,?SocketFlags,?SocketError,?AsyncCallback,?Object)

开始异步接收数据从连接 Socket。

BeginReceive(IList<ArraySegment<Byte>>,?SocketFlags,?AsyncCallback,?Object)

开始异步接收数据从连接 Socket。

BeginReceive(IList<ArraySegment<Byte>>,?SocketFlags,?SocketError,?AsyncCallback,?Object)

开始异步接收数据从连接 Socket。

BeginReceiveFrom(Byte[],?Int32,?Int32,?SocketFlags,?EndPoint,?AsyncCallback,?Object)

开始以异步方式从指定的网络设备上接收数据。

BeginReceiveMessageFrom(Byte[],?Int32,?Int32,?SocketFlags,?EndPoint,?AsyncCallback,?Object)

开始异步接收指定的数据的字节数,到使用指定的数据缓冲区的指定位置 SocketFlags, ,并将终结点和数据包信息存储...

BeginSend(Byte[],?Int32,?Int32,?SocketFlags,?AsyncCallback,?Object)

将数据异步发送到连接 Socket。

BeginSend(Byte[],?Int32,?Int32,?SocketFlags,?SocketError,?AsyncCallback,?Object)

将数据异步发送到连接 Socket。

BeginSend(IList<ArraySegment<Byte>>,?SocketFlags,?AsyncCallback,?Object)

将数据异步发送到连接 Socket。

BeginSend(IList<ArraySegment<Byte>>,?SocketFlags,?SocketError,?AsyncCallback,?Object)

将数据异步发送到连接 Socket。

BeginSendFile(String,?AsyncCallback,?Object)

将文件发送 fileName 到连接 Socket 对象使用 UseDefaultWorkerThread 标志。

BeginSendFile(String,?Byte[],?Byte[],?TransmitFileOptions,?AsyncCallback,?Object)

文件和数据缓冲区将异步发送到连接 Socket 对象。

BeginSendTo(Byte[],?Int32,?Int32,?SocketFlags,?EndPoint,?AsyncCallback,?Object)

以异步方式将数据发送到特定的远程主机。

Bind(EndPoint)

将相关联 Socket 与本地终结点。

CancelConnectAsync(SocketAsyncEventArgs)

取消对远程主机连接的异步请求。

Close()

关闭 Socket 连接和释放所有关联资源。

Close(Int32)

关闭 Socket 连接并释放所有与指定超时关联的资源,以允许要发送的数据排队。

Connect(EndPoint)

建立与远程主机的连接。

Connect(IPAddress,?Int32)

建立与远程主机的连接。 主机指定的 IP 地址和端口号。

Connect(IPAddress[],?Int32)

建立与远程主机的连接。 主机指定的 IP 地址数组和端口号。

Connect(String,?Int32)

建立与远程主机的连接。 主机由主机名和端口号指定。

ConnectAsync(SocketAsyncEventArgs)

开始对到远程主机的连接的异步请求。

ConnectAsync(SocketType,?ProtocolType,?SocketAsyncEventArgs)

开始对到远程主机的连接的异步请求。

Disconnect(Boolean)

关闭套接字连接,并允许重用套接字。

DisconnectAsync(SocketAsyncEventArgs)

开始一个异步请求来断开与远程终结点的连接。

Dispose()

释放 Socket 类的当前实例所使用的所有资源。

Dispose(Boolean)

释放由 Socket 使用的非托管资源,并可根据需要释放托管资源。

DuplicateAndClose(Int32)

复制目标进程的套接字引用,并关闭此进程的套接字。

EndAccept(Byte[],?IAsyncResult)

异步接受传入的连接尝试,并创建一个新 Socket 对象以处理远程主机通信。 此方法返回包含传输的初始数据的缓冲区。

EndAccept(Byte[],?Int32,?IAsyncResult)

异步接受传入的连接尝试,并创建一个新 Socket 对象以处理远程主机通信。 此方法返回包含初始数据和传输的字节数的缓冲区。

EndAccept(IAsyncResult)

异步接受传入的连接尝试,并创建一个新 Socket 来处理远程主机通信。

EndConnect(IAsyncResult)

结束挂起的异步连接请求。

EndDisconnect(IAsyncResult)

结束挂起的异步断开连接请求。

EndReceive(IAsyncResult)

结束挂起的异步读取。

EndReceive(IAsyncResult,?SocketError)

结束挂起的异步读取。

EndReceiveFrom(IAsyncResult,?EndPoint)

结束挂起的异步读取从特定的终结点。

EndReceiveMessageFrom(IAsyncResult,?SocketFlags,?EndPoint,?IPPacketInformation)

结束挂起的异步读取从特定的终结点。 此方法还显示有关比数据包的详细信息 EndReceiveFrom

EndSend(IAsyncResult)

结束挂起的异步发送。

EndSend(IAsyncResult,?SocketError)

结束挂起的异步发送。

EndSendFile(IAsyncResult)

结束挂起的异步发送的文件。

EndSendTo(IAsyncResult)

结束挂起的异步发送到特定位置。

Equals(Object)

确定指定的对象是否等于当前对象。(继承自 Object。)

Finalize()

释放 Socket 类使用的资源。(覆盖 Object.Finalize()。)

GetHashCode()

作为默认哈希函数。(继承自 Object。)

GetSocketOption(SocketOptionLevel,?SocketOptionName)

返回指定的值 Socket 选项时,表示为一个对象。

GetSocketOption(SocketOptionLevel,?SocketOptionName,?Byte[])

返回指定 Socket 选项设置,表示为字节数组。

GetSocketOption(SocketOptionLevel,?SocketOptionName,?Int32)

返回指定的值 Socket 数组中的选项。

GetType()

获取当前实例的 Type。(继承自 Object。)

IOControl(Int32,?Byte[],?Byte[])

设置为低级别操作模式 Socket 使用数字控制代码。

IOControl(IOControlCode,?Byte[],?Byte[])

设置为低级别操作模式 Socket 使用 IOControlCode 枚举来指定控制代码。

Listen(Int32)

位置 Socket 处于侦听状态。

MemberwiseClone()

创建当前 Object 的浅表副本。(继承自 Object。)

Poll(Int32,?SelectMode)

确定的状态 Socket。

Receive(Byte[])

从绑定接收数据 Socket 到接收缓冲区中。

Receive(Byte[],?Int32,?Int32,?SocketFlags)

从绑定接收指定的数目的字节 Socket 到接收缓冲区的指定偏移量的位置,使用指定 SocketFlags

Receive(Byte[],?Int32,?Int32,?SocketFlags,?SocketError)

从绑定接收数据 Socket 存入接收缓冲区,使用指定 SocketFlags

Receive(Byte[],?Int32,?SocketFlags)

从绑定接收指定的数目的数据的字节 Socket 存入接收缓冲区,使用指定 SocketFlags

Receive(Byte[],?SocketFlags)

从绑定接收数据 Socket 存入接收缓冲区,使用指定 SocketFlags

Receive(IList<ArraySegment<Byte>>)

从绑定接收数据 Socket 的接收缓冲区的列表中。

Receive(IList<ArraySegment<Byte>>,?SocketFlags)

从绑定接收数据 Socket 入接收缓冲区列表中,使用指定 SocketFlags

Receive(IList<ArraySegment<Byte>>,?SocketFlags,?SocketError)

从绑定接收数据 Socket 入接收缓冲区列表中,使用指定 SocketFlags

ReceiveAsync(SocketAsyncEventArgs)

开始一个异步请求,以便接收来自连接的数据 Socket 对象。

ReceiveFrom(Byte[],?EndPoint)

到数据缓冲区中接收数据报并存储终结点。

ReceiveFrom(Byte[],?Int32,?Int32,?SocketFlags,?EndPoint)

使用指定的 SocketFlags 将指定的数据字节数接收到数据缓冲区的指定位置,并存储终结点。

ReceiveFrom(Byte[],?Int32,?SocketFlags,?EndPoint)

将指定的数目的字节接收到的数据缓冲区,使用指定 SocketFlags, ,并将存储终结点。

ReceiveFrom(Byte[],?SocketFlags,?EndPoint)

接收到数据缓冲区,使用指定的数据报 SocketFlags, ,并将存储终结点。

ReceiveFromAsync(SocketAsyncEventArgs)

开始以异步方式从指定的网络设备上接收数据。

ReceiveMessageFrom(Byte[],?Int32,?Int32,?SocketFlags,?EndPoint,?IPPacketInformation)

接收到指定数据缓冲区,使用指定的位置指定的数据的字节数 SocketFlags, ,并将终结点和数据包信息存储。

ReceiveMessageFromAsync(SocketAsyncEventArgs)

开始异步接收指定的数据的字节数,到使用指定的数据缓冲区中的指定位置 SocketAsyncEventArgs.SocketFlags, ,并将终结点和数据包信息存储。

Select(IList,?IList,?IList,?Int32)

确定一个或多个套接字的状态。

Send(Byte[])

将数据发送到连接 Socket。

Send(Byte[],?Int32,?Int32,?SocketFlags)

从指定偏移量开始,使用指定 SocketFlags,将指定的数据字节数发送到已连接的 Socket。

Send(Byte[],?Int32,?Int32,?SocketFlags,?SocketError)

发送到已连接的指定的数据的字节数 Socket, ,按指定偏移量,从开始,使用指定 SocketFlags

Send(Byte[],?Int32,?SocketFlags)

发送到已连接的指定的数据的字节数 Socket, ,使用指定 SocketFlags

Send(Byte[],?SocketFlags)

将数据发送到连接 Socket 使用指定 SocketFlags

Send(IList<ArraySegment<Byte>>)

列表中的一组缓冲区发送到连接 Socket。

Send(IList<ArraySegment<Byte>>,?SocketFlags)

列表中的一组缓冲区发送到连接 Socket, ,使用指定 SocketFlags

Send(IList<ArraySegment<Byte>>,?SocketFlags,?SocketError)

列表中的一组缓冲区发送到连接 Socket, ,使用指定 SocketFlags

SendAsync(SocketAsyncEventArgs)

将数据异步发送到连接 Socket 对象。

SendFile(String)

将文件发送 fileName 到连接 Socket 对象 UseDefaultWorkerThread传输标志。

SendFile(String,?Byte[],?Byte[],?TransmitFileOptions)

通过指定的 TransmitFileOptions 值,将文件 fileName 和数据缓冲区发送到连接的 Socket 对象。

SendPacketsAsync(SocketAsyncEventArgs)

集合中的文件或在内存中数据缓冲区将异步发送到连接 Socket 对象。

SendTo(Byte[],?EndPoint)

将数据发送到指定的终结点。

SendTo(Byte[],?Int32,?Int32,?SocketFlags,?EndPoint)

将指定的数据的字节数发送到指定的终结点,在缓冲区中的指定位置开始并使用指定 SocketFlags

SendTo(Byte[],?Int32,?SocketFlags,?EndPoint)

将指定的数据的字节数发送到指定的终结点使用指定 SocketFlags

SendTo(Byte[],?SocketFlags,?EndPoint)

将数据发送到特定终结点使用指定 SocketFlags

SendToAsync(SocketAsyncEventArgs)

以异步方式将数据发送到特定的远程主机。

SetIPProtectionLevel(IPProtectionLevel)

套接字设置 IP 保护级别。

SetSocketOption(SocketOptionLevel,?SocketOptionName,?Boolean)

设置指定 Socket 到指定的选项 Boolean 值。

SetSocketOption(SocketOptionLevel,?SocketOptionName,?Byte[])

设置指定 Socket 选项指定的值,表示为字节数组。

SetSocketOption(SocketOptionLevel,?SocketOptionName,?Int32)

设置指定 Socket 选项指定的整数值。

SetSocketOption(SocketOptionLevel,?SocketOptionName,?Object)

设置指定 Socket 选项指定的值,表示为一个对象。

Shutdown(SocketShutdown)

禁用发送和接收的 Socket。

ToString()

返回表示当前对象的字符串。(继承自 Object。)

 

 

示例

 

 

下面的代码示例演示如何 Socket 类可以用于将数据发送到 HTTP 服务器并接收响应。 此示例中受到阻止,直到收到整个页面。

 

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);
    }
}


 


评价
每天学一学总会有用武之地
文章
6
评论
8
分类
16
关注
16
{{item.ArticleTitle}}
{{item.BlogName}} : {{item.Content}}