用泛型来实现编译时期的类型推断

    第一章都是讲泛型的，距离上一篇Effective C#的随笔已经是很久以前的事情了。。。

    今天Item4，讲的是泛型的类型推断功能。东西好不好，都是比较出来了，当然也不是绝对的好或者绝对的不好。

    首先上一段不用泛型的代码。 

 

public static class XmlPersistenceManager
{
    public static object LoadFromFile(Type typeToLoad, string filePath)
    {
        XmlSerializer factory = new XmlSerializer(typeToLoad);
        if (File.Exists(filePath)) {
            using (TextReader tr = new StreamReader(filePath)) {
                object rVal = factory.Deserialize(tr);
                return rVal;
            }
        }
        return default(object);//null
    }
    public static void SaveToFile(string filePath, object obj)
    {
        Type theType = obj.GetType();
        XmlSerializer factory = new XmlSerializer(theType);
        using (var sw = new StreamWriter(filePath, false)) {
            factory.Serialize(sw, obj);
        }
    }
}

两个方法，一个读取Xml生成Object的实例，另一个把一个obj保存成一个Xml。这里有几个缺点

①每次调用LoadFromFile方法，必须有一个类型转换，从Object转成自己要的类型，写的时候肯定不会报错的，因为Object是所有类型的基类，但是运行的时候，就不一定了~~ 。

②这是一个性能问题。每次调用这两个方法的时候，都重新new 了一个XmlSerializer对象。Framework的设计者是会尽量降低new对象的代价，但毕竟是需要创建，然后销毁一些零时的变量。

看到第二点，大家都会想到把XmlSerializer类型对象factory作为一个XmlPersistenceManager的静态成员变量。

看到第二点可能会写出下面的代码。

public static class XmlPersistenceManager2
{
    private static XmlSerializer factory;
    public static object LoadFromFile(Type typeToLoad, string filePath)
    {
        if (factory == null)
            factory = new XmlSerializer(typeToLoad);

        if (File.Exists(filePath)) {
            using (TextReader tr = new StreamReader(filePath)) {
                object rVal = factory.Deserialize(tr);
                return rVal;
            }
        }
        return default(object);//null
    }
    public static void SaveToFile(string filePath, object obj)
    {
        Type theType = obj.GetType();
        if (factory == null) factory = new XmlSerializer(theType);
        using (var sw = new StreamWriter(filePath, false)) {
            factory.Serialize(sw, obj);
        }
    }
}

性能问题是解决了，但是，明显，有个bug。20行，先ClassA类型的obj调用，factory生成一个实例，木有问题；然后来一个ClassB类型的obj调用，factory ！= null ；然后，22行，调用，异常就来了。 原先我以为是不会出错的，充其量应该只是生成一个空的xml文件，但原文用了Exception这个词，然后自己测试了一下。证明，我错了，确实是Exception，再看一下代码，factory实例化的时候传入了参数theType。为什么要传这个参数呢？我想应该还是性能问题吧。new 一个 XmlSerializer 之后肯定不会只（反）序列化同类型的对象一次。

要解决这个bug也很容易，用一个Dictionary来存XmlSerializer对象。。。但是这样意味着要写更多代码，写更多编译器和JIT引擎可以帮你实现的代码。

接下来泛型上场，原文叫“correct answer”。

public static class GenericXmlPersistenceManager<T>
{
    private static XmlSerializer factory;
    public static T LoadFromFile(string filePath)
    {
        if (File.Exists(filePath)) {
            using (XmlReader inputStream = XmlReader.Create(filePath)) {
                if (factory == null) factory = new XmlSerializer(typeof(T));
                T rVal = (T)factory.Deserialize(inputStream);
                return rVal;
            }
        }
        return default(T);
    }
    public static void SaveToFile(string filePath, T data)
    {
        using (XmlWriter writer = XmlWriter.Create(filePath)) {
            if (factory == null) factory = new XmlSerializer(typeof(T));
            factory.Serialize(writer, data);
        }
    }
}

代码上和最初的版本没有什么太大差异。解决了原先的几个问题。

①类型转换。泛型类中的LoadFromFile方法，返回的类型其实已经被限定了，就是T类型，至于T具体是什么类型，就看自己在调用的时候尖括号之间写的具体的值了。

②性能问题和那个Exception bug。用了静态变量，缓存了XmlSerializer对象，当序列化同个类型的obj的时候，不需再去重新new一个XmlSerializer。并且，如果传入了不同类型的obj，也会重新new一个对应类型的XmlSerializer 类型的factory，这样就不会报错。（想到一个问题，写完之后查资料了解一下）。

最后一段：

很多时候如果用了Type类型的参数，通常都可以定义出一个泛型的版本。编译器就会 “Create the Specific version for you.”。