Dynamics crm Dynamics CRM 4.0中的自定义搜索

我有两个相关的问题

第一: 我希望在Dynamics CRM 4.0中对自定义实体进行全文搜索。以前有没有人这样做过，或者知道怎么做

我知道我可以用web服务和sdk构建QueryExpression，但是我可以用这个方法用布尔类型语法进行全文搜索吗？据我所知，那是行不通的

第二：

---

其他人是否觉得Dynamics CRM 4.0提供的搜索能力有限？我知道有一些第三方搜索产品，但我还没有找到一个我喜欢的。如果您有任何建议，我们将不胜感激。

通过CRM SDK进行搜索和筛选确实需要一些时间才能习惯。为了模拟全文搜索，您需要使用嵌套的FilterExpressions作为QueryExpression.Criteria。最困难的部分是找出如何建立父子关系。布尔逻辑太多了，很容易迷路

我需要为我们的一个定制实体构建一个“搜索引擎”。将此方法用于具有多个可搜索属性的复杂搜索字符串（“一、二或三”）是很难看的。如果你感兴趣，我可以把它挖出来。虽然它实际上不受支持，但如果您可以直接访问数据库，我建议您使用SQL的全文搜索功能

-- 好的，给你。我不认为你能复制粘贴这个来满足你的需要。我的客户只进行了两到三次关键词搜索，他们对搜索结果感到满意。在一个简单的搜索场景中，您可以看到这样做是多么痛苦。我基本上吐出了代码，直到它“工作”

    private FilterExpression BuildFilterV2(string[] words, string[] seachAttributes)
    {
        FilterExpression filter = new FilterExpression();
        List<FilterExpression> allchildfilters = new List<FilterExpression>();

        List<string> andbucket = new List<string>();
        List<string> orBucket = new List<string>();

        // clean up commas, quotes, etc
        words = ScrubWords(words);

        int index = 0;

        while (index < words.Length)
        {
            // if current word is 'and' then add the next wrod to the ad bucket
            if (words[index].ToLower() == "and")
            {
                andbucket.Add(words[index + 1]);
                index += 2;
            }
            else
            {
                if (andbucket.Count > 0)
                {

                    List<FilterExpression> filters = new List<FilterExpression>();
                    foreach (string s in andbucket)
                    {
                        filters.Add(BuildSingleWordFilter(s, seachAttributes));
                    }

                    // send existing and bucket to condition builder 
                    FilterExpression childFilter = new FilterExpression();
                    childFilter.FilterOperator = LogicalOperator.And;
                    childFilter.Filters = filters.ToArray();

                    // add to child filter list
                    allchildfilters.Add(childFilter);

                    //new 'and' bucket
                    andbucket = new List<string>();
                }
                if (index + 1 < words.Length && words[index + 1].ToLower() == "and")
                {
                    andbucket.Add(words[index]);
                    if (index + 2 <= words.Length)
                    {
                        andbucket.Add(words[index + 2]);
                    }
                    index += 3;
                }
                else
                {
                    orBucket.Add(words[index]);
                    index++;
                }
            }
        }

        if (andbucket.Count > 0)
        {
            List<FilterExpression> filters = new List<FilterExpression>();
            foreach (string s in andbucket)
            {
                filters.Add(BuildSingleWordFilter(s, seachAttributes));
            }

            // send existing and bucket to condition builder 
            FilterExpression childFilter = new FilterExpression();
            childFilter.FilterOperator = LogicalOperator.And;
            childFilter.Filters = filters.ToArray();

            // add to child filter list
            allchildfilters.Add(childFilter);

            //new 'and' bucket
            andbucket = new List<string>();
        }
        if (orBucket.Count > 0)
        {
            filter.Conditions = BuildConditions(orBucket.ToArray(), seachAttributes);
        }
        filter.FilterOperator = LogicalOperator.Or;
        filter.Filters = allchildfilters.ToArray();

        return filter;
    }
    private FilterExpression BuildSingleWordFilter(string word, string[] seachAttributes)
    {
        List<ConditionExpression> conditions = new List<ConditionExpression>();

        foreach (string attr in seachAttributes)
        {
                ConditionExpression expr = new ConditionExpression();
                expr.AttributeName = attr;
                expr.Operator = ConditionOperator.Like;
                expr.Values = new string[] { "%" + word + "%" };

                conditions.Add(expr);
        }

        FilterExpression filter = new FilterExpression();
        filter.FilterOperator = LogicalOperator.Or;
        filter.Conditions = conditions.ToArray();

        return filter;
    }

    private ConditionExpression[] BuildConditions(string[] words, string[] seachAttributes)
    {
        List<ConditionExpression> conditions = new List<ConditionExpression>();

        foreach (string s in words)
        {
            foreach (string attr in seachAttributes)
            {
                ConditionExpression expr = new ConditionExpression();
                expr.AttributeName = attr;
                expr.Operator = ConditionOperator.Like;
                expr.Values = new string[] { "%" + s + "%" };

                conditions.Add(expr);
            }
        }

        return conditions.ToArray();
    }

private FilterExpression BuildFilterV2（字符串[]单词，字符串[]seachAttributes）
{
FilterExpression filter=新的FilterExpression（）；
List allchildfilters=新列表（）；
List和bucket=新列表（）；
List orBucket=新列表（）；
//清除逗号、引号等
单词=ScrubWords（单词）；
int指数=0；
while（索引0）
{
列表过滤器=新列表（）；
foreach（andbucket中的字符串s）
{
添加（BuildSingleWordFilter，seachAttributes）；
}
//将现有和存储桶发送到条件生成器
FilterExpression childFilter=新的FilterExpression（）；
childFilter.FilterOperator=逻辑运算符和；
childFilter.Filters=Filters.ToArray（）；
//添加到子筛选器列表
添加（childFilter）；
//新的“和”桶
andbucket=新列表（）；
}
如果（索引+10）
{
filter.Conditions=BuildConditions（orBucket.ToArray（），seachAttributes）；
}
filter.FilterOperator=逻辑运算符。或；
filter.Filters=allchildfilters.ToArray（）；
回流过滤器；
}
私有筛选器Expression BuildSingleWordFilter（字符串word，字符串[]seachAttributes）
{
列表条件=新列表（）；
foreach（SeachatAttributes中的字符串属性）
{
ConditionExpression expr=新的ConditionExpression（）；
expr.AttributeName=attr；
expr.Operator=ConditionOperator.Like；
expr.Values=新字符串[]{“%”+单词+“%”}；
条件。添加（expr）；
}
FilterExpression filter=新的FilterExpression（）；
filter.FilterOperator=逻辑运算符。或；
filter.Conditions=Conditions.ToArray（）；
回流过滤器；
}
私有条件表达式[]构建条件（字符串[]单词，字符串[]SeachatAttributes）
{
列表条件=新列表（）；
foreach（单词中的字符串s）
{
foreach（SeachatAttributes中的字符串属性）
{
ConditionExpression expr=新的ConditionExpression（）；
expr.AttributeName=attr；
expr.Operator=ConditionOperator.Like；
expr.Values=新字符串[]{“%”+s+“%”}；
条件。添加（expr）；
}
}
返回条件。ToArray（）；
}

嗯，这是一个非常有趣的场景

您当然可以执行“Like”查询，并将希望包含在搜索中的列/属性条件一起执行“or”。CRM似乎就是这样从实体列表上方的框中进行查询的（而且它们非常快速）。看起来CRM数据库有一个全文索引，尽管在短暂浏览之后，我对用于填充该数据库的具体列有点迷茫

记住CRM查询爱（我开始了这个项目，很抱歉这个无耻的插件）。