Designing an object with a long running constructor

Question

I have a class that is designed to provide quick access to some metadata for some specific files that are used multiple times throughout my application. Unfortunately some of the metadata can only be extracted with a very long running method call.

I have another class that provides an async wrapper for the long running method (can be 5 or more minutes depending on the size of the file), but I'm trying to figure out how to call this async method and if it would be appropriate to put it into the constructor, or if there is a better design pattern for this scenario.

Here's some pseudo code to try and illustrate my question:

public class MetaData
{
    public string Data1 { get; private set; }
    public string Data2 { get; private set; }

    public MetaData(String filepath)
    {
        var extractor = new ExtractMetaData(filepath);  //create instance of class that fetches the metadata

        this.Data1 = extractor.GetData1(); // short running method

        extractor.Data2Received += Data2Received;  
        extractor.GetData2Async();  // long running method, called with via async method

    }        

    private void Data2Received(object sender, MetaDataEventArgs args)
    {
        this.Data2 = args.Data;  // finally set Data2 property
    }
}

class ExtractMetaData
{

    public event Data2ReceivedEventHandler Data2Received;

    public ExtractMetaData (string filePath) { }

    public String GetData1();  // very fast method to get Data1
    public void GetData2Async();  // very slow method to get Data2

}

What I'm trying to figure out is if there is better way to accomplish this?

With my code now, there is virtually no wait for MetaData to be constructed, but if someone were to try to access the MetaData.Data2 property before the GetData2Async() method returns and fires the Data2Received event, they are going to get a null response. But if they call if after it is returned, it will contain the correct information. Since there is really no way to notify the user that this method has completed, I'm worried this will turn into a bad user experience as they don't havr to wait for the constructor, but have to wait for all of the properties to be set.

Answer 1

First, you said that there is no way to notify the user that getting Data2 completed. That's not true, you can use any number of ways to notify the user of that, for example an event or Task.

But I think you should actually restructure your class. You said that getting Data2 takes very long, which most likely means it uses a lot of resources. Because of that, I think you shouldn't even try to initialize Data2 unless you have to. And how do you know that? The user will have to tell you. And ideally, if the user doesn't want Data2, he shouldn't even be able to access it, which means splitting MetaData into two classes: something like BasicMetaData and ExtendedMetaData, which inherits from BasicMetaData.

In ExtendedMetaData, either you would have some way of notifying the user that the initialization completed (most likely using an event), or you could make the constructor wait until the initialization is complete (you could use Monitor.Wait() and Monitor.Pulse() to do that).

Personally, I think the best option would be if you had a static factory method that would return Task<ExtendedMetaData>. That way, the user can wait for the result synchronously (using Result) or asynchronously (using ContinueWith() or await where it's available). This would be especially useful in .Net 4.5 (because of await), but also on .Net 4.0. Unfortunately, the tag on your question indicates that you're using .Net 3.5, which doesn't have Task. I would recommend you to upgrade, if possible.

Answer 2

I think you need to spend your attention on the following patterns: Lazy loading (to call 'long' methods only when you really need it) and Proxy (to implement caching layer if needed, hide internal realization, maybe multiple various different patterns on the bottom of your object). If you decide to use several objects to ensure whole functionality - then Facade also could be reasonable choice.

Answer 3

You will get several different answers for this question. Here is my take on it.

IMO, you shouldn't call any operation in your constructor, such as what you are doing right now. All that stuff in your MetaData constructor shouldn't be there to start with.

While you are instantiating an object, it might throw an exception, which is fine but your object won't be constructed. Some of the best practices. constructor should be short running and should ensure that object graph will be created after constructor.

Look at this question also: How much code should one put in a constructor?

Alternatively, you should inject your dependencies and create methods to populate the data.

It would be more helpful, if you could describe your problem little more.

You really need to simplify your process and design.