怎样Interlocked.Increment一个反射得到的field?

原始的问题是：“如何修改一个用reflection得到的field值，并且保证线程安全”。根据所采用的同步技术，解决方案各有不同。如果是采用lock，那么自然可以反射得到同步对象然后使用Monitor来同步。但如果对象采用的是Interlocked那一套方法，问题就变得有些麻烦了。其中最典型的，也就是如何Increment一个reflection得到的int型field。困难之处在于Increment方法需要ref int参数（编译时），而若使用FieldInfo的GetValue方法只能得到box后的值（运行时），对其进行修改已经没有意义。既然前者的需求无法在编译时满足，那就干脆把它的编译推迟。使用Expression Tree或者类似技术可以做到。下面展示如何自增目标类Foo中具有CounterAttribute的字段。

// This attribute indicates the field to be increased.

[AttributeUsage(AttributeTargets.Field, AllowMultiple = false)]

public class CounterAttribute : Attribute

{

}



public class Foo

{

    // This counter will be increased.

    [Counter]

    public long Counter = 0;

}



class Program

{

    static void Main(string[] args)

    {

        var foo = new Foo();

        // Print the counter before increasement.

        Console.WriteLine(foo.Counter);

        // Do the increasement.

        IncreaseCounter(foo);

        // Print the increased counter.

        Console.WriteLine(foo.Counter);

    }



    private static void IncreaseCounter(object instance)

    {

        // Get the target type whose public field is to be increased.

        var targetType = instance.GetType();

        // Get the target field.

        var targetField = targetType.GetFields(BindingFlags.Public | BindingFlags.Instance)

            .First(p => p.GetCustomAttributes(typeof (CounterAttribute), false).Any());

        // The Interlocked.Increment method

        var increaseMethod = typeof (Interlocked).GetMethod("Increment", new[] {typeof (long).MakeByRefType()});

        // The parameter of the finally built lambda.

        var parameter = Expression.Parameter(typeof (object));

        // Cast the parameter into the target type.

        var targetInstance = Expression.TypeAs(parameter, targetType);

        // Access the target field of the target instance, and pass it as parameter to the call of Interlocked.Increment.

        var call = Expression.Call(increaseMethod, Expression.Field(targetInstance, targetField));

        // Build the lambda.

        var lambda = Expression.Lambda(typeof (Action<object>), call, parameter);

        // Compile into delegate.

        var func = (Action<object>)lambda.Compile();

        // Call the compiled delegate.

        func(instance);

    }

}

这样做必定会有一些性能损失，但是如果lambda的Compile与调用相比少得多的话，那么影响应该不至于十分显著；更何况，原本都已经使用了反射了。