Content Search using an index and Predicate

public static string IndexName = String.Format("sitecore_{0}_index", Sitecore.Context.Database.Name);

ISearchIndex index = ContentSearchManager.GetIndex(SearchUtil.Settings.IndexName);

                    using (var context = index.CreateSearchContext())

                    {

                        List<ID> templatesIdsToFind = new List<ID>

                        {

                            ILogbookArticleEntryConstants.TemplateId,

                            ILogbookPhotoEntryConstants.TemplateId,

                            ILogbookVideoEntryConstants.TemplateId,

                            ILogbookCampaignEntryConstants.TemplateId

                        };

                        // Build an "or" predicate for each type

                        var typePredicate = PredicateBuilder.True<LogbookSearchResultItem>();

                        typePredicate = templatesIdsToFind.Aggregate(typePredicate,

                            (current, id) => current.Or(l => l.TemplateId == id));

                        ID topicsFilterRoot = new ID(Model.TopicsFilterRoot);

                        var queryable = context.GetQueryable<LogbookSearchResultItem>()

                            .Where(item => item.LatestVersion)

                            .Where(typePredicate)

                            .Where(item => item.Language == Sitecore.Context.Language.Name);

                        // Limit results to only those below the topics filter root, if one is set

                        if (Model.TopicsFilterRoot != Guid.Parse(ResourceIDs.ContentItemIDs.TxtAv.MetaDataRoot))

                        {

                            queryable = queryable.Where(item => item.Categories.Contains(topicsFilterRoot));

                        }

                        // Facet

                        queryable = queryable

                            .FacetOn(item => item.Categories)

                            .FacetOn(item => item.TemplateId);

                        // Apply track/topic filter

                        if (SearchQueryBuilder.TopicFilterOption.HasValue)

                        {

                            ID trackId = new ID(SearchQueryBuilder.TopicFilterOption.Value);

                            queryable = queryable.Where(item => item.Tracks.Contains(trackId));

                        }

                        // Apply Media Type filter

                        if (SearchQueryBuilder.MediaTypeFilterOption.HasValue)

                        {

                            ID mediaId = new ID(SearchQueryBuilder.MediaTypeFilterOption.Value);

                            queryable = queryable.Where(item => item.TemplateId == mediaId);

                        }

                        // Apply aircraft filter

                        if (SearchQueryBuilder.AircraftFilterOption.HasValue)

                        {

                            ID aircraftId = new ID(SearchQueryBuilder.AircraftFilterOption.Value);

                            queryable = queryable.Where(item => item.Categories.Contains(aircraftId));

                        }

                        // Apply search filter

                        if (!string.IsNullOrEmpty(SearchQueryBuilder.SearchQuery))

                        {

                            string[] splitSearchString = SearchQueryBuilder.SearchQuery.Split(' ');

                            var queryPredicate = PredicateBuilder.True<LogbookSearchResultItem>();

                            queryPredicate = splitSearchString.Aggregate(queryPredicate,

                                (current, term) => current.Or(l => l.Content.Contains(term)));

                            queryPredicate = splitSearchString.Aggregate(queryPredicate,

                                (current, term) => current.Or(l => l.TrackNames.Contains(term)));

                            queryable = queryable.Where(queryPredicate);

                        }

                        // Sort by entry date

                        queryable = queryable.OrderByDescending(item => item.EntryDate);

                        // Get the results

                        var results = queryable.GetResults();

                        TotalLogbookItems = results.TotalSearchResults;

                        BindFilterDropDownLists(results);

                        // Apply pagination and build list of items

                        int currentPage = SearchQueryBuilder.CurrentPage ?? 1;

                        foreach (var hit in results.Hits.Take(currentPage * Model.PageSize))

                        {

                            BaseLogbookEntry entry = hit.Document.GetItem().GlassCast<BaseLogbookEntry>();

                            if (entry != null)

                            {

                                LogbookItems.Add(entry);

                            }

                        }

                        BindResultSummaryMessage();

                    }

                }