static 关键字

导读

1、静态成员(static member)

2、静态类(static class)

3、静态构造器(static ctor)

4、用静态构造器实现单例模式

---

静态成员

        我们知道类的成员有静态成员(static member)和实例成员(Instance Member)之分。静态成员属于类，实例成员属于对象即类的实例。我们通过类名.成员的方式访问静态成员，通过对象.成员的方式访问实例成员。一个类的静态成员(主要指字段)在AppDomain所管理的内存中只有一份，无论初始化多少个对象都是访问这一份。

看一个例子

using System;

namespace StaticDemo
{
    // 模拟用户储户类
    public class SaveCount
    {
        private double _currBalnce;  // 当前账户余额
        private static double _currRate; // 当前存款利率 注意静态字段
        
        public double CurrRate
        {
            get{return _currRate;}
            set{_currRate = value;}
        }
        
        public SaveCount(double currBalnce)
        {
            _currBalnce = currBalnce;
        }
    }
    
    // 调用类
    class App
    {   
        static void Main()
        {
            SaveCount s1 = new SaveCount(1000);
            s1.CurrRate = 0.03;
            Console.WriteLine("当前s1利率: {0}",s1.CurrRate); 
            
            SaveCount s2 = new SaveCount(3000);
            s2.CurrRate = 0.05;
            Console.WriteLine("当前s2利率: {0}",s2.CurrRate); 
            Console.WriteLine("当前s1利率: {0}",s1.CurrRate); 
        }
    }
}

编译 csc demo.cs

运行结果

可以看出对象 s2 改变了静态字段是影响到了对象 s1

 

静态类

        用 static 修饰的类称为静态类，静态类中成员只能为静态成员。静态通在开发中常用作为工具类，附送一段项目工程中的代码

using System;
using System.Text;
using System.IO;
using System.Xml.Serialization ;

namespace XXX.Common.Util
{
    // xml 序列化帮助类
    public static class XmlSerHelper
    {    
        // 序列化
        public static string XmlSer <T >( T t)
        {
            if(t == null ) return null;
            XmlSerializer ser = new XmlSerializer(t .GetType());
            using(StringWriter sw = new StringWriter())
            {
                ser .Serialize(sw,t );
                return sw. ToString();
            }
        }
      
        // 反序列化
        public static T XmlDeser <T>( string xml) where T : class
        {
            if(string .IsNullOrEmpty(xml )) return default (T );
            XmlSerializer ser = new XmlSerializer(typeof(T));
            using(StringReader reader = new StringReader(xml ))
            {
                try
                {
                    T item = ser. Deserialize(reader ) as T;
                    return item;
                }
                catch(Exception )
                {
                    return default (T);
                }
            }
        }
    }     
}

调用的方式为 string xmlStr = XXX.Common.Util.XmlSer<Type>(Instance);

 

静态构造器

静态构造器是个好玩的东西，它有如下特性：

1、一个给定的类（或结构）只能定义一个静态构造器

2、静态构造器仅执行一次，与创建了多少这种类型的对象无关

3、静态构造器不带访问修饰符，也不带任何参数

4、当静态构造函数创建这个类的实例时，或在调用者访问第一个静态成员之前，运行库会调用静态构造器

5、静态构造函数在任何实例级别的构造函数之前执行

看一个例子：

using System;
class SaveCount
{
    public double _currBalnce;
    private static double _curRate;
    
    public SaveCount(double blance)
    {    
        _currBalnce = blance;
        Console.WriteLine("Instance Ctor");
    }
    // 静态构造器
    static SaveCount()
    {
        Console.WriteLine("Static Ctor");
        _curRate = 0.4;
    }
    
    public double CurRate
    {
        get{return _curRate;}
        set{_curRate = value;}
    }
}

class App
{
    static void Main()
    {
        SaveCount s1 = new SaveCount(50);
        SaveCount s2 = new SaveCount(100);
        
        // 获取并设置s1 利率
        Console.WriteLine("当前s1利率 {0}",s1.CurRate);
        s1.CurRate = 0.08;
        
        SaveCount s3 = new SaveCount(150);
        Console.WriteLine("当前s3利率 {0}",s3.CurRate);
    }
}

编译 csc demo.cs

运行效果为

 

用静态构造器实现单例模式

代码如下(写法有好几种，下面的是最简单的)

public sealed class Singleton
{   
    // 不允许更改，只运行读，所以用 readonly
    // 为什么不用 const,因为const 必须在编译时确定值
    // 内联初始化，编译器会自己调用 staic constructor
    public readonly static Singleton instance = new Singleton();
    // 禁用到公有 构造器
    private Singleton ()
    {       
    }   
}

 

本文完