【IOS网络编程】socket编程

1. Phone的标准推荐是CFNetwork 库编程，其封装好的开源库是 cocoa AsyncSocket库，用它来简化CFNetwork的调用，它提供了异步操作
2.        主要特性有：       

1. 队列的非阻塞的读和写，而且可选超时。你可以调用它读取和写入，它会当完成后告知你
2. 自动的socket接收。如果你调用它接收连接，它将为每个连接启动新的实例，当然，也可以立即关闭这些连接
3. 委托（delegate）支持。错误、连接、接收、完整的读取、完整的写入、进度以及断开连接，都可以通过委托模式调用
4. 基于run loop的，而不是线程的。虽然可以在主线程或者工作线程中使用它，但你不需要这样做。它异步的调用委托方法，使用NSRunLoop。委托方法包括socket的参数，可让你在多个实例中区分
5. 自包含在一个类中。你无需操作流或者socket，这个类帮你做了全部
6. 支持基于IPV4和IPV6的TCP流

1. 
   
2. 
   
3.       加入：AsynSocket.h .m与AsynUdpSocket.h .m四个文件 及CFNetwork.framework
4.      TCP客户端 
5.            #import "AsyncSocket.h"
6. 
   
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];
44. 
    
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];
59. 
    
60.       6、TCP连接读取制定长度的数据
61.            socket连接，可能会读取固定长度的字节
62.            [socket readDataToLength: withTimeout :tag]
63. 
    
64. 
    
65. 
    
66. 
    
67. 
    
68. 各方法的解析
69.        -（void）onSocket：（AsyncSocket *）sock willDisconnectWithError：(NSError *)err;   
70.        发生错误，socket关闭，可以在call-back过程调用"unreadData"去取得socket的最后的数据字节，当连接的时候，该委托方法在    onSocket:didAcceptNewSocket: 或者 onSocket:didConnectToHost： 之前调用
71. 
    
72.       -（void）onSocketDidDisconnect:(ASyncSocket *)sock;
73.       当socket由于或没有错误而断开连接，如果你想要在断开连接后release socket，在此方法工作，而在onSocket:willDisconnectWithError 释放则不安全
74. 
    
75.        -（void）onSocket:(AsyncSocket *)sock didAcceptNewSocket:(AsyncSocket *)newSocket;
76.         当产生一个socket去处理连接时调用，此方法会返回 线程上的run-loop 的新的socket和其应处理的委托，如果省略，则使用[NSRunLoop cunrrentRunLoop]
77. 
    
78.           -（BOOL）onSocketWillConnect:(AsyncSocket *)sock;
79. 
    
80.        -（void）onSocket:(AsyncSocket *)sock didConnectToHost :(NSString *)host port:(UINt16)port;
81.           当socket连接正准备读和写的时候调用，host属性是一个IP地址，而不是一个DNS 名称
82. 
    
83.          -（void）onSocket:(AsyncSocket *)sock didReadData:(NSData *)data withTag:(long) tag;
84.          当socket已完成所要求的数据读入内存时调用，如果有错误则不调用
85. 
    
86.          -（void）onSocket:(Asyncsocket *)sock didReadPartialDataOfLength:(NSUInteger)partiaLength tag:(long)tag;
87.            当一个socket读取数据，但尚未完成读操作的时候调用，如果使用 readToData: or readToLength: 方法 会发生,可以被用来更新进度条等东西
88. 
    
89.             -（void）onSocket:(AsyncSocket *)sock didWriteDataWithTag:(long)tag;
90.              当一个socket已完成请求数据的写入时候调用
91. 
    
92.             -（void）onSocket:(AsyncSocket *)sock didWritePartialDataOfLength:(NSUInteger)partialLength tag:(long)tag;
93.              当一个socket写入一些数据，但还没有完成整个写入时调用，它可以用来更新进度条等东西
94. 
    
95.                -（NSTimeInterval）onSocket:(AsyncSocket *)sock shouldTimeoutReadWithTag:(long)tag elapsed:(NSTimeInterval)exapsed bytesDone:(NSUInteger)length
96.               使用读操作已超时但还没完成时调用，此方法允许随意延迟超时，如果返回一个正的时间间隔，读取的超时将有一定量的扩展，如果不实现这个方法，或会像往常一样返回一个负的时间间隔，elapsed参数是  原超时的总和，加上先前通过这种方法添加的任何补充， length参数是 读操作到目前为止已读取的字节数， 注意，如果返回正数的话，这个方法可能被一个单独的读取多次调用
97. 
    
98.                -（NSTimeInterval）onSocket:(AsyncSocket *)sock shouldTimeoutWriteWithTag:(long)tag elapsed:(NSTimeInterval)elapsed bytesDone:(NSUInteger)length;
99.                 如果一个写操作已达到其超时但还没完成时调用，同上
100. 
     
101.                -（void）onSocketDidSecure:(AsyncSocket *)sock;
102.                在socket成功完成ssl/tls协商时调用，此方法除非你使用提供startTLS方法时候才调用，
103.     如果ssl/tls是无效的证书，socket将会立即关闭，onSocket:willDisconnectWithError:代理方法竟会与特定的ssl错误代码一起调用
104. 
     
105.                -（BOOL）canSafelySetDelegate
106.                用来查看在改变它之前，是否带有与当前的委托有悬而未决的业务(读/写)。当然，应在安全连接或接受委托之前改变委托
107. 
     
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，混乱可能会随之而来
118. 
     
119. 
     
120.              -（BOOL）acceptOnPort:(UInit16)port error:(NSError **)errPtr;
121.              告诉socket开始听取和接受制定端口上的连接，当一个连接到来的时候，AsyncSocket实例将调用各种委托方法，socket将听取所有可用的接口(wifi,以太网等)
122. 
     
123.              -（BOOL）connectToHost:(NSString *)hostname onPort:(UInt16)port error :(NSError **)errPtr;
124.              连接给定的主机和端口，主机hostname可以是域名或者是Ip地址
125. 
     
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];
130. 
     
131.              -（void）disconnect;
132.                 立即断开，任何未处理的读或写都将被丢弃
133.                 如果socket还没有断开，在这个方法返回之前，onSocketDidDisconnect 委托方法将会被立即调用
134.                  注意推荐释放AsyncSocket实例的方式：
135.                    [asyncSocket setDelegate:nil];
136.                    [asyncSocket disconnect];
137.                    [asyncSocket release];
138. 
     
139.               -（void）disconnectAfterReading;
140.                  在已经完成了所有悬而未决的读取时 断开,在调用之后，读取和写入方法将无用,socket将断开 即使仍有待写入
141. 
     
142.               - (NSString *)connectedHost;
143.               - (UInt16)connectedPort;
144.               - (NSString *)localHost;
145.               - (UInt16)localPort;
146.                 返回本地和远程主机和端口给连接的socket，如果没有连接会返回nil或0,主机将会是一个IP地址
147. 
     
148.              -（NSData *）connectedAddress
149.              -（NSData *）localAddresss
150.                 返回本地和远程的地址给连接的socket，指定一个socketaddr结构包裹在一个NSData对象
151. 
     
152. 
     
153.                 readData和writeData方法不会是block(它们是异步的)
154.                当读完成 onSocket:didReadData:withTag: 委托方法时调用
155.                当写完成 onSocket:didWriteDataWithTag: 委托方法时调用
156.                可以选择任何读/写操作的超时设置(为了不超时，使用负时间间隔。）
157.                如果读/写操作超时，相应的 onSocket:shouldTimeout...委托方法被调用去选择性地允许我们去延长超时
158.                超时后，onSocket:willDisconnectWithError: 方法被调用,紧接着是 onSocketDidDisconnect
159.                tag是为了方便，可以使用它作为数组的索引、步数、state id 、指针等 
160. 
     
161. 
     
162. 
     
163.             -（void）readDataWithTimeout:(NSTimeInterval)tiemout tag:(long)tag;
164.               读取socket上第一次成为可用的字节,如果timeout值是负数的，读操作将不使用timeout
165. 
     
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.               也就是说，它将会被引用到被追加的给定的缓冲区的字节
176. 
     
177.             -（void）readDataToLength:(NSUInterger)length withTimeout:(NSTimeInterval)timeout tag:(long)tag;
178.             读取给定的字节数，如果length为0，方法将无用，委托将不会被调用
179. 
     
180.             -（void）readDataToLength:(NSUInteger)length withTimeout:(NSTimeInterval)tiemout buffer:(NSMutableData *)buffer bufferOffset:(NSUInteger) offset tag:(long)tag;
181.             读取给定的字节数,在给定的偏移开始，字节将被追加到给定的字节缓冲区
182. 
     
183.             -（void）readDataToData:(NSData *)data withTimeout:(NSTimeInterval)timeout tag:(long)tag;
184.             读取字节直到(包括)传入的作为分隔的"data"参数
185.             如果传递0或者0长度的数据，"data"参数，该方法将无用，委托将不会被调用
186.             从socket读取一行，使用"data"参数作为行的分隔符 (如HTTP的CRLF)
187.             注意，此方法不是字符集，因此，如果一个分隔符出现，它自然可以作为进行编码的一部分，读取将提前结束
188. 
     
189.             -（void）readDataToData:(NSData *)data withTimeout:(NSTimeInterval)timeout buffer:(NSMutableData *)buffer bufferOffset:(NSUInteger) offset tag:(long)tag;
190.            读取字节直到(包括)传入的作为分隔的“data”参数，在给定的偏移量开始，字节将被追加到给定的字节缓冲区。
191.            从socket读取一行，使用"data"参数作为行的分隔符(如HTTP的CRLF)
192. 
     
193.            -（void）writeData:(NSData *)data withTimeout:(NSTimeInterval) timeout tag:(long)tag;
194.           将data写入socket，当完成的时候委托被调用 
195. 
     
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如果不为空的话，它们将会被填补
200. 
     
201.            
202. 
     
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
216. 
     
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开源项目的一部分
226. 
     
227.          -（void）enablePrebuffering
228.          对于处理readDataToData请求，数据是必须从socket以小增量的方式读取出来的
229.          性能通过允许AsyncSocket去一次性读大块的数据和存储任何一个小的内部缓冲区溢出的东西来大大提高
230.          这被称为预缓冲，就好像一些数据在你要求它之前就可能被读取出来
231.          如果你经常使用readDataToData，使用预缓冲会有更好的性能，尤其是在iphone上
232.          默认的预缓冲状态是由DEFAULT_PREBUFFERING 定义控制的，强烈建议设置其为yes
233.          这方法存在一些预缓冲需要一些不可预见的原因被默认禁用的情况，这时，这种方法存在允许当就绪时，可轻松启用预缓冲
234. 
     
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
243. 
     
244. 
     
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
253. 
     
254.           -（NSArray *）runLoopModes
255.             返回当前正在运行的循环模式的AsyncSocket实例， run loop modes的默认设置是NSDefaultRunLoopMode
256. 
     
257.           -（NSData *）unreadData;
258.          一个错误的事件，在 onSocket:willDisconnectWithError: 将会被调用 去读取留在socket上的任何数据
259. 
     
260.           + (NSData *)CRLFData;   // 0x0D0A
261.   
262. 
     
263. 
     
264. 
     
265. 各方法的解析
266.        -（void）onSocket：（AsyncSocket *）sock willDisconnectWithError：(NSError *)err;   
267.        发生错误，socket关闭，可以在call-back过程调用"unreadData"去取得socket的最后的数据字节，当连接的时候，该委托方法在    onSocket:didAcceptNewSocket: 或者 onSocket:didConnectToHost： 之前调用
268. 
     
269.       -（void）onSocketDidDisconnect:(ASyncSocket *)sock;
270.       当socket由于或没有错误而断开连接，如果你想要在断开连接后release socket，在此方法工作，而在onSocket:willDisconnectWithError 释放则不安全
271. 
     
272.        -（void）onSocket:(AsyncSocket *)sock didAcceptNewSocket:(AsyncSocket *)newSocket;
273.         当产生一个socket去处理连接时调用，此方法会返回 线程上的run-loop 的新的socket和其应处理的委托，如果省略，则使用[NSRunLoop cunrrentRunLoop]
274. 
     
275.           -（BOOL）onSocketWillConnect:(AsyncSocket *)sock;
276. 
     
277.        -（void）onSocket:(AsyncSocket *)sock didConnectToHost :(NSString *)host port:(UINt16)port;
278.           当socket连接正准备读和写的时候调用，host属性是一个IP地址，而不是一个DNS 名称
279. 
     
280.          -（void）onSocket:(AsyncSocket *)sock didReadData:(NSData *)data withTag:(long) tag;
281.          当socket已完成所要求的数据读入内存时调用，如果有错误则不调用
282. 
     
283.          -（void）onSocket:(Asyncsocket *)sock didReadPartialDataOfLength:(NSUInteger)partiaLength tag:(long)tag;
284.            当一个socket读取数据，但尚未完成读操作的时候调用，如果使用 readToData: or readToLength: 方法 会发生,可以被用来更新进度条等东西
285. 
     
286.             -（void）onSocket:(AsyncSocket *)sock didWriteDataWithTag:(long)tag;
287.              当一个socket已完成请求数据的写入时候调用
288. 
     
289.             -（void）onSocket:(AsyncSocket *)sock didWritePartialDataOfLength:(NSUInteger)partialLength tag:(long)tag;
290.              当一个socket写入一些数据，但还没有完成整个写入时调用，它可以用来更新进度条等东西
291. 
     
292.                -（NSTimeInterval）onSocket:(AsyncSocket *)sock shouldTimeoutReadWithTag:(long)tag elapsed:(NSTimeInterval)exapsed bytesDone:(NSUInteger)length
293.               使用读操作已超时但还没完成时调用，此方法允许随意延迟超时，如果返回一个正的时间间隔，读取的超时将有一定量的扩展，如果不实现这个方法，或会像往常一样返回一个负的时间间隔，elapsed参数是  原超时的总和，加上先前通过这种方法添加的任何补充， length参数是 读操作到目前为止已读取的字节数， 注意，如果返回正数的话，这个方法可能被一个单独的读取多次调用
294. 
     
295.                -（NSTimeInterval）onSocket:(AsyncSocket *)sock shouldTimeoutWriteWithTag:(long)tag elapsed:(NSTimeInterval)elapsed bytesDone:(NSUInteger)length;
296.                 如果一个写操作已达到其超时但还没完成时调用，同上
297. 
     
298.                -（void）onSocketDidSecure:(AsyncSocket *)sock;
299.                在socket成功完成ssl/tls协商时调用，此方法除非你使用提供startTLS方法时候才调用，
300.     如果ssl/tls是无效的证书，socket将会立即关闭，onSocket:willDisconnectWithError:代理方法竟会与特定的ssl错误代码一起调用
301. 
     
302.                -（BOOL）canSafelySetDelegate
303.                用来查看在改变它之前，是否带有与当前的委托有悬而未决的业务(读/写)。当然，应在安全连接或接受委托之前改变委托
304. 
     
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，混乱可能会随之而来
315. 
     
316. 
     
317.              -（BOOL）acceptOnPort:(UInit16)port error:(NSError **)errPtr;
318.              告诉socket开始听取和接受制定端口上的连接，当一个连接到来的时候，AsyncSocket实例将调用各种委托方法，socket将听取所有可用的接口(wifi,以太网等)
319. 
     
320.              -（BOOL）connectToHost:(NSString *)hostname onPort:(UInt16)port error :(NSError **)errPtr;
321.              连接给定的主机和端口，主机hostname可以是域名或者是Ip地址
322. 
     
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];
327. 
     
328.              -（void）disconnect;
329.                 立即断开，任何未处理的读或写都将被丢弃
330.                 如果socket还没有断开，在这个方法返回之前，onSocketDidDisconnect 委托方法将会被立即调用
331.                  注意推荐释放AsyncSocket实例的方式：
332.                    [asyncSocket setDelegate:nil];
333.                    [asyncSocket disconnect];
334.                    [asyncSocket release];
335. 
     
336.               -（void）disconnectAfterReading;
337.                  在已经完成了所有悬而未决的读取时 断开,在调用之后，读取和写入方法将无用,socket将断开 即使仍有待写入
338. 
     
339.               - (NSString *)connectedHost;
340.               - (UInt16)connectedPort;
341.               - (NSString *)localHost;
342.               - (UInt16)localPort;
343.                 返回本地和远程主机和端口给连接的socket，如果没有连接会返回nil或0,主机将会是一个IP地址
344. 
     
345.              -（NSData *）connectedAddress
346.              -（NSData *）localAddresss
347.                 返回本地和远程的地址给连接的socket，指定一个socketaddr结构包裹在一个NSData对象
348. 
     
349. 
     
350.                 readData和writeData方法不会是block(它们是异步的)
351.                当读完成 onSocket:didReadData:withTag: 委托方法时调用
352.                当写完成 onSocket:didWriteDataWithTag: 委托方法时调用
353.                可以选择任何读/写操作的超时设置(为了不超时，使用负时间间隔。）
354.                如果读/写操作超时，相应的 onSocket:shouldTimeout...委托方法被调用去选择性地允许我们去延长超时
355.                超时后，onSocket:willDisconnectWithError: 方法被调用,紧接着是 onSocketDidDisconnect
356.                tag是为了方便，可以使用它作为数组的索引、步数、state id 、指针等 
357. 
     
358. 
     
359. 
     
360.             -（void）readDataWithTimeout:(NSTimeInterval)tiemout tag:(long)tag;
361.               读取socket上第一次成为可用的字节,如果timeout值是负数的，读操作将不使用timeout
362. 
     
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.               也就是说，它将会被引用到被追加的给定的缓冲区的字节
373. 
     
374.             -（void）readDataToLength:(NSUInterger)length withTimeout:(NSTimeInterval)timeout tag:(long)tag;
375.             读取给定的字节数，如果length为0，方法将无用，委托将不会被调用
376. 
     
377.             -（void）readDataToLength:(NSUInteger)length withTimeout:(NSTimeInterval)tiemout buffer:(NSMutableData *)buffer bufferOffset:(NSUInteger) offset tag:(long)tag;
378.             读取给定的字节数,在给定的偏移开始，字节将被追加到给定的字节缓冲区
379. 
     
380.             -（void）readDataToData:(NSData *)data withTimeout:(NSTimeInterval)timeout tag:(long)tag;
381.             读取字节直到(包括)传入的作为分隔的"data"参数
382.             如果传递0或者0长度的数据，"data"参数，该方法将无用，委托将不会被调用
383.             从socket读取一行，使用"data"参数作为行的分隔符 (如HTTP的CRLF)
384.             注意，此方法不是字符集，因此，如果一个分隔符出现，它自然可以作为进行编码的一部分，读取将提前结束
385. 
     
386.             -（void）readDataToData:(NSData *)data withTimeout:(NSTimeInterval)timeout buffer:(NSMutableData *)buffer bufferOffset:(NSUInteger) offset tag:(long)tag;
387.            读取字节直到(包括)传入的作为分隔的“data”参数，在给定的偏移量开始，字节将被追加到给定的字节缓冲区。
388.            从socket读取一行，使用"data"参数作为行的分隔符(如HTTP的CRLF)
389. 
     
390.            -（void）writeData:(NSData *)data withTimeout:(NSTimeInterval) timeout tag:(long)tag;
391.           将data写入socket，当完成的时候委托被调用 
392. 
     
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如果不为空的话，它们将会被填补
397. 
     
398.            
399. 
     
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
413. 
     
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开源项目的一部分
423. 
     
424.          -（void）enablePrebuffering
425.          对于处理readDataToData请求，数据是必须从socket以小增量的方式读取出来的
426.          性能通过允许AsyncSocket去一次性读大块的数据和存储任何一个小的内部缓冲区溢出的东西来大大提高
427.          这被称为预缓冲，就好像一些数据在你要求它之前就可能被读取出来
428.          如果你经常使用readDataToData，使用预缓冲会有更好的性能，尤其是在iphone上
429.          默认的预缓冲状态是由DEFAULT_PREBUFFERING 定义控制的，强烈建议设置其为yes
430.          这方法存在一些预缓冲需要一些不可预见的原因被默认禁用的情况，这时，这种方法存在允许当就绪时，可轻松启用预缓冲
431. 
     
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
440. 
     
441. 
     
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
450. 
     
451.           -（NSArray *）runLoopModes
452.             返回当前正在运行的循环模式的AsyncSocket实例， run loop modes的默认设置是NSDefaultRunLoopMode
453. 
     
454.           -（NSData *）unreadData;
455.          一个错误的事件，在 onSocket:willDisconnectWithError: 将会被调用 去读取留在socket上的任何数据
456. 
     
457.           + (NSData *)CRLFData;   // 0x0D0A
458.   
459. 
     
460. 
     
461. 各方法的解析
462.        -（void）onSocket：（AsyncSocket *）sock willDisconnectWithError：(NSError *)err;   
463.        发生错误，socket关闭，可以在call-back过程调用"unreadData"去取得socket的最后的数据字节，当连接的时候，该委托方法在    onSocket:didAcceptNewSocket: 或者 onSocket:didConnectToHost： 之前调用
464. 
     
465.       -（void）onSocketDidDisconnect:(ASyncSocket *)sock;
466.       当socket由于或没有错误而断开连接，如果你想要在断开连接后release socket，在此方法工作，而在onSocket:willDisconnectWithError 释放则不安全
467. 
     
468.        -（void）onSocket:(AsyncSocket *)sock didAcceptNewSocket:(AsyncSocket *)newSocket;
469.         当产生一个socket去处理连接时调用，此方法会返回 线程上的run-loop 的新的socket和其应处理的委托，如果省略，则使用[NSRunLoop cunrrentRunLoop]
470. 
     
471.           -（BOOL）onSocketWillConnect:(AsyncSocket *)sock;
472. 
     
473.        -（void）onSocket:(AsyncSocket *)sock didConnectToHost :(NSString *)host port:(UINt16)port;
474.           当socket连接正准备读和写的时候调用，host属性是一个IP地址，而不是一个DNS 名称
475. 
     
476.          -（void）onSocket:(AsyncSocket *)sock didReadData:(NSData *)data withTag:(long) tag;
477.          当socket已完成所要求的数据读入内存时调用，如果有错误则不调用
478. 
     
479.          -（void）onSocket:(Asyncsocket *)sock didReadPartialDataOfLength:(NSUInteger)partiaLength tag:(long)tag;
480.            当一个socket读取数据，但尚未完成读操作的时候调用，如果使用 readToData: or readToLength: 方法 会发生,可以被用来更新进度条等东西
481. 
     
482.             -（void）onSocket:(AsyncSocket *)sock didWriteDataWithTag:(long)tag;
483.              当一个socket已完成请求数据的写入时候调用
484. 
     
485.             -（void）onSocket:(AsyncSocket *)sock didWritePartialDataOfLength:(NSUInteger)partialLength tag:(long)tag;
486.              当一个socket写入一些数据，但还没有完成整个写入时调用，它可以用来更新进度条等东西
487. 
     
488.                -（NSTimeInterval）onSocket:(AsyncSocket *)sock shouldTimeoutReadWithTag:(long)tag elapsed:(NSTimeInterval)exapsed bytesDone:(NSUInteger)length
489.               使用读操作已超时但还没完成时调用，此方法允许随意延迟超时，如果返回一个正的时间间隔，读取的超时将有一定量的扩展，如果不实现这个方法，或会像往常一样返回一个负的时间间隔，elapsed参数是  原超时的总和，加上先前通过这种方法添加的任何补充， length参数是 读操作到目前为止已读取的字节数， 注意，如果返回正数的话，这个方法可能被一个单独的读取多次调用
490. 
     
491.                -（NSTimeInterval）onSocket:(AsyncSocket *)sock shouldTimeoutWriteWithTag:(long)tag elapsed:(NSTimeInterval)elapsed bytesDone:(NSUInteger)length;
492.                 如果一个写操作已达到其超时但还没完成时调用，同上
493. 
     
494.                -（void）onSocketDidSecure:(AsyncSocket *)sock;
495.                在socket成功完成ssl/tls协商时调用，此方法除非你使用提供startTLS方法时候才调用，
496.     如果ssl/tls是无效的证书，socket将会立即关闭，onSocket:willDisconnectWithError:代理方法竟会与特定的ssl错误代码一起调用
497. 
     
498.                -（BOOL）canSafelySetDelegate
499.                用来查看在改变它之前，是否带有与当前的委托有悬而未决的业务(读/写)。当然，应在安全连接或接受委托之前改变委托
500. 
     
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，混乱可能会随之而来
511. 
     
512. 
     
513.              -（BOOL）acceptOnPort:(UInit16)port error:(NSError **)errPtr;
514.              告诉socket开始听取和接受制定端口上的连接，当一个连接到来的时候，AsyncSocket实例将调用各种委托方法，socket将听取所有可用的接口(wifi,以太网等)
515. 
     
516.              -（BOOL）connectToHost:(NSString *)hostname onPort:(UInt16)port error :(NSError **)errPtr;
517.              连接给定的主机和端口，主机hostname可以是域名或者是Ip地址
518. 
     
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];
523. 
     
524.              -（void）disconnect;
525.                 立即断开，任何未处理的读或写都将被丢弃
526.                 如果socket还没有断开，在这个方法返回之前，onSocketDidDisconnect 委托方法将会被立即调用
527.                  注意推荐释放AsyncSocket实例的方式：
528.                    [asyncSocket setDelegate:nil];
529.                    [asyncSocket disconnect];
530.                    [asyncSocket release];
531. 
     
532.               -（void）disconnectAfterReading;
533.                  在已经完成了所有悬而未决的读取时 断开,在调用之后，读取和写入方法将无用,socket将断开 即使仍有待写入
534. 
     
535.               - (NSString *)connectedHost;
536.               - (UInt16)connectedPort;
537.               - (NSString *)localHost;
538.               - (UInt16)localPort;
539.                 返回本地和远程主机和端口给连接的socket，如果没有连接会返回nil或0,主机将会是一个IP地址
540. 
     
541.              -（NSData *）connectedAddress
542.              -（NSData *）localAddresss
543.                 返回本地和远程的地址给连接的socket，指定一个socketaddr结构包裹在一个NSData对象
544. 
     
545. 
     
546.                 readData和writeData方法不会是block(它们是异步的)
547.                当读完成 onSocket:didReadData:withTag: 委托方法时调用
548.                当写完成 onSocket:didWriteDataWithTag: 委托方法时调用
549.                可以选择任何读/写操作的超时设置(为了不超时，使用负时间间隔。）
550.                如果读/写操作超时，相应的 onSocket:shouldTimeout...委托方法被调用去选择性地允许我们去延长超时
551.                超时后，onSocket:willDisconnectWithError: 方法被调用,紧接着是 onSocketDidDisconnect
552.                tag是为了方便，可以使用它作为数组的索引、步数、state id 、指针等 
553. 
     
554. 
     
555. 
     
556.             -（void）readDataWithTimeout:(NSTimeInterval)tiemout tag:(long)tag;
557.               读取socket上第一次成为可用的字节,如果timeout值是负数的，读操作将不使用timeout
558. 
     
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.               也就是说，它将会被引用到被追加的给定的缓冲区的字节
569. 
     
570.             -（void）readDataToLength:(NSUInterger)length withTimeout:(NSTimeInterval)timeout tag:(long)tag;
571.             读取给定的字节数，如果length为0，方法将无用，委托将不会被调用
572. 
     
573.             -（void）readDataToLength:(NSUInteger)length withTimeout:(NSTimeInterval)tiemout buffer:(NSMutableData *)buffer bufferOffset:(NSUInteger) offset tag:(long)tag;
574.             读取给定的字节数,在给定的偏移开始，字节将被追加到给定的字节缓冲区
575. 
     
576.             -（void）readDataToData:(NSData *)data withTimeout:(NSTimeInterval)timeout tag:(long)tag;
577.             读取字节直到(包括)传入的作为分隔的"data"参数
578.             如果传递0或者0长度的数据，"data"参数，该方法将无用，委托将不会被调用
579.             从socket读取一行，使用"data"参数作为行的分隔符 (如HTTP的CRLF)
580.             注意，此方法不是字符集，因此，如果一个分隔符出现，它自然可以作为进行编码的一部分，读取将提前结束
581. 
     
582.             -（void）readDataToData:(NSData *)data withTimeout:(NSTimeInterval)timeout buffer:(NSMutableData *)buffer bufferOffset:(NSUInteger) offset tag:(long)tag;
583.            读取字节直到(包括)传入的作为分隔的“data”参数，在给定的偏移量开始，字节将被追加到给定的字节缓冲区。
584.            从socket读取一行，使用"data"参数作为行的分隔符(如HTTP的CRLF)
585. 
     
586.            -（void）writeData:(NSData *)data withTimeout:(NSTimeInterval) timeout tag:(long)tag;
587.           将data写入socket，当完成的时候委托被调用 
588. 
     
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如果不为空的话，它们将会被填补
593. 
     
594.            
595. 
     
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
609. 
     
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开源项目的一部分
619. 
     
620.          -（void）enablePrebuffering
621.          对于处理readDataToData请求，数据是必须从socket以小增量的方式读取出来的
622.          性能通过允许AsyncSocket去一次性读大块的数据和存储任何一个小的内部缓冲区溢出的东西来大大提高
623.          这被称为预缓冲，就好像一些数据在你要求它之前就可能被读取出来
624.          如果你经常使用readDataToData，使用预缓冲会有更好的性能，尤其是在iphone上
625.          默认的预缓冲状态是由DEFAULT_PREBUFFERING 定义控制的，强烈建议设置其为yes
626.          这方法存在一些预缓冲需要一些不可预见的原因被默认禁用的情况，这时，这种方法存在允许当就绪时，可轻松启用预缓冲
627. 
     
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
636. 
     
637. 
     
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
646. 
     
647.           -（NSArray *）runLoopModes
648.             返回当前正在运行的循环模式的AsyncSocket实例， run loop modes的默认设置是NSDefaultRunLoopMode
649. 
     
650.           -（NSData *）unreadData;
651.          一个错误的事件，在 onSocket:willDisconnectWithError: 将会被调用 去读取留在socket上的任何数据
652. 
     
653.           + (NSData *)CRLFData;   // 0x0D0A
654.   
655. 
     
656. 各方法的解析
657.        -（void）onSocket：（AsyncSocket *）sock willDisconnectWithError：(NSError *)err;   
658.        发生错误，socket关闭，可以在call-back过程调用"unreadData"去取得socket的最后的数据字节，当连接的时候，该委托方法在    onSocket:didAcceptNewSocket: 或者 onSocket:didConnectToHost： 之前调用
659. 
     
660.       -（void）onSocketDidDisconnect:(ASyncSocket *)sock;
661.       当socket由于或没有错误而断开连接，如果你想要在断开连接后release socket，在此方法工作，而在onSocket:willDisconnectWithError 释放则不安全
662. 
     
663.        -（void）onSocket:(AsyncSocket *)sock didAcceptNewSocket:(AsyncSocket *)newSocket;
664.         当产生一个socket去处理连接时调用，此方法会返回 线程上的run-loop 的新的socket和其应处理的委托，如果省略，则使用[NSRunLoop cunrrentRunLoop]
665. 
     
666.           -（BOOL）onSocketWillConnect:(AsyncSocket *)sock;
667. 
     
668.        -（void）onSocket:(AsyncSocket *)sock didConnectToHost :(NSString *)host port:(UINt16)port;
669.           当socket连接正准备读和写的时候调用，host属性是一个IP地址，而不是一个DNS 名称
670. 
     
671.          -（void）onSocket:(AsyncSocket *)sock didReadData:(NSData *)data withTag:(long) tag;
672.          当socket已完成所要求的数据读入内存时调用，如果有错误则不调用
673. 
     
674.          -（void）onSocket:(Asyncsocket *)sock didReadPartialDataOfLength:(NSUInteger)partiaLength tag:(long)tag;
675.            当一个socket读取数据，但尚未完成读操作的时候调用，如果使用 readToData: or readToLength: 方法 会发生,可以被用来更新进度条等东西
676. 
     
677.             -（void）onSocket:(AsyncSocket *)sock didWriteDataWithTag:(long)tag;
678.              当一个socket已完成请求数据的写入时候调用
679. 
     
680.             -（void）onSocket:(AsyncSocket *)sock didWritePartialDataOfLength:(NSUInteger)partialLength tag:(long)tag;
681.              当一个socket写入一些数据，但还没有完成整个写入时调用，它可以用来更新进度条等东西
682. 
     
683.                -（NSTimeInterval）onSocket:(AsyncSocket *)sock shouldTimeoutReadWithTag:(long)tag elapsed:(NSTimeInterval)exapsed bytesDone:(NSUInteger)length
684.               使用读操作已超时但还没完成时调用，此方法允许随意延迟超时，如果返回一个正的时间间隔，读取的超时将有一定量的扩展，如果不实现这个方法，或会像往常一样返回一个负的时间间隔，elapsed参数是  原超时的总和，加上先前通过这种方法添加的任何补充， length参数是 读操作到目前为止已读取的字节数， 注意，如果返回正数的话，这个方法可能被一个单独的读取多次调用
685. 
     
686.                -（NSTimeInterval）onSocket:(AsyncSocket *)sock shouldTimeoutWriteWithTag:(long)tag elapsed:(NSTimeInterval)elapsed bytesDone:(NSUInteger)length;
687.                 如果一个写操作已达到其超时但还没完成时调用，同上
688. 
     
689.                -（void）onSocketDidSecure:(AsyncSocket *)sock;
690.                在socket成功完成ssl/tls协商时调用，此方法除非你使用提供startTLS方法时候才调用，
691.     如果ssl/tls是无效的证书，socket将会立即关闭，onSocket:willDisconnectWithError:代理方法竟会与特定的ssl错误代码一起调用
692. 
     
693.                -（BOOL）canSafelySetDelegate
694.                用来查看在改变它之前，是否带有与当前的委托有悬而未决的业务(读/写)。当然，应在安全连接或接受委托之前改变委托
695. 
     
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，混乱可能会随之而来
706. 
     
707. 
     
708.              -（BOOL）acceptOnPort:(UInit16)port error:(NSError **)errPtr;
709.              告诉socket开始听取和接受制定端口上的连接，当一个连接到来的时候，AsyncSocket实例将调用各种委托方法，socket将听取所有可用的接口(wifi,以太网等)
710. 
     
711.              -（BOOL）connectToHost:(NSString *)hostname onPort:(UInt16)port error :(NSError **)errPtr;
712.              连接给定的主机和端口，主机hostname可以是域名或者是Ip地址
713. 
     
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];
718. 
     
719.              -（void）disconnect;
720.                 立即断开，任何未处理的读或写都将被丢弃
721.                 如果socket还没有断开，在这个方法返回之前，onSocketDidDisconnect 委托方法将会被立即调用
722.                  注意推荐释放AsyncSocket实例的方式：
723.                    [asyncSocket setDelegate:nil];
724.                    [asyncSocket disconnect];
725.                    [asyncSocket release];
726. 
     
727.               -（void）disconnectAfterReading;
728.                  在已经完成了所有悬而未决的读取时 断开,在调用之后，读取和写入方法将无用,socket将断开 即使仍有待写入
729. 
     
730.               - (NSString *)connectedHost;
731.               - (UInt16)connectedPort;
732.               - (NSString *)localHost;
733.               - (UInt16)localPort;
734.                 返回本地和远程主机和端口给连接的socket，如果没有连接会返回nil或0,主机将会是一个IP地址
735. 
     
736.              -（NSData *）connectedAddress
737.              -（NSData *）localAddresss
738.                 返回本地和远程的地址给连接的socket，指定一个socketaddr结构包裹在一个NSData对象
739. 
     
740. 
     
741.                 readData和writeData方法不会是block(它们是异步的)
742.                当读完成 onSocket:didReadData:withTag: 委托方法时调用
743.                当写完成 onSocket:didWriteDataWithTag: 委托方法时调用
744.                可以选择任何读/写操作的超时设置(为了不超时，使用负时间间隔。）
745.                如果读/写操作超时，相应的 onSocket:shouldTimeout...委托方法被调用去选择性地允许我们去延长超时
746.                超时后，onSocket:willDisconnectWithError: 方法被调用,紧接着是 onSocketDidDisconnect
747.                tag是为了方便，可以使用它作为数组的索引、步数、state id 、指针等 
748. 
     
749. 
     
750. 
     
751.             -（void）readDataWithTimeout:(NSTimeInterval)tiemout tag:(long)tag;
752.               读取socket上第一次成为可用的字节,如果timeout值是负数的，读操作将不使用timeout
753. 
     
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.               也就是说，它将会被引用到被追加的给定的缓冲区的字节
764. 
     
765.             -（void）readDataToLength:(NSUInterger)length withTimeout:(NSTimeInterval)timeout tag:(long)tag;
766.             读取给定的字节数，如果length为0，方法将无用，委托将不会被调用
767. 
     
768.             -（void）readDataToLength:(NSUInteger)length withTimeout:(NSTimeInterval)tiemout buffer:(NSMutableData *)buffer bufferOffset:(NSUInteger) offset tag:(long)tag;
769.             读取给定的字节数,在给定的偏移开始，字节将被追加到给定的字节缓冲区
770. 
     
771.             -（void）readDataToData:(NSData *)data withTimeout:(NSTimeInterval)timeout tag:(long)tag;
772.             读取字节直到(包括)传入的作为分隔的"data"参数
773.             如果传递0或者0长度的数据，"data"参数，该方法将无用，委托将不会被调用
774.             从socket读取一行，使用"data"参数作为行的分隔符 (如HTTP的CRLF)
775.             注意，此方法不是字符集，因此，如果一个分隔符出现，它自然可以作为进行编码的一部分，读取将提前结束
776. 
     
777.             -（void）readDataToData:(NSData *)data withTimeout:(NSTimeInterval)timeout buffer:(NSMutableData *)buffer bufferOffset:(NSUInteger) offset tag:(long)tag;
778.            读取字节直到(包括)传入的作为分隔的“data”参数，在给定的偏移量开始，字节将被追加到给定的字节缓冲区。
779.            从socket读取一行，使用"data"参数作为行的分隔符(如HTTP的CRLF)
780. 
     
781.            -（void）writeData:(NSData *)data withTimeout:(NSTimeInterval) timeout tag:(long)tag;
782.           将data写入socket，当完成的时候委托被调用 
783. 
     
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如果不为空的话，它们将会被填补
788. 
     
789.            
790. 
     
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
804. 
     
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开源项目的一部分
814. 
     
815.          -（void）enablePrebuffering
816.          对于处理readDataToData请求，数据是必须从socket以小增量的方式读取出来的
817.          性能通过允许AsyncSocket去一次性读大块的数据和存储任何一个小的内部缓冲区溢出的东西来大大提高
818.          这被称为预缓冲，就好像一些数据在你要求它之前就可能被读取出来
819.          如果你经常使用readDataToData，使用预缓冲会有更好的性能，尤其是在iphone上
820.          默认的预缓冲状态是由DEFAULT_PREBUFFERING 定义控制的，强烈建议设置其为yes
821.          这方法存在一些预缓冲需要一些不可预见的原因被默认禁用的情况，这时，这种方法存在允许当就绪时，可轻松启用预缓冲
822. 
     
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
831. 
     
832. 
     
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
841. 
     
842.           -（NSArray *）runLoopModes
843.             返回当前正在运行的循环模式的AsyncSocket实例， run loop modes的默认设置是NSDefaultRunLoopMode
844. 
     
845.           -（NSData *）unreadData;
846.          一个错误的事件，在 onSocket:willDisconnectWithError: 将会被调用 去读取留在socket上的任何数据
847. 
     
848.           + (NSData *)CRLFData;   // 0x0D0A
849.   
850. 各方法的解析
851.        -（void）onSocket：（AsyncSocket *）sock willDisconnectWithError：(NSError *)err;   
852.        发生错误，socket关闭，可以在call-back过程调用"unreadData"去取得socket的最后的数据字节，当连接的时候，该委托方法在    onSocket:didAcceptNewSocket: 或者 onSocket:didConnectToHost： 之前调用
853. 
     
854.       -（void）onSocketDidDisconnect:(ASyncSocket *)sock;
855.       当socket由于或没有错误而断开连接，如果你想要在断开连接后release socket，在此方法工作，而在onSocket:willDisconnectWithError 释放则不安全
856. 
     
857.        -（void）onSocket:(AsyncSocket *)sock didAcceptNewSocket:(AsyncSocket *)newSocket;
858.         当产生一个socket去处理连接时调用，此方法会返回 线程上的run-loop 的新的socket和其应处理的委托，如果省略，则使用[NSRunLoop cunrrentRunLoop]
859. 
     
860.           -（BOOL）onSocketWillConnect:(AsyncSocket *)sock;
861. 
     
862.        -（void）onSocket:(AsyncSocket *)sock didConnectToHost :(NSString *)host port:(UINt16)port;
863.           当socket连接正准备读和写的时候调用，host属性是一个IP地址，而不是一个DNS 名称
864. 
     
865.          -（void）onSocket:(AsyncSocket *)sock didReadData:(NSData *)data withTag:(long) tag;
866.          当socket已完成所要求的数据读入内存时调用，如果有错误则不调用
867. 
     
868.          -（void）onSocket:(Asyncsocket *)sock didReadPartialDataOfLength:(NSUInteger)partiaLength tag:(long)tag;
869.            当一个socket读取数据，但尚未完成读操作的时候调用，如果使用 readToData: or readToLength: 方法 会发生,可以被用来更新进度条等东西
870. 
     
871.             -（void）onSocket:(AsyncSocket *)sock didWriteDataWithTag:(long)tag;
872.              当一个socket已完成请求数据的写入时候调用
873. 
     
874.             -（void）onSocket:(AsyncSocket *)sock didWritePartialDataOfLength:(NSUInteger)partialLength tag:(long)tag;
875.              当一个socket写入一些数据，但还没有完成整个写入时调用，它可以用来更新进度条等东西
876. 
     
877.                -（NSTimeInterval）onSocket:(AsyncSocket *)sock shouldTimeoutReadWithTag:(long)tag elapsed:(NSTimeInterval)exapsed bytesDone:(NSUInteger)length
878.               使用读操作已超时但还没完成时调用，此方法允许随意延迟超时，如果返回一个正的时间间隔，读取的超时将有一定量的扩展，如果不实现这个方法，或会像往常一样返回一个负的时间间隔，elapsed参数是  原超时的总和，加上先前通过这种方法添加的任何补充， length参数是 读操作到目前为止已读取的字节数， 注意，如果返回正数的话，这个方法可能被一个单独的读取多次调用
879. 
     
880.                -（NSTimeInterval）onSocket:(AsyncSocket *)sock shouldTimeoutWriteWithTag:(long)tag elapsed:(NSTimeInterval)elapsed bytesDone:(NSUInteger)length;
881.                 如果一个写操作已达到其超时但还没完成时调用，同上
882. 
     
883.                -（void）onSocketDidSecure:(AsyncSocket *)sock;
884.                在socket成功完成ssl/tls协商时调用，此方法除非你使用提供startTLS方法时候才调用，
885.     如果ssl/tls是无效的证书，socket将会立即关闭，onSocket:willDisconnectWithError:代理方法竟会与特定的ssl错误代码一起调用
886. 
     
887.                -（BOOL）canSafelySetDelegate
888.                用来查看在改变它之前，是否带有与当前的委托有悬而未决的业务(读/写)。当然，应在安全连接或接受委托之前改变委托
889. 
     
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，混乱可能会随之而来
900. 
     
901. 
     
902.              -（BOOL）acceptOnPort:(UInit16)port error:(NSError **)errPtr;
903.              告诉socket开始听取和接受制定端口上的连接，当一个连接到来的时候，AsyncSocket实例将调用各种委托方法，socket将听取所有可用的接口(wifi,以太网等)
904. 
     
905.              -（BOOL）connectToHost:(NSString *)hostname onPort:(UInt16)port error :(NSError **)errPtr;
906.              连接给定的主机和端口，主机hostname可以是域名或者是Ip地址
907. 
     
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];
912. 
     
913.              -（void）disconnect;
914.                 立即断开，任何未处理的读或写都将被丢弃
915.                 如果socket还没有断开，在这个方法返回之前，onSocketDidDisconnect 委托方法将会被立即调用
916.                  注意推荐释放AsyncSocket实例的方式：
917.                    [asyncSocket setDelegate:nil];
918.                    [asyncSocket disconnect];
919.                    [asyncSocket release];
920. 
     
921.               -（void）disconnectAfterReading;
922.                  在已经完成了所有悬而未决的读取时 断开,在调用之后，读取和写入方法将无用,socket将断开 即使仍有待写入
923. 
     
924.               - (NSString *)connectedHost;
925.               - (UInt16)connectedPort;
926.               - (NSString *)localHost;
927.               - (UInt16)localPort;
928.                 返回本地和远程主机和端口给连接的socket，如果没有连接会返回nil或0,主机将会是一个IP地址
929. 
     
930.              -（NSData *）connectedAddress
931.              -（NSData *）localAddresss
932.                 返回本地和远程的地址给连接的socket，指定一个socketaddr结构包裹在一个NSData对象
933. 
     
934. 
     
935.                 readData和writeData方法不会是block(它们是异步的)
936.                当读完成 onSocket:didReadData:withTag: 委托方法时调用
937.                当写完成 onSocket:didWriteDataWithTag: 委托方法时调用
938.                可以选择任何读/写操作的超时设置(为了不超时，使用负时间间隔。）
939.                如果读/写操作超时，相应的 onSocket:shouldTimeout...委托方法被调用去选择性地允许我们去延长超时
940.                超时后，onSocket:willDisconnectWithError: 方法被调用,紧接着是 onSocketDidDisconnect
941.                tag是为了方便，可以使用它作为数组的索引、步数、state id 、指针等 
942. 
     
943. 
     
944. 
     
945.             -（void）readDataWithTimeout:(NSTimeInterval)tiemout tag:(long)tag;
946.               读取socket上第一次成为可用的字节,如果timeout值是负数的，读操作将不使用timeout
947. 
     
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.               也就是说，它将会被引用到被追加的给定的缓冲区的字节
958. 
     
959.             -（void）readDataToLength:(NSUInterger)length withTimeout:(NSTimeInterval)timeout tag:(long)tag;
960.             读取给定的字节数，如果length为0，方法将无用，委托将不会被调用
961. 
     
962.             -（void）readDataToLength:(NSUInteger)length withTimeout:(NSTimeInterval)tiemout buffer:(NSMutableData *)buffer bufferOffset:(NSUInteger) offset tag:(long)tag;
963.             读取给定的字节数,在给定的偏移开始，字节将被追加到给定的字节缓冲区
964. 
     
965.             -（void）readDataToData:(NSData *)data withTimeout:(NSTimeInterval)timeout tag:(long)tag;
966.             读取字节直到(包括)传入的作为分隔的"data"参数
967.             如果传递0或者0长度的数据，"data"参数，该方法将无用，委托将不会被调用
968.             从socket读取一行，使用"data"参数作为行的分隔符 (如HTTP的CRLF)
969.             注意，此方法不是字符集，因此，如果一个分隔符出现，它自然可以作为进行编码的一部分，读取将提前结束
970. 
     
971.             -（void）readDataToData:(NSData *)data withTimeout:(NSTimeInterval)timeout buffer:(NSMutableData *)buffer bufferOffset:(NSUInteger) offset tag:(long)tag;
972.            读取字节直到(包括)传入的作为分隔的“data”参数，在给定的偏移量开始，字节将被追加到给定的字节缓冲区。
973.            从socket读取一行，使用"data"参数作为行的分隔符(如HTTP的CRLF)
974. 
     
975.            -（void）writeData:(NSData *)data withTimeout:(NSTimeInterval) timeout tag:(long)tag;
976.           将data写入socket，当完成的时候委托被调用 
977. 
     
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如果不为空的话，它们将会被填补
982. 
     
983.            
984. 
     
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
998. 
     
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开源项目的一部分
1008. 
      
1009.          -（void）enablePrebuffering
1010.          对于处理readDataToData请求，数据是必须从socket以小增量的方式读取出来的
1011.          性能通过允许AsyncSocket去一次性读大块的数据和存储任何一个小的内部缓冲区溢出的东西来大大提高
1012.          这被称为预缓冲，就好像一些数据在你要求它之前就可能被读取出来
1013.          如果你经常使用readDataToData，使用预缓冲会有更好的性能，尤其是在iphone上
1014.          默认的预缓冲状态是由DEFAULT_PREBUFFERING 定义控制的，强烈建议设置其为yes
1015.          这方法存在一些预缓冲需要一些不可预见的原因被默认禁用的情况，这时，这种方法存在允许当就绪时，可轻松启用预缓冲
1016. 
      
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
1025. 
      
1026. 
      
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
1035. 
      
1036.           -（NSArray *）runLoopModes
1037.             返回当前正在运行的循环模式的AsyncSocket实例， run loop modes的默认设置是NSDefaultRunLoopMode
1038. 
      
1039.           -（NSData *）unreadData;
1040.          一个错误的事件，在 onSocket:willDisconnectWithError: 将会被调用 去读取留在socket上的任何数据
1041. 
      
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，混乱可能会随之而来
1083. 
      
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对象
1109. 
      
1110.                 readData和writeData方法不会是block(它们是异步的)
1111.                当读完成 onSocket:didReadData:withTag: 委托方法时调用
1112.                当写完成 onSocket:didWriteDataWithTag: 委托方法时调用
1113.                可以选择任何读/写操作的超时设置(为了不超时，使用负时间间隔。）
1114.                如果读/写操作超时，相应的 onSocket:shouldTimeout...委托方法被调用去选择性地允许我们去延长超时
1115.                超时后，onSocket:willDisconnectWithError: 方法被调用,紧接着是 onSocketDidDisconnect
1116.                tag是为了方便，可以使用它作为数组的索引、步数、state id 、指针等 
1117. 
      
1118. 
      
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
1187. 
      
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