一个利用了异步处理，事件驱动,对象序列化等技术的类Parser完整代码示例

示例介绍：

类Parser是一个对Log文件进行分析的class.在对log文件进行分析的时候，会需要花费一定的时间。这样就必须使用异步的方法进行分析：即分析结束之后发送一个消息给调用程序，告诉调用程序分析过程结束,以便调用程序进行相应的处理。以下是完整的source code.

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;
using System.Windows.Forms;
using LogQuery = MSUtil.LogQueryClassClass;
using EventLogInputFormat = MSUtil.COMEventLogInputContextClassClass;
using IISLogInputFormat = MSUtil.COMIISW3CInputContextClassClass;
using LogRecordSet = MSUtil.ILogRecordset;
using System.Data;
using System.Runtime.Serialization;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using System.Threading;
using System.Runtime.Remoting.Messaging;

namespace winlogparser
{
    [Serializable]
    public class Parser
    {
       
        private string logArguments = "";
        public ArrayList selectField;
        private string intoField;
        private string fromField;
        private string whereField;

        public string conditonField1="";
        public string conditonField2="";
        public string conditonField3="";
        public string conditonField4="";

        public string conditonArg1 = "";
        public string conditonArg2 = "";
        public string conditonArg3 = "";
        public string conditonArg4 = "";

        public string conditonValue1 = "";
        public string conditonValue2 = "";
        public string conditonValue3 = "";
        public string conditonValue4 = "";

        public string conditonAndOr1 = "";
        public string conditonAndOr2 = "";
        public string conditonAndOr3 = "";

        private string groupByField;
        private int parseTimeTaken;
        public bool ScriptManually;
       private DataTable dt_Result;
       public DataTable dt_ListSource;

       public DataTable DataTable_Result
       {
           get
           {
               return dt_Result;
           }
           set
           {
               dt_Result = value;
           }
       }

       public int ParseTimeTaken
       {
           get
           {
               return parseTimeTaken;
           }
           set
           {
               parseTimeTaken = value;
           }
       }

         public Parser()
        {
            selectField = new ArrayList();
            intoField = "";
            fromField = "";
            whereField = "";
            groupByField = "";
            dt_Result = null;
            ScriptManually = false;
        }

        public string SelectField
        {
            get
            {
                if (selectField.Count == 0)
                    return null;
                else
                {
                   string tempStr="select ";
                   for (int i = 0; i < selectField.Count; i++)
                   {
                       tempStr += selectField[i];
                       if (i < selectField.Count - 1)
                           tempStr += ",";
                   }
                   return tempStr;
                }
            }
        }

        public string IntoField
        {
            get
            {
                if (intoField == "")
                    return null;
                else
                    return " into " + intoField;
            }

            set
            {
                intoField = value;
            }
        }

        public string FromField
        {
            get
            {
                if (fromField =="")
                    return null;
                else
                    return " from " + fromField;
            }
            set
            {
                fromField = value;
            }
        }

        public string WhereField
        {
            get
            {
                if (whereField == "")
                    return null;
                else
                    return " where " + whereField;
            }
            set
            {
                whereField = value;
            }
        }

        public string LogArguments
        {
            get
            {
                return logArguments;//SelectField + FromField +WhereField;
               
            }
            set
            {
                logArguments = value;
            }
        }

        public DataTable  CreateListSource(string fieldName)
        {
            if (fieldName == "")
                return null;

            DataColumn dc = new DataColumn(fieldName, typeof(string));
            DataTable dt = new DataTable();
            dt.Columns.Add(dc);

            string strSql = "select distinct " + fieldName + "  from " + fromField;
            LogQuery query = new LogQuery();
            IISLogInputFormat oIISInput = new IISLogInputFormat();
            LogRecordSet oRecordSet = query.Execute(strSql, oIISInput);
                       
            for (; !oRecordSet.atEnd(); oRecordSet.moveNext())
            {
                DataRow dr=dt.NewRow();
                dr[0]=oRecordSet.getRecord().getValue(0).ToString();              
                dt.Rows.Add(dr);
            }
            //dt_ListSource = dt;            
            return dt;
        }




        /// <summary>
        /// get listsource for combobox asychronousely
        /// </summary>

        public delegate DataTable CreateListDelegate(string fieldName);
        public void BeginToCreateListSource(string fieldName)
        {
            CreateListDelegate dc = new CreateListDelegate(this.CreateListSource);         
            AsyncCallback cb = new AsyncCallback(this.GetListOnCallback);
            IAsyncResult ar = dc.BeginInvoke(fieldName,cb, null);   
        }


        public delegate void GetListCompleted();
        public event GetListCompleted OnGetListCompletedHandler;
        public void GetListOnCallback(IAsyncResult ar)
        {
            CreateListDelegate pd = (CreateListDelegate)((AsyncResult)ar).AsyncDelegate;
            try
            {
               DataTable dt =pd.EndInvoke(ar);
                 this.dt_ListSource = dt;
                if (OnGetListCompletedHandler != null)
                    OnGetListCompletedHandler();               
             
            
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
               
            }
        }
        
        private DataTable CreateDataSource()
        {
            DataTable dt = new DataTable();
            for (int i = 0; i < selectField.Count; i++)
            {

                DataColumn dc = new DataColumn(selectField[i].ToString(), typeof(string));
                dt.Columns.Add(dc);
            }
            return dt;
        }

        //delegate for Parsing
        public delegate DataTable ParseDelegate();

        public DataTable Parse()
        {
            
            LogQuery query = new LogQuery();
            IISLogInputFormat oIISInput = new IISLogInputFormat();
            LogRecordSet oRecordSet = query.Execute(LogArguments, oIISInput);
            

            DataTable dt =CreateDataSource();
            for (; !oRecordSet.atEnd(); oRecordSet.moveNext())
            {
                DataRow dr=dt.NewRow();
                for(int index=0;index < selectField.Count;index++)
                {
                    dr[index]=oRecordSet.getRecord().getValue(index).ToString();
                }
                dt.Rows.Add(dr);
            }
            //dg.DataSource = dt;
           // dg.Show();
           return dt; //this.dt_Result;
        }

        //parse log file asynchronousely
        public void BeginToParse()
        {
           ParseDelegate dc = new ParseDelegate(this.Parse);

            AsyncCallback cb = new AsyncCallback(this.GetResultsOnCallback);
            IAsyncResult ar = dc.BeginInvoke(cb, null);         
        }


        /// <summary>
        /// asynchronize
        /// </summary>
        /// 

        public delegate void ParseCompleted();
        public event ParseCompleted OnparseCompletedHandler;
        public void GetResultsOnCallback(IAsyncResult ar)
        {
            ParseDelegate pd = (ParseDelegate)((AsyncResult)ar).AsyncDelegate;
            try
            {
                DataTable dt = null;
               dt=pd.EndInvoke(ar);
                this.dt_Result = dt;             
               MessageBox.Show("the log has parsed successfully!", "Windows LogPaser parsing Result", MessageBoxButtons.OK, MessageBoxIcon.Information);
              //send out a event;
                if (OnparseCompletedHandler != null)
                   OnparseCompletedHandler();
                
               //return dt;
                //Console.WriteLine("On CallBack :result is " + result);
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
               // return null;
            }
        }

    }

      


    public class SerializeParseSQL
    {
        private Parser parser;
        public string templateCreatedTime;

        public SerializeParseSQL()
        {
            
        }

        public SerializeParseSQL(Parser parserObj)
        {
            parser = parserObj;
        }

        public void SaveParseSQL(string filename)
        {
            FileStream fs = new FileStream(filename, FileMode.Create);
            BinaryFormatter binF = new BinaryFormatter();
            binF.Serialize(fs, parser);
            fs.Close();
        }

        public void ReadParseSQLTemplate(string filename, out Parser parser)
        {
            FileStream fs = new FileStream(filename, FileMode.Open,FileAccess.Read, FileShare.Read);
            BinaryFormatter binF = new BinaryFormatter();
            parser=(Parser)binF.Deserialize(fs);
        }
    }
}