.NET泛型04,使用Lazy<T>實現延遲加載

2019-11-14 16:33:54

字體：大中小

來源：轉載

供稿：網友

對于一些"大對象"的創建，我們常常希望延遲加載，即在需要的時候再創建對象實例。現在Lazy<T>很好地支持了這一特點。主要包括：

沒有Lazy<T>之前
Lazy<T>實例
延遲加載的本質

沒有Lazy<T>之前

在沒有Lazy<T>之前，我們通過如下方式實現延遲加載。

public class LazySinleton

    PRivate LazySingleton()

{}

    public static LazySingleton Instance

get

            return Lazy.data;

    private class Lazy

        static Lazy()

{}

        internal static readonly LazySingleton data = new LazySingleton();

以上
● 通過私有構造函數屏蔽了LazySingleton類通過構造函數創建的方式
● 私有嵌套類Lazy的data字段負責提供一個LazySingleton的實例
● 只能通過LazySingleton的屬性Instance，才能拿到內部類Lazy.data所代表的實例

Lazy<T>實例

先看Lazy<T>的定義：

public class Lazy<T>{    public Lazy();    public Lazy(bool isThreadSafe);    public Lazy(Func<T> valueFactory);    public Lazy(LazyThreadSafeMode mode);    public Lazy(Func<T> valueFactory, bool isThreadSafe);    public Lazy(Funct<T> valueFactory, LazyThreadSafetyMode mode);    public bool IsValueCreated{get;}    public T Value {get;}    public override string ToStirng();}

通過Lazy<T>的構造函數重載創建對象，再通過體現延遲加載的Value屬性來實現對象的創建，并獲取對象實例。

public class SomeClass{    public int ID{get;set;}}Lazy<SomeClass> temp = new Lazy<SomeClass>();Console.WriteLine(temp.Value.ID);

以上，只適用于沒有構造函數的情況，如果有構造函數如何處理呢？
--使用public Lazy(Func<T> valueFactory)，通過委托創建對象

pubic class SomeClass{    public int ID{get;set;}    public SomeClass(int id)    {        this.ID = id;    }}Lazy<SomeClass> temp = new Lazy<SomeClass>(() => new Big(100));Console.WriteLine(temp.Value.ID);

延遲加載的本質

創建自定義延遲加載類。

public class MyLazy<T>    {        private volatile object boxed; //volatile說明在多線程狀況下，也可以修改該字段        private Func<T> valueFactory; //委托，用來生產T對象實例        static MyLazy(){}        public MyLazy(){}        public MyLazy(Func<T> valueFactory)        {            this.valueFactory = valueFactory;        }        public T Value        {            get            {                Boxed boxed = null;                if (this.boxed != null)                {                    boxed = this.boxed as Boxed;                    if (boxed != null)                    {                        return boxed.value;                    }                }                return this.Init();            }        }        //初始化對象實例        private T Init()        {            Boxed boxed = null;            if (this.boxed == null)            {                boxed = this.CreateValue();                this.boxed = boxed;            }            return boxed.value;        }        //創建內部類實例        private Boxed CreateValue()        {            //如果創建對象實例的委托valueFactory存在            if (this.valueFactory != null)            {                //就通過委托生成對象實例                return new Boxed(this.valueFactory());            }            else            {                //否則，通過反射生成對象實例                return new Boxed((T)Activator.CreateInstance(typeof(T)));            }        }        //內部嵌套類，通過構造函數對其字段賦值        private class Boxed        {            internal T value;            internal Boxed(T value)            {                this.value = value;            }        }    }

自定義帶構造函數的類。

public class Big    {        public int ID { get; set; }        public Big(int id)        {            this.ID = id;        }    }

自定義創建對象實例的工廠類。

public class BigFactory    {        public static Big Build()        {            return new Big(10);        }    }

客戶端調用。

class Program    {        static void Main(string[] args)        {            MyLazy<Big> temp = new MyLazy<Big>(() => BigFactory.Build());            Console.WriteLine(temp.Value.ID);            Console.ReadKey();        }    }

延遲加載的本質大致是：

● 由延遲加載類的內部嵌套類產生對象實例
● 再通過延遲加載類的某個屬性來延遲獲取對象實例，而對象實例是通過委托等方式創建的

參考資料：
《你必須知道的.NET(第2版)》，作者王濤。

".NET泛型"系列包括：