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 ()

    {       

    }   

}

 

本文完