Lazy<T>的应用之类内部字段与C#延迟加载

    延迟加载主要应用在以下场景:

数据层 – ADO.NET或Entity Framework等ORM
反射 – 加载assemblies, types, MEF
缓存对象,领域实体

    下面以领域实体为例, 在实体中我们经常检查某个属性下字段是否为空引用. 如果是空的话,计算或填充这个字段. 像这样:

    /// <summary>
    /// Order
    /// </summary>
    public class Order
    {
        private Customer _customer;
        /// <summary>
        /// Gets the customer.
        /// </summary>
        public Customer Customer
        {
            get
            {
                if (_customer == null)
                {
                    _customer = new Customer();
                } return _customer;
            }
        }
        /// <summary>
        /// Prints the label.
        /// </summary>
        /// <returns></returns>
        public string PrintLabel()
        {
            return Customer.CompanyName + "\n" + Customer.Address;
        }
    }

如果PrintLabel方法写成这样:

        public string PrintLabel()
        {
            string result = _customer.CompanyName; // probably results in a NullReferenceException
            return result + "\n" + Customer.Address; // ok to access Customer
        }

注意上面第4行代码,可能有空引用异常. 下面我们使用Lazy<T>来解决这个问题:

    /// <summary>
    /// Order
    /// </summary>
    public class Order
    {
        /// <summary>
        /// _customerInitializer
        /// </summary>
        private Lazy<Customer> _customerInitializer;

        /// <summary>
        /// Initializes a new instance of the <see cref="Order"/> class.
        /// </summary>
        public Order()
        {
            _customerInitializer = new Lazy<Customer>(() => new Customer(),isThreadSafe:true);
        }

        /// <summary>
        /// Gets the customer.
        /// </summary>
        public Customer Customer
        {
            get{ return _customerInitializer.Value;}
        }

        /// <summary>
        /// Prints the label.
        /// </summary>
        /// <returns></returns>
        public string PrintLabel()
        {
            string result = Customer.CompanyName; // ok to access Customer
            return result + "\n" + _customerInitializer.Value.Address; // ok to access via .Value
        }
    }

上面的代码16行,我们延迟初始化对像实例,并且设置线程安全.  Lazy<T>内部是使用Func<T>来实现的,看下面其中构造器的源代码:

public Lazy(Func<T> valueFactory, LazyThreadSafetyMode mode)
{
    if (valueFactory == null) throw new ArgumentNullException("valueFactory");
    this.m_threadSafeObj = Lazy<T>.GetObjectFromMode(mode);
    this.m_valueFactory = valueFactory;
}

有兴趣请自行查看.net framework中的源码. 我们还可以扩展一个LazyNotNull<T>

    /// <summary>
    /// LazyNotNull
    /// </summary>
    /// <typeparam name="T">Type</typeparam>
    public class LazyNotNull<T>
    {
        private Lazy<T> _lazyValue = null;
        private Func<T> _valueFactory = null;

        /// <summary>
        /// Initializes a new instance of the <see cref="LazyNotNull&lt;T&gt;"/> class.
        /// </summary>
        /// <param name="valueFactory">The value factory.</param>
        public LazyNotNull(Func<T> valueFactory)
        {
            _lazyValue = new Lazy<T>(valueFactory);
            _valueFactory = valueFactory;
        }

        /// <summary>
        /// Gets T value.
        /// </summary>
        public T Value
        {
            get
            {
                var lazyValue = _lazyValue;
                if (lazyValue.Value != null)
                {
                    return lazyValue.Value;
                }
                _lazyValue = new Lazy<T>(_valueFactory);
                return default(T);
            }
        }
    }

希望这篇POST对您开发有帮助.
您可能感兴趣的文章:

.net4.0下的Lazy<T>类型简单应用
.net3.5下使用LINQ递归算法实现简洁代码

作者：Petter Liu
出处：http://www.cnblogs.com/wintersun/
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。
该文章也同时发布在我的独立博客中-Petter Liu Blog。