异步编程（2）

APM支持三种聚集的技巧：等待直到完成，轮询和方法回调，下面追一介绍这几种技巧：

1.等待直至完成

using System;
using System.IO;
using System.Threading;
public static class Program ...{
public static void Main() ...{
FileStream fs = new FileStream(@"C:Boot.ini", FileMode.Open,
FileAccess.Read, FileShare.Read, 1024,
FileOptions.Asynchronous);
Byte[] data = new Byte[100];

//异步读取文件，所有的BeginXXX方法都会返回IAsyncResult类型的变量
IAsyncResult ar = fs.BeginRead(data, 0, data.Length, null, null);

//执行一些其他操作

Int32 bytesRead = fs.EndRead(ar);
fs.Close();
Console.WriteLine("Number of bytes read={0}", bytesRead);
Console.WriteLine(BitConverter.ToString(data, 0, bytesRead));
}
}

//输出
5B-62-6F-6F-74-20-6C-6F-61-64-65-72-5D-0D-0A-74-69-6D-65-6F-
75-74-3D-33-30-0D-0A-64-65-66-61-75-6C-74-3D-6D-75-6C-74-69-
28-30-29-64-69-73-6B-28-30-29-72-64-69-73-6B-28-30-29-70-61-
72-74-69-74-69-6F-6E-28-31-29-5C-57-49-4E-44-4F-57-53-0D-0A-
5B-6F-70-65-72-61-74-69-6E-67-20-73-79-73-74-65-6D-73-5D-0D

 注意上面的调用，如果执行到ENDXXX，文件还没有读取完成，那么将会挂起调用线程，直至方法返回结果。下面看一下一个改进的版本，这个版本可以从多个文件，套接字，甚至串口中读取字节：

private static void ReadMultipieFiles(params String[] pathnames) ...{

AsyncStreamRead[] asrs = new AsyncStreamRead[pathnames.Length];

for (Int32 n = 0; n < pathnames.Length; n++) ...{
Stream stream = new FileStream(pathnames[n], FileMode.Open,FileAccess.Read, FileShare.Read, 1024,FileOptions.Asynchronous);
asrs[n] = new AsyncStreamRead(stream, 100);
}

for (Int32 n = 0; n < asrs.Length; n++) ...{
Byte[] bytesRead = asrs[n].EndRead() ;
Console.WriteLine("Number of bytes read={0}", bytesRead.Length);
Console.WriteLine(BitConverter.ToString(bytesRead));
}
}

private sealed class AsyncStreamRead ...{

private Stream m_stream;
private IAsyncResult m_ar;
private Byte[] m_data;

public AsyncStreamRead(Stream stream, Int32 numBytes) ...{
m_stream = stream;
m_data = new Byte[numBytes];
m_ar = stream.BeginRead(m_data, 0, numBytes, null, null);
}

public Byte[] EndRead() ...{
Int32 numBytesRead = m_stream.EndRead(m_ar);
m_stream.Close();
Array.Resize(ref m_data, numBytesRead);
return m_data;
}
}

上面的方法还有一个低效的地方就是在第二个循环，我们要按顺序调用ENDXXX方法，但是每个文件的大小不一样，那么他的读取完成时间就会不同，如果前面有一个非常大的文件，而后面的文件比较小，我们在等待大文件读取完毕的时候，他后面的文件已经读取完了，但是我们还要等待这个大文件读取完了才能显示后面的文件内容。

2.轮询

public static void PollingWithIsCompleted() ...{

FileStream fs = new FileStream(@"C:Boot.ini", FileMode.Open,FileAccess.Read, FileShare.Read, 1024,FileOptions.Asynchronous);
Byte[] data = new Byte[100];

IAsyncResult ar = fs.BeginRead(data, 0, data.Length, null, null);
while (!ar.IsCompleted) ...{
Console.WriteLine("Operation not completed; still waiting.");
Thread.Sleep(10);
}
Int32 bytesRead = fs.EndRead(ar);
fs.Close();
Console.WriteLine("Number of bytes read={0}", bytesRead);
Console.WriteLine(BitConverter.ToString(data, 0, bytesRead));
}

我们可以看出轮询比较容易实现，但是效率可不高，因为我们要在花费一个线程来询问那个异步请求是否完成了，这样就浪费了一个线程。建议不要使用轮询。

下面我们看一下IAsyncResult的内容，前面已经用到了一个IsCompleted方法，后面可能还会用到它：

public interface IAsyncResult ...{
Object AsyncState ...{ get; }
WaitHandle AsyncWaitHandle ...{ get; }
Boolean IsCompleted ...{ get; }
Boolean CompletedSynchronously ...{ get; }
}

下面看一下轮询的另一种写法，效果和上面的一样：

public static void PollingWithIsCompleted() ...{
FileStream fs = new FileStream(@"C:Boot.ini", FileMode.Open,FileAccess.Read, FileShare.Read, 1024,FileOptions.Asynchronous);
Byte[] data = new Byte[100];
IAsyncResult ar = fs.BeginRead(data, 0, data.Length, null, null);
while (!ar.AsyncWaitHandle.WaitOne(10, false)) ...{
Console.WriteLine("Operation not completed; still waiting.");
}
Int32 bytesRead = fs.EndRead(ar);
fs.Close();
Console.WriteLine("Number of bytes read={0}", bytesRead);
Console.WriteLine(BitConverter.ToString(data, 0, bytesRead));
}

3.方法回调，这个是这几种里面效率最高的

下面先看一个委托，因为所有的回调方法必须满足为这个委托的要求：

delegate void AsyncCallback(IAsyncResult ar);

using System;
using System.IO;
using System.Threading;
public static class Program ...{
private static Byte[] s_data = new Byte[100];
public static void Main() ...{

Console.WriteLine("Main thread ID={0}",
Thread.CurrentThread.ManagedThreadId);

FileStream fs = new FileStream(@"C:Boot.ini", FileMode.Open,FileAccess.Read, FileShare.Read, 1024,FileOptions.Asynchronous);
fs.BeginRead(s_data, 0, s_data.Length, ReadIsDone, fs);
Console.ReadLine() ;
}

private static void ReadIsDone(IAsyncResult ar) ...{
Console.WriteLine("ReadIsDone thread ID={0}",
Thread.CurrentThread.ManagedThreadId);
FileStream fs = (FileStream) ar.AsyncState;
Int32 bytesRead = fs.EndRead(ar);
fs.Close();
Console.WriteLine("Number of bytes read={0}", bytesRead);
Console.WriteLine(BitConverter.ToString(s_data, 0, bytesRead));
}
}

//输出
Main thread ID=1
ReadIsDone thread ID=4
Number of bytes read=100
5B-62-6F-6F-74-20-6C-6F-61-64-65-72-5D-0D-0A-74-69-6D-65-6F-
75-74-3D-33-30-0D-0A-64-65-66-61-75-6C-74-3D-6D-75-6C-74-69-
28-30-29-64-69-73-6B-28-30-29-72-64-69-73-6B-28-30-29-70-61-
72-74-69-74-69-6F-6E-28-31-29-5C-57-49-4E-44-4F-57-53-0D-0A-
5B-6F-70-65-72-61-74-69-6E-67-20-73-79-73-74-65-6D-73-5D-0D

下面看一下如何利用c#的匿名方法更简单的实现：

public static void Main() ...{
Console.WriteLine("Main thread ID={0}",
Thread.CurrentThread.ManagedThreadId);
FileStream fs = new FileStream(@"C:Boot.ini", FileMode.Open,FileAccess.Read, FileShare.Read, 1024,FileOptions.Asynchronous);
Byte[] data = new Byte[100];

fs.BeginRead(data, 0, data.Length,

delegate(IAsyncResult ar)
...{
Console.WriteLine("ReadIsDone thread ID={0}",
Thread.CurrentThread.ManagedThreadId);
Int32 bytesRead = fs.EndRead(ar);
fs.Close();
Console.WriteLine("Number of bytes read={0}", bytesRead);
Console.WriteLine(BitConverter.ToString(data, 0, bytesRead));
}, null);

Console.ReadLine();
}

下面看一下如何解决我们上面文件大小不同读取时间不一样的问题：

private static void ReadMultipleFiles(params String[] pathnames) ...{
for (Int32 n = 0; n < pathnames.Length; n++) ...{
Stream stream = new FileStream(pathnames[n], FileMode.Open,FileAccess.Read, FileShare.Read, 1024,FileOptions.Asynchronous);
new AsyncStreamRead(stream, 100,
delegate(Byte[] data)
...{
Console.WriteLine("Number of bytes read={0}", data.Length);
Console.WriteLine(BitConverter.ToString(data));
});
}

Console.WriteLine("Hit <Enter> to end this program...");
Console.ReadLine() ;
}
private delegate void StreamBytesRead(Byte[] streamData);
private sealed class AsyncStreamRead ...{
private Stream m_stream;
private Byte[] m_data;
StreamBytesRead m_callback;

public AsyncStreamRead(Stream stream, Int32 numBytes,StreamBytesRead callback) ...{
m_stream = stream;
m_data = new Byte[numBytes];
m_callback = callback;
stream.BeginRead(m_data, 0, numBytes, ReadIsDone, null);
}

private void ReadIsDone(IAsyncResult ar) ...{
Int32 numBytesRead = m_stream.EndRead(ar);
m_stream.Close();
Array.Resize(ref m_data, numBytesRead);
m_callback(m_data);
}
}