系统.反射性能

Question

我有一个数据库管理器，用于插入或添加到内部SQLite数据库以及用于读取。

对于回读，我使用像这样的泛型方法

 public List<T> GetListOfObjects<T>(string id) where T:IIdentity, new()
    {
        lock (dbLock)
        {
            using (var sqlCon = new SQLiteConnection(DBPath))
            {
                sqlCon.Execute(Constants.DBClauseSyncOff);
                sqlCon.BeginTransaction();
                string sql = string.Format("SELECT * FROM {0} WHERE id="{1}"", GetName(typeof(T).ToString()), id);
                var data = sqlCon.Query<T>(sql);
                return data;
            }
        }
    }

没什么了不起的，但是我所有的read方法总共大约有130行代码。

我的setter是不同的——大约1500行，覆盖了一堆类。我想做的是使用系统反射来合理化插入/更新方法，而不是担心被插入的类，而是允许反射为我做这件事。

根据我所读到的，这是完全可能的，因此我应该能够将代码压缩成类似于

的东西

public void InsertOrUpdateClass<T>(List<T> obj) : where T:IIdentity, new()
{
     foreach(var o in obj)
         InsertOrUpdateClass(o);
}
public void InsertOrUpdateClass<T>(T o) : where T:IIdentity, new()
{
     lock (dbLock)
        {
            using (var sqlcon = new SQLiteConnection(DBPath))
            {
                sqlcon.Execute(Constants.DBClauseSyncOff);
                sqlcon.BeginTransaction();
                try
                {
                    // use reflection to construct the SQLite command line, insert
                    // into a string and pass into the query
                   if (sqlcon.Execute(SQLquery) == 0)
                        sqlcon.Insert(o, typeof(T));
                    sqlcon.Commit(); 
                }
                catch (Exception ex)
                {
                    Console.WriteLine("Error in InsertOrUpdateClass : {0}", ex.Message);
                    sqlcon.Rollback();
                }
            }
        }

然而，从我所读到的，使用反射来做这件事会给性能带来大约x5比更标准的单个方法每个类插入或更新。我看到的大多数示例都表明，由于我没有使用任何令人讨厌的东西(如Activator.Create…)，我的方法应该与"标准"代码一样快

类(因为它们是数据库)有不同的长度，并添加了[Ignore]和[PrimaryKey]的数据参数。我没有发现任何关于反射是否会混淆这两个

Answer 1

使用表达式树的非常基本/幼稚的方法。根据对象的复杂性，您肯定需要为此做一些工作，但这应该是一个很好的起点:

private readonly Dictionary<Type, Func<Object, String>> queryBuilders =
   new Dictionary<Type, Func<object, string>>();
public String GetInsertQuery(Object entity)
{
   var type = entity.GetType();
   if (!queryBuilders.ContainsKey(type))
   {
      var param = Expression.Parameter(typeof(Object), "entity");
      var typedObject = Expression.Variable(type, "obj");
      var stringBuilder = Expression.Variable(typeof (StringBuilder), "sb");
      var appendString = typeof (StringBuilder).GetMethod("Append", new[] {typeof (String)});
      var objectToString = typeof(Object).GetMethod("ToString");
      var code = new List<Expression>();
      code.Add(Expression.Assign(typedObject, Expression.Convert(param, type)));
      code.Add(Expression.Assign(stringBuilder, Expression.New(typeof (StringBuilder))));
      code.Add(Expression.Call(stringBuilder, appendString, Expression.Constant(string.Format("INSERT INTO {0} (", type.Name))));
      var properties = type.GetProperties();
      for (int i = 0; i < properties.Length - 1; i++)
      {
         code.Add(Expression.Call(stringBuilder, appendString, Expression.Constant(properties[i].Name)));
         code.Add(Expression.Call(stringBuilder, appendString, Expression.Constant(", ")));
      }
      code.Add(Expression.Call(stringBuilder, appendString, Expression.Constant(properties[properties.Length - 1].Name)));
      code.Add(Expression.Call(stringBuilder, appendString, Expression.Constant(") VALUES (")));
      for (int i = 0; i < properties.Length - 1; i++)
      {
         code.Add(Expression.Call(stringBuilder, appendString, Expression.Constant("'")));
         code.Add(Expression.Call(stringBuilder, appendString, Expression.Call(Expression.Property(typedObject, properties[i]), objectToString)));
         code.Add(Expression.Call(stringBuilder, appendString, Expression.Constant("', ")));
      }
      code.Add(Expression.Call(stringBuilder, appendString, Expression.Constant("'")));
      code.Add(Expression.Call(stringBuilder, appendString, Expression.Call(Expression.Property(typedObject, properties[properties.Length - 1]), objectToString)));
      code.Add(Expression.Call(stringBuilder, appendString, Expression.Constant("', ")));
      code.Add(Expression.Call(stringBuilder, appendString, Expression.Constant(");")));

      code.Add(Expression.Call(stringBuilder, "ToString", new Type[] { }));
      var expression = Expression.Lambda<Func<Object, String>>(Expression.Block(new[] { typedObject, stringBuilder }, code), param);
      queryBuilders[type] = expression.Compile();
   }
   return queryBuilders[type](entity);
}

虽然这也使用反射，但主要的区别是反射只使用一次，而对每个对象类型的进一步调用使用已编译的代码，因此没有明显的性能影响。主要的缺点是明显的复杂性——简单的方法，远不是万无一失和通用的，需要相当多的代码行——你肯定需要考虑减少代码库的好处(也可能提高可维护性)是否值得付出代价(这也是可维护性——但不是成千上万的方法，而是一个相当复杂的方法)。