Lazy initialization or lazy
instantiation means that an object is not created until it is
first referenced. Lazy initialization is used to
reduce wasteful computation, memory requirements. Following is an example where
Lazy initialization is particularly useful.
We have Department Object that has a Managers Property
which is an array of all the managers in the department. To initialize Managers
object we need a database connection. In the normal scenario Managers property
will be initialized each time Department object is created. But by using lazy
initialization we can defer the creation of the Managers Property (which is an
array of Manager Objects) till the time it is actually referenced in code. We
can declare Managers property like Lazy<Manager> to defer the creation of
Manager Objects.
Another scenario where it is useful is:
Suppose we have several objects that are initialized on
application startup we can defer the creation of objects that are not required
immediately by using Lazy initialization and initialize only the required
objects.
We can use Lazy<T> to do lazy initialization
which also support thread-safety and exception propagation.
Lazy
Initialization Example
To lazy initialize a type MyType use Lazy<MyType>.If
we do not pass any delegate to the Lazy<T> constructor the wrapped type
is created using the default constructor when we access the
value property for the first time otherwise the constructor referenced by the
passed delegate is invoked.
On first access, the wrapped type
is created and returned, and stored for any future access.
After the Lazy object is created,
no instance of object is created until the value property of the Lazy variable is
accessed for the first time. On first access, the wrapped type is created and
returned, and stored for any future access. In the
following example we have a Manager class that is Lazy Initialized.
Lazy<Manager>
_manager = new Lazy<Manager>();
Console.WriteLine(_manager); //Manager
object is null
_manager.Value.Id="10";
_manager.Value.Name
= "ashish";
Console.WriteLine(_manager);//Manager
object is initialized now
Console.Read();
class Manager
{
string
_name;
public string Name
{
get
{ return _name; }
set
{ _name = value; }
}
string
_id;
public string Id
{
get
{ return _id; }
set
{ _id = value; }
}
}
Output Window
We can also pass a delegate in the Lazy<T> constructor that invokes the
constructor at object creation time that performs the required initialization
steps at object creation time.
Lazy<Manager>
_manager = new Lazy<Manager>(()=>new Manager(10));