Nhibernate 通过StartsWith查询

我必须尝试根据搜索查找结果，搜索结果应该是startswith，但我找不到

QueryOver

搜索结果应该是startswith，还有其他方法吗

public IEnumerable<Company> Find(string keyword)
{
     var sesion = SessionController.CurrentSession;
     return sesion.QueryOver<Company>()
     .Where(
        Restrictions.On<Company>(x => x.CompanyName).IsLike("%" + keyword + "%") ||
        Restrictions.On<Company>(x => x.Id).IsLike("%" + keyword + "%")
     )
     .List<Company>();
}

public IEnumerable查找（字符串关键字）
{
var sesion=SessionController.CurrentSession；
返回sesion.QueryOver（）
.在哪里(
限制.On（x=>x.CompanyName）.IsLike（“%”+关键字+“%”）||
限制.On（x=>x.Id）.IsLike（“%”+关键字+“%”）
)
.List（）；
}
由
QueryOver
基础结构支持的方法是使用显式
匹配模式
：

sesion
  .QueryOver<Company>()
  .Where
  (
     Restrictions.On<Company>(x => x.CompanyName).IsLike(keyword, MatchMode.Start) ||
     Restrictions.On<Company>(x => x.Id         ).IsLike(keyword, MatchMode.Start)
  )
  .List<Company>();

以及
限制的定义：

public static class Restrict
{
    public static StringRestrictionBuilder<T> On<T>(Expression<Func<T, object>> expr)
    {
        return new StringRestrictionBuilder<T>(expr);
    }
    public class StringRestrictionBuilder<T>
    {
        readonly Expression<Func<T, object>> _expression;
        public StringRestrictionBuilder(Expression<Func<T, object>> expression)
        {
            _expression = expression;
        }
        public AbstractCriterion StartsWith(string value)
        {
            return Restrictions.On(_expression).IsLike(value, MatchMode.Start);
        }
        public AbstractCriterion Contains(string value)
        {
            return Restrictions.On(_expression).IsLike(value, MatchMode.Anywhere);
        }
        public AbstractCriterion EndsWith(string value)
        {
            return Restrictions.On(_expression).IsLike(value, MatchMode.End);
        }
    }
}

公共静态类限制
{
上的公共静态StringRestrictionBuilder（表达式表达式表达式）
{
返回新的StringRestrictionBuilder（expr）；
}
公共类StringRestrictionBuilder
{
只读表达式\u表达式；
public StringRestrictionBuilder（表达式）
{
_表达式=表达式；
}
public AbstractCriteria StartsWith（字符串值）
{
返回限制.On（_expression）.IsLike（值，MatchMode.Start）；
}
公共抽象条件包含（字符串值）
{
返回限制.On（_expression）.IsLike（值，MatchMode.Anywhere）；
}
公共抽象标准EndsWith（字符串值）
{
返回限制.On（_expression）.IsLike（值，MatchMode.End）；
}
}
}
您的意思是，除了删除IsLike限制中的前导%之外，还有其他方法吗？
public static class Restrict
{
    public static StringRestrictionBuilder<T> On<T>(Expression<Func<T, object>> expr)
    {
        return new StringRestrictionBuilder<T>(expr);
    }
    public class StringRestrictionBuilder<T>
    {
        readonly Expression<Func<T, object>> _expression;
        public StringRestrictionBuilder(Expression<Func<T, object>> expression)
        {
            _expression = expression;
        }
        public AbstractCriterion StartsWith(string value)
        {
            return Restrictions.On(_expression).IsLike(value, MatchMode.Start);
        }
        public AbstractCriterion Contains(string value)
        {
            return Restrictions.On(_expression).IsLike(value, MatchMode.Anywhere);
        }
        public AbstractCriterion EndsWith(string value)
        {
            return Restrictions.On(_expression).IsLike(value, MatchMode.End);
        }
    }
}