Hi all I want to be able to search in Umbraco by the domain part of a member's email address.

I've been advised to add this setting to enable leading wildcards

<add name="InternalMemberSearcher" type="UmbracoExamine.UmbracoExamineSearcher, UmbracoExamine"
           analyzer="Lucene.Net.Analysis.Standard.StandardAnalyzer, Lucene.Net" enableLeadingWildcard="true"/>

So I've done that, and now I've edited the method in EntitiesController. I've commented above the line I added.

    private IEnumerable<EntityBasic> ExamineSearch(string query, UmbracoEntityTypes entityType, int pageSize, int pageIndex, out int totalFound, string searchFrom = null)
    {
        //TODO: We need to update this to support paging

        var sb = new StringBuilder();

        string type;
        var searcher = Constants.Examine.InternalSearcher;            
        var fields = new[] { "id", "__NodeId" };

        //TODO: WE should really just allow passing in a lucene raw query
        switch (entityType)
        {
            case UmbracoEntityTypes.Member:
                searcher = Constants.Examine.InternalMemberSearcher;
                type = "member";
                fields = new[] { "id", "__NodeId", "email", "loginName"};
                if (searchFrom != null && searchFrom != Constants.Conventions.MemberTypes.AllMembersListId && searchFrom.Trim() != "-1")
                {
                    sb.Append("+__NodeTypeAlias:");
                    sb.Append(searchFrom);
                    sb.Append(" ");
                }
                break;
            case UmbracoEntityTypes.Media:
                type = "media";

                var mediaSearchFrom = int.MinValue;

                if (Security.CurrentUser.StartMediaId > 0 ||
                    //if searchFrom is specified and it is greater than 0
                    (searchFrom != null && int.TryParse(searchFrom, out mediaSearchFrom) && mediaSearchFrom > 0))
                {
                    sb.Append("+__Path: \\-1*\\,");
                    sb.Append(mediaSearchFrom > 0
                        ? mediaSearchFrom.ToString(CultureInfo.InvariantCulture)
                        : Security.CurrentUser.StartMediaId.ToString(CultureInfo.InvariantCulture));
                    sb.Append("\\,* ");
                }
                break;
            case UmbracoEntityTypes.Document:
                type = "content";

                var contentSearchFrom = int.MinValue;

                if (Security.CurrentUser.StartContentId > 0 || 
                    //if searchFrom is specified and it is greater than 0
                    (searchFrom != null && int.TryParse(searchFrom, out contentSearchFrom) && contentSearchFrom > 0))
                {
                    sb.Append("+__Path: \\-1*\\,");
                    sb.Append(contentSearchFrom > 0
                        ? contentSearchFrom.ToString(CultureInfo.InvariantCulture)
                        : Security.CurrentUser.StartContentId.ToString(CultureInfo.InvariantCulture));
                    sb.Append("\\,* ");
                }
                break;
            default:
                throw new NotSupportedException("The " + typeof(EntityController) + " currently does not support searching against object type " + entityType);                    
        }

        var internalSearcher = ExamineManager.Instance.SearchProviderCollection[searcher];

        //build a lucene query:
        // the __nodeName will be boosted 10x without wildcards
        // then __nodeName will be matched normally with wildcards
        // the rest will be normal without wildcards


        //check if text is surrounded by single or double quotes, if so, then exact match
        var surroundedByQuotes = Regex.IsMatch(query, "^\".*?\"$")
                                 || Regex.IsMatch(query, "^\'.*?\'$");

        if (surroundedByQuotes)
        {
            //strip quotes, escape string, the replace again
            query = query.Trim(new[] { '\"', '\'' });

            query = Lucene.Net.QueryParsers.QueryParser.Escape(query);

            //nothing to search
            if (searchFrom.IsNullOrWhiteSpace() && query.IsNullOrWhiteSpace())
            {
                totalFound = 0;
                return new List<EntityBasic>();
            }

            //update the query with the query term
            if (query.IsNullOrWhiteSpace() == false)
            {
                //add back the surrounding quotes
                query = string.Format("{0}{1}{0}", "\"", query);

                //node name exactly boost x 10
                sb.Append("+(__nodeName: (");
                sb.Append(query.ToLower());
                sb.Append(")^10.0 ");

                foreach (var f in fields)
                {
                    //additional fields normally
                    sb.Append(f);
                    sb.Append(": (");
                    sb.Append(query);
                    sb.Append(") ");
                }

                sb.Append(") ");
            }
        }
        else
        {
            var trimmed = query.Trim(new[] {'\"', '\''});

            //nothing to search
            if (searchFrom.IsNullOrWhiteSpace() && trimmed.IsNullOrWhiteSpace())
            {
                totalFound = 0;
                return new List<EntityBasic>();
            }

            //update the query with the query term
            if (trimmed.IsNullOrWhiteSpace() == false)
            {
                query = Lucene.Net.QueryParsers.QueryParser.Escape(query);

                var querywords = query.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);

                //node name exactly boost x 10
                sb.Append("+(__nodeName:");
                sb.Append("\"");
                sb.Append(query.ToLower());
                sb.Append("\"");
                sb.Append("^10.0 ");

                //node name normally with wildcards
                sb.Append(" __nodeName:");
                sb.Append("(");
                foreach (var w in querywords)
                {
                    sb.Append(w.ToLower());
                    sb.Append("* ");
                }
                sb.Append(") ");


                foreach (var f in fields)
                {
                    //additional fields normally
                    sb.Append(f);
                    sb.Append(":");
                    sb.Append("(");
                    foreach (var w in querywords)
                    {
                        //I added this line below
                        sb.Append("*");
                        sb.Append(w.ToLower());
                        sb.Append("* ");
                    }
                    sb.Append(")");
                    sb.Append(" ");
                }

                sb.Append(") ");
            }
        }

        //must match index type
        sb.Append("+__IndexType:");
        sb.Append(type);

        var raw = internalSearcher.CreateSearchCriteria().RawQuery(sb.ToString());

        var result = internalSearcher
            //only return the number of items specified to read up to the amount of records to fill from 0 -> the number of items on the page requested
            .Search(raw, pageSize * (pageIndex + 1)); 

        totalFound = result.TotalItemCount;

        var pagedResult = result.Skip(pageIndex);

        switch (entityType)
        {
            case UmbracoEntityTypes.Member:
                return MemberFromSearchResults(pagedResult.ToArray());
            case UmbracoEntityTypes.Media:
                return MediaFromSearchResults(pagedResult);                    
            case UmbracoEntityTypes.Document:
                return ContentFromSearchResults(pagedResult);
            default:
                throw new NotSupportedException("The " + typeof(EntityController) + " currently does not support searching against object type " + entityType);
        }
    }

It hasn't worked, I get a YSOD error message.

Please can you help me, or tell me I'm doing it wrong, or point me in the right direction.