一、 static 多对象共享一段空间，或者说没有对象概念，就是类的概念，不需要实例化，自动被创建。多用于长期共享。不会为对象的创建或销毁而消失。
public class C
{ static A a = new A("C 创建A",) public A Ci
{
get
{
return a;
} } public C(A b)
{
a = b;
Console.WriteLine("构造" + a.Presentation);
} //public static void Set()
//{
// a = new A("", 11);
//} } public class A
{
private string _presentation;
private int _intvalue = -; public int A1
{
get
{
return _intvalue;
}
} public string Presentation
{
get
{
return _presentation;
}
} public A(string presentation, int intvalue)
{
_presentation = presentation;
_intvalue = intvalue;
Console.WriteLine("构造A类" + presentation + "," + intvalue);
}
}
以上代码有几点说明
1.在C类创建静态A时，虽然在字段中（实建C类会自动创建一个静态构造方法，它会把类中声明的字段初始化值全放在你定义的前面,也就是后面的值可以随时改变字 段的定义的值）
2.Static A类也就是上面a,可以随时被定义成别的对象
3.Static 是什么？就是在单个进程中仅仅保留一份。而它又可以随时被读写。
static void Main(string[] args)
{
A a1 = new A("a1", );
A a2 = new A("a2", );
C c1 = new C(a1);
C c2 = new C(a2);
Console.WriteLine(object.ReferenceEquals(c1.Ci, c2.Ci)); Console.ReadKey(); }
二、readonly人们常常与const相比，我不解释值类型readonly的问题，只说明引用类型readonly,只读，不会被改变，最直接了解。
public class C
{ readonly A a = new A("",); public A Ci
{
get
{
return a;
}
//set
//{
// a = value;//别试图在类内部使用时改变它的引用
//} } public C(A b)
{
a = b;//仅仅是在构方法内被初始化
Console.WriteLine("构造" + a.Presentation);
} //public static void Set()
//{
// a = new A("改变", 10000);
//}
}
说明：
1.readonly仅仅可以在构造方法中初始化（字段中一样）
2.readonly不可能在静态构造方法中初始化
3.在类中的任何地方，都无法改变readonly的值（无论是值类型，还是引用类型）
4.为了保证类内部中被调用的稳定性，不会被改变，readonly吧！
5.在不同类中有不同的readonly指向不同地址。也就是多类中保留多份
然而，第三点是有条件的它不能是IEnumerable（最后说明这一点）
public class B
{
readonly IList<A> geta = new List<A>();
public IList<A> GetA
{
get { return geta; } } public int B1
{
get;
set;
} public B()
{
GetA.Add(new A("B内部创建", ));
Console.WriteLine(geta[].Presentation);
}
}
static void Main(string[] args)
{
A a1 = new A("a1", );
A a2 = new A("a2", );
B b = new B();
b.GetA[] = a1;
Console.WriteLine(b.GetA[].Presentation);
Console.ReadKey(); }
被改变了，readonly面对IEnumerable时，一，虽然IList只读，同样会被改变，二、可以从外面很容易通过属性方法改变Ilist所引用的地址。虽然我给A类重载了
Equals和GetHashCode，可依然改变了，看来IEnumerable.add不会判断这个。(这点我希望能给我指正原理性问题）
（今天修改一下我的这个内容，readonly锁定的是IEnumerable，不是内部元素，也就是锁定的是IEnumerable本身地址不会改变）
三、static readonly 根据上面的定义，做了以下假设，
1，肯定需要构造方法中定义（静态的，还是默认的？)
2 .进程中保留一份还是多份，?
3。在类中可以改变吗？
public class C
{ static readonly A a = new A("A1",); public A Ci
{
get
{
return a;
}
//set
//{
// a = value;//别试图在类内部使用时改变它的引用
//}
} public C()
{
// a = new A("A3", 333); 也不可以这里定义
Console.WriteLine("构造C类" + a.Presentation);
}
static C()
{
a = new A("A2", );
Console.WriteLine("构造C静态类" + a.Presentation);
} //public static void Set()
//{
// a = new A("改变", 10000);//也不可以这里改变
//}
}
static void Main(string[] args)
{
A a1 = new A("a1", );
A a2 = new A("a2", );
C c1 = new C();
C c2 = new C();
Console.WriteLine(object.ReferenceEquals(c1.Ci, c2.Ci)); Console.ReadKey(); }
上面的结果
构造A类a1,11
构造A类a2,12
构造A类A1,1111
构造A类A2,2222
构造C静态类A2
构造C类A2
构造C类A2
True
说明：
1.如果一个静态构造方法与一个构造方法同时存在，首先静态构造方法执行，然后是构造方法
2在任何一个构造方法中都会把字段的值重新被定义。
以上是任一本原理书都可以找到的重点是回答上面问题
1.只有静态构造方法可以初始化static readonly
2.进程中仅保留一份
3.类中不可以改原有的值。
想想我们的单例为什么那样创建（上一篇说过http://www.cnblogs.com/shouhongxiao/p/3530091.html），我们单例就是想在一个进程中只保留一份，且不会被已经进入类中多线程改变已经创建的对象，当然是双重锁定了
if (null == instance)
{
lock (threadSafeLocker)
{
if (null == instance)
{
instance = new VFactory; }
}
}
第一个null = instance 解决效率问题（如果多线程进入对象被创建，就不需lock了）
第二个就是防止已经进入多线程改变
第三个肯定是一个单线程进入了（判断对象是否被创建）
那我们就创建了一份且只有一份，而且不会被进入的多线程改变的单例。
总结一下:static 是为了保证共性(多对象共享，一损具损)，readonly是了了保持个性(每个单一对象有自己固定的特性),static readonly ？这世界上仅有我一个，有个性的我。