框架设计之菜鸟漫漫江湖路系列 四：江湖学艺（上）

 

四：江湖学艺（上）

创业帮派项目遇难，引入技术总监人物，力挽狂澜；本人敬之并从其学得武艺

 

本节开始，语言就不复古了，转成大众话的记述文，不然怕是得拖十年才能写完。 

话说当年，我去游乐乐的时候加上我也才4个人，美工2名，加我和技术老大，还有BOSS，凑和5个。

 

就在我闭头苦B Coding 时，短短数日， 游乐乐人员招聘速度飞快；
转眼间各部门已不断成立，美工一部门，编辑一部门，策划一部门，技术一部门。

BOSS想法也日复一日不断演变中，项目已超出原有的规划，上线日期也不断往后推延。

最神秘的，当属原活动版块负责人神秘失踪后，才新招一人负责，第一天一起吃过中午饭，第二天发现人又失踪了。

由于技术老大和BOSS有朋友关系，说好帮手数月，大体项目差不多就会离开，所以BOSS引入技术总监人物，负责统管技术部。

同时原来的技术老大，则转到开发Ulolo后台管理系统。

技术总监来的第一件事，就是审核项目代码，并找出了项目里“经常黄页”的原因：DataReader关闭问题。

我曾经写过一篇关于DataReader，可以参考：DataReader不奇怪，该出手时就出手！，此文介绍了DataReader本质上的相关内涵信息。

关于DataReader问题，由于项目里多处是Ctrl+C，Ctrl+V，批量代码生成量产，已经散落在各个页面中。

所以技术总监的想法是重写SQLHelper里的SqlDataReader的返回：

通过重写DataReader， 将原来DataReader的数据，快速读取到一个新的容器MDataReader，然后关闭链接再返回。

所以整体项目代码基本不用改动，当年的秋天小白还是按原来的方式编码，继续CTRL+C+V。

 

这是当年的MDataReader的实现代码：

 

MDataReader 实现

using System;
using System.Collections;
using System.ComponentModel;
using System.Data;
namespace UloloDataFramework.Core.Data
{
     public  class MDataReader : System.Data.IDataReader, System.Collections.IEnumerable
    {
         public  static  implicit  operator MDataReader(System.Data.SqlClient.SqlDataReader _SourceDataReader)
        {
            MDataReader mrdr =  new MDataReader();
            mrdr.CreateSelf( ref _SourceDataReader);
            _SourceDataReader.Close();
            _SourceDataReader.Dispose();
             return mrdr;
        }

         // public static implicit operator MDataReader(System.Data.IDataReader _SourceDataReader)
         // {
         //     MDataReader mrdr = new MDataReader();
         //     mrdr.CreateSelf(ref (SqlDataReader)_SourceDataReader);
         //     _SourceDataReader.Close();
         //     _SourceDataReader.Dispose();
         //     return mrdr;
         // }


         private System.Collections.Specialized.OrderedDictionary[] _MeList;
         private  int _MeListI = - 1;
         private  int _BaseListI =  0;

         private  bool isRead =  false;
         private  int _RecordsAffected = - 1;
         private  int _FieldCount = - 1;

         public MDataReader()
        {
        }
         public MDataReader(System.Data.IDataReader _SourceDataReader)
        {
             // MDataReader mrdr = new MDataReader();
             this.CreateSelf( ref  _SourceDataReader);
            _SourceDataReader.Close();
            _SourceDataReader.Dispose();
             // return mrdr;
        }
         public MDataReader(System.Data.SqlClient.SqlDataReader _SourceDataReader)
        {
             // MDataReader mrdr = new MDataReader();
             this.CreateSelf( ref _SourceDataReader);
            _SourceDataReader.Close();
            _SourceDataReader.Dispose();
             // return mrdr;
        }
         public  void CreateSelf( ref System.Data.SqlClient.SqlDataReader _SourceDataReader)
        {
             do
            {
                 if (_SourceDataReader.HasRows)
                {
                    _MeListI++;
                    System.Array.Resize<System.Collections.Specialized.OrderedDictionary>( ref _MeList, _MeListI +  1);
                    _MeList[_MeListI] =  new System.Collections.Specialized.OrderedDictionary();

                    _FieldCount = _SourceDataReader.FieldCount;
                    _RecordsAffected = _SourceDataReader.RecordsAffected;
                     for ( int j =  0; _SourceDataReader.Read(); j++)
                    {
                        _MeList[_MeListI].Add(j.ToString(),  new ReaderDataItemClass());
                         for ( int i =  0; i < _SourceDataReader.FieldCount; i++)
                        {
                            ((ReaderDataItemClass)_MeList[_MeListI][j.ToString()]).Add(_SourceDataReader.GetName(i), _SourceDataReader[_SourceDataReader.GetName(i)]);
                        }
                    }
                }

            }  while (_SourceDataReader.NextResult());
        }
         public  void CreateSelf( ref System.Data.IDataReader _SourceDataReader)
        {
            System.Data.SqlClient.SqlDataReader srd = (System.Data.SqlClient.SqlDataReader)_SourceDataReader;
            CreateSelf( ref srd);
            srd.Close();
            srd.Dispose();
        }
         public  bool NextResult()
        {
            _BaseListI++;
             if (_BaseListI > _MeListI)
            {
                Dispose();
                 return  false;

            }
             else
            {
                _MeList[_BaseListI -  1].Clear();
                _MeList[_BaseListI -  1] =  null;
                isRead =  false;
                 return  true;
            }
        }

         public  bool Read()
        {
             try
            {
                 if (!isRead)
                {
                    isRead =  true;
                     return (_MeList[_BaseListI].Count ==  0) ?  false :  true;
                }


                ((ReaderDataItemClass)_MeList[_BaseListI][ 0]).Clear();
                _MeList[_BaseListI][ 0] =  null;
                _MeList[_BaseListI].RemoveAt( 0);
                 return (_MeList[_BaseListI].Count ==  0) ?  false :  true;
            }
             catch {  return  false; }
        }

         public  object  this[ int index]
        {
             get
            {
                 return ((ReaderDataItemClass)_MeList[_BaseListI][ 0])[index];
            }
        }

         public  object  this[ string key]
        {
             get
            {
                 return ((ReaderDataItemClass)_MeList[_BaseListI][ 0])[key];
            }
        }

         public  bool HasRows
        {
             get
            {
                 return (_MeList[_BaseListI].Count ==  0) ?  false :  true;
            }
        }



         public  void Dispose()
        {
            _MeList =  null;
        }

         public  void Close()
        {
            _MeList =  null;
        }

         #region IDataRecord 成员

         public  int FieldCount
        {
             get {  return _MeList ==  null ?  0 : ((ReaderDataItemClass)_MeList[_BaseListI][ 0]).Count; }
        }

         public  bool GetBoolean( int i)
        {
             return  bool.Parse(((ReaderDataItemClass)_MeList[_BaseListI][ 0])[i].ToString());
        }

         public  byte GetByte( int i)
        {
             return  byte.Parse(((ReaderDataItemClass)_MeList[_BaseListI][ 0])[i].ToString());
        }

         public  long GetBytes( int i,  long fieldOffset,  byte[] buffer,  int bufferoffset,  int length)
        {
             return  0;
        }

         public  char GetChar( int i)
        {
             return  char.Parse(((ReaderDataItemClass)_MeList[_BaseListI][ 0])[i].ToString());
        }

         public  long GetChars( int i,  long fieldoffset,  char[] buffer,  int bufferoffset,  int length)
        {
             return  0;
        }


         public  string GetDataTypeName( int i)
        {
             return (((ReaderDataItemClass)_MeList[_BaseListI][ 0])[i].GetType().Name);
        }

         public DateTime GetDateTime( int i)
        {
             return DateTime.Parse(((ReaderDataItemClass)_MeList[_BaseListI][ 0])[i].ToString());
        }

         public  decimal GetDecimal( int i)
        {
             return  decimal.Parse(((ReaderDataItemClass)_MeList[_BaseListI][ 0])[i].ToString());
        }

         public  double GetDouble( int i)
        {
             return  double.Parse(((ReaderDataItemClass)_MeList[_BaseListI][ 0])[i].ToString());
        }

         public Type GetFieldType( int i)
        {
             return (((ReaderDataItemClass)_MeList[_BaseListI][ 0])[i].GetType());
        }

         public  float GetFloat( int i)
        {
             return  float.Parse(((ReaderDataItemClass)_MeList[_BaseListI][ 0])[i].ToString());
        }

         public Guid GetGuid( int i)
        {
             return  new Guid((((ReaderDataItemClass)_MeList[_BaseListI][ 0])[i].ToString()));
        }

         public  short GetInt16( int i)
        {
             return  short.Parse(((ReaderDataItemClass)_MeList[_BaseListI][ 0])[i].ToString());
        }

         public  int GetInt32( int i)
        {
             return  int.Parse(((ReaderDataItemClass)_MeList[_BaseListI][ 0])[i].ToString());
        }

         public  long GetInt64( int i)
        {
             return  long.Parse(((ReaderDataItemClass)_MeList[_BaseListI][ 0])[i].ToString());
        }

         public  string GetName( int i)
        {
             return ((ReaderDataItemClass)_MeList[_BaseListI][ 0]).Keys[i].ToString();

        }

         public  int GetOrdinal( string name)
        {
            System.Collections.ArrayList tmpList = ((ReaderDataItemClass)_MeList[_BaseListI][ 0]).Keys;
             return tmpList.IndexOf(name);
        }

         public  string GetString( int i)
        {
             return ((ReaderDataItemClass)_MeList[_BaseListI][ 0])[i].ToString();
        }

         public  object GetValue( int i)
        {
             return ((ReaderDataItemClass)_MeList[_BaseListI][ 0])[i];
        }

         public  int GetValues( object[] values)
        {
             for ( int i =  0; i < values.Length; i++)
            {
                values[i] = ((ReaderDataItemClass)_MeList[_BaseListI][ 0])[i];
            }
             return values.Length;
        }

         public  bool IsDBNull( int i)
        {
             return (TypeCode)((ReaderDataItemClass)_MeList[_BaseListI][ 0])[i] == System.TypeCode.DBNull;
        }

         #endregion



         #region IDataReader 成员


         public  int Depth
        {
             get {  return  0; }
        }

         public DataTable GetSchemaTable()
        {
            DataTable dt =  new DataTable();
             object[] tmpObj =  null;
             for ( int i =  0; i < ((ReaderDataItemClass)_MeList[_BaseListI][ 0]).Count -  1; i++)
            {
                dt.Columns.Add( this.GetName(i));
            }

             while ( this.Read())
            {
                ((ReaderDataItemClass)_MeList[_BaseListI][ 0]).CopyTo(tmpObj,  0);
                dt.Rows.Add(tmpObj);
            }

             return dt;
        }

         public  bool IsClosed
        {
             get {  return  true; }
        }

         public  int RecordsAffected
        {
             get {  return _RecordsAffected; }
        }

         #endregion

         #region IDataRecord 成员


         public IDataReader GetData( int i)
        {
             throw  new Exception( " ERR ");
        }

         #endregion

         #region IEnumerable 成员

         public IEnumerator GetEnumerator()
        {
             return  new System.Data.Common.DbEnumerator( this);
        }

         #endregion
    }

     class ReaderDataItemClass : System.Collections.Specialized.OrderedDictionary, System.Collections.Specialized.IOrderedDictionary
    {
         private System.Collections.ArrayList _KeyList;
         public ReaderDataItemClass()
            :  base()
        {
            _KeyList =  new System.Collections.ArrayList();
        }



         public  new System.Collections.ArrayList Keys
        {
             get {  return _KeyList; }
        }



         public  new  void Add( object key,  object value)
        {
            _KeyList.Add(key);
             base.Add(key, value);
        }

         public  new  void Clear()
        {
            _KeyList.Clear();
             base.Clear();
        }


         public  void Remove( int index)
        {
            _KeyList.RemoveAt(index);

             base.RemoveAt(index);
        }

    }

 

当年我是小白，连SQLHelper看着都吃力，连存储过程的编写，也是扔给技术老大的，所以对技术总监的实力就很崇拜了。 

后来招了一个“副技术总监”，负责了原来的活动模块和新开发论坛模块，还有论坛的编辑器。

当我原有项目基本落定时，前后又完成了几个小项目，犹记得刚完成了“目地的指南”模块时，事情就发生了。

我稍有点闲空时，技术总监突然让我写一个缓存类：

我苦思N小时，基于对控件的熟悉程度，我知道页面有这东东可以设置缓存：

然而写成缓存类，那会小白的我，除了会写个实体类，写其它类，咪咪，一时找不着北，蛋疼了近小时。。。

稍会，技术总监和BOSS开完会后出来，问我写的怎样了，我摸了摸头，说了句无从下手。

然后他花了点时间把缓存类的大体写了下，然后让我看懂了再补充。

我看了看，看到一个List<string>，就看不懂了，问技术总监那个List<T>是什么东东。

总监只回答了两个字“泛型”，我没有再问，在网络搜索泛型，看了相关文章和介绍。

同时当年电脑里存档了这样一份CHM知识库文档，在我闲时，总会抽空看看：

 

 

经过多篇文章的学习之后，加上上下左右前中后的扫了多次代码，基本把缓存这块，除了不懂的，能懂的都懂了。

于是一转身，问总监需要加什么功能？

后来大体是要求“缓存优先级别，和界限设置，及按要求定时检测并清空缓存功能”。

基本上前后按总监要求，来回改了N十次，还特别写了个winform界面来测试缓存的稳定性。

2天左右。。一句差不多也算交差了。

 

那会的源码，好在我的硬盘里有存档，这里顺路提供大伙下载，见识下我当年的潜力：点击下载 

那段快速时间，是求知欲最强的时候，和技术总监的交流中，总会遇到一些不明白的词，像“网关”，“VPN”，"DNS“，”Hosts“，"Hook"。

聊的时候我不懂，只能呵呵，总监以为我知道，聊完后回电脑桌边第一件事就是查相关词，了解下是什么东东。

经过不断的搜索，看文章，那时候的智商，看完文章，还是有理解不了词，像”VPN“，”流“，”Hook“。

下篇预告：

四：江湖学艺（下）：缓存过后，技术总监让我写MDataTable，不明觉厉。