Given a class with a method GetData. A few other clients call GetData, and instead of it fetching data each time, i would like to create a pattern where the first call starts the task to get the data, and the rest of the calls wait for the task to complete.

private Task<string> _data;
private async Task<string> _getdata()
{
    return "my random data from the net"; //get_data_from_net()
}
public string GetData()
{
    if(_data==null)
        _data=_getdata();

    _data.wait(); //are there not a problem here. cant wait a task that is already completed ? if(_data.status != rantocompletion) _data.wait() is not any better, it might complete between the check and the _data.wait?


    return _data.Result;
}

How would i do the pattern correctly?

(Solution)

    private static object _servertime_lock = new object();
    private static Task<string> _servertime;
    private static async Task<string> servertime()
    {
        try
        {
            var thetvdb = new HttpClient();
            thetvdb.Timeout = TimeSpan.FromSeconds(5);
            // var st = await thetvdb.GetStreamAsync("http://www.thetvdb.com/api/Updates.php?type=none");
            var response = await thetvdb.GetAsync("http://www.thetvdb.com/api/Updates.php?type=none");
            response.EnsureSuccessStatusCode();
            Stream stream = await response.Content.ReadAsStreamAsync();
            XDocument xdoc = XDocument.Load(stream);
            return xdoc.Descendants("Time").First().Value;
        }
        catch
        {
            return null;
        }
    }
    public static async Task<string> GetServerTime()
    {
        lock (_servertime_lock)
        {
            if (_servertime == null)
                _servertime = servertime();
        }

        var time = await _servertime;
        if (time == null)
            _servertime = null;

        return time;

    }