基于Context的数据缓存与属性的LazyLoad，一个范型的练习。(24日更新-DataPair能复活来延迟回收)-迷失网络

基于Context的数据缓存与属性的LazyLoad，一个范型的练习。(24日更新-DataPair能复活来延迟回收)

把VS.NET2005Beta2下载了下来，一直都没有好好地去研究一下。
今天突然想到一个有意思的Idea,关于程序中数据的获取方式的。
反正想试试而已，于是顺便练习了一下范型。

通常做数据缓存的时候，都是依靠Cache来实现的。
其实DotNet的垃圾回收和WeakReference类就可以用来做缓存了。
测试的代码如下：

//5
using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Data;
using System.Data.SqlClient;

namespace Test1
{

#region 第一部分，通用的
    public interface IDataItemProvider<K, T>
    {
        void GetItem(SomeContext context, K key, out T val);
    }
    public class SomeContext
    {
        public SomeContext(SqlConnection conn)
        {
            if (conn == null) throw (new ArgumentNullException("conn"));

_conn = conn;
        }

SqlConnection _conn;
        public SqlConnection Connection
        {
            get
            {
                return _conn;
            }
        }

class KTPair<K, T> { }

Hashtable _itemtable = Hashtable.Synchronized(new Hashtable());
        public T GetDataItem<K, T>(IDataItemProvider<K, T> adapter, K key, bool throwIfNotFound)
        {
            if (adapter == null) throw (new ArgumentNullException("adapter"));
            if (key == null) throw (new ArgumentNullException("key"));

object tablekey = typeof(KTPair<K, T>);

//根据 tablekey 得到一个用于储存WeakReference的dictionary
            Dictionary<K, WeakReference> dict;
            lock (_itemtable.SyncRoot)
            {
                dict = (Dictionary<K, WeakReference>)_itemtable[tablekey];
                if (dict == null)
                {
                    dict = new Dictionary<K, WeakReference>();
                    _itemtable[tablekey] = dict;
                }
            }

lock (dict)
            {
                //察看是否已经有纪录。
                if (dict.ContainsKey(key))
                {
                    //返回对象。
                    WeakReference wr = dict[key];
                    if (wr.IsAlive)
                    {
                        try
                        {
                            return (T)wr.Target;
                        }
                        catch //如果刚好被回收了。。
                        {

}
                    }

dict.Remove(key);
                }

//根据IDataItemProvider来得到这个对象

T item;
                adapter.GetItem(this, key, out item);

//如果有结果.
                if (item != null)   //注意T不应该是ValueType
                {
                    dict.Add(key, new WeakReference(item,true));

return item;
                }

//没有结果则
                if (throwIfNotFound)
                    throw (new Exception("Not Found"));

return default(T);
            }
        }

public void RemoveDataItem<K, T>(K key)
        {
            Dictionary<K, WeakReference> dict;
            object tablekey = typeof(KTPair<K, T>);

lock (_itemtable.SyncRoot)
            {
                dict = (Dictionary<K, WeakReference>)_itemtable[tablekey];
                if (dict == null)
                    return;
            }
            lock (dict)
            {
                if (dict.ContainsKey(key))
                    dict.Remove(key);
            }
        }
    }
    public class DataPair<K, T>
    {
        SomeContext _store;
        K _key;
        T _val;

DateTime _lastget = DateTime.Now;
        TimeSpan _timereset = TimeSpan.FromMinutes(1);
        bool _autoreset = false;

~DataPair()
        {
            if (DateTime.Now - _lastget > _timereset)
            {
                _store.RemoveDataItem<K, DataPair<K, T>>(_key);
            }
            else
            {
                GC.KeepAlive(this);
                GC.ReRegisterForFinalize(this);
            }
        }

public TimeSpan TimeReset
        {
            get
            {
                return _timereset;
            }
            set
            {
                _timereset = value;
            }
        }
        public bool AutoReset
        {
            get
            {
                return _autoreset;
            }
            set
            {
                _autoreset = value;
            }
        }

public DataPair(SomeContext store, K key, T val)
        {
            if (store == null) throw (new ArgumentNullException("store"));
            if (key == null) throw (new ArgumentNullException("key"));
            if (val == null) throw (new ArgumentNullException("val"));

_store = store;
            _key = key;
            _val = val;
        }

public SomeContext Store
        {
            get
            {
                return _store;
            }
        }
        public K Key
        {
            get
            {
                return _key;
            }
        }
        public T Value
        {
            get
            {
                return _val;
            }
        }
    }
    #endregion

#region 第二部分，某一个数据类型
    public class Supplier
    {
        class DataItemAdater : IDataItemProvider<int, Supplier>
        {
            static public readonly DataItemAdater Instance = new DataItemAdater();

public void GetItem(SomeContext context, int key, out Supplier val)
            {
                using (SqlCommand cmd = context.Connection.CreateCommand())
                {
                    cmd.CommandType = CommandType.Text;
                    cmd.CommandText = "SELECT * FROM Suppliers WHERE SupplierId=@SupplierId";
                    cmd.Parameters.AddWithValue("@SupplierId", key);

CommandBehavior behavior = CommandBehavior.Default;
                    if (context.Connection.State != ConnectionState.Open)
                    {
                        behavior = CommandBehavior.CloseConnection;
                        context.Connection.Open();
                    }
                    using (SqlDataReader sdr = cmd.ExecuteReader(behavior))
                    {
                        if (!sdr.Read())
                        {
                            val = null;
                        }
                        else
                        {
                            val = new Supplier(context, sdr);
                        }
                    }
                }
            }
        }

static public Supplier GetSupplier(SomeContext context, int supplierId, bool throwIfNotFound)
        {
            return context.GetDataItem<int, Supplier>(DataItemAdater.Instance, supplierId, throwIfNotFound);
        }

~Supplier()
        {
            Console.WriteLine("~Supplier() , id={0}", _id);

_context.RemoveDataItem<int, Supplier>(_id);
        }
        private Supplier(SomeContext context, IDataRecord record)
        {
            _context = context;
            _id = record.GetInt32(0);
            _name = record.GetString(1);
            //...more..fields...
        }

SomeContext _context;
        int _id;
        string _name;

public int SupplierId
        {
            get
            {
                return _id;
            }
        }
        public string CompanyName
        {
            get
            {
                return _name;
            }
        }

public override string ToString()
        {
            return _name;
        }

string[] _products;
        public string[] Products
        {
            get
            {
                //Load on demand..
                if (_products != null) return _products;
                lock (this)
                {
                    if (_products != null) return _products;

Console.WriteLine("Get Products , id={0}", _id);

List<string> strs = new List<string>();

using (SqlCommand cmd = _context.Connection.CreateCommand())
                    {
                        cmd.CommandType = CommandType.Text;
                        cmd.CommandText = "SELECT ProductName FROM Products WHERE SupplierId=@SupplierId";
                        cmd.Parameters.AddWithValue("@SupplierId", _id);

CommandBehavior behavior = CommandBehavior.Default;
                        if (_context.Connection.State != ConnectionState.Open)
                        {
                            behavior = CommandBehavior.CloseConnection;
                            _context.Connection.Open();
                        }

using (SqlDataReader sdr = cmd.ExecuteReader(behavior))
                        {
                            while (sdr.Read())
                                strs.Add(sdr.GetString(0));
                        }

}

_products = strs.ToArray();
                }
                return _products;
            }
        }
    }
    #endregion

#region 第三部分 使用DataPair。

public class Employeee
    {
        public Employeee(IDataReader record)
        {
            _id = record.GetInt32(0);
            _fn = record.GetString(1);
            _ln = record.GetString(2);
            _title = record.GetString(3);
        }

int _id;
        string _fn;
        string _ln;
        string _title;

public int EmployeeId
        {
            get
            {
                return _id;
            }
        }
        public string FirstName
        {
            get
            {
                return _fn;
            }
        }
        public string LastName
        {
            get
            {
                return _ln;
            }
        }
        public string Title
        {
            get
            {
                return _title;
            }
        }
    }

public class SomeController : IDataItemProvider<int, DataPair<int, Employeee>>
    {
        static readonly SomeController Instance = new SomeController();

private SomeController()
        {
        }

static public Employeee GetEmployee(SomeContext context, int empid, bool throwIfNotFound)
        {
            DataPair<int, Employeee> dp = context.GetDataItem<int, DataPair<int, Employeee>>(Instance, empid, throwIfNotFound);
            if (dp == null)
                return null;
            return dp.Value;
        }

public void GetItem(SomeContext context, int key, out DataPair<int, Employeee> val)
        {
            using (SqlCommand cmd = context.Connection.CreateCommand())
            {
                cmd.CommandType = CommandType.Text;
                cmd.CommandText = "SELECT EmployeeId,FirstName,LastName,Title FROM Employees WHERE EmployeeId=@EmployeeId";
                cmd.Parameters.AddWithValue("@EmployeeId", key);

CommandBehavior behavior = CommandBehavior.Default;
                if (context.Connection.State != ConnectionState.Open)
                {
                    behavior = CommandBehavior.CloseConnection;
                    context.Connection.Open();
                }
                using (SqlDataReader sdr = cmd.ExecuteReader(behavior))
                {
                    if (!sdr.Read())
                    {
                        val = null;
                    }
                    else
                    {
                        val = new DataPair<int, Employeee>(context, key, new Employeee(sdr));
                    }
                }
            }
        }
    }

#endregion

//测试
    class Program
    {
        static void Main(string[] args)
        {
            SqlConnection conn = new SqlConnection("server=(local);database=northwind;trusted_connection=true;");
            SomeContext context = new SomeContext(conn);

Supplier s1 = Supplier.GetSupplier(context, 1, true);

Console.WriteLine("s1.CompanyName = {0} , Products Count = {1} ", s1.CompanyName, s1.Products.Length);

Supplier s2 = Supplier.GetSupplier(context, 1, true);

Console.WriteLine("返回相同的结果？ {0}", s1 == s2);

s1 = null;

Console.WriteLine("Collect #1");

GC.Collect();

s2 = null;

Console.WriteLine("Collect #2");

GC.Collect();

Employeee e1 = SomeController.GetEmployee(context, 1, true);
            Employeee e2 = SomeController.GetEmployee(context, 1, true);

Console.WriteLine("Employee 又如何？ {0}", e1 == e2);

e1 = null;
            e2 = null;

for (int times = 0; times < 20; times++)
            {
                Console.WriteLine("Collect times #" + times);
                GC.Collect();
            }

Console.WriteLine("End..");
        }
    }
}

下面说说大概的做法：

首先，在某个Context下（当然作成全局也可以。）
有一个储存这些数据的地方，在例子中是SomeContext._itemtable
而SomeContext.GetDataItem则使用一种类似Provider的方式来获取数据。
当执行GetDataItem时，需要指定一个key
如果_itemtable不存在这个key,则需要访问Provder来获取这个数据。
如果_itemtable已经有了这个数据了，则直接返回该数据就OK了。

当然，_itemtable和里面的Dictionary都不是 Cache 类型的，
那么数据是怎样自动释放的呢？

这里关键就是_itemtable里并不引用T类型的对象，它只储存WeakReference.
当T对象没有被任何引用，并且内存紧张，DotNet进行回收的时候，~T()就会被调用。
~T()最好主动告诉SameContext.RemoveDataItem，它已经被回收啦。

所以，要执行SameContext.RemoveDataItem, T对象必须要引用着SameContext的实例，这使序列化有点麻烦。

当然如果要做序列化，那么就不要把_context也带过去了，~T()可以判断一下_context是否为空。
因为复制后对象并不是在_context._itemtable中的，并不存在回收的问题。

例子中还包含了一个 Products 属性。这个属性告诉了，怎样令Supplier本身是有生命的。
_products本身是为null的，一直到get_Products时，才开始使用_context来获取。
而且这个_products本身也算是缓存了。除非Supplier被回收了，否则就不需要重新访问数据库。

当然，基于这个也许能做很多更有意思的东西，例如基于这个来做一个ORM。
不过等有空的时候再完善这个模型吧。

-----------------------------------------------

如果希望目标的数据类型与这个模型无关，例如使用已有的数据类型，

那么可以使用后来做的DataPair<K,T>类来协助实现。

打印 | 张贴于 2005-04-22 17:59:00 | Tag:DotNet 迷失中 DotNet2学习

留言反馈

#回复: 基于Context的数据缓存与属性的LazyLoad，一个范型的练习。(24日更新-DataPair能复活来延迟回收) 编辑

能否发一封到我邮箱?谢谢

2006-12-27 14:07:00 | [匿名用户:我考百试通]

#re:基于Context的数据缓存与属性的LazyLoad，一个范型的练习。(24日更新-DataPair能复活来延迟回收) 编辑

基于Context的数据缓存与属性的LazyLoad，一个范型的练习。(24日更新-DataPair能复活来延迟回收)ooeess

2005-05-30 11:55:00 | [匿名用户:转基因]

#re:基于Context的数据缓存与属性的LazyLoad，一个范型的练习。(24日更新-DataPair能复活来延迟回收) 编辑

^_~,pretty good!csharpsseeoo

2005-05-08 14:33:00 | [匿名用户:电缆长度仪]

#re: 基于Context的数据缓存与属性的LazyLoad，一个范型的练习。(24日更新-DataPair能复活来延迟回收) 编辑

这里说的Context是自定义的Context。

Context是一种概念，意思是你在某段代码时能得到的一些相关信息，HttpContext只是其中一种。

2005-04-25 23:20:00 | [匿名用户:Lostinet]

#re: 基于Context的数据缓存与属性的LazyLoad，一个范型的练习。(24日更新-DataPair能复活来延迟回收) 编辑

有个问题想请教您
上面说的HttpContext有某一个也可以是全局的是什么意思？
这个我知道很久了，但是一直没搞清楚单个和全局有什么区别。

按我的理解，每次访问服务器，IIS应该会产生一个HttpContext，同时也会产生HttpApplication吧？这个是针对某个客户端的？
那全局是什么意思？HttpApplication也是分全局和单一吧？

我糊涂了。。。。。。

2005-04-25 16:50:00 | [匿名用户:小东]

#re: 基于Context的数据缓存与属性的LazyLoad，一个范型的练习。编辑

里面的
f (_context.Connection.State != ConnectionState.Open)
behavior = CommandBehavior.Default;
应该是
behavior = CommandBehavior.CloseConnection;

2005-04-22 19:01:00 | [匿名用户:Lostinet]

对不起，目前本随笔不允许发表新评论.

迷失网络

导航

关于

标签

每月存档

最新留言

广告

留言反馈