More Effective C# Item4 : 使用泛型强制编译期类型推断

    模式的作用在于标准化那些尚未被语言或者框架直接支持的常见算法逻辑。遵循模式即可解决一类常见的问题。提供模式是为了在无法进行代码层面的重用时，也能给出一定程度上编程思想的重用。若使用模式无法得到最优化方案，那是因为很难从模式的实现代码中分离开所有的特殊部分。

    泛型类能够帮助你实现很多常用的、可重用的模式。模式的本质在于它必定包含一系列通用的算法和代码，支持应用于应用程序中各种特定类型上。泛型无法应用于每个模式，不过却能极大地减少实现某个模式所需要的代码。

    我们来看下面的示例，来使用XML序列化器对对象进行序列化，首先是非泛型版本的。

public class XmlPersistenceManager
{
    public static object LoadFormFile(Type typeToLoad, string filePath)
    {
        if (!File.Exists(filePath))
        {
            return default(object);
        }
        XmlSerializer factory = new XmlSerializer(typeToLoad);
        using (TextReader reader = new StreamReader(filePath))
        {
            return factory.Deserialize(reader);                
        }            
    }

    public static void SaveToFile(string filePath, object obj)
    {
        if (!File.Exists(filePath))
        {
            return;
        }

        Type typeToLoad = obj.GetType();
        XmlSerializer factory = new XmlSerializer(typeToLoad);
        using (TextWriter writer = new StreamWriter(filePath))
        {
            factory.Serialize(writer, obj);    
        }
    }
}

    上述代码已经提供了一个可以重用的接口，在很大程度上，可以解决使用者遇到的问题。但是上述的做法有以下几个不完美的地方：

1. 在LoadFromFile()方法和SaveToFile()方法中，每次调用时都要重新创建一个XmlSerializer对象，虽然.NET框架已经尽可能的降低了创建对象所花费的开销，但还是需要尽量避免创建不必要的对象。
2. 来看一下LoadFromFile()的返回值，是一个System.Object类型，对于使用者来说，需要类型转换，这样做会带来不方便。

    为了解决上述两个问题，我们需要进行一些思考和改善，首先，我们是否可以向以下这种方式来修改代码呢？

public class XmlPersistenceManager
{
    private static XmlSerializer factory = null;
    public static object LoadFormFile(Type typeToLoad, string filePath)
    {
        if (!File.Exists(filePath))
        {
            return default(object);
        }
        //XmlSerializer factory = new XmlSerializer(typeToLoad);
         if (factory == null)
        {
            factory = new XmlSerializer(typeToLoad);
        }
        using (TextReader reader = new StreamReader(filePath))
        {
            return factory.Deserialize(reader);                
        }            
    }

    public static void SaveToFile(string filePath, object obj)
    {
        if (!File.Exists(filePath))
        {
            return;
        }

        Type typeToLoad = obj.GetType();
        //XmlSerializer factory = new XmlSerializer(typeToLoad);
         if (factory == null)
        {
            factory = new XmlSerializer(typeToLoad);
        }
        using (TextWriter writer = new StreamWriter(filePath))
        {
            factory.Serialize(writer, obj);    
        }
    }
}

    上述代码并没有解决问题，反而又引发了一些其他问题，如果两次调用XmlPersistenceManager时，第二次调用时，XmlSerializer实例中的类型使用的是第一次调用时的类型，很显然这是不正确的。

    我们可以使用泛型的方式来解决上述的两个问题，来看下面的代码。

public class XmlPersistenceManager<T>
{
    private static XmlSerializer factory = null;

    public static T LoadFormFile(string filePath)
    {
        if (!File.Exists(filePath))
        {
            return default(T);
        }
        if (factory == null)
        {
            factory = new XmlSerializer(typeof(T));
        }
        using (TextReader reader = new StreamReader(filePath))
        {
            return (T)factory.Deserialize(reader);
        }
    }

    public static void SaveToFile(string filePath, T data)
    {
        if (!File.Exists(filePath))
        {
            return;
        }
        if (factory == null)
        {
            factory = new XmlSerializer(typeof(T));
        }
        using (TextWriter writer = new StreamWriter(filePath))
        {
            factory.Serialize(writer, data);
        }
    }
}

    我们来看一下，针对第一个问题，上述中factory作为全局变量，是不会产生之前代码的问题的，因为对于泛型来说，factory针对每一种泛型类型，只会保留一个实例；针对第二个问题，我们来看一下LoadFromFile()方法，它的返回值已经是泛型类型了。

    下面我们来看一下针对上述代码的测试程序。

[Serializable]
 public class Employee
{
    private string m_strName;

    [XmlElement("Name")]
    public string Name
    {
        get { return m_strName; }
        set { m_strName = value; }
    }

    private string m_strAddress;

    [XmlElement("Address")]
    public string Address
    {
        get { return m_strAddress; }
        set { m_strAddress = value; }
    }

    public override string ToString()
    {
        return string.Format("{0},{1}", m_strName, m_strAddress);
    }
}


    private static void TestWithoutGenerics()
    {
        Console.WriteLine("TestWithoutGenerics:");
        Employee empA = new Employee();
        empA.Name = "Wing";
        empA.Address = "BeiJing";
        Console.WriteLine(empA.ToString());
        XmlPersistenceManager.SaveToFile(@"D:\ConfigSample.xml", empA);

        Object obj = XmlPersistenceManager.LoadFormFile(typeof(Employee), @"D:\ConfigSample.xml");
        if (obj is Employee)
        {
            Console.WriteLine((obj as Employee).ToString());
        }
    }

    private static void TestWithGenerics()
    {
        Console.WriteLine("TestWithGenerics:");
        Employee empA = new Employee();
        empA.Name = "UnKnown";
        empA.Address = "Moon";
        Console.WriteLine(empA.ToString());
        XmlPersistenceManager<Employee>.SaveToFile(@"D:\ConfigSample.xml", empA);

        Employee empTemp = XmlPersistenceManager<Employee>.LoadFormFile(@"D:\ConfigSample.xml");
        Console.WriteLine(empTemp.ToString());
    }

    总结：在实现某一算法逻辑时，我们很多时候需要知道传入参数的类型，这时，通常可以创建一个泛型的实现，将方法的类型参数抽象到泛型参数中，随后编译器即可根据泛型参数创建出所需要的类型。