using System;
using System.Linq.Expressions;

namespace Test
{
    public interface IBase { int Id { get; set; } }
    public class Run
    {
        public Run()
        {
            Expression<Func<IBase, bool>> filter = x => x.Id == 1;
            var a1 = new A1(filter);
        }
    }

    public class A1 : AbstrReload<Entity1>
    {
        public A1(Expression<Func<IBase, bool>> filter)
        {
            Reload(filter); // Вот здесь происходит не соответствие типов
        }
    }

    public abstract class AbstrReload<TEntity>
        where TEntity : class, IBase
    {
        protected void Reload(Expression<Func<TEntity, bool>> filter)
        {
        } 
    }

    public class Entity1 : IBase
    {
        public int Id { get; set; }
        public string Name { get; set; }
    }
    public class Entity2 : IBase
    {
        public int Id { get; set; }
        public string Caption { get; set; }
    }
}

public abstract class AbstrReload<TEntity>
        where TEntity : class, IBase
    {
        protected DbContext Context;

        protected void Reload(Expression<Func<TEntity, bool>> filter)
        {
            List<TEntity> items = Context.Set<TEntity>().AsNoTracking().Where(filter).ToList();
        }
    }

public interface IBase { int Id { get; set; } }
public class Entity1 : IBase
{
    public int Id { get; set; }
    public string Name { get; set; }
}
public class Entity2 : IBase
{
    public int Id { get; set; }
    public string Caption { get; set; }
}
// Вариант №1
Expression<Func<Entity1, bool>> filter = x => x.Name != null;
new A1(filter);

// Вариант №2 (Ошибка при преобразовании IBase в Entity1 или Entity2)
Expression<Func<IBase, bool>> filter = x => x.Id == 1;
Expression convert = Expression.Convert(filter.Body, typeof(Entity1));

public class A1 : AbstrReload<Entity1>
{
    public A1(Expression<Func<Entity1, bool>> filter)
    {
         Reload(filter);
    }
}
public abstract class AbstrReload<TEntity> where TEntity : class, IBase
{
    protected void Reload(Expression<Func<TEntity, bool>> filter)
    {
    } 
}

Expression<Func<IBase, bool>> filter = x => x.Id == 1;
Expression convert = Expression.Convert(filter.Body, typeof(Entity1));

Entity1 entity = new Entity1();
IBase ibase = entity as IBase;
entity  = (Entity1)ibase;

// Ваш пример:
var a1 = new A1(x => x.Id == 1); // теперь всё работает!

// Это вариант уже создаёт проблему в реализации!
var a1 = Activator.CreateInstance(typeof(A1), /* вот как тут объявишь expression в реалтайме, если знаешь только getType() объекта (Entity1 или Entity2)? */)

// Ваш пример:
var a = new A1(x => x.Id == 1); // теперь всё работает!
           
// Создание лямбды при помощи expression, в реалтайме ( когда знаем только типы объектов (getType()) ) 
ParameterExpression parametr = Expression.Parameter(typeof(Entity1), "x");
MemberExpression property = Expression.Property(parametr, "Id");
BinaryExpression equal = Expression.Equal(property, Expression.Constant(1));
var delegateType = typeof (Func<,>).MakeGenericType(typeof(Entity1), typeof(bool));
var runtimeExpression = Expression.Lambda(delegateType, equal, parametr);
var classA1Creator = Activator.CreateInstance(typeof(A1), runtimeExpression);