[C#][.NET][式木] メタプログラミング入門 – 応用編 – オブジェクトの文字列変換のメタプログラミング (式木編)

// テスト用のクラス
public sealed class Book
{
public string Title { get; set; }
public int    Price { get; set; }
}

// 動的に作りたいラムダ式の例 (実際のコードは targetType による):
item => new StringBuilder().Append("Title: ").Append(item.Title)
.Append(", ")
.Append("Price: ").Append(item.Price)
.ToString()

using System;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Text;
// ToString メソッド生成器 (式木版)
public static class ToStringGeneratorByExpression
{
// メソッドを生成
public static Func<T, string> Generate<T>()
{
// 対象とする型の全プロパティ情報を取得
var            properties                  = typeof(T).GetProperties(bindingAttr: BindingFlags.Public | BindingFlags.Instance)
.Where(property => property.CanRead)
.ToArray();
var parameterExpression = Expression.Parameter(typeof(T), "item");
LambdaExpression lambdaExpression;
if (properties.Length > 0) {
// 動的に作りたいラムダ式の例 (実際のコードは targetType による):
// item => new StringBuilder().Append("Title: ").Append(item.Title)
//                            .Append(", ")
//                            .Append("Price: ").Append(item.Price)
//                            .ToString()
var        callGetTypeOfItemExpression = Expression.Call(
instance: parameterExpression           ,
method  : typeof(T).GetMethod("GetType")
);
Expression stringBuilderExpression     = Expression.New(type: typeof(StringBuilder));
// プロパティ毎に文字列に変換する式を生成
for (var index = 0; index < properties.Length; index++)
stringBuilderExpression = GenerateForEachProperty(
property                   : properties[index]            ,
expression                 : stringBuilderExpression      ,
parameterExpression        : parameterExpression          ,
callGetTypeOfItemExpression: callGetTypeOfItemExpression  ,
needsSeparator             : index < properties.Length - 1
);
stringBuilderExpression                = stringBuilderExpression.CallMethod(typeof(StringBuilder).GetMethod("ToString", Type.EmptyTypes));
lambdaExpression                       = Expression.Lambda(stringBuilderExpression, parameterExpression);
} else {
// 動的に作りたいラムダ式の例:
// item => string.Empty
lambdaExpression = Expression.Lambda(Expression.Constant(string.Empty, typeof(string)),
parameterExpression);
}
// ラムダ式をコンパイルしてデリゲートとして返す
return (Func<T, string>)lambdaExpression.Compile();
}
// 何度も使われるメソッドは static メンバーに
static readonly MethodInfo stringBuilderAppendStringMethod = typeof(StringBuilder).GetMethod("Append"     , new[] { typeof(string) });
static readonly MethodInfo stringBuilderAppendObjectMethod = typeof(StringBuilder).GetMethod("Append"     , new[] { typeof(object) });
static readonly MethodInfo typeGetPropertyMethod           = typeof(Type         ).GetMethod("GetProperty", new[] { typeof(string) });
static readonly MethodInfo propertyInfoGetValueMethod      = typeof(PropertyInfo ).GetMethod("GetValue"   , new[] { typeof(object) });
// プロパティ毎に文字列に変換する式を生成
static Expression GenerateForEachProperty(PropertyInfo property, Expression expression, ParameterExpression parameterExpression, MethodCallExpression callGetTypeOfItemExpression, bool needsSeparator)
{
// 例えば、item.Title の式を生成 (実際のコードは property による)
var callGetValueExpression = callGetTypeOfItemExpression
.CallMethod(typeGetPropertyMethod         , Expression.Constant(property.Name)        )
.CallMethod(propertyInfoGetValueMethod    , parameterExpression                       );
// 例えば、stringBuilder.Append("Title: ").Append(item.Title) の式を生成 (実際のコードは property による)
expression                 = expression
.CallMethod(stringBuilderAppendStringMethod, Expression.Constant(property.Name + ": "))
.CallMethod(stringBuilderAppendObjectMethod, callGetValueExpression                   );
// 必要なら、stringBuilder.Append(", ") の式を生成
if (needsSeparator)
expression = expression.CallMethod(stringBuilderAppendStringMethod, Expression.Constant(", "));
return expression;
}
// Expression.Call をメソッドチェーンにするための拡張メソッド
static Expression CallMethod(this Expression @this, MethodInfo method, params Expression[] arguments)
{
return Expression.Call(@this, method, arguments);
}
}

// 改良前 (メソッドのキャッシュ無し)
public static class ToStringByExpressionExtensions初期型
{
// ToString に代わる拡張メソッド (式木版)
public static string ToStringByExpression初期型<T>(this T @this)
{
// 動的にメソッドを生成し、それを実行
return ToStringGeneratorByExpression.Generate<T>()(@this);
}
}

using System;
static class Program
{
static void Main()
{
var book = new Book { Title = "Metaprogramming C#", Price = 3200 };
Console.WriteLine(book.ToStringByExpression初期型());
}
}

using System;
using System.Collections.Generic;
//  生成したメソッド用のキャッシュ
public class MethodCache<TResult>
{
// メソッド格納用
readonly Dictionary<Type, Delegate> methods = new Dictionary<Type, Delegate>();
// メソッドの呼び出し (メソッド生成用のメソッドを引数 generator として受け取る)
public TResult Call<T>(T item, Func<Func<T, TResult>> generator)
{
return Get<T>(generator)(item); // キャッシュにあるメソッドを呼び出す
}
// メソッドをキャッシュを介して取得 (メソッド生成用のメソッドを引数 generator として受け取る)
Func<T, TResult> Get<T>(Func<Func<T, TResult>> generator)
{
var      targetType = typeof(T);
Delegate method;
if (!methods.TryGetValue(key: targetType, value: out method)) { // キャッシュに無い場合は
method = generator();                                       // 動的にメソッドを生成して
methods.Add(key: targetType, value: method);                // キャッシュに格納
}
return (Func<T, TResult>)method;
}
}

// 改良後 (メソッドのキャッシュ有り)
public static class ToStringByExpressionExtensions改
{
// 生成したメソッドのキャッシュ
static readonly MethodCache<string> toStringCache = new MethodCache<string>();
// ToString に代わる拡張メソッド (式木版)
public static string ToStringByExpression改<T>(this T @this)
{
// キャッシュを利用してメソッドを呼ぶ
return toStringCache.Call(item: @this, generator: ToStringGeneratorByExpression.Generate<T>);
}
}

using System;
static class Program
{
static void Main()
{
var book = new Book { Title = "Metaprogramming C#", Price = 3200 };
Console.WriteLine(book.ToStringByExpression改());
}
}