Lazy<T>解决什么问题？
1、大对象加载
考虑下面的需求，有个对象很大，创建耗时，并且要在托管堆上分配一大块空间。我们当然希望，用到它的时候再去创建。也就是延迟加载，等到真正需要它的时候，才去加载。
显然，这里需要加一个中间层，将大对象封装起来，暴露接口，开始并不创建大对象，等到用户真正访问对象的时候，再去创建。另外，这个中间层应该可以封装不同类型的大对象，因此需要类模版。Lazy<T>就是为了解决这个问题。
典型的使用
public Lazy<AccountService> AccountServ = new Lazy<AccountService>(); public Lazy<ProductService> ProductService = new Lazy<ProductService>();
2、将委托或者方法对象保存，并在需要的时候调用。
private readonly Lazy<IDbConnection> _connectionLazy;
public CallHistoryRepository(ConnectionFactory connectionFactory)
{
_connectionLazy = new Lazy<IDbConnection>(()=>connectionFactory.Connection);
}
一旦使用.Vale，那么对应的变量就会被实例化，IsValueCreated属性也就变成了true。
实现自己的Lazy<T>
在.NET Framework 4.0之前，大对象就是存在的，那么对于一个大型系统而言，怎么样对付一个大对象呢。主要有两点：延迟加载和即时清理。前者解决创建问题，后者解决回收问题。
那么在来看Lazy<T>的.NET Framework实现之前，我们先来自己实现一个简单的Lazy<T>吧。
class MyLazy<T> where T : new() { private T value; private bool isLoaded; public MyLazy() { isLoaded = false; } public T Value { get { if (!isLoaded) { value = new T(); isLoaded = true; } return value; } } }
这应该是最简单版本的Lazy<T>了，没有线程安全检测，只有着访问时创建真实对象，可是对于我们一般的应用来说也许就已经足够了。
.NET Lazy<T> 实现
.NET Core和我们的实现，有两点主要的不同：
1、 引入了Boxed内部类：
[Serializable] private class Boxed { // Fields internal T m_value; // Methods [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")] internal Boxed(T value) { this.m_value = value; } }
该内部类取代了我在上面实现中的泛型约束，使之更通用。
但是我们也应该注意到，如果T为结构体，那么由于T很大，所以装箱拆箱反而也许是个更耗费效率的事情，因此，个人建议，对值类型慎用Lazy<T>。
2、 线程安全的控制
在线程安全的控制选项中，.NET Framework为我们提供了这样的枚举选项：
public enum LazyThreadSafetyMode { None, PublicationOnly, ExecutionAndPublication }
默认值为ExecutionAndPublication
枚举选项MSDN介绍如下
http://msdn.microsoft.com/en-us/library/system.threading.lazythreadsafetymode%28VS.100%29.aspx
isThreadSafe则应用于多线程环境下，如果isThreadSafe为false，那么延迟加载对象则一次只能创建于一个线程。
Lazy<T>源码
System.Runtime命名空间下
由于core中的lazy源码我只找到了下图这个，再往下lazy的实现并没找
所以我使用.Net 4.5的lazy源码
一、最常使用的属性Value
[DebuggerBrowsable(DebuggerBrowsableState.Never)] public T Value { get { Boxed boxed = null; if (m_boxed != null ) { // Do a quick check up front for the fast path. boxed = m_boxed as Boxed; if (boxed != null) { return boxed.m_value; } LazyInternalExceptionHolder exc = m_boxed as LazyInternalExceptionHolder; Contract.Assert(m_boxed != null); exc.m_edi.Throw(); } return LazyInitValue(); } } //null --> value is not created //m_value is Boxed --> the value is created, and m_value holds the value //m_value is LazyExceptionHolder --> it holds an exception private object m_boxed;
如果m_boxed有值，就直接装箱返回对应值（这里就要注意值类型装箱的性能损失了）。这个装箱是为了检验下m_boxed的值，因为其中有可能是异常。
二、LazyInitValue方法
如果m_boxed为空，就调用LazyInitValue方法，这里有针对线程安全模式的判断
/// <summary> /// local helper method to initialize the value /// </summary> /// <returns>The inititialized T value</returns> private T LazyInitValue() { Boxed boxed = null; LazyThreadSafetyMode mode = Mode; if (mode == LazyThreadSafetyMode.None) { boxed = CreateValue(); m_boxed = boxed; } else if (mode == LazyThreadSafetyMode.PublicationOnly) { boxed = CreateValue(); if (boxed == null || Interlocked.CompareExchange(ref m_boxed, boxed, null) != null) { // If CreateValue returns null, it means another thread successfully invoked the value factory // and stored the result, so we should just take what was stored. If CreateValue returns non-null // but we lose the ---- to store the single value, again we should just take what was stored. boxed = (Boxed)m_boxed; } else { // We successfully created and stored the value. At this point, the value factory delegate is // no longer needed, and we don't want to hold onto its resources. m_valueFactory = ALREADY_INVOKED_SENTINEL; } } else { object threadSafeObj = Volatile.Read(ref m_threadSafeObj); bool lockTaken = false; try { if (threadSafeObj != (object)ALREADY_INVOKED_SENTINEL) Monitor.Enter(threadSafeObj, ref lockTaken); else Contract.Assert(m_boxed != null); if (m_boxed == null) { boxed = CreateValue(); m_boxed = boxed; Volatile.Write(ref m_threadSafeObj, ALREADY_INVOKED_SENTINEL); } else // got the lock but the value is not null anymore, check if it is created by another thread or faulted and throw if so { boxed = m_boxed as Boxed; if (boxed == null) // it is not Boxed, so it is a LazyInternalExceptionHolder { LazyInternalExceptionHolder exHolder = m_boxed as LazyInternalExceptionHolder; Contract.Assert(exHolder != null); exHolder.m_edi.Throw(); } } } finally { if (lockTaken) Monitor.Exit(threadSafeObj); } } Contract.Assert(boxed != null); return boxed.m_value; }
三、CreateValue方法
返回一个实例对象T，采用传入的func方法，这里会对是否已经返回做出判断，如果已经返回，就返回null
/// <summary>Creates an instance of T using m_valueFactory in case its not null or use reflection to create a new T()</summary> /// <returns>An instance of Boxed.</returns> private Boxed CreateValue() { Boxed boxed = null; LazyThreadSafetyMode mode = Mode; if (m_valueFactory != null) { try { // check for recursion if (mode != LazyThreadSafetyMode.PublicationOnly && m_valueFactory == ALREADY_INVOKED_SENTINEL) throw new InvalidOperationException(Environment.GetResourceString("Lazy_Value_RecursiveCallsToValue")); Func<T> factory = m_valueFactory; if (mode != LazyThreadSafetyMode.PublicationOnly) // only detect recursion on None and ExecutionAndPublication modes { m_valueFactory = ALREADY_INVOKED_SENTINEL; } else if (factory == ALREADY_INVOKED_SENTINEL) { // Another thread ----d with us and beat us to successfully invoke the factory. return null; } boxed = new Boxed(factory()); } catch (Exception ex) { if (mode != LazyThreadSafetyMode.PublicationOnly) // don't cache the exception for PublicationOnly mode m_boxed = new LazyInternalExceptionHolder(ex); throw; } } else { try { boxed = new Boxed((T)Activator.CreateInstance(typeof(T))); } catch (System.MissingMethodException) { Exception ex = new System.MissingMemberException(Environment.GetResourceString("Lazy_CreateValue_NoParameterlessCtorForT")); if (mode != LazyThreadSafetyMode.PublicationOnly) // don't cache the exception for PublicationOnly mode m_boxed = new LazyInternalExceptionHolder(ex); throw ex; } } return boxed; }