只能生成一个实例的类

这次遇到的是一个c#问题，本着迎难而上精神虽然c#不熟但是盘它就行了。
问题如下：

用linux编译c#需要先搭建环境，那就先搭建一个吧。
搭建环境有好多坑，根据以下内容可以完成并且解决各种问题：
https://www.cnblogs.com/ddrsql/p/6030110.html
https://www.cnblogs.com/guoyuanwei/archive/2012/03/04/2378403.html
https://blog.csdn.net/razertang/article/details/45694567
还有就是4版本以上的，只能用mcs命令编译

搭建好之后可以开始写代码了，对c#不太熟悉先了解一些基础概念：
1：sealed修饰符表示密封用于类时，表示该类不能再被继承。
2：c#中属性的作用：保护字段，对字段取值与赋值进行限定
属性的使用：
_name(属性名)
public [对应字段类型] 属性名Name
{
get{return _name;}
set{_name=value;}
}
3：在c#中有静态构造函数。这个函数的特点是在类型第一次被使用之前由运行时自动调用，而且保证只调用一次。
4：private static readonly object 同步锁名字 = new object();
上面这条语句是同步锁，多线程编程使用。

综上，最好根据静态构造函数的特点，可以利用它实现单例模式。
代码如下：

using System;
namespace Singleton
{
    public sealed class Singleton1/*第一种方法用sealed修饰符，定义静态实例当需要的时候创建该实例。*/
    {
        private Singleton1()
        {
        }

        private static Singleton1 instance = null;
        public static Singleton1 Instance
        {
            get
            {
                if (instance == null)
                    instance = new Singleton1();

                return instance;
            }
        }
    }

    public sealed class Singleton2/*第二种方法用sealed修饰符，定义静态实例当需要的时候创建该实例。防止多线程同时运行到判断instance是否为空的语句，添加同步锁。*/
    {
        private Singleton2()
        {
        }

        private static readonly object syncObj = new object();

        private static Singleton2 instance = null;
        public static Singleton2 Instance
        {
            get
            {
                lock (syncObj)
                {
                    if (instance == null)
                        instance = new Singleton2();
                }

                return instance;
            }
        }
    }

    public sealed class Singleton3/*第三种方法用sealed修饰符，定义静态实例当需要的时候创建该实例。防止多线程同时运行到判断instance是否为空的语句，添加同步锁。并且进行判断只在该实例被第一次创建之前添加同步锁，创建之后则不增加同步锁。*/
    {
        private Singleton3()
        {
        }

        private static object syncObj = new object();

        private static Singleton3 instance = null;
        public static Singleton3 Instance
        {
            get
            {
                if (instance == null)
                {
                    lock (syncObj)
                    {
                        if (instance == null)
                            instance = new Singleton3();
                    }
                }

                return instance;
            }
        }
    }

    public sealed class Singleton4/*第四种方法用sealed修饰符，定义静态构造函数。*/
    {
        private Singleton4()
        {
            Console.WriteLine("An instance of Singleton4 is created.");
        }

        public static void Print()
        {
            Console.WriteLine("Singleton4 Print");
        }

        private static Singleton4 instance = new Singleton4();
        public static Singleton4 Instance
        {
            get
            {
                return instance;
            }
        }
    }

    public sealed class Singleton5/*第五种方法用sealed修饰符，定义静态构造函数。并在内部定义私有类型，避免了第一次用到时被创建，使得当调用属性Singleton5.Instance时创建实例。*/
    {
        Singleton5()
        {
            Console.WriteLine("An instance of Singleton5 is created.");
        }

        public static void Print()
        {
            Console.WriteLine("Singleton5 Print");
        }

        public static Singleton5 Instance
        {
            get
            {
                return Nested.instance;
            }
        }

        class Nested
        {
            static Nested()
            {
            }

            internal static readonly Singleton5 instance = new Singleton5();
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Singleton4.Print();      
            Singleton5.Print();
        }
    }
}

运行结果如图：