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
 
posted @ 2014-08-11 19:46  codeTao  阅读(799)  评论(0)  编辑  收藏  举报