[Serializable]
    public class MyClass
    {
        public string Name
        {
            get;
            set;
        }

        public int Age
        {
            get;
            set;
        }
    }

        在对像上加个[Serializable]属性就是告诉编译器该类是可以被序列化的，

        对客户端还要使用有命名空间System.Runtime.Serialization.Formatters.Binary中的BinaryFormatter类，将MyClass 的对像序列化成二进制的文件流写入到文件中

        客户端例子

            MyClass my = new MyClass();
            my.Name = “sherlock”;
            my.Age = int.MaxValue;
            System.Runtime.Serialization.IFormatter formatter = new BinaryFormatter();

            //创建一个文件流
            Stream stream = new FileStream(@”c:\MyClass.bin”, FileMode.Create, FileAccess.Write);

            using (stream)
            {
                //这里就是进行序列化了
                formatter.Serialize(stream, my);
            }

        对像被序列化进去了。当你的程序闭关下次要用的时候就将c:\MyClass.bin的文件反序列化出来就好了，反序列化出来的对像的Nam值还是凤姐，Age值还是int.MaxValue

        现在我将介绍如何反序列化

        客户端例子

            //不用NEW了反序列化后会给出一个该对像的引用
            MyClass my;
            System.Runtime.Serialization.IFormatter formatter = new BinaryFormatter();

            //打开一个文件流
            Stream stream = new FileStream(@”c:\MyClass.bin”, FileMode.Open, FileAccess.Read);

            using (stream)
            {
                //这里就是反进行序列化了
                my = (MyClass)formatter.Deserialize(stream);
            }

        现在最简单的 序列化和反序列化都介绍完了大家可以看出，我们不用去把数据库在数据库中在去数据库取数据构造对像，序列化的功能在一些特殊的场景还是比较方便的

        序列化引用类型

        序列化类默认的情况下是要求他的所有的成员都是要可序列化的（除事件、委托、显式定义不可序列化）

  [Serializable]
    public class MyClass
    {
        public string Name
        {
            get;
            set;
        }
        public int Age
        {
            get;
            set;
        }
        public Work MyWork
        {
            get;
            set;
        }
    }

    [Serializable]
    public class Work
    {
        public string Name
        {
            set;
            get;
        }
        public string Address
        {
            set;
            get;
        }
    }

        其实很简单的，就是把MyClass类中有的类成员都加上为[Serializable]属性即可，.NET会去MyClass中遍历所有的成员，智能的跳过类的循环引用。如果MyClass中的Work类型不加[Serializable]属性，那就是说Work不可序列化，那.NET就会报出错误。

        不可序列化成员

        如果你在MyClass中有个SqlConnection类型成员，大家都知道SqlConnection中管理的是数据库的连接，不好被序列化，所以我们在设计的时候不能把SqlConnection序列化了，我们要在SqlConnection的成员中把它加上 [NonSerialized]属性告诉.NET这个类不要被序列化，当反序列化的时候SqlConnection就为null。

 [Serializable]
    public class MyClass
    {
        public string Name
        {
            get;
            set;
        }
        public int Age
        {
            get;
            set;
        }
        [NonSerialized]
        Work myWork;

        public Work MyWork
        {
            get
            {
                return myWork;
            }
            set
            {
                myWork = value;
            }
        }
    }

    public class Work
    {
        public string Name
        {
            set;
            get;
        }
        public string Address
        {
            set;
            get;
        }
    }

        这样Work对像就不会被序列化到文件流中，当被反序列化时就MyWork属性就为null了。

        序列化SOAP文件

        要序列化成SOAP就要先用引用System.Runtime.Serialization.Formatters.Soap命名空间中的SoapFormatter类了。SoapFormatter是一个Soap的格式器

 [Serializable]
    public class MyClass
    {
        public string Name
        {
            get;
            set;
        }
        public int Age
        {
            get;
            set;
        }
        public Work MyWork
        {
            get;
            set;
        }
    }

    [Serializable]
    public class Work
    {
        public string Name
        {
            set;
            get;
        }
        public string Address
        {
            set;
            get;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            MyClass my = new MyClass();
            my.Name = “凤姐”;
            my.Age = int.MaxValue;

            Work work = new Work();
            work.Address = “你家隔壁”;
            work.Name = “不知道”;
            my.MyWork = work;

            //这里new 的是Soap格式的了
            System.Runtime.Serialization.IFormatter formatter = new SoapFormatter();

            //创建一个文件流
            Stream stream = new FileStream(@”c:\MyClass.xml”, FileMode.Create, FileAccess.Write);

            using (stream)
            {
                //这里就是进行序列化了
                formatter.Serialize(stream, my);
            }
        }
    }

        这样子就把”凤姐”这个对像序列成SOAP格式，生成到你的C盘里了

        SOAP格式的序列化文件就有一定的可读性了，这样就可以更好的跨平台的反序列化对像了。不过从速度上来说，当然还是二进制文件更快，可是二进制文件不好进行跨平台的反序列化，各有各的优点吧。

        序列化泛型

其实泛型和非泛型其实没有什么不同，不过要注意以下两点：

1.泛型只支持BinaryFormatter格式，不支持SOAP格式

2.泛型序列化的类型和反序列化的类型要一致，如果把MyClass<int> 类型序列化，你不能反序列化出MyClass<string>类型。

  [Serializable]
    public class MyClass<T>
    {
        public string Name
        {
            get;
            set;
        }
        public int Age
        {
            get;
            set;
        }
        public T MyWork
        {
            get;
            set;
        }
    }

    [Serializable]
    public class Work
    {
        public string Name
        {
            set;
            get;
        }
        public string Address
        {
            set;
            get;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            MyClass<Work> my = new MyClass<Work>();
            my.Name = “凤姐”;
            my.Age = int.MaxValue;

            Work work = new Work();
            work.Address = “你家隔壁”;
            work.Name = “不知道”;
            my.MyWork = work;

            //泛型只支持BinaryFormatter格式，不支持SOAP格式
            System.Runtime.Serialization.IFormatter formatter = new BinaryFormatter();

            //创建一个文件流
            Stream stream = new FileStream(@”c:\MyClass.bin”, FileMode.Create, FileAccess.Write);

            using (stream)
            {
                //这里就是进行序列化了
                formatter.Serialize(stream, my);
            }
        }
    }

我们利用OnDeserialized属性事件人工完成了SqlConnection的反序列化。

注意:

1.事件的签名一定要是 void <方法名>(StreamingContext context)这个样子的，context只有在高级的场景中才用到，现在先不讨论。

2.最好是把事件方法写成私有的，以避免子类的重载件方法产生异常。

public string Utf8ToGB2312(string utf8String)
{
Encoding fromEncoding = Encoding.UTF8;
Encoding toEncoding = Encoding.GetEncoding(“gb2312″);
return EncodingConvert(utf8String, fromEncoding, toEncoding);
}

public string EncodingConvert(string fromString, Encoding fromEncoding, Encoding toEncoding)
{
byte[] fromBytes = fromEncoding.GetBytes(fromString);
byte[] toBytes = Encoding.Convert(fromEncoding, toEncoding, fromBytes);

string toString = toEncoding.GetString(toBytes);
return toString;
} ]]> http://www.9tongz.com/sherlock/?feed=rss2&p=155 0