Occassional local cache failed error

);

   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.
What would cause this?

Class:
#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
    }
}