Готовим основное блюдо

 private static string CreateBody(string dbName, Type type)
        {
           //получаем имя таблицы в бд, согласно атрибутам в объявлении бизнес-объекта
            var tableName = CommonCommandBuilder.GetTableName(type);
            var cmdBulder = new StringBuilder();
//получаем все поля свойства объекта, у которых есть атрибуты привязки к таблицам в бд
            foreach (var prop in CacheTypeReflectionWrapper.GetProps(type).Where(x =>      x.FieldNameAttributes.Any()))
            {
                var attrs = prop.FieldNameAttributes;
//в текущей реализации только один атрибут привязки к имени в бд является действительным
                cmdBulder.Append(string.Format("[{0}].[{1}],", tableName, attrs.First().Value));
            }
            return string.Format("SELECT {0} FROM [{1}].[dbo].[{2}] ",
                                 cmdBulder.ToString().Trim(','), dbName, tableName);
        }

repo.Get(x => x.RoleId == 2 && x.UserInfoId > 4 && x.Id < 6)

//в метод необходимо передать экземпляр IDbCommand, в который будут сформируются  параметры и значения, передаваемые в динамический SQL
  public static string BuildClauseByExpression(IDbCommand command, Type type, BinaryExpression exp)
        {
            var strBuilder = new StringBuilder();
           //точка входа в главный метод
            return BuildClauseByNode(command, type, exp, strBuilder);
        }
//рекурсивный метод обхода дерева выражений
 private static string BuildClauseByNode(IDbCommand command, Type type, BinaryExpression left, StringBuilder strBuilder)
        {
            var tableName = GetTableName(type);
            if (left != null)
            {
                var parameter = command.CreateParameter();
                var fieldName = string.Empty;
                var expField = left.Left as MemberExpression;
                if (expField == null)
                {
                 
                    if (left.Left is BinaryExpression)
                    {
                      //если вершина типа Binary - рекурсивный вызов
                        BuildClauseByNode(command, type, left.Left as BinaryExpression, strBuilder);
//ExpressionTypeToDbClause содержит словарь, где ключ-значение ExpressionType, а значение строковое выражение SQL операции:_instance[ExpressionType.AndAlso] = " AND "
                        strBuilder.Append(ExpressionTypeToDbClause.Instance[left.NodeType]);
                    }
                }
                else
                {
            //если вершина типа Member - формируем значения названий полей и часть SQL условия
                    var name = expField.Member.Name;
                    var prop = CacheTypeReflectionWrapper.GetProps(type)
                        .Where(x => x.FieldNameAttributes.Any()).First(x => x.Name.Equals(name));
                    var attrs = prop.FieldNameAttributes;
                    fieldName = attrs.First().Value;
                    strBuilder.Append(string.Format("[{0}].[{1}]", tableName, fieldName));
//ExpressionTypeToDbClause содержит словарь, где ключ-значение ExpressionType, а значение строковое выражение SQL операции:_instance[ExpressionType.AndAlso] = " AND "
                    var action = ExpressionTypeToDbClause.Instance[left.NodeType];
                    strBuilder.Append(action);
      //TypeMap содержит словарь для поиска соответствия c# типов и бд типов
                    parameter.DbType = TypeMap[prop.Type];
                }

                var expValue = left.Right as ConstantExpression;
                if (expValue == null)
                {
                    var unaryNode = left.Right as UnaryExpression;
                    if (unaryNode != null)
                    {
//если вершина типа UnaryExpression необходимо воспользоватся свойством Operand и привести к //ConstantExpression
                        expValue = unaryNode.Operand as ConstantExpression;
                        if (expValue != null)
                        {
                        //метод формирует параметры для динамического SQL-запроса
                            InitParams(command, strBuilder, fieldName, parameter, expValue);
                        }
                    }

                    if (expValue == null)
                    {
                        if (left.Right is BinaryExpression)
                        {
                            //если вершина типа Binary - рекурсивный вызов
                            BuildClauseByNode(command, type, left.Right as BinaryExpression, strBuilder);
                        }
                    }

                }
                else
                {
                    InitParams(command, strBuilder, fieldName, parameter, expValue);
                }

            }
            return strBuilder.ToString();
        }
//метод формирования параметров динамического SQL-запроса
  private static void InitParams(IDbCommand command, StringBuilder strBuilder, string fieldName,
                                       IDataParameter parameter, ConstantExpression expValue)
        {

            var valueFormat = GetParamsFormat(fieldName);
            strBuilder.Append(valueFormat);
            parameter.ParameterName = valueFormat;
            parameter.Value = expValue.Value;
            if (!command.Parameters.Contains(parameter.ParameterName))
                command.Parameters.Add(parameter);
        }
//служебный метод форматирования строки параметра динамического SQL-запроса
  public static string GetParamsFormat(string fieldName)
        {
            return string.Format("@{0}", fieldName);
        }

 public static string Create<T>(IDbCommand command, BinaryExpression exp)
            where T : class, IEntity, new()
        {
            var type = typeof(T);
            var selectBody = CreateBody(command.Connection.Database, type);
            return string.Format("{0} WHERE {1}", selectBody, CommonCommandBuilder.BuildClauseByExpression(command, type, exp));
        }