不可变对象
不可变(immutable)： 即对象一旦被创建初始化后，它们的值就不能被改变，之后的每次改变都会产生一个新对象。
var str="mushroomsir";
str.Substring(0, 6)
</div>
c#中的string是不可变的，Substring(0, 6)返回的是一个新字符串值，而原字符串在共享域中是不变的。另外一个StringBuilder是可变的，这也是推荐使用StringBuilder的原因。
var age=18;
</div>
当存储值18的内存分配给age变量时，它的内存值也是不可以被修改的。
age=2;
</div>
此时会在栈中开辟新值2赋值给age变量，而不能改变18这个内存里的值，int在c#中也是不可变的。
class Contact
{
public string Name { get; set; }
public string Address { get; set; }
public Contact(string contactName, string contactAddress)
{
Name = contactName;
Address = contactAddress;
}
}
var mutable = new Contact("二毛", "清华");
mutable.Name = "大毛";
mutable.Address = "北大";
</div>
我们实例化MutableContact赋值给mutable，随后我们可以修改MutableContact对象内部字段值，它已经不是初始后的值，可称为可变(mutable)对象。
可变对象在多线程并发中共享，是存在一些问题的。多线程下A线程赋值到 Name = "大毛" 这一步，其他的线程有可能读取到的数据就是：
mutable.Name == "大毛";
mutable.Address == "清华";
</div>
很明显这样数据完整性就不能保障，也有称数据撕裂。我们把可变对象更改为不可变对象如下：
public class Contact2
{
public string Name { get; private set; }
public string Address { get; private set; }
private Contact2(string contactName, string contactAddress)
{
Name = contactName;
Address = contactAddress;
}
public static Contact2 CreateContact(string name, string address)
{
return new Contact2(name, address);
}
}
</div>
使用时只能通过Contact2的构造函数来初始化Name和Address字段。Contact2此时即为不可变对象，因为对象本身是个不可变整体。通过使用不可变对象可以不用担心数据完整性，也能保证数据安全性，不会被其他线程修改。
自定义不可变集合
我们去枚举可变集合时，出于线程安全的考虑我们往往需要进行加锁处理，防止该集合在其他线程被修改，而使用不可变集合则能避免这个问题。我们平常使用的数据结构都是采用可变模式来实现的，那怎么实现一个不可变数据结构呢！以栈来示例，具体代码如下：
public interface IStack<T> : IEnumerable<T>
{
IStack<T> Push(T value);
IStack<T> Pop();
T Peek();
bool IsEmpty { get; }
}
public sealed class Stack<T> : IStack<T>
{
private sealed class EmptyStack : IStack<T>
{
public bool IsEmpty { get { return true; } }
public T Peek() { throw new Exception("Empty stack"); }
public IStack<T> Push(T value) { return new Stack<T>(value, this); }
public IStack<T> Pop() { throw new Exception("Empty stack"); }
public IEnumerator<T> GetEnumerator() { yield break; }
IEnumerator IEnumerable.GetEnumerator() { return this.GetEnumerator(); }
}
private static readonly EmptyStack empty = new EmptyStack();
public static IStack<T> Empty { get { return empty; } }
private readonly T head;
private readonly IStack<T> tail;
private Stack(T head, IStack<T> tail)
{
this.head = head;
this.tail = tail;
}
public bool IsEmpty { get { return false; } }
public T Peek() { return head; }
public IStack<T> Pop() { return tail; }
public IStack<T> Push(T value) { return new Stack<T>(value, this); }
public IEnumerator<T> GetEnumerator()
{
for (IStack<T> stack = this; !stack.IsEmpty; stack = stack.Pop())
yield return stack.Peek();
}
IEnumerator IEnumerable.GetEnumerator() { return this.GetEnumerator(); }
}
</div>
1.入栈时会实例化一个新栈对象
2.将新值通过构造函数传入，并存放在新对象Head位置，旧栈对象放在在Tail位置引用
3.出栈时返回当前栈对象的Tail引用的栈对象
使用方法如下：
IStack<int> s1 = Stack<int>.Empty;
IStack<int> s2 = s1.Push(10);
IStack<int> s3 = s2.Push(20);
IStack<int> s4 = s3.Push(30);
IStack<int> v3 = s4.Pop();
foreach (var item in s4)
{
//dosomething
}
</div>
每次Push都是一个新对象，旧对象不可修改，这样在枚举集合就不需要担心其他线程修改