Developer forum

        protected virtual IEnumerable<KeyValuePair<String, Int32>> GetQueryFacets(Query query, string facetField)
        {
            facetField = facetField.ToLowerInvariant();
            if (!FacetsCacheContainer.ContainsKey(facetField))
            {
                var cache = new List<FacetValueCache>();
                var allDistinctField = FieldCache_Fields.DEFAULT.GetStrings(IndexReader, facetField).Distinct();

                foreach (var fieldValue in allDistinctField)
                {
                    if (!String.IsNullOrWhiteSpace(fieldValue)) // We do not want to search for null values
                    {
                        var facetQuery = new TermQuery(new Term(facetField, fieldValue));
                        var facetQueryFilter = new CachingWrapperFilter(new QueryWrapperFilter(facetQuery));
                        cache.Add(new FacetValueCache(fieldValue, facetQueryFilter));
                    }
                }
                FacetsCacheContainer.Add(facetField, cache);
            }

            //now calculate facets.
            var mainQueryFilter = new CachingWrapperFilter(new QueryWrapperFilter(query));
            var facetDefinition = FacetsCacheContainer[facetField];
            return facetDefinition.Select(fd =>
                new KeyValuePair<String, Int32>(fd.FacetValue, fd.GetFacetCount(IndexReader, mainQueryFilter)));
        }

internal Document AsDocument(bool createSumaryField)
        {
            var document = new Document();
            var dictionary = new Dictionary<string, string>(this.Fields);
            if (createSumaryField)
                dictionary.Add(IndexEntry.GetSystemFieldName(IndexEntrySystemField.Summary), this.Summary);
            foreach (string name in dictionary.Keys)
            {
                if (!string.IsNullOrEmpty(dictionary[name]))
                {
                    string str2 = dictionary[name];
                    IndexEntryFieldInfo indexEntryFieldInfo = this.InitializeField(name, str2);
                    if (indexEntryFieldInfo != null)
                    {
                        if (indexEntryFieldInfo.Value is Enumerable)
                        {
                            foreach (var value in indexEntryFieldInfo.Value)
                            {
                                document.Add(
                                    new Field(indexEntryFieldInfo.Name, value,
                                              indexEntryFieldInfo.Store ? Field.Store.YES : Field.Store.NO,
                                              indexEntryFieldInfo.Tokenize ? Field.Index.ANALYZED : Field.Index.NOT_ANALYZED,
                                              indexEntryFieldInfo.UseTermVector ? Field.TermVector.YES : Field.TermVector.NO));
                            }
                        }
                        else
                        {
                            document.Add(
                                new Field(indexEntryFieldInfo.Name, Convert.ToString(indexEntryFieldInfo.Value),
                                          indexEntryFieldInfo.Store ? Field.Store.YES : Field.Store.NO,
                                          indexEntryFieldInfo.Tokenize ? Field.Index.ANALYZED : Field.Index.NOT_ANALYZED,
                                          indexEntryFieldInfo.UseTermVector ? Field.TermVector.YES : Field.TermVector.NO));
                        }
                    }
                }
            }
            return document;
        }

using Dynamicweb.Searching;
using Dynamicweb.Searching.Queries;
using Dynamicweb.Searching.Queries.Criterias;

...

// Select distinct group Ids either from DB or search index
IEnumerable<string> groupIds = GetGroupIds();

// Queuing group Ids
var groups = new Queue<string>(groupIds);

// The actual search query, e.g. "sys_description:bike"
var query = new SearchQuery(/* ... */);

// Serving next group Id without rebuilding the query (performance)
query.Add(new VolatileQueryElement((reset) =>
	{
		return groups.Any() ?
			new Criteria("groups", groups.Dequeue()) 
			: null;
	}));

// Querying the index (bulk mode)
BulkQuerySearchResult<string, GeneralIndexEntry> result =
	IndexManager.Current.BulkQueryIndex<string, GeneralIndexEntry>("Products", query, groupIds);

var estimates = new Dictionary<string, long>();

// Building a dictionary with estimates (group Id -> # of search results)
foreach (var groupId in result.Keys)
	estimates.Add(groupId, result.GetResult(groupId).Total);

var allDistinctField = FieldCache_Fields.DEFAULT.GetStrings(IndexReader, facetField).Distinct();