zoukankan      html  css  js  c++  java

  • IOS socket编程--Asyncsocket

    1. iPhone的标准推荐是CFNetwork 库编程，其封装好的开源库是 cocoa AsyncSocket库，用它来简化CFNetwork的调用，它提供了异步操作
    2.        主要特性有：       
    1. 队列的非阻塞的读和写，而且可选超时。你可以调用它读取和写入，它会当完成后告知你
    2. 自动的socket接收。如果你调用它接收连接，它将为每个连接启动新的实例，当然，也可以立即关闭这些连接
    3. 委托（delegate）支持。错误、连接、接收、完整的读取、完整的写入、进度以及断开连接，都可以通过委托模式调用
    4. 基于run loop的，而不是线程的。虽然可以在主线程或者工作线程中使用它，但你不需要这样做。它异步的调用委托方法，使用NSRunLoop。委托方法包括socket的参数，可让你在多个实例中区分
    5. 自包含在一个类中。你无需操作流或者socket，这个类帮你做了全部
    6. 支持基于IPV4和IPV6的TCP流
    3.       加入：AsynSocket.h .m与AsynUdpSocket.h .m四个文件 及CFNetwork.framework
    4.      TCP客户端 
    5.            #import "AsyncSocket.h"
    7.            @interface HelloiPhoneViewController : UIViewController {
    8.                 UITextField    * textField;
    9.                 AsyncSocket * asyncSocket;
    10.              }
    11.             @property (retain, nonatomic) IBOutlet UITextField *textField;
    12.              - (IBAction) buttonPressed: (id)sender;
    13.              - (IBAction) textFieldDoneEditing: (id)sender;    
    14.              @end
    15.  
    16.              在需要联接地方使用connectToHost联接服务器
    17.               其中initWithDelegate的参数中self是必须。这个对象指针中的各个Socket响应的函数将被ASyncSocket所调用.initWithDelegate把将当前对象传递进去，这样只要在当前对象方法实现相应方法
    18.  
    19.                asyncSocket = [[AsyncSocket alloc] initWithDelegate:self]; 
    20.                NSError *err = nil; 
    21.                if(![asyncSocket connectToHost:host on:port error:&err]) 
    22.                 { 
    23.                    NSLog(@"Error: %@", err); 
    24.                  } 
    25.  
    26.              关于NSData对象
    27.               无论SOCKET收发都采用NSData对象.它的定义是 http://developer.apple.com/library/mac /#documentation/Cocoa/Reference/Foundation/Classes/NSData_Class/Reference/Reference.html
    28.               NSData主要是带一个(id)data指向的数据空间和长度 length.
    29.               NSString 转换成NSData 对象
    30.  
    31.                NSData* xmlData = [@"testdata" dataUsingEncoding:NSUTF8StringEncoding];
    32.               NSData 转换成NSString对象
    33.  
    34.              NSData * data;
    35.                NSString *result = [[NSString alloc] initWithData:data        encoding:NSUTF8StringEncoding];
    36.  
    37.                发送数据
    38.                 AsyncSocket  writeData    方法来发送数据，它有如下定义
    39.     - (void)writeData:(NSData *)data withTimeout:(NSTimeInterval)timeout tag:(long)tag;
    40.  
    41.                以下是一个实例语句.
    42.                NSData* aData= [@"test data" dataUsingEncoding: NSUTF8StringEncoding];
    43.               [sock writeData:aData withTimeout:-1 tag:1];
    45.               在onSocket重载函数，有如定义采用是专门用来处理SOCKET的发送数据的：
    46.                -(void)onSocket(AsyncSocket *)sock didWriteDataWithTag:(long)tag
    47.               {
    48.                     NSLog(@"thread(%),onSocket:%p didWriteDataWithTag:%d",[[NSThread currentThread] name],
    49.      sock,tag);
    50.                } 
    51.  
    52.                接收Socket数据.
    53.                在onSocket重载函数，有如定义采用是专门用来处理SOCKET的接收数据的.
    54.                -(void) onSocket:(AsyncSocket *)sock didReadData:(NSData *)data withTag:(long)tag
    55.                在中间将其转换成NSString进行显示.
    56.     NSString* aStr = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding]; 
    57.     NSLog(@"===%@",aStr); 
    58.     [aStr release];
    60.       6、TCP连接读取制定长度的数据
    61.            socket连接，可能会读取固定长度的字节
    62.            [socket readDataToLength: withTimeout :tag]
    68. 各方法的解析
    69.        -（void）onSocket：（AsyncSocket *）sock willDisconnectWithError：(NSError *)err;   
    70.        发生错误，socket关闭，可以在call-back过程调用"unreadData"去取得socket的最后的数据字节，当连接的时候，该委托方法在    onSocket:didAcceptNewSocket: 或者 onSocket:didConnectToHost： 之前调用
    72.       -（void）onSocketDidDisconnect:(ASyncSocket *)sock;
    73.       当socket由于或没有错误而断开连接，如果你想要在断开连接后release socket，在此方法工作，而在onSocket:willDisconnectWithError 释放则不安全
    75.        -（void）onSocket:(AsyncSocket *)sock didAcceptNewSocket:(AsyncSocket *)newSocket;
    76.         当产生一个socket去处理连接时调用，此方法会返回 线程上的run-loop 的新的socket和其应处理的委托，如果省略，则使用[NSRunLoop cunrrentRunLoop]
    78.           -（BOOL）onSocketWillConnect:(AsyncSocket *)sock;
    80.        -（void）onSocket:(AsyncSocket *)sock didConnectToHost :(NSString *)host port:(UINt16)port;
    81.           当socket连接正准备读和写的时候调用，host属性是一个IP地址，而不是一个DNS 名称
    83.          -（void）onSocket:(AsyncSocket *)sock didReadData:(NSData *)data withTag:(long) tag;
    84.          当socket已完成所要求的数据读入内存时调用，如果有错误则不调用
    86.          -（void）onSocket:(Asyncsocket *)sock didReadPartialDataOfLength:(NSUInteger)partiaLength tag:(long)tag;
    87.            当一个socket读取数据，但尚未完成读操作的时候调用，如果使用 readToData: or readToLength: 方法 会发生,可以被用来更新进度条等东西
    89.             -（void）onSocket:(AsyncSocket *)sock didWriteDataWithTag:(long)tag;
    90.              当一个socket已完成请求数据的写入时候调用
    92.             -（void）onSocket:(AsyncSocket *)sock didWritePartialDataOfLength:(NSUInteger)partialLength tag:(long)tag;
    93.              当一个socket写入一些数据，但还没有完成整个写入时调用，它可以用来更新进度条等东西
    95.                -（NSTimeInterval）onSocket:(AsyncSocket *)sock shouldTimeoutReadWithTag:(long)tag elapsed:(NSTimeInterval)exapsed bytesDone:(NSUInteger)length
    96.               使用读操作已超时但还没完成时调用，此方法允许随意延迟超时，如果返回一个正的时间间隔，读取的超时将有一定量的扩展，如果不实现这个方法，或会像往常一样返回一个负的时间间隔，elapsed参数是  原超时的总和，加上先前通过这种方法添加的任何补充， length参数是 读操作到目前为止已读取的字节数， 注意，如果返回正数的话，这个方法可能被一个单独的读取多次调用
    98.                -（NSTimeInterval）onSocket:(AsyncSocket *)sock shouldTimeoutWriteWithTag:(long)tag elapsed:(NSTimeInterval)elapsed bytesDone:(NSUInteger)length;
    99.                 如果一个写操作已达到其超时但还没完成时调用，同上
    101.                -（void）onSocketDidSecure:(AsyncSocket *)sock;
    102.                在socket成功完成ssl/tls协商时调用，此方法除非你使用提供startTLS方法时候才调用，
    103.     如果ssl/tls是无效的证书，socket将会立即关闭，onSocket:willDisconnectWithError:代理方法竟会与特定的ssl错误代码一起调用
    105.                -（BOOL）canSafelySetDelegate
    106.                用来查看在改变它之前，是否带有与当前的委托有悬而未决的业务(读/写)。当然，应在安全连接或接受委托之前改变委托
    108.               一旦接收或连接方法之一被调用，AsyncSocket实例会被锁定，其他接收/连接方法在没有先断开socket不会被调用
    109.               如果尝试失败或超时，这些方法要么返回NO 要么调用 onSocket:willDisconnectWithError: 或 onSockedDidDisconnect
    110.               当传入的连接被接受，AsyncSocket调用多个委托方法。这些方法按照时间顺序排列：
    111.                  1.onSocket:didAcceptNewSocket:
    112.                  2.onSocket:wantsRunLoopForNewSocket:
    113.                  3. onSocketWillConnect:
    114.                
    115.               你的服务器的代码将需要保留公认的socket(如果要接受它)，最好的地方是要做到这一点可能在onSocket:didAcceptNewSocket:方法    
    116.              在读和写流已经为新接受的socket设置，onSocket:didConnectToHost:port 方法将在适当的运行循环调用
    117.              多线程注意，如果要想通过实施onSocket：wantsRunLoopForNewSocket：，移动另一个新接受的socket去到另一个循环的socket。然后，应该在调用读和写或者startTLS方法前，等待直到onSocket:didConnectToHost:port:方法。否则读和写时间原定于不正确的runloop，混乱可能会随之而来
    120.              -（BOOL）acceptOnPort:(UInit16)port error:(NSError **)errPtr;
    121.              告诉socket开始听取和接受制定端口上的连接，当一个连接到来的时候，AsyncSocket实例将调用各种委托方法，socket将听取所有可用的接口(wifi,以太网等)
    123.              -（BOOL）connectToHost:(NSString *)hostname onPort:(UInt16)port error :(NSError **)errPtr;
    124.              连接给定的主机和端口，主机hostname可以是域名或者是Ip地址
    126.              -（BOOL）connectToAddress:(NSData *)remoteAddr error:(NSError *)errPtr;
    127.              连接到一个给定的地址，制定一个sockaddr结构包裹住一个NSData对象,例如，NSData对象从NSNetService的地址方法返回,如果有一个现有的sockaddr结构，可以将它转换到一个NSData对象，像这样：
    128.  struct sockaddr sa  -> NSData *dsa = [NSData dataWithBytes:&remoteAddr length:remoteAddr.sa_len];
    129.  struct sockaddr *sa -> NSData *dsa = [NSData dataWithBytes:remoteAddr length:remoteAddr->sa_len];
    131.              -（void）disconnect;
    132.                 立即断开，任何未处理的读或写都将被丢弃
    133.                 如果socket还没有断开，在这个方法返回之前，onSocketDidDisconnect 委托方法将会被立即调用
    134.                  注意推荐释放AsyncSocket实例的方式：
    135.                    [asyncSocket setDelegate:nil];
    136.                    [asyncSocket disconnect];
    137.                    [asyncSocket release];
    139.               -（void）disconnectAfterReading;
    140.                  在已经完成了所有悬而未决的读取时 断开,在调用之后，读取和写入方法将无用,socket将断开 即使仍有待写入
    142.               - (NSString *)connectedHost;
    143.               - (UInt16)connectedPort;
    144.               - (NSString *)localHost;
    145.               - (UInt16)localPort;
    146.                 返回本地和远程主机和端口给连接的socket，如果没有连接会返回nil或0,主机将会是一个IP地址
    148.              -（NSData *）connectedAddress
    149.              -（NSData *）localAddresss
    150.                 返回本地和远程的地址给连接的socket，指定一个socketaddr结构包裹在一个NSData对象
    153.                 readData和writeData方法不会是block(它们是异步的)
    154.                当读完成 onSocket:didReadData:withTag: 委托方法时调用
    155.                当写完成 onSocket:didWriteDataWithTag: 委托方法时调用
    156.                可以选择任何读/写操作的超时设置(为了不超时，使用负时间间隔。）
    157.                如果读/写操作超时，相应的 onSocket:shouldTimeout...委托方法被调用去选择性地允许我们去延长超时
    158.                超时后，onSocket:willDisconnectWithError: 方法被调用,紧接着是 onSocketDidDisconnect
    159.                tag是为了方便，可以使用它作为数组的索引、步数、state id 、指针等 
    163.             -（void）readDataWithTimeout:(NSTimeInterval)tiemout tag:(long)tag;
    164.               读取socket上第一次成为可用的字节,如果timeout值是负数的，读操作将不使用timeout
    166.             - （void）readDataWithTimeout:(NSTimeInterval)timeout buffer:(NSMutableData *)buffer bufferOffset:(NSUInterger)offset tag:(long)tag;
    167.               读取socket上第一次成为可用的字节
    168.               字节将被追加到给定的字节缓冲区，从给定的偏移量开始
    169.               如果需要，给定的缓冲区大小将会自动增加
    170.               如果timeout值是负数的，读操作将不使用timeout
    171.               如果缓冲区为空，socket会为我们创建一个缓冲区
    172.               如果bufferOffset是大于给定的缓冲区的长度，该方法将无用，委托将不会被调用
    173.               如果你传递一个缓冲区，当AsyncSocket在使用它的时候你不能以任何方式改变它
    174.               完成之后，onSocket:didReadData:withTag 返回的数据将是一个给定的缓冲区的子集
    175.               也就是说，它将会被引用到被追加的给定的缓冲区的字节
    177.             -（void）readDataToLength:(NSUInterger)length withTimeout:(NSTimeInterval)timeout tag:(long)tag;
    178.             读取给定的字节数，如果length为0，方法将无用，委托将不会被调用
    180.             -（void）readDataToLength:(NSUInteger)length withTimeout:(NSTimeInterval)tiemout buffer:(NSMutableData *)buffer bufferOffset:(NSUInteger) offset tag:(long)tag;
    181.             读取给定的字节数,在给定的偏移开始，字节将被追加到给定的字节缓冲区
    183.             -（void）readDataToData:(NSData *)data withTimeout:(NSTimeInterval)timeout tag:(long)tag;
    184.             读取字节直到(包括)传入的作为分隔的"data"参数
    185.             如果传递0或者0长度的数据，"data"参数，该方法将无用，委托将不会被调用
    186.             从socket读取一行，使用"data"参数作为行的分隔符 (如HTTP的CRLF)
    187.             注意，此方法不是字符集，因此，如果一个分隔符出现，它自然可以作为进行编码的一部分，读取将提前结束
    189.             -（void）readDataToData:(NSData *)data withTimeout:(NSTimeInterval)timeout buffer:(NSMutableData *)buffer bufferOffset:(NSUInteger) offset tag:(long)tag;
    190.            读取字节直到(包括)传入的作为分隔的“data”参数，在给定的偏移量开始，字节将被追加到给定的字节缓冲区。
    191.            从socket读取一行，使用"data"参数作为行的分隔符(如HTTP的CRLF)
    193.            -（void）writeData:(NSData *)data withTimeout:(NSTimeInterval) timeout tag:(long)tag;
    194.           将data写入socket，当完成的时候委托被调用 
    196.            - (float)progressOfReadReturningTag:(long *)tag bytesDone:(NSUInteger *)done total:(NSUInteger *)total;
    197.            - (float)progressOfWriteReturningTag:(long *)tag bytesDone:(NSUInteger *)done total:(NSUInteger *)total;
    198.            返回当前读或写的进度，从0.0 到 1.0 或者 如果没有读/写的时候返回Nan(使用isNan来检查)
    199.    tag、done、total如果不为空的话，它们将会被填补
    201.            
    203.            - (void)startTLS:(NSDictionary *)tlsSettings;
    204.            确保使用ssl/tls连接
    205.            这方法可被随时调用，tls握手将会发生在所有悬而未决的读/写完成之后。这紧跟着一个发送依赖 StartTLS消息的协议选项，在排队升级到TLS的同一时间，而不必等待写入完成。在这个方法被调用后,任何读写计划 将会发生在安全链接
    206.            对于可能的keys和TLS设置的值是有据可查的
    207.            一些可能的keys是:
    208.               * - kCFStreamSSLLevel
    209.               * - kCFStreamSSLAllowsExpiredCertificates
    210.               * - kCFStreamSSLAllowsExpiredRoots
    211.               * - kCFStreamSSLAllowsAnyRoot
    212.               * - kCFStreamSSLValidatesCertificateChain
    213.               * - kCFStreamSSLPeerName
    214.               * - kCFStreamSSLCertificates
    215.               * - kCFStreamSSLIsServer
    217.            如果你传递空或者空字典，将使用默认的字典
    218.            默认设置将检查以确保由签署可信的第三方证书机构和没有过期的远程连接的证书
    219.            然而，它不会验证证书上的名字，除非你给它一个名字，通过kCFStreamSSLPeerName键去验证
    220.            这对安全的影响是重要的理解
    221.            想象一下你正试图创建一个到MySecureServer.com的安全连接，但因为一个被攻击的DNS服务器，所以你的socket被定向到MaliciousServer.com
    222.            如果你只是使用默认设置，MaliciousServer.com 有一个有效的证书
    223.            默认设置将无法监测到任何问题，因为证书是有效的
    224.           在这个特殊的情况下，要妥善保护你的连接，应设置kCFStreamSSLPeerName性质为MySecureServer.com.
    225.          如果事前你不知道对等的名字的远程主机(例如，你不确认它是domain.com" or "www.domain.com")，那么你可以使用默认设置来验证证书，然后在获得验证的发行后使用X509Certificate类来验证,X509Certificate类的CocoaAsyncSocket开源项目的一部分
    227.          -（void）enablePrebuffering
    228.          对于处理readDataToData请求，数据是必须从socket以小增量的方式读取出来的
    229.          性能通过允许AsyncSocket去一次性读大块的数据和存储任何一个小的内部缓冲区溢出的东西来大大提高
    230.          这被称为预缓冲，就好像一些数据在你要求它之前就可能被读取出来
    231.          如果你经常使用readDataToData，使用预缓冲会有更好的性能，尤其是在iphone上
    232.          默认的预缓冲状态是由DEFAULT_PREBUFFERING 定义控制的，强烈建议设置其为yes
    233.          这方法存在一些预缓冲需要一些不可预见的原因被默认禁用的情况，这时，这种方法存在允许当就绪时，可轻松启用预缓冲
    235.           -（BOOL）moveToRunLoop:(NSRunLoop *)runLoop;
    236.           当你创建一个AsyncSocket，它被添加到当前线程runloop
    237.           对于手动创建的socket，在线程上你打算使用它，它是最容易简单的创建的线程上的socket
    238.           当一个新的socket被接受，委托方法 onSocket:wantsRunLoopForNewSocket 会被调用 允许你在一个单独的线程上放置socket，这个工作最好结合在同一个线程池设计
    239.           如果，但是，在一个单独的线程上，在之后的时间，你需要移动一个socket，这个方法可以用来完成任务
    240.           此方法必须从 当前运行的 线程/runloop 的socket 调用
    241.           注意：此方法调用后，所有进一步的方法应该从给定的runloop上调用这个对象
    242.           此外，所有委托调用将会发送到给定的runloop
    245.           - (BOOL)setRunLoopModes:(NSArray *)runLoopModes;
    246.           - (BOOL)addRunLoopMode:(NSString *)runLoopMode;
    247.           - (BOOL)removeRunLoopMode:(NSString *)runLoopMode;
    248.            允许你配置 socket 使用的 运行循环模式
    249.            运行循环模式设置默认是NSRunLoopCommonModes
    250.            如果你想你的socket 在其他模式下继续操作，你可能需要添加模式 NSModalPanelRunLoopMode 或者 NSEventTrackingRunLoopMode ,或者你可能只想使用 NSRunLoopCommonModes
    251.            可接受的socket将自动 继承相同的运行循环模式就像侦听socket
    252.            注意：NSRunLoopCommonModes 定义在10.5，对于之前的版本可使用 kCFRunLoopCommonModes
    254.           -（NSArray *）runLoopModes
    255.             返回当前正在运行的循环模式的AsyncSocket实例， run loop modes的默认设置是NSDefaultRunLoopMode
    257.           -（NSData *）unreadData;
    258.          一个错误的事件，在 onSocket:willDisconnectWithError: 将会被调用 去读取留在socket上的任何数据
    260.           + (NSData *)CRLFData;   // 0x0D0A
    261.   
    265. 各方法的解析
    266.        -（void）onSocket：（AsyncSocket *）sock willDisconnectWithError：(NSError *)err;   
    267.        发生错误，socket关闭，可以在call-back过程调用"unreadData"去取得socket的最后的数据字节，当连接的时候，该委托方法在    onSocket:didAcceptNewSocket: 或者 onSocket:didConnectToHost： 之前调用
    269.       -（void）onSocketDidDisconnect:(ASyncSocket *)sock;
    270.       当socket由于或没有错误而断开连接，如果你想要在断开连接后release socket，在此方法工作，而在onSocket:willDisconnectWithError 释放则不安全
    272.        -（void）onSocket:(AsyncSocket *)sock didAcceptNewSocket:(AsyncSocket *)newSocket;
    273.         当产生一个socket去处理连接时调用，此方法会返回 线程上的run-loop 的新的socket和其应处理的委托，如果省略，则使用[NSRunLoop cunrrentRunLoop]
    275.           -（BOOL）onSocketWillConnect:(AsyncSocket *)sock;
    277.        -（void）onSocket:(AsyncSocket *)sock didConnectToHost :(NSString *)host port:(UINt16)port;
    278.           当socket连接正准备读和写的时候调用，host属性是一个IP地址，而不是一个DNS 名称
    280.          -（void）onSocket:(AsyncSocket *)sock didReadData:(NSData *)data withTag:(long) tag;
    281.          当socket已完成所要求的数据读入内存时调用，如果有错误则不调用
    283.          -（void）onSocket:(Asyncsocket *)sock didReadPartialDataOfLength:(NSUInteger)partiaLength tag:(long)tag;
    284.            当一个socket读取数据，但尚未完成读操作的时候调用，如果使用 readToData: or readToLength: 方法 会发生,可以被用来更新进度条等东西
    286.             -（void）onSocket:(AsyncSocket *)sock didWriteDataWithTag:(long)tag;
    287.              当一个socket已完成请求数据的写入时候调用
    289.             -（void）onSocket:(AsyncSocket *)sock didWritePartialDataOfLength:(NSUInteger)partialLength tag:(long)tag;
    290.              当一个socket写入一些数据，但还没有完成整个写入时调用，它可以用来更新进度条等东西
    292.                -（NSTimeInterval）onSocket:(AsyncSocket *)sock shouldTimeoutReadWithTag:(long)tag elapsed:(NSTimeInterval)exapsed bytesDone:(NSUInteger)length
    293.               使用读操作已超时但还没完成时调用，此方法允许随意延迟超时，如果返回一个正的时间间隔，读取的超时将有一定量的扩展，如果不实现这个方法，或会像往常一样返回一个负的时间间隔，elapsed参数是  原超时的总和，加上先前通过这种方法添加的任何补充， length参数是 读操作到目前为止已读取的字节数， 注意，如果返回正数的话，这个方法可能被一个单独的读取多次调用
    295.                -（NSTimeInterval）onSocket:(AsyncSocket *)sock shouldTimeoutWriteWithTag:(long)tag elapsed:(NSTimeInterval)elapsed bytesDone:(NSUInteger)length;
    296.                 如果一个写操作已达到其超时但还没完成时调用，同上
    298.                -（void）onSocketDidSecure:(AsyncSocket *)sock;
    299.                在socket成功完成ssl/tls协商时调用，此方法除非你使用提供startTLS方法时候才调用，
    300.     如果ssl/tls是无效的证书，socket将会立即关闭，onSocket:willDisconnectWithError:代理方法竟会与特定的ssl错误代码一起调用
    302.                -（BOOL）canSafelySetDelegate
    303.                用来查看在改变它之前，是否带有与当前的委托有悬而未决的业务(读/写)。当然，应在安全连接或接受委托之前改变委托
    305.               一旦接收或连接方法之一被调用，AsyncSocket实例会被锁定，其他接收/连接方法在没有先断开socket不会被调用
    306.               如果尝试失败或超时，这些方法要么返回NO 要么调用 onSocket:willDisconnectWithError: 或 onSockedDidDisconnect
    307.               当传入的连接被接受，AsyncSocket调用多个委托方法。这些方法按照时间顺序排列：
    308.                  1.onSocket:didAcceptNewSocket:
    309.                  2.onSocket:wantsRunLoopForNewSocket:
    310.                  3. onSocketWillConnect:
    311.                
    312.               你的服务器的代码将需要保留公认的socket(如果要接受它)，最好的地方是要做到这一点可能在onSocket:didAcceptNewSocket:方法    
    313.              在读和写流已经为新接受的socket设置，onSocket:didConnectToHost:port 方法将在适当的运行循环调用
    314.              多线程注意，如果要想通过实施onSocket：wantsRunLoopForNewSocket：，移动另一个新接受的socket去到另一个循环的socket。然后，应该在调用读和写或者startTLS方法前，等待直到onSocket:didConnectToHost:port:方法。否则读和写时间原定于不正确的runloop，混乱可能会随之而来
    317.              -（BOOL）acceptOnPort:(UInit16)port error:(NSError **)errPtr;
    318.              告诉socket开始听取和接受制定端口上的连接，当一个连接到来的时候，AsyncSocket实例将调用各种委托方法，socket将听取所有可用的接口(wifi,以太网等)
    320.              -（BOOL）connectToHost:(NSString *)hostname onPort:(UInt16)port error :(NSError **)errPtr;
    321.              连接给定的主机和端口，主机hostname可以是域名或者是Ip地址
    323.              -（BOOL）connectToAddress:(NSData *)remoteAddr error:(NSError *)errPtr;
    324.              连接到一个给定的地址，制定一个sockaddr结构包裹住一个NSData对象,例如，NSData对象从NSNetService的地址方法返回,如果有一个现有的sockaddr结构，可以将它转换到一个NSData对象，像这样：
    325.  struct sockaddr sa  -> NSData *dsa = [NSData dataWithBytes:&remoteAddr length:remoteAddr.sa_len];
    326.  struct sockaddr *sa -> NSData *dsa = [NSData dataWithBytes:remoteAddr length:remoteAddr->sa_len];
    328.              -（void）disconnect;
    329.                 立即断开，任何未处理的读或写都将被丢弃
    330.                 如果socket还没有断开，在这个方法返回之前，onSocketDidDisconnect 委托方法将会被立即调用
    331.                  注意推荐释放AsyncSocket实例的方式：
    332.                    [asyncSocket setDelegate:nil];
    333.                    [asyncSocket disconnect];
    334.                    [asyncSocket release];
    336.               -（void）disconnectAfterReading;
    337.                  在已经完成了所有悬而未决的读取时 断开,在调用之后，读取和写入方法将无用,socket将断开 即使仍有待写入
    339.               - (NSString *)connectedHost;
    340.               - (UInt16)connectedPort;
    341.               - (NSString *)localHost;
    342.               - (UInt16)localPort;
    343.                 返回本地和远程主机和端口给连接的socket，如果没有连接会返回nil或0,主机将会是一个IP地址
    345.              -（NSData *）connectedAddress
    346.              -（NSData *）localAddresss
    347.                 返回本地和远程的地址给连接的socket，指定一个socketaddr结构包裹在一个NSData对象
    350.                 readData和writeData方法不会是block(它们是异步的)
    351.                当读完成 onSocket:didReadData:withTag: 委托方法时调用
    352.                当写完成 onSocket:didWriteDataWithTag: 委托方法时调用
    353.                可以选择任何读/写操作的超时设置(为了不超时，使用负时间间隔。）
    354.                如果读/写操作超时，相应的 onSocket:shouldTimeout...委托方法被调用去选择性地允许我们去延长超时
    355.                超时后，onSocket:willDisconnectWithError: 方法被调用,紧接着是 onSocketDidDisconnect
    356.                tag是为了方便，可以使用它作为数组的索引、步数、state id 、指针等 
    360.             -（void）readDataWithTimeout:(NSTimeInterval)tiemout tag:(long)tag;
    361.               读取socket上第一次成为可用的字节,如果timeout值是负数的，读操作将不使用timeout
    363.             - （void）readDataWithTimeout:(NSTimeInterval)timeout buffer:(NSMutableData *)buffer bufferOffset:(NSUInterger)offset tag:(long)tag;
    364.               读取socket上第一次成为可用的字节
    365.               字节将被追加到给定的字节缓冲区，从给定的偏移量开始
    366.               如果需要，给定的缓冲区大小将会自动增加
    367.               如果timeout值是负数的，读操作将不使用timeout
    368.               如果缓冲区为空，socket会为我们创建一个缓冲区
    369.               如果bufferOffset是大于给定的缓冲区的长度，该方法将无用，委托将不会被调用
    370.               如果你传递一个缓冲区，当AsyncSocket在使用它的时候你不能以任何方式改变它
    371.               完成之后，onSocket:didReadData:withTag 返回的数据将是一个给定的缓冲区的子集
    372.               也就是说，它将会被引用到被追加的给定的缓冲区的字节
    374.             -（void）readDataToLength:(NSUInterger)length withTimeout:(NSTimeInterval)timeout tag:(long)tag;
    375.             读取给定的字节数，如果length为0，方法将无用，委托将不会被调用
    377.             -（void）readDataToLength:(NSUInteger)length withTimeout:(NSTimeInterval)tiemout buffer:(NSMutableData *)buffer bufferOffset:(NSUInteger) offset tag:(long)tag;
    378.             读取给定的字节数,在给定的偏移开始，字节将被追加到给定的字节缓冲区
    380.             -（void）readDataToData:(NSData *)data withTimeout:(NSTimeInterval)timeout tag:(long)tag;
    381.             读取字节直到(包括)传入的作为分隔的"data"参数
    382.             如果传递0或者0长度的数据，"data"参数，该方法将无用，委托将不会被调用
    383.             从socket读取一行，使用"data"参数作为行的分隔符 (如HTTP的CRLF)
    384.             注意，此方法不是字符集，因此，如果一个分隔符出现，它自然可以作为进行编码的一部分，读取将提前结束
    386.             -（void）readDataToData:(NSData *)data withTimeout:(NSTimeInterval)timeout buffer:(NSMutableData *)buffer bufferOffset:(NSUInteger) offset tag:(long)tag;
    387.            读取字节直到(包括)传入的作为分隔的“data”参数，在给定的偏移量开始，字节将被追加到给定的字节缓冲区。
    388.            从socket读取一行，使用"data"参数作为行的分隔符(如HTTP的CRLF)
    390.            -（void）writeData:(NSData *)data withTimeout:(NSTimeInterval) timeout tag:(long)tag;
    391.           将data写入socket，当完成的时候委托被调用 
    393.            - (float)progressOfReadReturningTag:(long *)tag bytesDone:(NSUInteger *)done total:(NSUInteger *)total;
    394.            - (float)progressOfWriteReturningTag:(long *)tag bytesDone:(NSUInteger *)done total:(NSUInteger *)total;
    395.            返回当前读或写的进度，从0.0 到 1.0 或者 如果没有读/写的时候返回Nan(使用isNan来检查)
    396.    tag、done、total如果不为空的话，它们将会被填补
    398.            
    400.            - (void)startTLS:(NSDictionary *)tlsSettings;
    401.            确保使用ssl/tls连接
    402.            这方法可被随时调用，tls握手将会发生在所有悬而未决的读/写完成之后。这紧跟着一个发送依赖 StartTLS消息的协议选项，在排队升级到TLS的同一时间，而不必等待写入完成。在这个方法被调用后,任何读写计划 将会发生在安全链接
    403.            对于可能的keys和TLS设置的值是有据可查的
    404.            一些可能的keys是:
    405.               * - kCFStreamSSLLevel
    406.               * - kCFStreamSSLAllowsExpiredCertificates
    407.               * - kCFStreamSSLAllowsExpiredRoots
    408.               * - kCFStreamSSLAllowsAnyRoot
    409.               * - kCFStreamSSLValidatesCertificateChain
    410.               * - kCFStreamSSLPeerName
    411.               * - kCFStreamSSLCertificates
    412.               * - kCFStreamSSLIsServer
    414.            如果你传递空或者空字典，将使用默认的字典
    415.            默认设置将检查以确保由签署可信的第三方证书机构和没有过期的远程连接的证书
    416.            然而，它不会验证证书上的名字，除非你给它一个名字，通过kCFStreamSSLPeerName键去验证
    417.            这对安全的影响是重要的理解
    418.            想象一下你正试图创建一个到MySecureServer.com的安全连接，但因为一个被攻击的DNS服务器，所以你的socket被定向到MaliciousServer.com
    419.            如果你只是使用默认设置，MaliciousServer.com 有一个有效的证书
    420.            默认设置将无法监测到任何问题，因为证书是有效的
    421.           在这个特殊的情况下，要妥善保护你的连接，应设置kCFStreamSSLPeerName性质为MySecureServer.com.
    422.          如果事前你不知道对等的名字的远程主机(例如，你不确认它是domain.com" or "www.domain.com")，那么你可以使用默认设置来验证证书，然后在获得验证的发行后使用X509Certificate类来验证,X509Certificate类的CocoaAsyncSocket开源项目的一部分
    424.          -（void）enablePrebuffering
    425.          对于处理readDataToData请求，数据是必须从socket以小增量的方式读取出来的
    426.          性能通过允许AsyncSocket去一次性读大块的数据和存储任何一个小的内部缓冲区溢出的东西来大大提高
    427.          这被称为预缓冲，就好像一些数据在你要求它之前就可能被读取出来
    428.          如果你经常使用readDataToData，使用预缓冲会有更好的性能，尤其是在iphone上
    429.          默认的预缓冲状态是由DEFAULT_PREBUFFERING 定义控制的，强烈建议设置其为yes
    430.          这方法存在一些预缓冲需要一些不可预见的原因被默认禁用的情况，这时，这种方法存在允许当就绪时，可轻松启用预缓冲
    432.           -（BOOL）moveToRunLoop:(NSRunLoop *)runLoop;
    433.           当你创建一个AsyncSocket，它被添加到当前线程runloop
    434.           对于手动创建的socket，在线程上你打算使用它，它是最容易简单的创建的线程上的socket
    435.           当一个新的socket被接受，委托方法 onSocket:wantsRunLoopForNewSocket 会被调用 允许你在一个单独的线程上放置socket，这个工作最好结合在同一个线程池设计
    436.           如果，但是，在一个单独的线程上，在之后的时间，你需要移动一个socket，这个方法可以用来完成任务
    437.           此方法必须从 当前运行的 线程/runloop 的socket 调用
    438.           注意：此方法调用后，所有进一步的方法应该从给定的runloop上调用这个对象
    439.           此外，所有委托调用将会发送到给定的runloop
    442.           - (BOOL)setRunLoopModes:(NSArray *)runLoopModes;
    443.           - (BOOL)addRunLoopMode:(NSString *)runLoopMode;
    444.           - (BOOL)removeRunLoopMode:(NSString *)runLoopMode;
    445.            允许你配置 socket 使用的 运行循环模式
    446.            运行循环模式设置默认是NSRunLoopCommonModes
    447.            如果你想你的socket 在其他模式下继续操作，你可能需要添加模式 NSModalPanelRunLoopMode 或者 NSEventTrackingRunLoopMode ,或者你可能只想使用 NSRunLoopCommonModes
    448.            可接受的socket将自动 继承相同的运行循环模式就像侦听socket
    449.            注意：NSRunLoopCommonModes 定义在10.5，对于之前的版本可使用 kCFRunLoopCommonModes
    451.           -（NSArray *）runLoopModes
    452.             返回当前正在运行的循环模式的AsyncSocket实例， run loop modes的默认设置是NSDefaultRunLoopMode
    454.           -（NSData *）unreadData;
    455.          一个错误的事件，在 onSocket:willDisconnectWithError: 将会被调用 去读取留在socket上的任何数据
    457.           + (NSData *)CRLFData;   // 0x0D0A
    458.   
    461. 各方法的解析
    462.        -（void）onSocket：（AsyncSocket *）sock willDisconnectWithError：(NSError *)err;   
    463.        发生错误，socket关闭，可以在call-back过程调用"unreadData"去取得socket的最后的数据字节，当连接的时候，该委托方法在    onSocket:didAcceptNewSocket: 或者 onSocket:didConnectToHost： 之前调用
    465.       -（void）onSocketDidDisconnect:(ASyncSocket *)sock;
    466.       当socket由于或没有错误而断开连接，如果你想要在断开连接后release socket，在此方法工作，而在onSocket:willDisconnectWithError 释放则不安全
    468.        -（void）onSocket:(AsyncSocket *)sock didAcceptNewSocket:(AsyncSocket *)newSocket;
    469.         当产生一个socket去处理连接时调用，此方法会返回 线程上的run-loop 的新的socket和其应处理的委托，如果省略，则使用[NSRunLoop cunrrentRunLoop]
    471.           -（BOOL）onSocketWillConnect:(AsyncSocket *)sock;
    473.        -（void）onSocket:(AsyncSocket *)sock didConnectToHost :(NSString *)host port:(UINt16)port;
    474.           当socket连接正准备读和写的时候调用，host属性是一个IP地址，而不是一个DNS 名称
    476.          -（void）onSocket:(AsyncSocket *)sock didReadData:(NSData *)data withTag:(long) tag;
    477.          当socket已完成所要求的数据读入内存时调用，如果有错误则不调用
    479.          -（void）onSocket:(Asyncsocket *)sock didReadPartialDataOfLength:(NSUInteger)partiaLength tag:(long)tag;
    480.            当一个socket读取数据，但尚未完成读操作的时候调用，如果使用 readToData: or readToLength: 方法 会发生,可以被用来更新进度条等东西
    482.             -（void）onSocket:(AsyncSocket *)sock didWriteDataWithTag:(long)tag;
    483.              当一个socket已完成请求数据的写入时候调用
    485.             -（void）onSocket:(AsyncSocket *)sock didWritePartialDataOfLength:(NSUInteger)partialLength tag:(long)tag;
    486.              当一个socket写入一些数据，但还没有完成整个写入时调用，它可以用来更新进度条等东西
    488.                -（NSTimeInterval）onSocket:(AsyncSocket *)sock shouldTimeoutReadWithTag:(long)tag elapsed:(NSTimeInterval)exapsed bytesDone:(NSUInteger)length
    489.               使用读操作已超时但还没完成时调用，此方法允许随意延迟超时，如果返回一个正的时间间隔，读取的超时将有一定量的扩展，如果不实现这个方法，或会像往常一样返回一个负的时间间隔，elapsed参数是  原超时的总和，加上先前通过这种方法添加的任何补充， length参数是 读操作到目前为止已读取的字节数， 注意，如果返回正数的话，这个方法可能被一个单独的读取多次调用
    491.                -（NSTimeInterval）onSocket:(AsyncSocket *)sock shouldTimeoutWriteWithTag:(long)tag elapsed:(NSTimeInterval)elapsed bytesDone:(NSUInteger)length;
    492.                 如果一个写操作已达到其超时但还没完成时调用，同上
    494.                -（void）onSocketDidSecure:(AsyncSocket *)sock;
    495.                在socket成功完成ssl/tls协商时调用，此方法除非你使用提供startTLS方法时候才调用，
    496.     如果ssl/tls是无效的证书，socket将会立即关闭，onSocket:willDisconnectWithError:代理方法竟会与特定的ssl错误代码一起调用
    498.                -（BOOL）canSafelySetDelegate
    499.                用来查看在改变它之前，是否带有与当前的委托有悬而未决的业务(读/写)。当然，应在安全连接或接受委托之前改变委托
    501.               一旦接收或连接方法之一被调用，AsyncSocket实例会被锁定，其他接收/连接方法在没有先断开socket不会被调用
    502.               如果尝试失败或超时，这些方法要么返回NO 要么调用 onSocket:willDisconnectWithError: 或 onSockedDidDisconnect
    503.               当传入的连接被接受，AsyncSocket调用多个委托方法。这些方法按照时间顺序排列：
    504.                  1.onSocket:didAcceptNewSocket:
    505.                  2.onSocket:wantsRunLoopForNewSocket:
    506.                  3. onSocketWillConnect:
    507.                
    508.               你的服务器的代码将需要保留公认的socket(如果要接受它)，最好的地方是要做到这一点可能在onSocket:didAcceptNewSocket:方法    
    509.              在读和写流已经为新接受的socket设置，onSocket:didConnectToHost:port 方法将在适当的运行循环调用
    510.              多线程注意，如果要想通过实施onSocket：wantsRunLoopForNewSocket：，移动另一个新接受的socket去到另一个循环的socket。然后，应该在调用读和写或者startTLS方法前，等待直到onSocket:didConnectToHost:port:方法。否则读和写时间原定于不正确的runloop，混乱可能会随之而来
    513.              -（BOOL）acceptOnPort:(UInit16)port error:(NSError **)errPtr;
    514.              告诉socket开始听取和接受制定端口上的连接，当一个连接到来的时候，AsyncSocket实例将调用各种委托方法，socket将听取所有可用的接口(wifi,以太网等)
    516.              -（BOOL）connectToHost:(NSString *)hostname onPort:(UInt16)port error :(NSError **)errPtr;
    517.              连接给定的主机和端口，主机hostname可以是域名或者是Ip地址
    519.              -（BOOL）connectToAddress:(NSData *)remoteAddr error:(NSError *)errPtr;
    520.              连接到一个给定的地址，制定一个sockaddr结构包裹住一个NSData对象,例如，NSData对象从NSNetService的地址方法返回,如果有一个现有的sockaddr结构，可以将它转换到一个NSData对象，像这样：
    521.  struct sockaddr sa  -> NSData *dsa = [NSData dataWithBytes:&remoteAddr length:remoteAddr.sa_len];
    522.  struct sockaddr *sa -> NSData *dsa = [NSData dataWithBytes:remoteAddr length:remoteAddr->sa_len];
    524.              -（void）disconnect;
    525.                 立即断开，任何未处理的读或写都将被丢弃
    526.                 如果socket还没有断开，在这个方法返回之前，onSocketDidDisconnect 委托方法将会被立即调用
    527.                  注意推荐释放AsyncSocket实例的方式：
    528.                    [asyncSocket setDelegate:nil];
    529.                    [asyncSocket disconnect];
    530.                    [asyncSocket release];
    532.               -（void）disconnectAfterReading;
    533.                  在已经完成了所有悬而未决的读取时 断开,在调用之后，读取和写入方法将无用,socket将断开 即使仍有待写入
    535.               - (NSString *)connectedHost;
    536.               - (UInt16)connectedPort;
    537.               - (NSString *)localHost;
    538.               - (UInt16)localPort;
    539.                 返回本地和远程主机和端口给连接的socket，如果没有连接会返回nil或0,主机将会是一个IP地址
    541.              -（NSData *）connectedAddress
    542.              -（NSData *）localAddresss
    543.                 返回本地和远程的地址给连接的socket，指定一个socketaddr结构包裹在一个NSData对象
    546.                 readData和writeData方法不会是block(它们是异步的)
    547.                当读完成 onSocket:didReadData:withTag: 委托方法时调用
    548.                当写完成 onSocket:didWriteDataWithTag: 委托方法时调用
    549.                可以选择任何读/写操作的超时设置(为了不超时，使用负时间间隔。）
    550.                如果读/写操作超时，相应的 onSocket:shouldTimeout...委托方法被调用去选择性地允许我们去延长超时
    551.                超时后，onSocket:willDisconnectWithError: 方法被调用,紧接着是 onSocketDidDisconnect
    552.                tag是为了方便，可以使用它作为数组的索引、步数、state id 、指针等 
    556.             -（void）readDataWithTimeout:(NSTimeInterval)tiemout tag:(long)tag;
    557.               读取socket上第一次成为可用的字节,如果timeout值是负数的，读操作将不使用timeout
    559.             - （void）readDataWithTimeout:(NSTimeInterval)timeout buffer:(NSMutableData *)buffer bufferOffset:(NSUInterger)offset tag:(long)tag;
    560.               读取socket上第一次成为可用的字节
    561.               字节将被追加到给定的字节缓冲区，从给定的偏移量开始
    562.               如果需要，给定的缓冲区大小将会自动增加
    563.               如果timeout值是负数的，读操作将不使用timeout
    564.               如果缓冲区为空，socket会为我们创建一个缓冲区
    565.               如果bufferOffset是大于给定的缓冲区的长度，该方法将无用，委托将不会被调用
    566.               如果你传递一个缓冲区，当AsyncSocket在使用它的时候你不能以任何方式改变它
    567.               完成之后，onSocket:didReadData:withTag 返回的数据将是一个给定的缓冲区的子集
    568.               也就是说，它将会被引用到被追加的给定的缓冲区的字节
    570.             -（void）readDataToLength:(NSUInterger)length withTimeout:(NSTimeInterval)timeout tag:(long)tag;
    571.             读取给定的字节数，如果length为0，方法将无用，委托将不会被调用
    573.             -（void）readDataToLength:(NSUInteger)length withTimeout:(NSTimeInterval)tiemout buffer:(NSMutableData *)buffer bufferOffset:(NSUInteger) offset tag:(long)tag;
    574.             读取给定的字节数,在给定的偏移开始，字节将被追加到给定的字节缓冲区
    576.             -（void）readDataToData:(NSData *)data withTimeout:(NSTimeInterval)timeout tag:(long)tag;
    577.             读取字节直到(包括)传入的作为分隔的"data"参数
    578.             如果传递0或者0长度的数据，"data"参数，该方法将无用，委托将不会被调用
    579.             从socket读取一行，使用"data"参数作为行的分隔符 (如HTTP的CRLF)
    580.             注意，此方法不是字符集，因此，如果一个分隔符出现，它自然可以作为进行编码的一部分，读取将提前结束
    582.             -（void）readDataToData:(NSData *)data withTimeout:(NSTimeInterval)timeout buffer:(NSMutableData *)buffer bufferOffset:(NSUInteger) offset tag:(long)tag;
    583.            读取字节直到(包括)传入的作为分隔的“data”参数，在给定的偏移量开始，字节将被追加到给定的字节缓冲区。
    584.            从socket读取一行，使用"data"参数作为行的分隔符(如HTTP的CRLF)
    586.            -（void）writeData:(NSData *)data withTimeout:(NSTimeInterval) timeout tag:(long)tag;
    587.           将data写入socket，当完成的时候委托被调用 
    589.            - (float)progressOfReadReturningTag:(long *)tag bytesDone:(NSUInteger *)done total:(NSUInteger *)total;
    590.            - (float)progressOfWriteReturningTag:(long *)tag bytesDone:(NSUInteger *)done total:(NSUInteger *)total;
    591.            返回当前读或写的进度，从0.0 到 1.0 或者 如果没有读/写的时候返回Nan(使用isNan来检查)
    592.    tag、done、total如果不为空的话，它们将会被填补
    594.            
    596.            - (void)startTLS:(NSDictionary *)tlsSettings;
    597.            确保使用ssl/tls连接
    598.            这方法可被随时调用，tls握手将会发生在所有悬而未决的读/写完成之后。这紧跟着一个发送依赖 StartTLS消息的协议选项，在排队升级到TLS的同一时间，而不必等待写入完成。在这个方法被调用后,任何读写计划 将会发生在安全链接
    599.            对于可能的keys和TLS设置的值是有据可查的
    600.            一些可能的keys是:
    601.               * - kCFStreamSSLLevel
    602.               * - kCFStreamSSLAllowsExpiredCertificates
    603.               * - kCFStreamSSLAllowsExpiredRoots
    604.               * - kCFStreamSSLAllowsAnyRoot
    605.               * - kCFStreamSSLValidatesCertificateChain
    606.               * - kCFStreamSSLPeerName
    607.               * - kCFStreamSSLCertificates
    608.               * - kCFStreamSSLIsServer
    610.            如果你传递空或者空字典，将使用默认的字典
    611.            默认设置将检查以确保由签署可信的第三方证书机构和没有过期的远程连接的证书
    612.            然而，它不会验证证书上的名字，除非你给它一个名字，通过kCFStreamSSLPeerName键去验证
    613.            这对安全的影响是重要的理解
    614.            想象一下你正试图创建一个到MySecureServer.com的安全连接，但因为一个被攻击的DNS服务器，所以你的socket被定向到MaliciousServer.com
    615.            如果你只是使用默认设置，MaliciousServer.com 有一个有效的证书
    616.            默认设置将无法监测到任何问题，因为证书是有效的
    617.           在这个特殊的情况下，要妥善保护你的连接，应设置kCFStreamSSLPeerName性质为MySecureServer.com.
    618.          如果事前你不知道对等的名字的远程主机(例如，你不确认它是domain.com" or "www.domain.com")，那么你可以使用默认设置来验证证书，然后在获得验证的发行后使用X509Certificate类来验证,X509Certificate类的CocoaAsyncSocket开源项目的一部分
    620.          -（void）enablePrebuffering
    621.          对于处理readDataToData请求，数据是必须从socket以小增量的方式读取出来的
    622.          性能通过允许AsyncSocket去一次性读大块的数据和存储任何一个小的内部缓冲区溢出的东西来大大提高
    623.          这被称为预缓冲，就好像一些数据在你要求它之前就可能被读取出来
    624.          如果你经常使用readDataToData，使用预缓冲会有更好的性能，尤其是在iphone上
    625.          默认的预缓冲状态是由DEFAULT_PREBUFFERING 定义控制的，强烈建议设置其为yes
    626.          这方法存在一些预缓冲需要一些不可预见的原因被默认禁用的情况，这时，这种方法存在允许当就绪时，可轻松启用预缓冲
    628.           -（BOOL）moveToRunLoop:(NSRunLoop *)runLoop;
    629.           当你创建一个AsyncSocket，它被添加到当前线程runloop
    630.           对于手动创建的socket，在线程上你打算使用它，它是最容易简单的创建的线程上的socket
    631.           当一个新的socket被接受，委托方法 onSocket:wantsRunLoopForNewSocket 会被调用 允许你在一个单独的线程上放置socket，这个工作最好结合在同一个线程池设计
    632.           如果，但是，在一个单独的线程上，在之后的时间，你需要移动一个socket，这个方法可以用来完成任务
    633.           此方法必须从 当前运行的 线程/runloop 的socket 调用
    634.           注意：此方法调用后，所有进一步的方法应该从给定的runloop上调用这个对象
    635.           此外，所有委托调用将会发送到给定的runloop
    638.           - (BOOL)setRunLoopModes:(NSArray *)runLoopModes;
    639.           - (BOOL)addRunLoopMode:(NSString *)runLoopMode;
    640.           - (BOOL)removeRunLoopMode:(NSString *)runLoopMode;
    641.            允许你配置 socket 使用的 运行循环模式
    642.            运行循环模式设置默认是NSRunLoopCommonModes
    643.            如果你想你的socket 在其他模式下继续操作，你可能需要添加模式 NSModalPanelRunLoopMode 或者 NSEventTrackingRunLoopMode ,或者你可能只想使用 NSRunLoopCommonModes
    644.            可接受的socket将自动 继承相同的运行循环模式就像侦听socket
    645.            注意：NSRunLoopCommonModes 定义在10.5，对于之前的版本可使用 kCFRunLoopCommonModes
    647.           -（NSArray *）runLoopModes
    648.             返回当前正在运行的循环模式的AsyncSocket实例， run loop modes的默认设置是NSDefaultRunLoopMode
    650.           -（NSData *）unreadData;
    651.          一个错误的事件，在 onSocket:willDisconnectWithError: 将会被调用 去读取留在socket上的任何数据
    653.           + (NSData *)CRLFData;   // 0x0D0A
    654.   
    656. 各方法的解析
    657.        -（void）onSocket：（AsyncSocket *）sock willDisconnectWithError：(NSError *)err;   
    658.        发生错误，socket关闭，可以在call-back过程调用"unreadData"去取得socket的最后的数据字节，当连接的时候，该委托方法在    onSocket:didAcceptNewSocket: 或者 onSocket:didConnectToHost： 之前调用
    660.       -（void）onSocketDidDisconnect:(ASyncSocket *)sock;
    661.       当socket由于或没有错误而断开连接，如果你想要在断开连接后release socket，在此方法工作，而在onSocket:willDisconnectWithError 释放则不安全
    663.        -（void）onSocket:(AsyncSocket *)sock didAcceptNewSocket:(AsyncSocket *)newSocket;
    664.         当产生一个socket去处理连接时调用，此方法会返回 线程上的run-loop 的新的socket和其应处理的委托，如果省略，则使用[NSRunLoop cunrrentRunLoop]
    666.           -（BOOL）onSocketWillConnect:(AsyncSocket *)sock;
    668.        -（void）onSocket:(AsyncSocket *)sock didConnectToHost :(NSString *)host port:(UINt16)port;
    669.           当socket连接正准备读和写的时候调用，host属性是一个IP地址，而不是一个DNS 名称
    671.          -（void）onSocket:(AsyncSocket *)sock didReadData:(NSData *)data withTag:(long) tag;
    672.          当socket已完成所要求的数据读入内存时调用，如果有错误则不调用
    674.          -（void）onSocket:(Asyncsocket *)sock didReadPartialDataOfLength:(NSUInteger)partiaLength tag:(long)tag;
    675.            当一个socket读取数据，但尚未完成读操作的时候调用，如果使用 readToData: or readToLength: 方法 会发生,可以被用来更新进度条等东西
    677.             -（void）onSocket:(AsyncSocket *)sock didWriteDataWithTag:(long)tag;
    678.              当一个socket已完成请求数据的写入时候调用
    680.             -（void）onSocket:(AsyncSocket *)sock didWritePartialDataOfLength:(NSUInteger)partialLength tag:(long)tag;
    681.              当一个socket写入一些数据，但还没有完成整个写入时调用，它可以用来更新进度条等东西
    683.                -（NSTimeInterval）onSocket:(AsyncSocket *)sock shouldTimeoutReadWithTag:(long)tag elapsed:(NSTimeInterval)exapsed bytesDone:(NSUInteger)length
    684.               使用读操作已超时但还没完成时调用，此方法允许随意延迟超时，如果返回一个正的时间间隔，读取的超时将有一定量的扩展，如果不实现这个方法，或会像往常一样返回一个负的时间间隔，elapsed参数是  原超时的总和，加上先前通过这种方法添加的任何补充， length参数是 读操作到目前为止已读取的字节数， 注意，如果返回正数的话，这个方法可能被一个单独的读取多次调用
    686.                -（NSTimeInterval）onSocket:(AsyncSocket *)sock shouldTimeoutWriteWithTag:(long)tag elapsed:(NSTimeInterval)elapsed bytesDone:(NSUInteger)length;
    687.                 如果一个写操作已达到其超时但还没完成时调用，同上
    689.                -（void）onSocketDidSecure:(AsyncSocket *)sock;
    690.                在socket成功完成ssl/tls协商时调用，此方法除非你使用提供startTLS方法时候才调用，
    691.     如果ssl/tls是无效的证书，socket将会立即关闭，onSocket:willDisconnectWithError:代理方法竟会与特定的ssl错误代码一起调用
    693.                -（BOOL）canSafelySetDelegate
    694.                用来查看在改变它之前，是否带有与当前的委托有悬而未决的业务(读/写)。当然，应在安全连接或接受委托之前改变委托
    696.               一旦接收或连接方法之一被调用，AsyncSocket实例会被锁定，其他接收/连接方法在没有先断开socket不会被调用
    697.               如果尝试失败或超时，这些方法要么返回NO 要么调用 onSocket:willDisconnectWithError: 或 onSockedDidDisconnect
    698.               当传入的连接被接受，AsyncSocket调用多个委托方法。这些方法按照时间顺序排列：
    699.                  1.onSocket:didAcceptNewSocket:
    700.                  2.onSocket:wantsRunLoopForNewSocket:
    701.                  3. onSocketWillConnect:
    702.                
    703.               你的服务器的代码将需要保留公认的socket(如果要接受它)，最好的地方是要做到这一点可能在onSocket:didAcceptNewSocket:方法    
    704.              在读和写流已经为新接受的socket设置，onSocket:didConnectToHost:port 方法将在适当的运行循环调用
    705.              多线程注意，如果要想通过实施onSocket：wantsRunLoopForNewSocket：，移动另一个新接受的socket去到另一个循环的socket。然后，应该在调用读和写或者startTLS方法前，等待直到onSocket:didConnectToHost:port:方法。否则读和写时间原定于不正确的runloop，混乱可能会随之而来
    708.              -（BOOL）acceptOnPort:(UInit16)port error:(NSError **)errPtr;
    709.              告诉socket开始听取和接受制定端口上的连接，当一个连接到来的时候，AsyncSocket实例将调用各种委托方法，socket将听取所有可用的接口(wifi,以太网等)
    711.              -（BOOL）connectToHost:(NSString *)hostname onPort:(UInt16)port error :(NSError **)errPtr;
    712.              连接给定的主机和端口，主机hostname可以是域名或者是Ip地址
    714.              -（BOOL）connectToAddress:(NSData *)remoteAddr error:(NSError *)errPtr;
    715.              连接到一个给定的地址，制定一个sockaddr结构包裹住一个NSData对象,例如，NSData对象从NSNetService的地址方法返回,如果有一个现有的sockaddr结构，可以将它转换到一个NSData对象，像这样：
    716.  struct sockaddr sa  -> NSData *dsa = [NSData dataWithBytes:&remoteAddr length:remoteAddr.sa_len];
    717.  struct sockaddr *sa -> NSData *dsa = [NSData dataWithBytes:remoteAddr length:remoteAddr->sa_len];
    719.              -（void）disconnect;
    720.                 立即断开，任何未处理的读或写都将被丢弃
    721.                 如果socket还没有断开，在这个方法返回之前，onSocketDidDisconnect 委托方法将会被立即调用
    722.                  注意推荐释放AsyncSocket实例的方式：
    723.                    [asyncSocket setDelegate:nil];
    724.                    [asyncSocket disconnect];
    725.                    [asyncSocket release];
    727.               -（void）disconnectAfterReading;
    728.                  在已经完成了所有悬而未决的读取时 断开,在调用之后，读取和写入方法将无用,socket将断开 即使仍有待写入
    730.               - (NSString *)connectedHost;
    731.               - (UInt16)connectedPort;
    732.               - (NSString *)localHost;
    733.               - (UInt16)localPort;
    734.                 返回本地和远程主机和端口给连接的socket，如果没有连接会返回nil或0,主机将会是一个IP地址
    736.              -（NSData *）connectedAddress
    737.              -（NSData *）localAddresss
    738.                 返回本地和远程的地址给连接的socket，指定一个socketaddr结构包裹在一个NSData对象
    741.                 readData和writeData方法不会是block(它们是异步的)
    742.                当读完成 onSocket:didReadData:withTag: 委托方法时调用
    743.                当写完成 onSocket:didWriteDataWithTag: 委托方法时调用
    744.                可以选择任何读/写操作的超时设置(为了不超时，使用负时间间隔。）
    745.                如果读/写操作超时，相应的 onSocket:shouldTimeout...委托方法被调用去选择性地允许我们去延长超时
    746.                超时后，onSocket:willDisconnectWithError: 方法被调用,紧接着是 onSocketDidDisconnect
    747.                tag是为了方便，可以使用它作为数组的索引、步数、state id 、指针等 
    751.             -（void）readDataWithTimeout:(NSTimeInterval)tiemout tag:(long)tag;
    752.               读取socket上第一次成为可用的字节,如果timeout值是负数的，读操作将不使用timeout
    754.             - （void）readDataWithTimeout:(NSTimeInterval)timeout buffer:(NSMutableData *)buffer bufferOffset:(NSUInterger)offset tag:(long)tag;
    755.               读取socket上第一次成为可用的字节
    756.               字节将被追加到给定的字节缓冲区，从给定的偏移量开始
    757.               如果需要，给定的缓冲区大小将会自动增加
    758.               如果timeout值是负数的，读操作将不使用timeout
    759.               如果缓冲区为空，socket会为我们创建一个缓冲区
    760.               如果bufferOffset是大于给定的缓冲区的长度，该方法将无用，委托将不会被调用
    761.               如果你传递一个缓冲区，当AsyncSocket在使用它的时候你不能以任何方式改变它
    762.               完成之后，onSocket:didReadData:withTag 返回的数据将是一个给定的缓冲区的子集
    763.               也就是说，它将会被引用到被追加的给定的缓冲区的字节
    765.             -（void）readDataToLength:(NSUInterger)length withTimeout:(NSTimeInterval)timeout tag:(long)tag;
    766.             读取给定的字节数，如果length为0，方法将无用，委托将不会被调用
    768.             -（void）readDataToLength:(NSUInteger)length withTimeout:(NSTimeInterval)tiemout buffer:(NSMutableData *)buffer bufferOffset:(NSUInteger) offset tag:(long)tag;
    769.             读取给定的字节数,在给定的偏移开始，字节将被追加到给定的字节缓冲区
    771.             -（void）readDataToData:(NSData *)data withTimeout:(NSTimeInterval)timeout tag:(long)tag;
    772.             读取字节直到(包括)传入的作为分隔的"data"参数
    773.             如果传递0或者0长度的数据，"data"参数，该方法将无用，委托将不会被调用
    774.             从socket读取一行，使用"data"参数作为行的分隔符 (如HTTP的CRLF)
    775.             注意，此方法不是字符集，因此，如果一个分隔符出现，它自然可以作为进行编码的一部分，读取将提前结束
    777.             -（void）readDataToData:(NSData *)data withTimeout:(NSTimeInterval)timeout buffer:(NSMutableData *)buffer bufferOffset:(NSUInteger) offset tag:(long)tag;
    778.            读取字节直到(包括)传入的作为分隔的“data”参数，在给定的偏移量开始，字节将被追加到给定的字节缓冲区。
    779.            从socket读取一行，使用"data"参数作为行的分隔符(如HTTP的CRLF)
    781.            -（void）writeData:(NSData *)data withTimeout:(NSTimeInterval) timeout tag:(long)tag;
    782.           将data写入socket，当完成的时候委托被调用 
    784.            - (float)progressOfReadReturningTag:(long *)tag bytesDone:(NSUInteger *)done total:(NSUInteger *)total;
    785.            - (float)progressOfWriteReturningTag:(long *)tag bytesDone:(NSUInteger *)done total:(NSUInteger *)total;
    786.            返回当前读或写的进度，从0.0 到 1.0 或者 如果没有读/写的时候返回Nan(使用isNan来检查)
    787.    tag、done、total如果不为空的话，它们将会被填补
    789.            
    791.            - (void)startTLS:(NSDictionary *)tlsSettings;
    792.            确保使用ssl/tls连接
    793.            这方法可被随时调用，tls握手将会发生在所有悬而未决的读/写完成之后。这紧跟着一个发送依赖 StartTLS消息的协议选项，在排队升级到TLS的同一时间，而不必等待写入完成。在这个方法被调用后,任何读写计划 将会发生在安全链接
    794.            对于可能的keys和TLS设置的值是有据可查的
    795.            一些可能的keys是:
    796.               * - kCFStreamSSLLevel
    797.               * - kCFStreamSSLAllowsExpiredCertificates
    798.               * - kCFStreamSSLAllowsExpiredRoots
    799.               * - kCFStreamSSLAllowsAnyRoot
    800.               * - kCFStreamSSLValidatesCertificateChain
    801.               * - kCFStreamSSLPeerName
    802.               * - kCFStreamSSLCertificates
    803.               * - kCFStreamSSLIsServer
    805.            如果你传递空或者空字典，将使用默认的字典
    806.            默认设置将检查以确保由签署可信的第三方证书机构和没有过期的远程连接的证书
    807.            然而，它不会验证证书上的名字，除非你给它一个名字，通过kCFStreamSSLPeerName键去验证
    808.            这对安全的影响是重要的理解
    809.            想象一下你正试图创建一个到MySecureServer.com的安全连接，但因为一个被攻击的DNS服务器，所以你的socket被定向到MaliciousServer.com
    810.            如果你只是使用默认设置，MaliciousServer.com 有一个有效的证书
    811.            默认设置将无法监测到任何问题，因为证书是有效的
    812.           在这个特殊的情况下，要妥善保护你的连接，应设置kCFStreamSSLPeerName性质为MySecureServer.com.
    813.          如果事前你不知道对等的名字的远程主机(例如，你不确认它是domain.com" or "www.domain.com")，那么你可以使用默认设置来验证证书，然后在获得验证的发行后使用X509Certificate类来验证,X509Certificate类的CocoaAsyncSocket开源项目的一部分
    815.          -（void）enablePrebuffering
    816.          对于处理readDataToData请求，数据是必须从socket以小增量的方式读取出来的
    817.          性能通过允许AsyncSocket去一次性读大块的数据和存储任何一个小的内部缓冲区溢出的东西来大大提高
    818.          这被称为预缓冲，就好像一些数据在你要求它之前就可能被读取出来
    819.          如果你经常使用readDataToData，使用预缓冲会有更好的性能，尤其是在iphone上
    820.          默认的预缓冲状态是由DEFAULT_PREBUFFERING 定义控制的，强烈建议设置其为yes
    821.          这方法存在一些预缓冲需要一些不可预见的原因被默认禁用的情况，这时，这种方法存在允许当就绪时，可轻松启用预缓冲
    823.           -（BOOL）moveToRunLoop:(NSRunLoop *)runLoop;
    824.           当你创建一个AsyncSocket，它被添加到当前线程runloop
    825.           对于手动创建的socket，在线程上你打算使用它，它是最容易简单的创建的线程上的socket
    826.           当一个新的socket被接受，委托方法 onSocket:wantsRunLoopForNewSocket 会被调用 允许你在一个单独的线程上放置socket，这个工作最好结合在同一个线程池设计
    827.           如果，但是，在一个单独的线程上，在之后的时间，你需要移动一个socket，这个方法可以用来完成任务
    828.           此方法必须从 当前运行的 线程/runloop 的socket 调用
    829.           注意：此方法调用后，所有进一步的方法应该从给定的runloop上调用这个对象
    830.           此外，所有委托调用将会发送到给定的runloop
    833.           - (BOOL)setRunLoopModes:(NSArray *)runLoopModes;
    834.           - (BOOL)addRunLoopMode:(NSString *)runLoopMode;
    835.           - (BOOL)removeRunLoopMode:(NSString *)runLoopMode;
    836.            允许你配置 socket 使用的 运行循环模式
    837.            运行循环模式设置默认是NSRunLoopCommonModes
    838.            如果你想你的socket 在其他模式下继续操作，你可能需要添加模式 NSModalPanelRunLoopMode 或者 NSEventTrackingRunLoopMode ,或者你可能只想使用 NSRunLoopCommonModes
    839.            可接受的socket将自动 继承相同的运行循环模式就像侦听socket
    840.            注意：NSRunLoopCommonModes 定义在10.5，对于之前的版本可使用 kCFRunLoopCommonModes
    842.           -（NSArray *）runLoopModes
    843.             返回当前正在运行的循环模式的AsyncSocket实例， run loop modes的默认设置是NSDefaultRunLoopMode
    845.           -（NSData *）unreadData;
    846.          一个错误的事件，在 onSocket:willDisconnectWithError: 将会被调用 去读取留在socket上的任何数据
    848.           + (NSData *)CRLFData;   // 0x0D0A
    849.   
    850. 各方法的解析
    851.        -（void）onSocket：（AsyncSocket *）sock willDisconnectWithError：(NSError *)err;   
    852.        发生错误，socket关闭，可以在call-back过程调用"unreadData"去取得socket的最后的数据字节，当连接的时候，该委托方法在    onSocket:didAcceptNewSocket: 或者 onSocket:didConnectToHost： 之前调用
    854.       -（void）onSocketDidDisconnect:(ASyncSocket *)sock;
    855.       当socket由于或没有错误而断开连接，如果你想要在断开连接后release socket，在此方法工作，而在onSocket:willDisconnectWithError 释放则不安全
    857.        -（void）onSocket:(AsyncSocket *)sock didAcceptNewSocket:(AsyncSocket *)newSocket;
    858.         当产生一个socket去处理连接时调用，此方法会返回 线程上的run-loop 的新的socket和其应处理的委托，如果省略，则使用[NSRunLoop cunrrentRunLoop]
    860.           -（BOOL）onSocketWillConnect:(AsyncSocket *)sock;
    862.        -（void）onSocket:(AsyncSocket *)sock didConnectToHost :(NSString *)host port:(UINt16)port;
    863.           当socket连接正准备读和写的时候调用，host属性是一个IP地址，而不是一个DNS 名称
    865.          -（void）onSocket:(AsyncSocket *)sock didReadData:(NSData *)data withTag:(long) tag;
    866.          当socket已完成所要求的数据读入内存时调用，如果有错误则不调用
    868.          -（void）onSocket:(Asyncsocket *)sock didReadPartialDataOfLength:(NSUInteger)partiaLength tag:(long)tag;
    869.            当一个socket读取数据，但尚未完成读操作的时候调用，如果使用 readToData: or readToLength: 方法 会发生,可以被用来更新进度条等东西
    871.             -（void）onSocket:(AsyncSocket *)sock didWriteDataWithTag:(long)tag;
    872.              当一个socket已完成请求数据的写入时候调用
    874.             -（void）onSocket:(AsyncSocket *)sock didWritePartialDataOfLength:(NSUInteger)partialLength tag:(long)tag;
    875.              当一个socket写入一些数据，但还没有完成整个写入时调用，它可以用来更新进度条等东西
    877.                -（NSTimeInterval）onSocket:(AsyncSocket *)sock shouldTimeoutReadWithTag:(long)tag elapsed:(NSTimeInterval)exapsed bytesDone:(NSUInteger)length
    878.               使用读操作已超时但还没完成时调用，此方法允许随意延迟超时，如果返回一个正的时间间隔，读取的超时将有一定量的扩展，如果不实现这个方法，或会像往常一样返回一个负的时间间隔，elapsed参数是  原超时的总和，加上先前通过这种方法添加的任何补充， length参数是 读操作到目前为止已读取的字节数， 注意，如果返回正数的话，这个方法可能被一个单独的读取多次调用
    880.                -（NSTimeInterval）onSocket:(AsyncSocket *)sock shouldTimeoutWriteWithTag:(long)tag elapsed:(NSTimeInterval)elapsed bytesDone:(NSUInteger)length;
    881.                 如果一个写操作已达到其超时但还没完成时调用，同上
    883.                -（void）onSocketDidSecure:(AsyncSocket *)sock;
    884.                在socket成功完成ssl/tls协商时调用，此方法除非你使用提供startTLS方法时候才调用，
    885.     如果ssl/tls是无效的证书，socket将会立即关闭，onSocket:willDisconnectWithError:代理方法竟会与特定的ssl错误代码一起调用
    887.                -（BOOL）canSafelySetDelegate
    888.                用来查看在改变它之前，是否带有与当前的委托有悬而未决的业务(读/写)。当然，应在安全连接或接受委托之前改变委托
    890.               一旦接收或连接方法之一被调用，AsyncSocket实例会被锁定，其他接收/连接方法在没有先断开socket不会被调用
    891.               如果尝试失败或超时，这些方法要么返回NO 要么调用 onSocket:willDisconnectWithError: 或 onSockedDidDisconnect
    892.               当传入的连接被接受，AsyncSocket调用多个委托方法。这些方法按照时间顺序排列：
    893.                  1.onSocket:didAcceptNewSocket:
    894.                  2.onSocket:wantsRunLoopForNewSocket:
    895.                  3. onSocketWillConnect:
    896.                
    897.               你的服务器的代码将需要保留公认的socket(如果要接受它)，最好的地方是要做到这一点可能在onSocket:didAcceptNewSocket:方法    
    898.              在读和写流已经为新接受的socket设置，onSocket:didConnectToHost:port 方法将在适当的运行循环调用
    899.              多线程注意，如果要想通过实施onSocket：wantsRunLoopForNewSocket：，移动另一个新接受的socket去到另一个循环的socket。然后，应该在调用读和写或者startTLS方法前，等待直到onSocket:didConnectToHost:port:方法。否则读和写时间原定于不正确的runloop，混乱可能会随之而来
    902.              -（BOOL）acceptOnPort:(UInit16)port error:(NSError **)errPtr;
    903.              告诉socket开始听取和接受制定端口上的连接，当一个连接到来的时候，AsyncSocket实例将调用各种委托方法，socket将听取所有可用的接口(wifi,以太网等)
    905.              -（BOOL）connectToHost:(NSString *)hostname onPort:(UInt16)port error :(NSError **)errPtr;
    906.              连接给定的主机和端口，主机hostname可以是域名或者是Ip地址
    908.              -（BOOL）connectToAddress:(NSData *)remoteAddr error:(NSError *)errPtr;
    909.              连接到一个给定的地址，制定一个sockaddr结构包裹住一个NSData对象,例如，NSData对象从NSNetService的地址方法返回,如果有一个现有的sockaddr结构，可以将它转换到一个NSData对象，像这样：
    910.  struct sockaddr sa  -> NSData *dsa = [NSData dataWithBytes:&remoteAddr length:remoteAddr.sa_len];
    911.  struct sockaddr *sa -> NSData *dsa = [NSData dataWithBytes:remoteAddr length:remoteAddr->sa_len];
    913.              -（void）disconnect;
    914.                 立即断开，任何未处理的读或写都将被丢弃
    915.                 如果socket还没有断开，在这个方法返回之前，onSocketDidDisconnect 委托方法将会被立即调用
    916.                  注意推荐释放AsyncSocket实例的方式：
    917.                    [asyncSocket setDelegate:nil];
    918.                    [asyncSocket disconnect];
    919.                    [asyncSocket release];
    921.               -（void）disconnectAfterReading;
    922.                  在已经完成了所有悬而未决的读取时 断开,在调用之后，读取和写入方法将无用,socket将断开 即使仍有待写入
    924.               - (NSString *)connectedHost;
    925.               - (UInt16)connectedPort;
    926.               - (NSString *)localHost;
    927.               - (UInt16)localPort;
    928.                 返回本地和远程主机和端口给连接的socket，如果没有连接会返回nil或0,主机将会是一个IP地址
    930.              -（NSData *）connectedAddress
    931.              -（NSData *）localAddresss
    932.                 返回本地和远程的地址给连接的socket，指定一个socketaddr结构包裹在一个NSData对象
    935.                 readData和writeData方法不会是block(它们是异步的)
    936.                当读完成 onSocket:didReadData:withTag: 委托方法时调用
    937.                当写完成 onSocket:didWriteDataWithTag: 委托方法时调用
    938.                可以选择任何读/写操作的超时设置(为了不超时，使用负时间间隔。）
    939.                如果读/写操作超时，相应的 onSocket:shouldTimeout...委托方法被调用去选择性地允许我们去延长超时
    940.                超时后，onSocket:willDisconnectWithError: 方法被调用,紧接着是 onSocketDidDisconnect
    941.                tag是为了方便，可以使用它作为数组的索引、步数、state id 、指针等 
    945.             -（void）readDataWithTimeout:(NSTimeInterval)tiemout tag:(long)tag;
    946.               读取socket上第一次成为可用的字节,如果timeout值是负数的，读操作将不使用timeout
    948.             - （void）readDataWithTimeout:(NSTimeInterval)timeout buffer:(NSMutableData *)buffer bufferOffset:(NSUInterger)offset tag:(long)tag;
    949.               读取socket上第一次成为可用的字节
    950.               字节将被追加到给定的字节缓冲区，从给定的偏移量开始
    951.               如果需要，给定的缓冲区大小将会自动增加
    952.               如果timeout值是负数的，读操作将不使用timeout
    953.               如果缓冲区为空，socket会为我们创建一个缓冲区
    954.               如果bufferOffset是大于给定的缓冲区的长度，该方法将无用，委托将不会被调用
    955.               如果你传递一个缓冲区，当AsyncSocket在使用它的时候你不能以任何方式改变它
    956.               完成之后，onSocket:didReadData:withTag 返回的数据将是一个给定的缓冲区的子集
    957.               也就是说，它将会被引用到被追加的给定的缓冲区的字节
    959.             -（void）readDataToLength:(NSUInterger)length withTimeout:(NSTimeInterval)timeout tag:(long)tag;
    960.             读取给定的字节数，如果length为0，方法将无用，委托将不会被调用
    962.             -（void）readDataToLength:(NSUInteger)length withTimeout:(NSTimeInterval)tiemout buffer:(NSMutableData *)buffer bufferOffset:(NSUInteger) offset tag:(long)tag;
    963.             读取给定的字节数,在给定的偏移开始，字节将被追加到给定的字节缓冲区
    965.             -（void）readDataToData:(NSData *)data withTimeout:(NSTimeInterval)timeout tag:(long)tag;
    966.             读取字节直到(包括)传入的作为分隔的"data"参数
    967.             如果传递0或者0长度的数据，"data"参数，该方法将无用，委托将不会被调用
    968.             从socket读取一行，使用"data"参数作为行的分隔符 (如HTTP的CRLF)
    969.             注意，此方法不是字符集，因此，如果一个分隔符出现，它自然可以作为进行编码的一部分，读取将提前结束
    971.             -（void）readDataToData:(NSData *)data withTimeout:(NSTimeInterval)timeout buffer:(NSMutableData *)buffer bufferOffset:(NSUInteger) offset tag:(long)tag;
    972.            读取字节直到(包括)传入的作为分隔的“data”参数，在给定的偏移量开始，字节将被追加到给定的字节缓冲区。
    973.            从socket读取一行，使用"data"参数作为行的分隔符(如HTTP的CRLF)
    975.            -（void）writeData:(NSData *)data withTimeout:(NSTimeInterval) timeout tag:(long)tag;
    976.           将data写入socket，当完成的时候委托被调用 
    978.            - (float)progressOfReadReturningTag:(long *)tag bytesDone:(NSUInteger *)done total:(NSUInteger *)total;
    979.            - (float)progressOfWriteReturningTag:(long *)tag bytesDone:(NSUInteger *)done total:(NSUInteger *)total;
    980.            返回当前读或写的进度，从0.0 到 1.0 或者 如果没有读/写的时候返回Nan(使用isNan来检查)
    981.    tag、done、total如果不为空的话，它们将会被填补
    983.            
    985.            - (void)startTLS:(NSDictionary *)tlsSettings;
    986.            确保使用ssl/tls连接
    987.            这方法可被随时调用，tls握手将会发生在所有悬而未决的读/写完成之后。这紧跟着一个发送依赖 StartTLS消息的协议选项，在排队升级到TLS的同一时间，而不必等待写入完成。在这个方法被调用后,任何读写计划 将会发生在安全链接
    988.            对于可能的keys和TLS设置的值是有据可查的
    989.            一些可能的keys是:
    990.               * - kCFStreamSSLLevel
    991.               * - kCFStreamSSLAllowsExpiredCertificates
    992.               * - kCFStreamSSLAllowsExpiredRoots
    993.               * - kCFStreamSSLAllowsAnyRoot
    994.               * - kCFStreamSSLValidatesCertificateChain
    995.               * - kCFStreamSSLPeerName
    996.               * - kCFStreamSSLCertificates
    997.               * - kCFStreamSSLIsServer
    999.            如果你传递空或者空字典，将使用默认的字典
    1000.            默认设置将检查以确保由签署可信的第三方证书机构和没有过期的远程连接的证书
    1001.            然而，它不会验证证书上的名字，除非你给它一个名字，通过kCFStreamSSLPeerName键去验证
    1002.            这对安全的影响是重要的理解
    1003.            想象一下你正试图创建一个到MySecureServer.com的安全连接，但因为一个被攻击的DNS服务器，所以你的socket被定向到MaliciousServer.com
    1004.            如果你只是使用默认设置，MaliciousServer.com 有一个有效的证书
    1005.            默认设置将无法监测到任何问题，因为证书是有效的
    1006.           在这个特殊的情况下，要妥善保护你的连接，应设置kCFStreamSSLPeerName性质为MySecureServer.com.
    1007.          如果事前你不知道对等的名字的远程主机(例如，你不确认它是domain.com" or "www.domain.com")，那么你可以使用默认设置来验证证书，然后在获得验证的发行后使用X509Certificate类来验证,X509Certificate类的CocoaAsyncSocket开源项目的一部分
    1009.          -（void）enablePrebuffering
    1010.          对于处理readDataToData请求，数据是必须从socket以小增量的方式读取出来的
    1011.          性能通过允许AsyncSocket去一次性读大块的数据和存储任何一个小的内部缓冲区溢出的东西来大大提高
    1012.          这被称为预缓冲，就好像一些数据在你要求它之前就可能被读取出来
    1013.          如果你经常使用readDataToData，使用预缓冲会有更好的性能，尤其是在iphone上
    1014.          默认的预缓冲状态是由DEFAULT_PREBUFFERING 定义控制的，强烈建议设置其为yes
    1015.          这方法存在一些预缓冲需要一些不可预见的原因被默认禁用的情况，这时，这种方法存在允许当就绪时，可轻松启用预缓冲
    1017.           -（BOOL）moveToRunLoop:(NSRunLoop *)runLoop;
    1018.           当你创建一个AsyncSocket，它被添加到当前线程runloop
    1019.           对于手动创建的socket，在线程上你打算使用它，它是最容易简单的创建的线程上的socket
    1020.           当一个新的socket被接受，委托方法 onSocket:wantsRunLoopForNewSocket 会被调用 允许你在一个单独的线程上放置socket，这个工作最好结合在同一个线程池设计
    1021.           如果，但是，在一个单独的线程上，在之后的时间，你需要移动一个socket，这个方法可以用来完成任务
    1022.           此方法必须从 当前运行的 线程/runloop 的socket 调用
    1023.           注意：此方法调用后，所有进一步的方法应该从给定的runloop上调用这个对象
    1024.           此外，所有委托调用将会发送到给定的runloop
    1027.           - (BOOL)setRunLoopModes:(NSArray *)runLoopModes;
    1028.           - (BOOL)addRunLoopMode:(NSString *)runLoopMode;
    1029.           - (BOOL)removeRunLoopMode:(NSString *)runLoopMode;
    1030.            允许你配置 socket 使用的 运行循环模式
    1031.            运行循环模式设置默认是NSRunLoopCommonModes
    1032.            如果你想你的socket 在其他模式下继续操作，你可能需要添加模式 NSModalPanelRunLoopMode 或者 NSEventTrackingRunLoopMode ,或者你可能只想使用 NSRunLoopCommonModes
    1033.            可接受的socket将自动 继承相同的运行循环模式就像侦听socket
    1034.            注意：NSRunLoopCommonModes 定义在10.5，对于之前的版本可使用 kCFRunLoopCommonModes
    1036.           -（NSArray *）runLoopModes
    1037.             返回当前正在运行的循环模式的AsyncSocket实例， run loop modes的默认设置是NSDefaultRunLoopMode
    1039.           -（NSData *）unreadData;
    1040.          一个错误的事件，在 onSocket:willDisconnectWithError: 将会被调用 去读取留在socket上的任何数据
    1042.           + (NSData *)CRLFData;   // 0x0D0A
    1043.   
    1044. 各方法的解析
    1045.        -（void）onSocket：（AsyncSocket *）sock willDisconnectWithError：(NSError *)err;   
    1046.        发生错误，socket关闭，可以在call-back过程调用"unreadData"去取得socket的最后的数据字节，当连接的时候，该委托方法在    onSocket:didAcceptNewSocket: 或者 onSocket:didConnectToHost： 之前调用
    1047.        发生错误，socket关闭，可以在call-back过程调用"unreadData"去取得socket的最后的数据字节，当连接的时候，该委托方法在    onSocket:didAcceptNewSocket: 或者 onSocket:didConnectToHost： 之前调用
    1048.       -（void）onSocketDidDisconnect:(ASyncSocket *)sock;
    1049.       当socket由于或没有错误而断开连接，如果你想要在断开连接后release socket，在此方法工作，而在onSocket:willDisconnectWithError 释放则不安全
    1050.        -（void）onSocket:(AsyncSocket *)sock didAcceptNewSocket:(AsyncSocket *)newSocket;
    1051.         当产生一个socket去处理连接时调用，此方法会返回 线程上的run-loop 的新的socket和其应处理的委托，如果省略，则使用[NSRunLoop cunrrentRunLoop]
    1052.         当产生一个socket去处理连接时调用，此方法会返回 线程上的run-loop 的新的socket和其应处理的委托，如果省略，则使用[NSRunLoop cunrrentRunLoop]
    1053.           -（BOOL）onSocketWillConnect:(AsyncSocket *)sock;
    1054.        -（void）onSocket:(AsyncSocket *)sock didConnectToHost :(NSString *)host port:(UINt16)port;
    1055.           当socket连接正准备读和写的时候调用，host属性是一个IP地址，而不是一个DNS 名称
    1056.          -（void）onSocket:(AsyncSocket *)sock didReadData:(NSData *)data withTag:(long) tag;
    1057.          当socket已完成所要求的数据读入内存时调用，如果有错误则不调用
    1058.          -（void）onSocket:(Asyncsocket *)sock didReadPartialDataOfLength:(NSUInteger)partiaLength tag:(long)tag;
    1059.            当一个socket读取数据，但尚未完成读操作的时候调用，如果使用 readToData: or readToLength: 方法 会发生,可以被用来更新进度条等东西
    1060.             -（void）onSocket:(AsyncSocket *)sock didWriteDataWithTag:(long)tag;
    1061.              当一个socket已完成请求数据的写入时候调用
    1062.             -（void）onSocket:(AsyncSocket *)sock didWritePartialDataOfLength:(NSUInteger)partialLength tag:(long)tag;
    1063.              当一个socket写入一些数据，但还没有完成整个写入时调用，它可以用来更新进度条等东西
    1064.                -（NSTimeInterval）onSocket:(AsyncSocket *)sock shouldTimeoutReadWithTag:(long)tag elapsed:(NSTimeInterval)exapsed bytesDone:(NSUInteger)length
    1065.               使用读操作已超时但还没完成时调用，此方法允许随意延迟超时，如果返回一个正的时间间隔，读取的超时将有一定量的扩展，如果不实现这个方法，或会像往常一样返回一个负的时间间隔，elapsed参数是  原超时的总和，加上先前通过这种方法添加的任何补充， length参数是 读操作到目前为止已读取的字节数， 注意，如果返回正数的话，这个方法可能被一个单独的读取多次调用
    1066.                -（NSTimeInterval）onSocket:(AsyncSocket *)sock shouldTimeoutWriteWithTag:(long)tag elapsed:(NSTimeInterval)elapsed bytesDone:(NSUInteger)length;
    1067.                 如果一个写操作已达到其超时但还没完成时调用，同上
    1068.                -（void）onSocketDidSecure:(AsyncSocket *)sock;
    1069.                在socket成功完成ssl/tls协商时调用，此方法除非你使用提供startTLS方法时候才调用，
    1070.     如果ssl/tls是无效的证书，socket将会立即关闭，onSocket:willDisconnectWithError:代理方法竟会与特定的ssl错误代码一起调用
    1071.                -（BOOL）canSafelySetDelegate
    1072.                用来查看在改变它之前，是否带有与当前的委托有悬而未决的业务(读/写)。当然，应在安全连接或接受委托之前改变委托
    1073.               一旦接收或连接方法之一被调用，AsyncSocket实例会被锁定，其他接收/连接方法在没有先断开socket不会被调用
    1074.               如果尝试失败或超时，这些方法要么返回NO 要么调用 onSocket:willDisconnectWithError: 或 onSockedDidDisconnect
    1075.               当传入的连接被接受，AsyncSocket调用多个委托方法。这些方法按照时间顺序排列：
    1076.                  1.onSocket:didAcceptNewSocket:
    1077.                  2.onSocket:wantsRunLoopForNewSocket:
    1078.                  3. onSocketWillConnect:
    1079.                
    1080.               你的服务器的代码将需要保留公认的socket(如果要接受它)，最好的地方是要做到这一点可能在onSocket:didAcceptNewSocket:方法    
    1081.              在读和写流已经为新接受的socket设置，onSocket:didConnectToHost:port 方法将在适当的运行循环调用
    1082.              多线程注意，如果要想通过实施onSocket：wantsRunLoopForNewSocket：，移动另一个新接受的socket去到另一个循环的socket。然后，应该在调用读和写或者startTLS方法前，等待直到onSocket:didConnectToHost:port:方法。否则读和写时间原定于不正确的runloop，混乱可能会随之而来
    1084.              -（BOOL）acceptOnPort:(UInit16)port error:(NSError **)errPtr;
    1085.              告诉socket开始听取和接受制定端口上的连接，当一个连接到来的时候，AsyncSocket实例将调用各种委托方法，socket将听取所有可用的接口(wifi,以太网等)
    1086.              -（BOOL）connectToHost:(NSString *)hostname onPort:(UInt16)port error :(NSError **)errPtr;
    1087.              连接给定的主机和端口，主机hostname可以是域名或者是Ip地址
    1088.              -（BOOL）connectToAddress:(NSData *)remoteAddr error:(NSError *)errPtr;
    1089.              连接到一个给定的地址，制定一个sockaddr结构包裹住一个NSData对象,例如，NSData对象从NSNetService的地址方法返回,如果有一个现有的sockaddr结构，可以将它转换到一个NSData对象，像这样：
    1090.  struct sockaddr sa  -> NSData *dsa = [NSData dataWithBytes:&remoteAddr length:remoteAddr.sa_len];
    1091.  struct sockaddr *sa -> NSData *dsa = [NSData dataWithBytes:remoteAddr length:remoteAddr->sa_len];
    1092.              -（void）disconnect;
    1093.                 立即断开，任何未处理的读或写都将被丢弃
    1094.                 如果socket还没有断开，在这个方法返回之前，onSocketDidDisconnect 委托方法将会被立即调用
    1095.                  注意推荐释放AsyncSocket实例的方式：
    1096.                    [asyncSocket setDelegate:nil];
    1097.                    [asyncSocket disconnect];
    1098.                    [asyncSocket release];
    1099.               -（void）disconnectAfterReading;
    1100.                  在已经完成了所有悬而未决的读取时 断开,在调用之后，读取和写入方法将无用,socket将断开 即使仍有待写入
    1101.               - (NSString *)connectedHost;
    1102.               - (UInt16)connectedPort;
    1103.               - (NSString *)localHost;
    1104.               - (UInt16)localPort;
    1105.                 返回本地和远程主机和端口给连接的socket，如果没有连接会返回nil或0,主机将会是一个IP地址
    1106.              -（NSData *）connectedAddress
    1107.              -（NSData *）localAddresss
    1108.                 返回本地和远程的地址给连接的socket，指定一个socketaddr结构包裹在一个NSData对象
    1110.                 readData和writeData方法不会是block(它们是异步的)
    1111.                当读完成 onSocket:didReadData:withTag: 委托方法时调用
    1112.                当写完成 onSocket:didWriteDataWithTag: 委托方法时调用
    1113.                可以选择任何读/写操作的超时设置(为了不超时，使用负时间间隔。）
    1114.                如果读/写操作超时，相应的 onSocket:shouldTimeout...委托方法被调用去选择性地允许我们去延长超时
    1115.                超时后，onSocket:willDisconnectWithError: 方法被调用,紧接着是 onSocketDidDisconnect
    1116.                tag是为了方便，可以使用它作为数组的索引、步数、state id 、指针等 
    1119.             -（void）readDataWithTimeout:(NSTimeInterval)tiemout tag:(long)tag;
    1120.               读取socket上第一次成为可用的字节,如果timeout值是负数的，读操作将不使用timeout
    1121.             - （void）readDataWithTimeout:(NSTimeInterval)timeout buffer:(NSMutableData *)buffer bufferOffset:(NSUInterger)offset tag:(long)tag;
    1122.               读取socket上第一次成为可用的字节
    1123.               字节将被追加到给定的字节缓冲区，从给定的偏移量开始
    1124.               如果需要，给定的缓冲区大小将会自动增加
    1125.               如果timeout值是负数的，读操作将不使用timeout
    1126.               如果缓冲区为空，socket会为我们创建一个缓冲区
    1127.               如果bufferOffset是大于给定的缓冲区的长度，该方法将无用，委托将不会被调用
    1128.               如果你传递一个缓冲区，当AsyncSocket在使用它的时候你不能以任何方式改变它
    1129.               完成之后，onSocket:didReadData:withTag 返回的数据将是一个给定的缓冲区的子集
    1130.               也就是说，它将会被引用到被追加的给定的缓冲区的字节
    1131.             -（void）readDataToLength:(NSUInterger)length withTimeout:(NSTimeInterval)timeout tag:(long)tag;
    1132.             读取给定的字节数，如果length为0，方法将无用，委托将不会被调用
    1133.             -（void）readDataToLength:(NSUInteger)length withTimeout:(NSTimeInterval)tiemout buffer:(NSMutableData *)buffer bufferOffset:(NSUInteger) offset tag:(long)tag;
    1134.             读取给定的字节数,在给定的偏移开始，字节将被追加到给定的字节缓冲区
    1135.             -（void）readDataToData:(NSData *)data withTimeout:(NSTimeInterval)timeout tag:(long)tag;
    1136.             读取字节直到(包括)传入的作为分隔的"data"参数
    1137.             如果传递0或者0长度的数据，"data"参数，该方法将无用，委托将不会被调用
    1138.             从socket读取一行，使用"data"参数作为行的分隔符 (如HTTP的CRLF)
    1139.             注意，此方法不是字符集，因此，如果一个分隔符出现，它自然可以作为进行编码的一部分，读取将提前结束
    1140.             -（void）readDataToData:(NSData *)data withTimeout:(NSTimeInterval)timeout buffer:(NSMutableData *)buffer bufferOffset:(NSUInteger) offset tag:(long)tag;
    1141.            读取字节直到(包括)传入的作为分隔的“data”参数，在给定的偏移量开始，字节将被追加到给定的字节缓冲区。
    1142.            从socket读取一行，使用"data"参数作为行的分隔符(如HTTP的CRLF)
    1143.            -（void）writeData:(NSData *)data withTimeout:(NSTimeInterval) timeout tag:(long)tag;
    1144.           将data写入socket，当完成的时候委托被调用 
    1145.            - (float)progressOfReadReturningTag:(long *)tag bytesDone:(NSUInteger *)done total:(NSUInteger *)total;
    1146.            - (float)progressOfWriteReturningTag:(long *)tag bytesDone:(NSUInteger *)done total:(NSUInteger *)total;
    1147.            返回当前读或写的进度，从0.0 到 1.0 或者 如果没有读/写的时候返回Nan(使用isNan来检查)
    1148.    tag、done、total如果不为空的话，它们将会被填补
    1149.            
    1150.            - (void)startTLS:(NSDictionary *)tlsSettings;
    1151.            确保使用ssl/tls连接
    1152.            这方法可被随时调用，tls握手将会发生在所有悬而未决的读/写完成之后。这紧跟着一个发送依赖 StartTLS消息的协议选项，在排队升级到TLS的同一时间，而不必等待写入完成。在这个方法被调用后,任何读写计划 将会发生在安全链接
    1153.            对于可能的keys和TLS设置的值是有据可查的
    1154.            一些可能的keys是:
    1155.               * - kCFStreamSSLLevel
    1156.               * - kCFStreamSSLAllowsExpiredCertificates
    1157.               * - kCFStreamSSLAllowsExpiredRoots
    1158.               * - kCFStreamSSLAllowsAnyRoot
    1159.               * - kCFStreamSSLValidatesCertificateChain
    1160.               * - kCFStreamSSLPeerName
    1161.               * - kCFStreamSSLCertificates
    1162.               * - kCFStreamSSLIsServer
    1163.            如果你传递空或者空字典，将使用默认的字典
    1164.            默认设置将检查以确保由签署可信的第三方证书机构和没有过期的远程连接的证书
    1165.            然而，它不会验证证书上的名字，除非你给它一个名字，通过kCFStreamSSLPeerName键去验证
    1166.            这对安全的影响是重要的理解
    1167.            想象一下你正试图创建一个到MySecureServer.com的安全连接，但因为一个被攻击的DNS服务器，所以你的socket被定向到MaliciousServer.com
    1168.            如果你只是使用默认设置，MaliciousServer.com 有一个有效的证书
    1169.            默认设置将无法监测到任何问题，因为证书是有效的
    1170.           在这个特殊的情况下，要妥善保护你的连接，应设置kCFStreamSSLPeerName性质为MySecureServer.com.
    1171.          如果事前你不知道对等的名字的远程主机(例如，你不确认它是domain.com" or "www.domain.com")，那么你可以使用默认设置来验证证书，然后在获得验证的发行后使用X509Certificate类来验证,X509Certificate类的CocoaAsyncSocket开源项目的一部分
    1172.          -（void）enablePrebuffering
    1173.          对于处理readDataToData请求，数据是必须从socket以小增量的方式读取出来的
    1174.          性能通过允许AsyncSocket去一次性读大块的数据和存储任何一个小的内部缓冲区溢出的东西来大大提高
    1175.          这被称为预缓冲，就好像一些数据在你要求它之前就可能被读取出来
    1176.          如果你经常使用readDataToData，使用预缓冲会有更好的性能，尤其是在iphone上
    1177.          默认的预缓冲状态是由DEFAULT_PREBUFFERING 定义控制的，强烈建议设置其为yes
    1178.          这方法存在一些预缓冲需要一些不可预见的原因被默认禁用的情况，这时，这种方法存在允许当就绪时，可轻松启用预缓冲
    1179.           -（BOOL）moveToRunLoop:(NSRunLoop *)runLoop;
    1180.           当你创建一个AsyncSocket，它被添加到当前线程runloop
    1181.           对于手动创建的socket，在线程上你打算使用它，它是最容易简单的创建的线程上的socket
    1182.           当一个新的socket被接受，委托方法 onSocket:wantsRunLoopForNewSocket 会被调用 允许你在一个单独的线程上放置socket，这个工作最好结合在同一个线程池设计
    1183.           如果，但是，在一个单独的线程上，在之后的时间，你需要移动一个socket，这个方法可以用来完成任务
    1184.           此方法必须从 当前运行的 线程/runloop 的socket 调用
    1185.           注意：此方法调用后，所有进一步的方法应该从给定的runloop上调用这个对象
    1186.           此外，所有委托调用将会发送到给定的runloop
    1188.           - (BOOL)setRunLoopModes:(NSArray *)runLoopModes;
    1189.           - (BOOL)addRunLoopMode:(NSString *)runLoopMode;
    1190.           - (BOOL)removeRunLoopMode:(NSString *)runLoopMode;
    1191.            允许你配置 socket 使用的 运行循环模式
    1192.            运行循环模式设置默认是NSRunLoopCommonModes
    1193.            如果你想你的socket 在其他模式下继续操作，你可能需要添加模式 NSModalPanelRunLoopMode 或者 NSEventTrackingRunLoopMode ,或者你可能只想使用 NSRunLoopCommonModes
    1194.            可接受的socket将自动 继承相同的运行循环模式就像侦听socket
    1195.            注意：NSRunLoopCommonModes 定义在10.5，对于之前的版本可使用 kCFRunLoopCommonModes
    1196.           -（NSArray *）runLoopModes
    1197.             返回当前正在运行的循环模式的AsyncSocket实例， run loop modes的默认设置是NSDefaultRunLoopMode
    1198.           -（NSData *）unreadData;
    1199.          一个错误的事件，在 onSocket:willDisconnectWithError: 将会被调用 去读取留在socket上的任何数据
    1200.           + (NSData *)CRLFData;   // 0x0D0A
     
  • 相关阅读:
    android AsyncTask
    android利用provider查询同一个数据库中没有对外暴露出来的表
    PowerProfile.java与power_profile.xml
    Java的动态绑定机制
    Activity Intent Flags及Task相关属性
    非阻塞socket调用connect, epoll和select检查连接情况示例
    Linux Epoll相关知识
    JAVA并发编程
    Activity生命周期（深入理解）
    Android线程间通信更新UI的方法（重点分析EventBus）
  • 原文地址：https://www.cnblogs.com/geek6/p/3905493.html
Copyright © 2011-2022 走看看