IL入门之旅（三）——Dump对象

Dump对象

    一个成熟的系统，都少不了一个强大的Log，而Log通常需要把当时的对象的很多信息记录下来，因此Dump对象的功能在很多场合下都会使用到。

    那么来看看普通的Dump如何实现：

public class Foo
{
    public string Bar { get; set; }
    public int FooBar { get; set; }
}

Foo foo = new Foo { Bar = "Bar", FooBar = 100, };
Trace.TraceInformation("Foo: Bar=" + foo.Bar + ",FooBar=" + foo.FooBar.ToString());

    如此，就把Foo实例的内容记录到Log中，但是，思考一下，如果有100多个地方需要记录Foo对象，就需要写100多遍这样的代码吗?

    当然不会这么傻啦，利用扩展方法可以很简单实现：

public static string Dump(this Foo foo)
{
    return "Foo: Bar=" + foo.Bar + ",FooBar=" + foo.FooBar.ToString();
}

Foo foo = new Foo { Bar = "Bar", FooBar = 100, };
Trace.TraceInformation(foo.Dump());

    看起来是不是简单多了，当时，如果有100个不同的类型需要Dump，那么就需要100多个扩展方法，并且需要经常性的维护之间的关系。

    别忘了，.net的还有强大的反射，来想想反射如何实现：

public static string Dump(this object obj)
{
    return obj.GetType().Name + ": " + string.Join(",",
        (from p in obj.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public)
         where p.GetGetMethod() != null && p.GetIndexParameters().Length == 0
         select p.Name + "=" + p.GetValue(obj, null)).ToArray());
}

    如此简单的就打造了一个近乎万能的Dump方法，不过，别忘了反射的代价：性能。在大多数情况下，使用这种方式的性能损失是可以接受的，但是，如果在一个要求高性能的系统下，这样的性能损失缺是需要深入思考的问题。

目标制定

    于是，本文的核心命题就变成寻找一个高性能的并且统一的Dumper。

    当然，限于篇幅，需要做明确要实现的Dump的实现范围：

• 仅仅Dump编译时已知的类型（为了最大限度的利用泛型的性能优势）
• 仅仅Dump第一层公开实例属性（如果支持Nest，会使问题复杂化）
• 需要支持null
• 需要支持结构体
• 需要支持可空类型

准备外壳

    那么首先准备一下Dump的外壳：

public static string Dump<T>(this T obj)
{
    var writer = new StringWriter();
    DumpCore<T>(obj, writer, null);
    return writer.ToString();
}

public static string Dump<T>(this T obj, string separator)
{
    var writer = new StringWriter();
    DumpCore<T>(obj, writer, separator);
    return writer.ToString();
}

public static void Dump<T>(this T obj, StringBuilder builder)
{
    if (builder == null)
        throw new ArgumentNullException("builder");
    DumpCore(obj, new StringWriter(builder), null);
}

public static void Dump<T>(this T obj, StringBuilder builder, string separator)
{
    if (builder == null)
        throw new ArgumentNullException("builder");
    DumpCore(obj, new StringWriter(builder), separator);
}

public static void Dump<T>(this T obj, TextWriter writer)
{
    if (writer == null)
        throw new ArgumentNullException("writer");
    DumpCore(obj, writer, null);
}

public static void Dump<T>(this T obj, TextWriter writer, string separator)
{
    if (writer == null)
        throw new ArgumentNullException("writer");
    DumpCore(obj, writer, separator);
}

    其中separator是用于连接属性的分隔符。

    所有的Dump方法仅仅检查一下参数，然后调用DumpCore方法，那么DumpCore方法如何实现哪？

    想想还是不太好办啊，算了再转嫁一次：

private static void DumpCore<T>(this T obj, TextWriter writer, string separator)
{
    DumperImpl<T>.Action(writer, obj, separator ?? Environment.NewLine);
}

    现在从DumpCore变成了DumperImpl<T>了，然后这个类型怎么实现哪？

准备内核

    现在想想DumperImpl<T>的骨架：

private static class DumperImpl<T>
{
    public readonly static Action<TextWriter, T, string> Action = CreateAction();

    private static Action<TextWriter, T, string> CreateAction()
    {
        throw new NotImplementedException();
    }
}

    这里利用静态构造函数只会运行一次的特性，让CLR帮助我们做同步。

    来看看CreateAction方法的实现，这个方法需要创建一个Action，第一个参数是TextWriter，用于写入Dump的内容，第二个参数是T，也就是被Dump的对象，第三个参数是separator，用于分割内容属性。

    当然这个Action不可能是现成的，所以需要一个DynamicMethod，于是代码就变成了这样：

private static Action<TextWriter, T, string> CreateAction()
{
    DynamicMethod dm = new DynamicMethod(string.Empty, typeof(void),
        new Type[] { typeof(TextWriter), typeof(T), typeof(string) });
    var il = dm.GetILGenerator();
    // string temp;
    var temp = il.DeclareLocal(typeof(string));
    ProcessWhenObjIsNull(il);
    WriteProperties(il, temp);
    il.Emit(OpCodes.Ret);
    return (Action<TextWriter, T, string>)dm.CreateDelegate(typeof(Action<TextWriter, T, string>));
}

    里面有2个方法需要处理，一个是ProcessWhenObjIsNull，用于处理对象是null的情况，第二个是WriteProperties，用于Dump对象的属性。

    先来看看第一个，不过先想一下，T在什么情况下，obj可以是null：

• 首先，T是引用类型
• 其次，T是可空类型

    那么，也就是需要对这两个情况需要添加null检测。不过，首先定义一个null的输出值和TextWriter.Write方法：

private const string NullLiterals = "(null)";

private static readonly MethodInfo TextWriter_Write =
    typeof(TextWriter).GetMethod("Write", new Type[] { typeof(string) });

    于是，ProcessWhenObjIsNull的实现就是：

private static void ProcessWhenObjIsNull(ILGenerator il)
{
    if (!typeof(T).IsValueType)
    {
        // if (obj == null) { writer.Write(NullLiterals); return; }
        var NotNullLable = il.DefineLabel();
        il.Emit(OpCodes.Ldarg_1);
        il.Emit(OpCodes.Brtrue_S, NotNullLable);
        il.Emit(OpCodes.Ldarg_0);
        il.Emit(OpCodes.Ldstr, NullLiterals);
        il.Emit(OpCodes.Callvirt, TextWriter_Write);
        il.Emit(OpCodes.Ret);
        il.MarkLabel(NotNullLable);
    }
    else if (Nullable.GetUnderlyingType(typeof(T)) != null)
    {
        // if (obj == null) { writer.Write(NullLiterals); return; }
        var NotNullLable = il.DefineLabel();
        il.Emit(OpCodes.Ldarg_1);
        il.Emit(OpCodes.Box, typeof(T));
        il.Emit(OpCodes.Brtrue_S, NotNullLable);
        il.Emit(OpCodes.Ldarg_0);
        il.Emit(OpCodes.Ldstr, NullLiterals);
        il.Emit(OpCodes.Callvirt, TextWriter_Write);
        il.Emit(OpCodes.Ret);
        il.MarkLabel(NotNullLable);
    }
}

    第一个if判断T是否是值类型，如果不是值类型（即：引用类型）则需要判null，第二个判断T是否是可空类型，如果是，则需要判null（利用可空类型为null时装箱值为null的特性）。

    剩下一个WriteProperties才是难点，先想想c#怎么写：

string propName = "Property";
writer.Write(propName + "=");
object propValue = obj.Property;
string temp;
if (propValue != null)
{
    temp = propValue.ToString();
}
else
{
    temp = "(null)";
}
writer.Write(temp);

    可以发现，Dump属性分成2个部分，一个是写属性的名字，另一个是写属性的值。对了，别忘了还要写separator。

    于是，方法的实现就是：

private static void WriteProperties(ILGenerator il, LocalBuilder temp)
{
    foreach (var prop in typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance))
    {
        if (prop.GetIndexParameters().Length > 0)
            continue;
        var getMethod = prop.GetGetMethod();
        if (getMethod == null)
            continue;
        WriteHead(il, prop);
        var propCompletedLable = il.DefineLabel();
        WriteValue(il, temp, prop, getMethod, propCompletedLable);
        il.MarkLabel(propCompletedLable);
        WriteSeparator(il);
    }
}

    然后就是WriteHead（即：属性名），WriteValue（属性值），WriteSeparator（分隔符），这3个方法。

    其中，WriteHead和WriteSeparator方法比较简单：

private static void WriteHead(ILGenerator il, PropertyInfo prop)
{
    // writer.Write("%PropertyName%=");
    il.Emit(OpCodes.Ldarg_0);
    il.Emit(OpCodes.Ldstr, prop.Name + "=");
    il.Emit(OpCodes.Callvirt, TextWriter_Write);
}

private static void WriteSeparator(ILGenerator il)
{
    // writer.Write(separator);
    il.Emit(OpCodes.Ldarg_0);
    il.Emit(OpCodes.Ldarg_2);
    il.Emit(OpCodes.Callvirt, TextWriter_Write);
}

    但是，WriteValue就比较复杂了，因为T可能是值类型，也可能是引用类型（在IL里面处理有区别），另外，属性的value同样有null的情况需要处理，另外有个性能优化，如果属性的值类型重写了ToString方法，就不要装箱后再调用object.ToString。

private static readonly MethodInfo Object_ToString =
    typeof(object).GetMethod("ToString", Type.EmptyTypes);

private static void WriteValue(ILGenerator il, LocalBuilder temp,
    PropertyInfo prop, MethodInfo getMethod, Label propCompletedLable)
{
    LoadPropertyValue(il, getMethod);
    var propType = prop.PropertyType;
    ProcessWhenValueIsNull(il, propType, propCompletedLable);
    GetValueString(il, propType, temp);
    WriteValueString(il, temp);
}

private static void LoadPropertyValue(ILGenerator il, MethodInfo getMethod)
{
    // var value = obj.%Property%;
    if (typeof(T).IsValueType)
    {
        il.Emit(OpCodes.Ldarga, 1);
        il.Emit(OpCodes.Call, getMethod);
    }
    else
    {
        il.Emit(OpCodes.Ldarg_1);
        il.Emit(OpCodes.Callvirt, getMethod);
    }
}

private static void ProcessWhenValueIsNull(ILGenerator il, Type propType, Label propCompletedLable)
{
    if (!propType.IsValueType)
    {
        // if (value == null) { writer.Write(NullLiterals); } else ...
        var NotNullLable = il.DefineLabel();
        il.Emit(OpCodes.Dup);
        il.Emit(OpCodes.Brtrue_S, NotNullLable);
        il.Emit(OpCodes.Pop);
        il.Emit(OpCodes.Ldarg_0);
        il.Emit(OpCodes.Ldstr, NullLiterals);
        il.Emit(OpCodes.Callvirt, TextWriter_Write);
        il.Emit(OpCodes.Br, propCompletedLable);
        il.MarkLabel(NotNullLable);
    }
    else if (Nullable.GetUnderlyingType(propType) != null)
    {
        // if (value == null) { writer.Write(NullLiterals); } else ...
        var NotNullLable = il.DefineLabel();
        il.Emit(OpCodes.Dup);
        il.Emit(OpCodes.Box, propType);
        il.Emit(OpCodes.Brtrue_S, NotNullLable);
        il.Emit(OpCodes.Pop);
        il.Emit(OpCodes.Ldarg_0);
        il.Emit(OpCodes.Ldstr, NullLiterals);
        il.Emit(OpCodes.Callvirt, TextWriter_Write);
        il.Emit(OpCodes.Br, propCompletedLable);
        il.MarkLabel(NotNullLable);
    }
}

private static void GetValueString(ILGenerator il, Type propType, LocalBuilder temp)
{
    if (propType.IsValueType)
    {
        // is override ToString method
        var toStringMethod = propType.GetMethod("ToString",
            BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly,
            null, Type.EmptyTypes, null);
        if (toStringMethod != null)
        {
            // call ToString without boxing
            // %PropertyType% x;
            var x = il.DeclareLocal(propType);
            // x = value;
            il.Emit(OpCodes.Stloc, x);
            // temp = x.ToString();
            il.Emit(OpCodes.Ldloca, x);
            il.Emit(OpCodes.Call, toStringMethod);
            il.Emit(OpCodes.Stloc, temp);
        }
        else
        {
            // call ToString with boxing
            // temp = ((object)value).ToString();
            il.Emit(OpCodes.Box, propType);
            il.Emit(OpCodes.Callvirt, Object_ToString);
            il.Emit(OpCodes.Stloc, temp);
        }
    }
    else
    {
        // temp = value.ToString();
        il.Emit(OpCodes.Callvirt, Object_ToString);
        il.Emit(OpCodes.Stloc, temp);
    }
}

private static void WriteValueString(ILGenerator il, LocalBuilder temp)
{
    // writer.Write(temp);
    il.Emit(OpCodes.Ldarg_0);
    il.Emit(OpCodes.Ldloc, temp);
    il.Emit(OpCodes.Callvirt, TextWriter_Write);
}

    终于，一个高性能的Dumper写好了，虽然比起纯反射版的代码复杂了很多。不过，性能方面可以提高很多，接下来不妨测试一下吧。

性能测试

    为了测试这个高性能的Dumper到底能有多少性能优势，使用了下面的测试代码：

Foo foo = new Foo { Bar = "Bar", FooBar = 100, };
const int count = 1000000;
Stopwatch sw = Stopwatch.StartNew();
for (int i = 0; i < count; i++)
{
    foo.DumpByReflection();
}
Console.WriteLine(sw.ElapsedMilliseconds);
sw.Reset();
sw.Start();
for (int i = 0; i < count; i++)
{
    foo.Dump();
}

    其中DumpByReflection使用第一节中的纯反射方式，来看看运行结果吧：

5795
906

    不快嘛，才6倍，为什么哪？再加一个对比测试：

sw.Reset();
sw.Start();
for (int i = 0; i < count; i++)
{
    var temp = "Bar=" + foo.Bar + ", FooBar=" + foo.FooBar.ToString();
}
Console.WriteLine(sw.ElapsedMilliseconds);

    再看看速度：

5769
892
353

    拼字符串本身就用了353ms，难怪速度快不上去了，那么900ms-350ms，那还有450ms用到哪里去了？

    不妨再加一个对比测试：

sw.Reset();
sw.Start();
for (int i = 0; i < count; i++)
{
    foo.Dump(TextWriter.Null);
}
Console.WriteLine(sw.ElapsedMilliseconds);

    将内容Dump到TextWriter.Null，这样就不会有字符串拼接带来的性能影响，再来看看结果：

5778
894
352
291

    Dumper本身花费的时间约300ms，Dumper另外使用的150ms在干什么哪？其中包括StringBuilder的扩容，还有StringWriter的包装的额外代价。

    而反射本身花费的时间越5400ms，也就是9倍的时间，而拼接字符串约350ms，占到Dumper的1/3，反射的6%。

匿名类型

    之前的类型都是明确定义的类型，如果是匿名类型呢？

var foo = new { Bar = "Bar", FooBar = 100, };

    再次运行，就会发现报错了MethodAccessException，为什么哪？

    因为匿名类型被c#编译器翻译为内部类型，而DynamicMethod默认是在Assembly之外的，所以，访问这个类型的方法是受限制的，因此需要修改一下DynamicMethod的声明：

DynamicMethod dm = new DynamicMethod(string.Empty, typeof(void),
    new Type[] { typeof(TextWriter), typeof(T), typeof(string) }, typeof(T));

    完成修改后，再跑一下，完全正常了。这个重载和原来的有什么区别哪？最后一个typeof(T)的作用就是把这个动态方法声明为T类型上的方法，因此，无论T是内部类型还是外部类型，对这个方法本身而言，都是可见的，因此绕过了CLR的检查。

    最后在来看看性能分析：

19395
889
353
291

    除了反射外，性能基本没变，那么反射为什么会变慢哪？因为，访问内部类型的方法需要经过安全检查，这个额外的工作自然拖慢反射的性能。