I have a base class that creates a query. The classes that inherit it just have to set the criteria. On occassion I get the following error: Execution of query against the server was successful but execution of query against the local cache failed.

#region using

using System;

using System.Collections.ObjectModel;

using System.Collections.Generic;

using System.IO;

using System.Linq;

using System.Linq.Expressions;

using System.Text;

using IdeaBlade.Linq;

using xxx.DomainModel;

using xxx.Foundation.Interfaces;

#endregion

namespace xxx

{

    public class Searcher<TSearchableEntity> : ISearcher where TSearchableEntity : IdeaBlade.EntityModel.Entity

    {

        #region using

        private string mCriteria;

        private IdeaBlade.EntityModel.EntityQuery<TSearchableEntity> mQuery = new IdeaBlade.EntityModel.EntityQuery<TSearchableEntity>();

        private EntityManager mEntityManager;

        private ObservableCollection<TSearchableEntity> mDataSource;

        private List<CriteriaColumn<TSearchableEntity>> mCriteriaColumns = new List<CriteriaColumn<TSearchableEntity>>();

        #endregion

        public Searcher()

        {

            BuildWhere();

            mEntityManager = EntityManager.DefaultManager;

        }

        public void Clear()

        {

            Criteria = string.Empty;

            DataSource = null;

        }

        #region Properties

        public string Criteria

        {

            get { return mCriteria; }

            set { mCriteria = value; }

        }

        public ObservableCollection<TSearchableEntity> DataSource

        {

            get { return mDataSource; }

            set { mDataSource = value; }

        }

        public List<CriteriaColumn<TSearchableEntity>> CriteriaColumns

        {

            get { return mCriteriaColumns; }

            set { mCriteriaColumns = value; }

        }

        #endregion

        /// <summary>

        /// Configure where clause for search routines.

        /// </summary>

        /// <example>

        ///    CriteriaColumns.Add(new CriteriaColumn<Contact>(Contact.EntityPropertyNames.FirstName, c => c.FirstName.Contains(Criteria)));

        ///    CriteriaColumns.Add(new CriteriaColumn<Contact>(Contact.EntityPropertyNames.InActive, c => c.InActive == false, LogicalOperation.And));

        /// </example>

        protected virtual void BuildWhere() { }

        /// <summary>

        /// Configure OrderBy clause for search routine results.

        /// </summary>

        /// <exmple>

        /// return pResultList.OrderBy(l => l.LastName).ThenBy(f => f.FirstName).ToList();

        /// </exmple>

        /// <param name="pResultList"></param>

        /// <returns></returns>

        protected virtual IList<TSearchableEntity> OrderBy(IdeaBlade.EntityModel.IEntityQuery<TSearchableEntity> pResultList) { return pResultList.ToList(); }

        /// <summary>

        /// Perform the search feature and return results.       

        /// </summary>

        /// <remarks>

        /// Searches the current datasource if exists if not searches the database.

        /// </remarks>

        /// <returns></returns>

        public ObservableCollection<TSearchableEntity> PerformSearch()

        {

            ObservableCollection<TSearchableEntity> mResults = new ObservableCollection<TSearchableEntity>();

            Expression<Func<TSearchableEntity, bool>> pred = SearchPredicateBuilder();

            if (mDataSource == null)

            {

                IdeaBlade.EntityModel.IEntityQuery<TSearchableEntity> mResultList = mEntityManager.GetQuery<TSearchableEntity>();

                //Apply Predicate if Criteria exists

                if (Criteria != null && Criteria != string.Empty)

                    mResultList = (IdeaBlade.EntityModel.IEntityQuery<TSearchableEntity>)mResultList.Where(pred);

                //Apply And predicates if Criteria exists or not

                else if (CriteriaColumnArray(LogicalOperation.And).Length > 0)

                    mResultList = (IdeaBlade.EntityModel.IEntityQuery<TSearchableEntity>)mResultList.Where(AndPredicateBuilder(null));               

                mResultList.QueryStrategy = IdeaBlade.EntityModel.QueryStrategy.DataSourceOnly;

                mResults = new ObservableCollection<TSearchableEntity>(OrderBy(mResultList));

            }

            else

                mResults = DataSourceSearch();

            return mResults;

        }

        public System.Collections.IEnumerable Search()

        {

            return PerformSearch();

        }

        /// <summary>

        /// Seach the datasource for the specified criteria.

        /// </summary>

        /// <returns></returns>

        private ObservableCollection<TSearchableEntity> DataSourceSearch()

        {

            ObservableCollection<TSearchableEntity> mResults = new ObservableCollection<TSearchableEntity>();

            foreach (TSearchableEntity aEntity in DataSource)

            {

                foreach (CriteriaColumn<TSearchableEntity> aColumn in CriteriaColumns)

                {

                    if (aEntity.EntityAspect[aColumn.Property].ToString().Contains(Criteria))

                    {

                        mResults.Add(aEntity);

                        break;

                    }

                }

            }

            return mResults;

        }

        /// <summary>

        /// Convert CriteriaColumn collection to an array for helping PerformSearch().

        /// </summary>

        /// <param name="pLogicalOperation"></param>

        /// <returns></returns>

        private Expression<Func<TSearchableEntity, bool>>[] CriteriaColumnArray(LogicalOperation pLogicalOperation)

        {

            List<Expression<Func<TSearchableEntity, bool>>> mCriteriaArray = new List<Expression<Func<TSearchableEntity, bool>>>();

            foreach (CriteriaColumn<TSearchableEntity> aColumn in CriteriaColumns)

            {

                if (aColumn.LogicalOperation == pLogicalOperation)

                    mCriteriaArray.Add(aColumn.Expression);

            }

            return mCriteriaArray.ToArray();

        }

        /// <summary>

        /// Create And predicatebuilder info.

        /// </summary>

        /// <param name="pPredicate"></param>

        /// <returns></returns>

        private Expression<Func<TSearchableEntity, bool>> AndPredicateBuilder(Expression<Func<TSearchableEntity, bool>> pPredicate)

        {

            Expression<Func<TSearchableEntity, bool>> mPredicate = pPredicate;

            Expression<Func<TSearchableEntity, bool>>[] mAnd = CriteriaColumnArray(LogicalOperation.And);

            for (int i = 0; i < mAnd.Length; i++)

            {

                if (pPredicate == null)

                    pPredicate = PredicateBuilder.And<TSearchableEntity>(mAnd[0]);

                else

                    pPredicate = pPredicate.And<TSearchableEntity>(mAnd);

            }

            return pPredicate;

        }

        /// <summary>

        /// Get the or predicatebuilder info.

        /// </summary>

        /// <returns></returns>

        private Expression<Func<TSearchableEntity, bool>> SearchPredicateBuilder()

        {

            Expression<Func<TSearchableEntity, bool>> mPredicate = PredicateBuilder.Or<TSearchableEntity>(CriteriaColumnArray(LogicalOperation.Or));

            mPredicate = AndPredicateBuilder(mPredicate);

            return mPredicate;

        }

    }

    public class CriteriaColumn<TSearchableEntity> where TSearchableEntity : IdeaBlade.EntityModel.Entity

    {

        public string Property;

        public Expression<Func<TSearchableEntity, bool>> Expression;

        public LogicalOperation LogicalOperation;

        public CriteriaColumn(string pProperty, Expression<Func<TSearchableEntity, bool>> pExpression)

        {

            Property = pProperty;

            Expression = pExpression;

            LogicalOperation = LogicalOperation.Or;

        }

        public CriteriaColumn(string pProperty, Expression<Func<TSearchableEntity, bool>> pExpression, LogicalOperation pLogicalOperation)

        {

            Property = pProperty;

            Expression = pExpression;

            LogicalOperation = pLogicalOperation;

        }

    }

    public enum LogicalOperation

    {

        Or, And

    }

}