Lazy实例
先看Lazy的定义:
public class Lazy
{
public Lazy();
public Lazy(bool isThreadSafe);
public Lazy(Func valueFactory);
public Lazy(LazyThreadSafeMode mode);
public Lazy(Func valueFactory, bool isThreadSafe);
public Lazy(Funct valueFactory, LazyThreadSafetyMode mode);
public bool IsValueCreated{get;}
public T Value {get;}
public override string ToStirng();
}
通过Lazy的构造函数重载创建对象,再通过体现延迟加载的Value属性来实现对象的创建,并获取对象实例。
public class SomeClass
{
public int ID{get;set;}
}
Lazy temp = new Lazy();
Console.WriteLine(temp.Value.ID);
以上,只适用于没有构造函数的情况,如果有构造函数如何处理呢?
--使用public Lazy(Func valueFactory),通过委托创建对象
pubic class SomeClass
{
public int ID{get;set;}
public SomeClass(int id)
{
this.ID = id;
}
}
Lazy temp = new Lazy(() => new Big(100));
Console.WriteLine(temp.Value.ID);
延迟加载的本质
创建自定义延迟加载类。
public class MyLazy
{
private volatile object boxed; //volatile说明在多线程状况下,也可以修改该字段
private Func valueFactory; //委托,用来生产T对象实例
static MyLazy(){}
public MyLazy(){}
public MyLazy(Func 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[B] temp = new MyLazy[B](() => BigFactory.Build());
Console.WriteLine(temp.Value.ID);
Console.ReadKey();
}
}
延迟加载的本质大致是: