Holding out on object creation

Is there ever a case where holding the necessary data to create an object and only creating it when is absolutely necessary, is better/more efficient than holding the object itself?

A trivial example:

class Bar
{
    public string Data { get; set; }
}

class Foo
{
    Bar bar;
    readonly str开发者_开发问答ing barData;

    public Foo(string barData)
    {
        this.barData = barData;
    }

    public void MaybeCreate(bool create)
    {
        if (create)
        {
            bar = new Bar { Data = barData };
        }
    }

    public Bar Bar { get { return bar; } }
}

It makes sense if the object performs some complex operation on construction, such as allocate system resources.

You have Lazy<T> to help you delay an object's instantiation. Among other things, it has thread safety built in, if you need it.

In general, no. (If I understand your question correct).

Allocations/constructions are cheap in terms of performance. Unless you are doing something crazy, construct your objects when it feels natural for the design - don't optimize prematurely.

Yes if creating the object means populating it, and to populate it you need to do a slow operation.

For example,

List<int> ll = returnDataFromDBVeryVerySlowly();

or

Lazy<List<int>> ll = new Lazy<List<int>>(() =>
{
    return returnDataFromDBVeryVerySlowly();
});

In first example returnDataFromDBVeryVerySlowly will be called always, even if you don't need it. In the second one it will be called only if it's necessary. This is quite common, for example, in ASP.NET where you want to have "ready" many "standard" datasets, but you don't want them to be populated unless they are needed and you want to put them as members of your Page, so that multiple methods can access them (otherwhise a method could call directly returnDataFromDBVeryVerySlowly)