2005年4月存档-迷失网络

获取高精度的时间差，可以用来分析页面运行时间的长短

DateTime.Now的精度是很低，这个低的意思是，两次获取的DateTime.Now的Ticks的差，只是一个较大数的整数倍。例如在我的机器上，这个差最小是10.114ms。所以，如果我用DateTime.Now来计算时间差，那么就无法精确到10ms以内。

后来发现ASP.NET的TRACE的精度很高，用Reflector看它的实现，发现了它是使用这两个方法的：

参考MSDN:How To: Time Managed Code Using QueryPerformanceCounter and QueryPerformanceFrequency

我自己了按照这个写了个类，代码如下
using System; using System.Runtime.InteropServices; public class A { [DllImport("kernel32.dll")] static extern bool QueryPerformanceCounter([In, Out] ref long lpPerformanceCount); [DllImport("kernel32.dll")] static extern bool QueryPerformanceFrequency([In, Out] ref long lpFrequency); static long _f = 0; static public long GetTickCount() { long f = _f; if (f == 0) { if (QueryPerformanceFrequency(ref f)) { _f = f; } else { _f = -1; } } if (f == -1) { return Environment.TickCount * 10000; } long c = 0; QueryPerformanceCounter(ref c); return (long)(((double)c) * 1000 * 10000 / ((double)f)); } //GetTickCount()为0时的DateTime.Ticks值 static long _tc = 0; //这个返回的不是真正的精确时间，但时间与时间的差是精确的。 //GetExactNow与DateTime.Now的偏差比DateTime.Now的精度还要小，所以该偏差 static public DateTime GetExactNow() { if (_tc == 0) { long tc = GetTickCount(); DateTime dt = DateTime.Now; _tc = dt.Ticks - tc; return dt; } return new DateTime(_tc + GetTickCount()); } }

在ASP。NET的应用，可以在Global.asax的Application_BeginRequest事件中加入代码来纪录程序开始时的TickCount：

Context.Items["BeginRequestTickCount"]=A.GetTickCount();

然后在页面输出的后面：

这样就可以达到获取页面运行时间值了。（当然输出TotalMilliseconds后Asp.Net还要一些后期工作的，不过这个时间应该只需要0.n ms）

posted on 2005-04-24 14:02:00 by lostinet 评论(18) 阅读(12227)

基于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>类来协助实现。

posted on 2005-04-22 17:59:00 by lostinet 评论(8) 阅读(6525)

迷失网络

导航

关于

标签

每月存档

最新留言

广告

获取高精度的时间差，可以用来分析页面运行时间的长短

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