Q:

Using static get only property thread safe?

I have this class:
class MyFoo
{
    private static readonly string _foo = InitFoo();

    public static string Foo
    {
        get
        {
            return _foo;
        }
    }

    private static string InitFoo()
    {
        Debug.WriteLine("InitFoo"); 
        // do some job
        return "Foo";
    }
}

The private static _foo member is initialized only once when there is a reference to MyFoo.Foo.
The data returned from InitFoo() is large and the method might be time consuming (a matter of 1-2 seconds max), My question, is there a chance that while a thread is referencing MyFoo.Foo another thread that reference it will get an uncompleted or un-initialized data back b/c the InitFoo() is not complete yet?
In other words, Is the above thread-safe? if not how to make it thread-safe (if possible avoid a lock object?)
Thanks.

EDIT: following the comments about Lazy<T> is it now better for thread safety?:
public sealed class MyFoo
{
    // Explicit static constructor to tell C# compiler not to mark type as beforefieldinit        
    static MyFoo() { }

    private static readonly Lazy<string> _foo = InitFoo();

    public static string Foo
    {
        get
        {
            return _foo.Value;
        }
    }

    private static Lazy<string> InitFoo()
    {
        string s = "Foo";
        return new Lazy<string>(() => s);
    }
}

A:

Is there a chance that while a thread is referencing MyFoo.Foo another thread that reference it will get an uncompleted or un-initialized data back b/c the InitFoo() is not complete yet?

No. Type initialization is thread-safe:

No other threads get to use your type while it's being initialized by another thread
All writes to memory performed by the initialization thread are made visible to other threads when the initialization has been performed

There's one wrinkle which is that if the same thread that's initializing MyFoo ends up reading MyFoo._foo before it's finished initializing, that will cause a problem. That can be particularly awkward to diagnose if there are types that depend on each other for initialization in a cycle.
Here's an example, with two type initializers that each use a value from the other. They both have static constructors to make the behavior deterministic. (The rules for when types are initialized depend on whether or not they have static constructors.)
using System;

public class Program 
{
    public static void Main(string[] args)
    {
        // Determine which type to initialize first based on whether there
        // are any command line arguemnts.
        if (args.Length > 0)
        {
            Class2.DoNothing();
        }
        Console.WriteLine($"Class1.Value1: {Class1.Value1}"); 
        Console.WriteLine($"Class2.Value2: {Class2.Value2}"); 
    }
}

public class Class1
{
    public static readonly string Value1 =
        $"When initializing Class1.Value1, Class2.Value2={Class2.Value2}";

    static Class1() {}
}

public class Class2
{
    public static readonly string Value2 =
        $"When initializing Class2.Value2, Class2.Value2={Class1.Value1}";

    static Class2() {}

    public static void DoNothing() {}
}

Running this without any command line arguments, Class1 starts initializing first, which in turn initializes Class2:
Class1.Value1: When initializing Class1.Value1, Class2.Value2=When initializing Class2.Value2, Class2.Value2=
Class2.Value2: When initializing Class2.Value2, Class2.Value2=

With any command line argument, we initialize Class2 first, which in turn initializes Class1:
Class1.Value1: When initializing Class1.Value1, Class2.Value2=
Class2.Value2: When initializing Class2.Value2, Class2.Value2=When initializing Class1.Value1, Class2.Value2=

