Lazy<int> myInt = new Lazy<int>();

var val = myInt.Value;

if(myInt.IsValueCreated)
{
    Console.WriteLine("Has value!");
}

class MyClass
{
    public string Name { get;set;}
}
Lazy<MyClass> lazyClass = new Lazy<MyClass>();
var myClassInstance = lazyClass.Value;

class MyClass
{
    public string Name { get;set;}
}
Lazy<MyClass> lazyClass = new Lazy<MyClass>(true); 

for(int i=0;i<10;i++)
{
    Task.Run(()=>{
        var myClassInstance = lazyClass.Value;
    });
}

public class MyClass
{
    private Random mRand = new Random();

    public MyClass()
    {
        var toWait = mRand.Next(100, 1000);
        Console.WriteLine("MyClass" + toWait.ToString());
        Thread.Sleep(toWait);
    }
}

public static void Main()
{
    Lazy<MyClass> lazy = new(LazyThreadSafetyMode.PublicationOnly);

    List<Task> allTasks = new List<Task>();
    for (int i = 0; i < 10; i++)
    {
        allTasks.Add(Task.Run(() =>
        {
            var myClassInstance = lazy.Value;
        }));
    }

    Task.WaitAll(allTasks.ToArray());
}

public class MyClass
{
    private string mValue;
    MyClass(string val) { mValue = val;}
}

Lazy<MyClass> classLazy = new Lazy<MyClass>(() => {
    var value = File.ReadAllText("MyFile.txt");
    return new MyClass(value);
});
classLazy.Value; // Reads file

class MyClass
{
    public string Name { get;set; }
}
Lazy<MyClass> lazyClass = new Lazy<MyClass>(new MyClass() { Name = "Bob" }); 

for(int i=0;i<10;i++)
{
    Task.Run(()=>{
        var myClassInstance = lazyClass.Value;
        Console.WriteLine(myClassInstance.Name);
    });
}

public class MyHandler
{
    private static object mLocker = new object();
    private static MyHandler Object;

    public static MyHandler GetHandler()
    {
        lock(mLocker)
        {
            if(Object == null)
            {
                lock(mLocker)
                {
                    Object = new MyHandler();
                }
            }
        }
        return Object;
    }
}

public class MyHandler
{
    private static Lazy<MyHandler> StaticLazy = new Lazy<MyHandler>(true);
    
    public static MyHandler GetHandler()
    {
        return StaticLazy.Value;
    }
}

public class ExpensiveClass
{
    private byte[] mBytes = new byte[100000000];
    private long CurrentIndex = 0;

    public long AddToCache() 
    { 
        // Add to bytes
        // Return index    
    }
}

public class Consumer
{
    private Lazy<ExpensiveClass> mCacheService = new Lazy<ExpensiveClass>(true);
    
    public void Do()
    {
        byte[] someData = //...
        if(shouldCache)
        {
            mCacheService.Value.AddToCache(someData);
        }
    }
}

public class Connection
{
    public void SetOption(Option flag, object value);

    public void Open(IpAdress address){ /*...*/ }
}


public class Client
{
    private Lazy<Connection> mConnection;

    public Client()
    {
        mConnection = new Lazy<Connection>(()=>{
            Connection c =  new Connection();
            c.SetOption(Option.UseMinMtu);
            c.Open("localhost");
            return c;
        });
    }

    // Somewhere else

    public void Response(Message m)
    {
        var connection = mConnection.Value;
        connection.Send(SerializeIntoBytes(m));
    }
}