C#学习——序列化和反序列化练习的重构

目的：

       代码的重构！我上一次写的随笔“C#学习——序列化和反序列化”对接口的理解似乎有误，接口基本上没进行什么设计，之后虽然也重新设计了一下，

但是写了两个接口IDeserialize和ISerialize每个接口里面只有一方法，分别为反序列化和序列化，有点感觉过度设计，所以现在写了一篇

C#学习——序列化和反序列化练习的重构，来改正这一错误，这一例子觉得有一些地方写的不妥，希望大家觉得哪里不顺眼，踊跃发言哈！

 

示例：

 

       1、新建解决方案Serializer

 

      2、新建类库Jack.Gao.Domain，并在该类库下添加Person类，Person类的代码如下：

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.Serialization.Formatters;

namespace Jack.Gao.Domain
{
    [Serializable]
    public class Person
    {
        //如果不想实例化某一个字段，可以使用特性NonSerialized标记
        private int _id;
        public int Id
        {
            get { return _id; }
            set { _id = value; }
        }

        private string _name;
        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }

        private string _sex;
        public string Sex
        {
            get { return _sex; }
            set { _sex = value; }
        }
    }
}

 

      3、新建类库Jack.Gao.PersonFactory，在该库下新建Factory类，用于生成Person。代码如下：

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using Jack.Gao.Domain;

namespace Jack.Gao.PersonFactory
{
    public class Factory
    {
        #region Create Person
        public static Person CreatePerson()
        {
            return new Person();
        }
        #endregion       
    }
}

 

          添加枚举类型SerializerType，代码如下：

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Jack.Gao.PersonFactory
{
    public enum SerializerType
    {
        Xml,
        Binary,
        Soap
    }
}

 

            再新建一个类SerializerTypeFactory，用于根据类型生成某一特点的序列化方式。不过这里写的代码感觉不想面向对象的，写的有点烂。添加如下代码：

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using System.Xml.Serialization;
using System.Diagnostics;
using System.Runtime.Serialization.Formatters.Soap;
using Jack.Gao.Domain;

namespace Jack.Gao.PersonFactory
{
    public static class SerializerTypeFactory
    {
        public static object CreateSerializerType(SerializerType serializerType)
        {
            object serializer=null;

            switch (serializerType)
            {
                case SerializerType.Xml:
                     serializer = new XmlSerializer(typeof(Person));
                     break;
                case SerializerType.Binary:
                     serializer = new BinaryFormatter();
                     break;
                case SerializerType.Soap:
                     serializer = new SoapFormatter();
                     break;
                default:
                    throw new Exception("Type is not correctly!");
            }

            return serializer;
        }
    }
}

 

       4、新建类库Jack.Gao.Persistence，新建

ISerialize接口、SerializeBase抽象类、BinarySerializePerson、SoapSerializePerson、XmlSerializePerson这三个类分别实现了ISerialize接口。代码如下：

SerializeBase：

using System.IO;
using Jack.Gao.Domain;
using Jack.Gao.PersonFactory;

namespace Jack.Gao.Persistence.Base
{
    public abstract class SerializeBase
    {
        protected Person PersonBase { get; set; }

        protected virtual FileStream FileStreamBase { get; set; }

        public SerializeBase()
        {
            PersonBase = Factory.CreatePerson();
        }

        //public virtual void SerializePerson()
        //{
            
        //}

        //public virtual Person DeSerializePerson()
        //{
        //    return new Person();
        //}
    }
}

ISerialize：

using Jack.Gao.Domain;

namespace Jack.Gao.Persistence.Interface
{
    interface ISerialize
    {
        void SerializePerson();
        Person DeSerializePerson();
    }
}

BinarySerializePerson：

using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using Jack.Gao.Domain;
using Jack.Gao.Persistence.Base;
using Jack.Gao.Persistence.Interface;
using Jack.Gao.PersonFactory;

namespace Jack.Gao.Persistence.Implement
{
    public class BinarySerializePerson : SerializeBase,ISerialize
    {
        public void SerializePerson()
        {
            PersonBase.Id = 2;
            PersonBase.Name = "Jim";
            PersonBase.Sex = "Man";

            using (FileStreamBase = new FileStream("Person.txt", FileMode.Create))
            {
                BinaryFormatter binaryFormatter = (BinaryFormatter)SerializerTypeFactory.CreateSerializerType
                    (SerializerType.Binary);
                binaryFormatter.Serialize(FileStreamBase, PersonBase);
            }
        }

        public Person DeSerializePerson()
        {
            using (FileStreamBase = new FileStream("Person.txt", FileMode.Open))
            {
                BinaryFormatter binaryFormatter =
                    (BinaryFormatter)SerializerTypeFactory.CreateSerializerType(SerializerType.Binary);
                PersonBase = (Person)binaryFormatter.Deserialize(FileStreamBase);
            }

            return PersonBase;
        }
    }
}

SoapSerializePerson：

using System.IO;
using System.Runtime.Serialization.Formatters.Soap;
using Jack.Gao.Domain;
using Jack.Gao.Persistence.Base;
using Jack.Gao.Persistence.Interface;
using Jack.Gao.PersonFactory;

namespace Jack.Gao.Persistence.Implement
{
    public class SoapSerializePerson : SerializeBase,ISerialize
    {
        public void SerializePerson()
        {
            PersonBase.Id = 3;
            PersonBase.Name = "Green";
            PersonBase.Sex = "Woman";

            using (FileStreamBase = new FileStream("Person.xml", FileMode.Create))
            {
                SoapFormatter soapFormatter = (SoapFormatter)SerializerTypeFactory.
                    CreateSerializerType(SerializerType.Soap);
                soapFormatter.Serialize(FileStreamBase, PersonBase);
            }
        }

        public Person DeSerializePerson()
        {
            using (FileStreamBase = new FileStream("Person.xml", FileMode.Open))
            {
                SoapFormatter soapFormatter = (SoapFormatter)SerializerTypeFactory.
                    CreateSerializerType(SerializerType.Soap);
                PersonBase = (Person)soapFormatter.Deserialize(FileStreamBase);
            }

            return PersonBase;
        }
    }
}

XmlSerializePerson：

using System.IO;
using System.Xml.Serialization;
using Jack.Gao.Domain;
using Jack.Gao.Persistence.Base;
using Jack.Gao.Persistence.Interface;
using Jack.Gao.PersonFactory;

namespace Jack.Gao.Persistence.Implement
{
    public class XmlSerializePerson : SerializeBase,ISerialize
    {
        public void SerializePerson()
        {
            using (FileStreamBase= new FileStream("Person.xml", FileMode.Create))
            {
                PersonBase.Id = 1;
                PersonBase.Name = "Jack Gao";
                PersonBase.Sex = "Man";

                XmlSerializer xmlSerializer = (XmlSerializer)SerializerTypeFactory.
                    CreateSerializerType(SerializerType.Xml);
                xmlSerializer.Serialize(FileStreamBase, PersonBase);
            }
        }

        public Person DeSerializePerson()
        {
            using (FileStreamBase = new FileStream("Person.xml", FileMode.Open))
            {
                XmlSerializer xmlSerializer = (XmlSerializer)SerializerTypeFactory.
                    CreateSerializerType(SerializerType.Xml);
                PersonBase = (Person)xmlSerializer.Deserialize(FileStreamBase);
            }

            return PersonBase;
        }
    }
}

      5、新建控制台输出程序Jack.Gao.AppSerializer，在Program.cs添加如下代码：

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Diagnostics;

using Jack.Gao.Domain;
using Jack.Gao.Persistence;
using Jack.Gao.Persistence.Implement;

namespace Jack.Gao.AppSerializer
{
    class Program
    {
        private static Person _person=null;

        static void Main(string[] args)
        {
            //XmlSerializePerson xmlSerializePerson = new XmlSerializePerson();
            //xmlSerializePerson.SerializePerson();
            //ShowIsSuccess();

            //_person = xmlSerializePerson.DeSerializePerson();
            //Console.WriteLine(_person.Id);
            //Console.WriteLine(_person.Name);
            //Console.WriteLine(_person.Sex);

            BinarySerializePerson binarySerializePerson = new BinarySerializePerson();
            binarySerializePerson.SerializePerson();
            ShowIsSuccess();

            _person = binarySerializePerson.DeSerializePerson();
            Console.WriteLine(_person.Id);
            Console.WriteLine(_person.Name);
            Console.WriteLine(_person.Sex);

            //SoapSerializePerson soapSerializePerson = new SoapSerializePerson();
            //soapSerializePerson.SerializePerson();
            //ShowIsSuccess();

            //_person = soapSerializePerson.DeSerializePerson();
            //Console.WriteLine(_person.Id);
            //Console.WriteLine(_person.Name);
            //Console.WriteLine(_person.Sex);

            Console.ReadKey();
        }

        private static void ShowIsSuccess()
        {
            if (IsExitFile())
            {
                Console.WriteLine("Create File sucessfull.");
            }
            else
            {
                Console.WriteLine("Create File error.");
            }
        }

        private static bool IsExitFile()
        {
            bool exitXmlFile = false;

            string currentApplicationPath = Process.GetCurrentProcess().MainModule.FileName;

            if (!string.IsNullOrEmpty(currentApplicationPath))
            {
                exitXmlFile = true;
            }

            return exitXmlFile;
        }
    }
}

 

           运行该程序，可以看到在输出目录下多了一个Person.xml的文件，可以查看里面的内容，以下内容使用soap序列化后生成的，你也可以查看其它的两种方式生成的内容。