C# 中 static 的一些使用方法和 单例模式

静态成员变量

用 static 修饰的成员变量称之为静态成员。例如：

class D
{
	int mem1;
	static int mem2;
}

mem2 就是所谓的静态成员变量。
而静态成员变量它在内存分布的位置也是与普通成员变量有所区别的。

1. 静态成员是属于类，普通成员数据对象的。当类第一次被加载的时候，所有的静态成员都会被加载。例如：
   上图，当在加载上面代码的时候，静态成员mem2已经被创建加载了，我们就可以通过 类名 + "."的形式调用静态变量。如：D.mem2。而普通成员变量则需要创建一个对象，通过对象 + "."的方式调用如下代码：

	class D
    {
        public int mem1;
        public static int mem2;
        public static void Printf()
        {
            Console.WriteLine("mem2 = {0}", mem2);
        }

        public void PrintF2()
        {
            Console.WriteLine("mem1 = {0}", mem1);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            D.mem2 = 10;
            D.Printf();

            D d = new D();
            d.mem1 = 20;
            d.PrintF2();

            Console.ReadKey();
        }
    }

输出的则是

mem2 = 10
mem1 = 20

2.静态变量对于整个类来说只有一份。而成员变量则是有多少对象，就有多少份。对于静态变量一旦创建出来，只有在程序结束时候，才会被销毁。而成员变量则在对象销毁时，跟着一起销毁。静态变量的内存分配跟成员对象的内存分配也是不一样的。静态成员变量内存分配是在堆中分配一个独立的空间。而成员变量是在对象堆中分配的一块空间。如下图：

首先创建了一个对象 d，在栈中存储它的地址。当 new D() 后，会在堆中分配一块内存d1，然后由d指向这块内存。从图中可以看出成员函数的内存地址都是在d1 中的，而静态函数的地址是在d1 外的一块内存。在来看下一张图。

用 D 类创建了 d2对象， 在堆中分配内存 d11， d2的对象 mem1， PrintF2 都在 d11 中，但是静态变量和静态方法的调用会指向同一个 mem2， Printf。这说明只要是用D类创建的对象，调用的静态变量和方法都是同一个。当然，一旦改动静态变量，所有的方法再次调用都会被改动。如下代码：

class D
    {
        public static int mem;

        public void setMem(int value)
        {
            mem = value;
        }

        public void PirntMem()
        {
            Console.WriteLine("mem = {0}", mem);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            D d = new D();
            d.setMem(10);
            d.PirntMem();

            D d1 = new D();
            d1.setMem(30);
            d1.PirntMem();

            d.PirntMem();

            Console.ReadKey();
        }
    }

则输出的结果为：

mem = 10
mem = 30
mem = 30

静态方法

静态方法就是用static修饰的方法

 class D
 {
     public static int mem;
     public static void setMem(int value)
     {
         mem = value;
     }
 }

上面代码中的 setMem 方法就是静态方法 有时候还会写成这样

static public void setMem(int value)
{
    mem = value;
}

因为 public 和static 都是修饰符，所以谁前谁后都是一样的。

静态方法与静态成员变量类似，都是属于类而不属于对象的。内存都是在堆中单独分配的。
而我们在调用静态成员方法的时候，需要用类名 + "."的方法来访问。

class D
{
    public static int mem;

    static public void setMem(int value)
    {
        mem = value;
    }
    static public void PrintF()
    {
        Console.WriteLine("mem = {0}", mem);
    }
}

class Program
{
    static void Main(string[] args)
    {
        D.setMem(10);
        D.PrintF();
        Console.ReadKey();
    }
}

执行输出的结果为：

mem = 10

单例模式

单例模式就是一个类能返回对象一个引用（永远是同一个）和一个获得该实例的方法（必须是静态方法），当我们调用这个方法时，如果返回的引用为空，则创建一个对象。不为空返回该引用。然后通过该引用调用函数的一些方法。
代码如下：

 class D
 {
     private static D instance;
     public static D Instance
     {
         get
         {
             if (instance == null)
             {
                 instance = new D();
             }
             return instance;
         }
     }
     public void PrintF()
     {
         Console.WriteLine("单例测试 --- ");
     }
 }

 class Program
 {
     static void Main(string[] args)
     {
         D.Instance.PrintF();
        
         Console.ReadKey();
     }
 }

输出结果为：

单例测试 ---

上述代码就完成了单例模式。

总结

最近在学习中，写的不够完整，仅供参考。