Core源码（三） Lazy<T>

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;

}

巴特西

Core源码（三） Lazy<T>

Lazy<T>解决什么问题？

实现自己的Lazy<T>

.NET Lazy<T> 实现

1、引入了Boxed内部类：

2、线程安全的控制

Lazy<T>源码

一、最常使用的属性Value

二、LazyInitValue方法

三、CreateValue方法

最新文章

热门文章

巴特西

Core源码（三） Lazy<T>

Lazy<T>解决什么问题？

实现自己的Lazy<T>

.NET Lazy<T> 实现

1、 引入了Boxed内部类：

2、 线程安全的控制

Lazy<T>源码

一、最常使用的属性Value

二、LazyInitValue方法

三、CreateValue方法

最新文章

热门文章

1、引入了Boxed内部类：

2、线程安全的控制