关于异步文件IO

近来由于BOSS提出，网站的速度太慢，要求提高速度，考虑到要读取大量的XML配置文件与HTML静态文件，

因此，想到先从最基本的XML文件读取方面入手，同时，结合网站上提供的一些老外的视频文件，看了一些，

便做了一个异步读取的类，经过试运行后，效果的确有所提高，因此便记录下来，也备后用。当然还有一些可以

优化与改进的地方，没办法，慢慢来吧。

using System;
using System.Collections.Generic;
using System.Text;
using System.Data ;
using System.Data.SqlClient ;
using System.Threading ;
using System.ComponentModel ;
using System.Collections;
using System.Collections.Specialized;
using System.IO;
namespace AsyncIO
{
public class ReadLargeFileCompletedEventArgs : AsyncCompletedEventArgs
{
byte[] _buffer;
public byte[] Buffer
{
get { return _buffer; }
}
public ReadLargeFileCompletedEventArgs(byte[] buffer,Exception e,bool canncel,object state)
: base(e, canncel, state)
{
_buffer = buffer;
}
}
public class ReadLargeFileProgressEventArgs : ProgressChangedEventArgs
{
int _FileLen;
int _Reads;
byte[] buffer;
public ReadLargeFileProgressEventArgs(int iFileLength, int iHasRead, int Percentage, object state,byte[] _Buffer)
:
base(Percentage, state)
{
_FileLen = iFileLength;
_Reads = iHasRead;
buffer = _Buffer;

}
public int FileLength
{
get{ return _FileLen ;}
}
public int HasRead
{
get { return _Reads; }
}
public byte[] Buffer
{
get { return buffer; }
}
}
public delegate void ReadLargeFileCompletedEventHander(object sender, ReadLargeFileCompletedEventArgs e);
public delegate void ReadLargeFileProgressEventHandler(object sender ,ReadLargeFileProgressEventArgs e);

public class AsyncDataAccess
{
internal delegate void WorkerEventHander(string sFilePath, object userToken);

public event ReadLargeFileCompletedEventHander ReadCompleted;
public event ReadLargeFileProgressEventHandler ReadProgressChanged;

HybridDictionary taskToker = new HybridDictionary();

SendOrPostCallback _complated;
SendOrPostCallback _reportProgress;
SendOrPostCallback _completionMethod;
protected void OnReadCompleted(ReadLargeFileCompletedEventArgs args)
{
if (ReadCompleted != null)
ReadCompleted(this, args);
}
protected void OnReadProgressChanged(ReadLargeFileProgressEventArgs args)
{
if (ReadProgressChanged != null)
ReadProgressChanged(this, args);
}

public AsyncDataAccess()
{
_complated = new SendOrPostCallback(comleted);
_reportProgress = new SendOrPostCallback(report);
_completionMethod = new SendOrPostCallback(completionMethod);
}
void comleted(object state)
{
ReadLargeFileCompletedEventArgs args = state as ReadLargeFileCompletedEventArgs;
OnReadCompleted(args);

}
void report(object state)
{
ReadLargeFileProgressEventArgs args = state as ReadLargeFileProgressEventArgs;
OnReadProgressChanged(args);
}

void completionMethod(object state)
{

AsyncDataAccessState ad = (AsyncDataAccessState)state;
AsyncOperation asyncOp = ad.AsyncOp;

ReadLargeFileCompletedEventArgs a = new ReadLargeFileCompletedEventArgs(ad.FileContent, null, false, ad.TaskID);

lock (taskToker.SyncRoot )
{
taskToker.Remove(asyncOp.UserSuppliedState);
}
asyncOp.PostOperationCompleted(_complated, a);
}

public void ReadLargeFile(string sFilePath,int iTaskID)
{
WorkerEventHander weh = new WorkerEventHander(read);
AsyncOperation op = AsyncOperationManager.CreateOperation(iTaskID);
lock (taskToker.SyncRoot )
{
if (!taskToker.Contains(iTaskID))
{
taskToker.Add(iTaskID,op);

FileInfo fi = new FileInfo(sFilePath);
AsyncDataAccessState dast = new AsyncDataAccessState(op,iTaskID, (int)fi.Length, weh, new byte[(int)fi.Length]);
#region 采用回调方式的做法
weh.BeginInvoke(sFilePath,dast, new AsyncCallback(callback), dast);
#endregion
#region 不采用回调方式时的做法
//weh.BeginInvoke(sFilePath, dast, null, null);
#endregion
}
}

}
void callback(IAsyncResult ar)
{

AsyncDataAccessState state =(AsyncDataAccessState) ar.AsyncState;
WorkerEventHander weh = state.Worker;
weh.EndInvoke(ar);
ReadLargeFileCompletedEventArgs args = new ReadLargeFileCompletedEventArgs(state.FileContent, null, false, state.TaskID);
_complated(args);
}

public void CancelAsync(int taskId)
{
lock(taskToker.SyncRoot )
{
object obj = taskToker[taskId];
if (obj != null)
{
AsyncOperation asyncOp = obj as AsyncOperation;
ReadLargeFileCompletedEventArgs args = new ReadLargeFileCompletedEventArgs(
null, null, true, taskId);
_complated(args);
}
}
}

private void read(string sFilepath,object userToken)
{
AsyncDataAccessState st = (AsyncDataAccessState)userToken;
FileStream fs = new FileStream(sFilepath, FileMode.Open, FileAccess.Read, FileShare.Read,0x1000 , true);
byte[] buffer = new byte[0x1000];
int res = fs.Read(buffer, 0, 0x1000);
int cnt=0;
while ( res> 0)
{
cnt +=res ;
byte[] cf=new byte[res];
for (int i = 0; i < res; i++)
cf[i] = buffer[i];
//lock (st.FileContent.SyncRoot)
//{
cf.CopyTo(st.FileContent, 0);
//}
int pctn = (int)((float)cnt / (float)st.FileLen *100);

ReadLargeFileProgressEventArgs args = new ReadLargeFileProgressEventArgs(st.FileLen, cnt,pctn, st.TaskID,cf);
//Console.WriteLine("read" + cnt.ToString());
this._reportProgress(args);//-----------A
#region 异步发送ChangedEvent,不保证发送的顺序，与A点是互斥的
// st.AsyncOp.Post(this._reportProgress, args);
#endregion
res = fs.Read(buffer, 0, 0x1000);
}
fs.Close();
#region 不采用回调方式时的做法
//ReadLargeFileCompletedEventArgs args1 = new ReadLargeFileCompletedEventArgs(st.FileContent, null, false, st.TaskID);
//_completionMethod(st);
#endregion

}

internal class AsyncDataAccessState
{
public AsyncOperation AsyncOp;
public int TaskID;
public int FileLen;
public WorkerEventHander Worker;
public Byte[] FileContent;
public AsyncDataAccessState(AsyncOperation op, int iTaskID, int iFileLen,WorkerEventHander workerDelete,Byte[] _FileContent)
{
FileContent = _FileContent;
AsyncOp = op;
TaskID = iTaskID;
FileLen = iFileLen;
Worker = workerDelete;
}
}
}
}

----------------Program.cs--------------
using System;
using System.Collections.Generic;
using System.Text;
using System.Xml;
using System.Threading;
using System.IO;
namespace AsyncIO
{
class Program
{
static DateTime St = DateTime.Now;
static DateTime En;
static void Main(string[] args)
{
Console.WriteLine(St);
CPX();
Console.WriteLine(En);
TimeSpan sp = En - St;
Console.WriteLine(sp.Milliseconds);

}
static void CPX()
{
AsyncDataAccess da = new AsyncDataAccess();
da.ReadCompleted += new ReadLargeFileCompletedEventHander(da_ReadCompleted);
da.ReadProgressChanged += new ReadLargeFileProgressEventHandler(da_ReadProgressChanged);
da.ReadLargeFile("H://CC.txt", 10);
////u505A/u5176/u5B83/u7684/u4E8B/u60C5
Thread.Sleep(100);
}
}
}

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1632808