PetaPoco源代码学习--2.TableInfo、ColumnInfo类和Cache类

　　当把常用的特性填写到POCO实体类时，执行数据库操作时，需要根据实体类上的特性信息进行相应的操作，PetaPoco中的TableInfo和ColumnInfo类就是用来保存实体类上的特性信息。

TableInfo用来保存数据库表的信息，包括TableName，PrimaryKey，主键是否自增字段，使用Oracle数据库时的Sequence名称。

ColumnInfo用来保存数据库表的列信息，包括ColumnName，是否结果列（不用更新数据库），数据库列类型是否转换为UTC时间、更新模板和插入模板。

　　通过POCO实体类获取到其对应的数据库表和数据库列的信息，就可以使用这些信息对数据库表执行增删改查的操作。

TableInfo包括一个静态方法，参数为POCO实体类的Type对象，从该对象上获取自定义特性信息来初始化TableInfo实例。

     /// <summary>
     /// POCO实体类对应的数据库表信息
     /// </summary>
     public class TableInfo
     {
         /// <summary>
         ///  数据库表名
         /// </summary>
         public string TableName { get; set; }

         /// <summary>
         /// 数据库表主键
         /// </summary>
         public string PrimaryKey { get; set; }

         /// <summary>
         /// 主键是否自增
         /// </summary>
         public bool AutoIncrement { get; set; }

         /// <summary>
         /// Oracle数据自增主键对应的Sequence名称
         /// </summary>
         public string SequenceName { get; set; }

         /// <summary>
         /// 从POCO实体类的特性上初始化TableInfo实例
         /// </summary>
         public static TableInfo FromPoco(Type t)
         {
             TableInfo ti = new TableInfo();
             //从TableNameAttribute上获取数据表名称，若不存在则使用POCO实体类的名称
             var a = t.GetCustomAttributes(typeof(TableNameAttribute), true);
             ti.TableName = a.Length ==  ? t.Name : (a[] as TableNameAttribute).Value;

             //从PrimaryKeyAttribute上获取数据库表主键名称
             a = t.GetCustomAttributes(typeof(PrimaryKeyAttribute), true);
             ti.PrimaryKey = a.Length ==  ? null : (a[] as PrimaryKeyAttribute).Value;
             ti.SequenceName = a.Length ==  ? null : (a[] as PrimaryKeyAttribute).SequenceName;
             ti.AutoIncrement = a.Length ==  ? false : (a[] as PrimaryKeyAttribute).AutoIncrement;
             //若不存在PrimaryKeyAttribute，则查找实体类属性中名称为“id"或者实体类名称+“id"或者“_id"的类属性。
             if (string.IsNullOrEmpty(ti.PrimaryKey))
             {
                 var prop = t.GetProperties().FirstOrDefault(p =>
                 {
                     if (p.Name.Equals("id", StringComparison.OrdinalIgnoreCase))
                         return true;
                     if (p.Name.Equals(t.Name + "id", StringComparison.OrdinalIgnoreCase))
                         return true;
                     if (p.Name.Equals(t.Name + "_id", StringComparison.OrdinalIgnoreCase))
                         return true;
                     return false;
                 });
                 if (prop != null)
                 {
                     ti.PrimaryKey = prop.Name;
                     ti.AutoIncrement = prop.PropertyType.IsValueType;
                 }
             }
             return ti;
         }
     }

ColumnInfo包括一个静态方法，参数为POCO实体类的属性对象，从对象上获取自定义特性信息来初始化ColumnInfo实例

/// <summary>
    /// POCO实体类属性对应的数据库列信息
    /// </summary>
    public class ColumnInfo
    {
        /// <summary>
        /// 数据库列名称
        /// </summary>
        public string ColumnName { get; set; }

        /// <summary>
        /// 是否结果值列，是的话，插入和更新操作不使用该属性
        /// </summary>
        public bool ResultColumn { get; set; }

        /// <summary>
        /// 若对应的数据库类类型是DateTime，是否强制转换为UTC时间
        /// </summary>
        public bool ForceToUtc { get; set; }

        /// <summary>
        /// 插入模板（暂未理解使用）
        /// </summary>
        public string InsertTemplate { get; set; }

        /// <summary>
        /// 更新模板（暂未理解使用）
        /// </summary>
        public string UpdateTemplate { get; set; }

        /// <summary>
        /// 从POCO实体类属性的特性初始化ColumnInfo
        /// </summary>
        public static ColumnInfo FromProperty(PropertyInfo propertyInfo)
        {
            // 获取属性所属的类实例上是否包括明确表示列信息的标志
            var explicitColumns = propertyInfo.DeclaringType.GetCustomAttributes(typeof(ExplicitColumnsAttribute), true).Length > ;

            // Check for [Column]/[Ignore] Attributes
            var colAttrs = propertyInfo.GetCustomAttributes(typeof(ColumnAttribute), true);
            //属性明确指定列信息时，但是该属性没有列特性，返回null
            if (explicitColumns)
            {
                if (colAttrs.Length == )
                    return null;
            }
            else
            {
                //没有明确指定时，该属性没有映射到数据库列，返回null
                if (propertyInfo.GetCustomAttributes(typeof(IgnoreAttribute), true).Length != )
                    return null;
            }
            //类具有明确映射信息，则从列特性获取对应的数据信息或者没有明确信息时，则使用属性名称初始化。
            var ci = new ColumnInfo();
            // Read attribute
            if (colAttrs.Length > )
            {
                var colattr = (ColumnAttribute) colAttrs[];
                ci.InsertTemplate = colattr.InsertTemplate;
                ci.UpdateTemplate = colattr.UpdateTemplate;
                ci.ColumnName = colattr.Name == null ? propertyInfo.Name : colattr.Name;
                ci.ForceToUtc = colattr.ForceToUtc;
                if ((colattr as ResultColumnAttribute) != null)
                    ci.ResultColumn = true;
            }
            else
            {
                ci.ColumnName = propertyInfo.Name;
                ci.ForceToUtc = false;
                ci.ResultColumn = false;
            }
            return ci;
        }
    }
　　PetaPoco中定义了一个缓存类，内部使用ReaderWriterLockSlim读写锁来控制读取和写入（ReaderWriterLockSlim支持多线程读取和单线程写入），
其公共方法Get的参数为缓存Key和创建函数，当缓存中没有对应的信息时，则使用创建函数创建信息并缓存起来。
方法内部先获取读取锁获取缓存信息，若没有则获取写入锁，获取后再次确认是否存在缓存信息，主要原因：获取写入锁需要释放之前所有的读写锁，防止在时间差创建了缓存信息。 

     /// <summary>
     /// 缓存信息类
     /// </summary>
     internal class Cache<TKey, TValue>
     {
         /// <summary>
         /// 读写锁
         /// </summary>
         private ReaderWriterLockSlim _lock = new ReaderWriterLockSlim();

         /// <summary>
         /// 存储数据的字典
         /// </summary>
         private Dictionary<TKey, TValue> _map = new Dictionary<TKey, TValue>();

         /// <summary>
         /// 缓存数据的数目
         /// </summary>
         public int Count
         {
             get { return _map.Count; }
         }

         /// <summary>
         /// 根据Key获取对应的数据，若没有数据，则创建它并缓存起来
         /// </summary>
         public TValue Get(TKey key, Func<TValue> factory)
         {
             _lock.EnterReadLock();//设置读锁
             TValue val;
             try
             {
                 if (_map.TryGetValue(key, out val))
                     return val;
             }
             finally
             {
                 _lock.ExitReadLock();//释放读锁
             }
             _lock.EnterWriteLock();//没有找到，设置写锁
             try
             {
                 //再次检测，避免等待获取写锁的时间差中已创建信息
                 if (_map.TryGetValue(key, out val))
                     return val;
                 //使用传入的创建方法创建信息并缓存起来
                 val = factory();
                 _map.Add(key, val);
                 return val;
             }
             finally
             {
                 _lock.ExitWriteLock();//释放写锁
             }
         }

         //清空缓存信息
         public void Flush()
         {
             _lock.EnterWriteLock();
             try
             {
                 _map.Clear();
             }
             finally
             {
                 _lock.ExitWriteLock();
             }
         }
     }