using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using Microsoft.Practices.EnterpriseLibrary.Caching;
using Microsoft.Practices.EnterpriseLibrary.Caching.Expirations;
using Microsoft.Practices.EnterpriseLibrary.Common.Configuration;

using System.Reflection;

namespace DataAccess
{
    public static class CacheHelper
    {
        private static ICacheManager cache = CacheFactory.GetCacheManager();

/// <summary>
        /// Add Cache
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <param name="isRefresh">if true, should reload data every 5 mins; default value = false</param>
        public static void Add(string key, object value, bool isRefresh)
        {
            if (isRefresh)
                cache.Add(key, value, CacheItemPriority.Normal, new ATSCacheItemRefreshAction(), new AbsoluteTime(TimeSpan.FromMinutes(5)));
            else
                cache.Add(key, value);
        }
        // Summary:
        //     Adds new CacheItem to cache. If another item already exists with the same
        //     key, that item is removed before the new item is added. If any failure occurs
        //     during this process, the cache will not contain the item being added. Items
        //     added with this method will be not expire, and will have a Normal Microsoft.Practices.EnterpriseLibrary.Caching.CacheItemPriority
        //     priority.
        //
        // Parameters:
        //   key:
        //     Identifier for this CacheItem
        //
        //   value:
        //     Value to be stored in cache. May be null.
        //
        // Exceptions:
        //   System.ArgumentNullException:
        //     Provided key is null
        //
        //   System.ArgumentException:
        //     Provided key is an empty string
        //
        // Remarks:
        //     The CacheManager can be configured to use different storage mechanisms in
        //     which to store the CacheItems.  Each of these storage mechanisms can throw
        //     exceptions particular to their own implementations.
        public static void Add(string key, object value)
        {
            Add(key, value, false);
        }

public static object Get(string key)
        {
            return cache.GetData(key);
        }

public static void Remove(string key)
        {
            cache.Remove(key);
        }
    }

[Serializable]
    public class ATSCacheItemRefreshAction : ICacheItemRefreshAction
    {

#region ICacheItemRefreshAction Members

public void Refresh(string removedKey, object expiredValue, CacheItemRemovedReason removalReason)
        {
            //when expired, reload it.
            if (removalReason == CacheItemRemovedReason.Expired)
            {
                ICacheManager c = CacheFactory.GetCacheManager();
                c.Add(removedKey, expiredValue);
            }
        }

#endregion
    }

/// <summary>
        /// 通用对象反射(包含缓存)
        /// </summary>
        /// <param name="className">要反射的类名</param>
        /// <returns></returns>
        public static T CreateObject(string className)
        {
            var typeName = assemblyString + "." + className;
            //判断对象是否被缓存,如果已经缓存则直接从缓存中读取,反之则直接反射并缓存
            var obj = (T)CacheHelper.GetCache(typeName);
            if (obj == null)
            {
                obj = (T)Assembly.Load(assemblyString).CreateInstance(typeName, true);
                CacheHelper.Add(typeName, obj, true);
            }
            return obj;
        }
public static IStudentService CreateStudent()
        {
            string typeName = assemblyString + ".StudentService";
            if (CacheHelper.GetCache(typeName) != null)
            {
                return (IStudentService)CacheHelper.GetCache(typeName);
            }
            else
            {
                IStudentService service = (IStudentService)Assembly.Load(assemblyString).CreateInstance(typeName, true);
                CacheHelper.Add(typeName, service, true);
                return service;
            }

private static readonly IStudentService studentService = DataAccess<IStudentService>.CreateObject("StudentService");

public Student SelectById(int id)
        {
            return studentService.SelectById(id);

/// <summary>
        /// 根据学生ID查询学生对象
        /// </summary>
        /// <param name="id">学生ID</param>
        /// <returns></returns>
        public Student SelectById(int id)
        {
            Student student = null;
            Database db = DBHelper.CreateDataBase();
            StringBuilder sb = new StringBuilder();
            sb.Append("select * from Student ");
            sb.Append(" where ID=@ID");
            DbCommand cmd = db.GetSqlStringCommand(sb.ToString());
            db.AddInParameter(cmd, "@ID", DbType.Int32, id);
 
            using (IDataReader reader = db.ExecuteReader(cmd))
            {
                if (reader.Read())
                {
                    student = new Student()
                    {
                        Id = reader.GetInt32(0),
                        ClassId = reader.GetInt32(1),
                        Sid = reader.GetString(2),
                        Password = reader.GetString(3),
                        Name = reader.GetString(4),
                        Sex = reader.GetInt32(5),
                        Birthday = reader.GetDateTime(6),
                        IsAdmin = reader.GetInt32(7)
                    };
                }
            }
 
            return student;

public Student SelectByIdWithCache(int id)
        {
            Student student = (Student)CacheHelper.GetCache(id.ToString());
            if (student == null)
            {
                student = SelectById(id);
                CacheHelper.Add(id.ToString(), student);
            }
            return student;

public class TableParameters : IParameters<tblTable>
    {
        public Guid? tableGuid { get; set; }
        public string tableName { get; set; }
        public string tableDesc { get; set; }
        public Guid? tableTypeGuid { get; set; }
        public Guid? schemeGuid { get; set; }
        public Guid index1TypeGuid { get; set; }
        public Guid? latestTableVersionGuid { get; set; }
        public Guid? tableFormatGuid { get; set; }
        public Guid? index2TypeGuid { get; set; }

public List<tblTable> GetQueryList(IParameters<tblTable> t)
        {
            TableParameters param = (TableParameters)t;

List<tblTable> query = new List<tblTable>();
            if (param.tableGuid != null)
            {
                tblTable result = (tblTable)CacheHelper.Get(GuidTable + param.tableGuid.Value.ToString());
                if (result != null)
                {                  
                    query.Add(result);
                    return query;
                }
            }

var _tableQuery = from c in db.tblTable.Expand("TableType").Expand("TableFormat").Expand("Scheme").Expand("Index1Type").Expand("Index2Type").Expand("LatestTableVersionGUID")
                                               select c;
            if (param.tableGuid != null)
            {
                _tableQuery = _tableQuery.Where(n => n.TableGUID == param.tableGuid.Value);
            }
            if (!string.IsNullOrEmpty(param.tableName))
            {
                _tableQuery = _tableQuery.Where(n => n.TableName.Contains(param.tableName));
            }
            if (param.tableTypeGuid != null)
            {
                _tableQuery = _tableQuery.Where(n => n.TableType.TableTypeGUID == param.tableTypeGuid.Value);
            }
            if (param.tableFormatGuid != null)
            {
                _tableQuery = _tableQuery.Where(n => n.TableFormat.TableFormatGUID == param.tableFormatGuid.Value);
            }
            if (param.schemeGuid != null)
                _tableQuery = _tableQuery.Where(n => n.Scheme.SchemeGUID == param.schemeGuid.Value);
            
            query = _tableQuery.ToList<tblTable>();
            foreach (var tb in query)
            {
                CacheHelper.Add(GuidTable + tb.TableGUID.ToString(), tb);
            }
            return query;

/// <summary>
        ///A test for GetQueryList
        ///</summary>
        [TestMethod()]
        public void GetQueryListTest()
        {
           
            TableParameters t = new TableParameters();
            t.schemeGuid = new Guid("9C962C55-A598-40B8-A39B-11788161A9D8");
           
            List<tblTable> actual;
            actual = ManagerFactory.TableManager.GetQueryList(t);
            Assert.AreEqual(" Sedgwick Marsh- B & pre2000-NRA65", actual[0].TableName);
            //Assert.Inconclusive("Verify the correctness of this test method.");