public interface ISpecification<T> where T : BaseEntity
{
        Expression<Func<T, bool>> IsSatisfied();
}

...select new {a, b, c }

q = q.Where(mySpecification.IsSatisfied())

public interface ISpecification<T> where T : BaseEntity
{
        IQueryable<T> Specify(IQueryable<T> source);
}

q = q.Where(mySpecification.IsSatisfied())

q = mySpecification.Specify(q);

public interface ISpecification<T> where T : BaseEntity
{
        IQueryable<T> Specify(IQueryable<T> source);
}

where T : BaseEntity

new {a, b, c }

repository.SaveChanges();

public class AmountTransactionQuery
    {
        public IQueryable<AmountTransactionDTO> Get(IQueryable<AmountTransaction> queryable1,
            IQueryable<Account> queryable2,
            IQueryable<User> queryable3)
        {
            return (from t in queryable1
                    join a in queryable2 on t.AccountId equals a.Id
                    join ac in queryable2 on t.СorrespondentAccountId equals ac.Id
                    join uc in queryable3 on ac.UserId equals uc.Id
                    select new AmountTransactionDTO()
                    {
                        Id = t.Id,
                        DateTransaction = t.DateTransaction,
                        Amount = Math.Round(t.Amount, 2),
                        Balance = t.Balance,
                        CorrespondentAccountUserName = uc.UserName,
                        UserId = a.UserId,
                        СorrespondentAccountId = t.СorrespondentAccountId,
                        СorrespondentAccountUserId = uc.Id
                    });
        }
}

// нужные интерфейсы

public interface IQuery {}
public interface IQuery<TResult> : IQuery {}
public interface IQueryHandler<TQuery> where TQuery : IQuery
{
   IEnumerable<TResult> Handle(TQuery query);
}
public interface IQueryProcessor
{
   IEnumerable<TResult> Process<TResult>(IQuery<TResult> query);
}

// вот что должно быть в итоге:

public class AmountTransactionService : BaseService, IAmountTransactionService
{
   ...
   public AmountTransactionService(..., IQueryProcessor queryProcessor,...)
   {
       ...
       _queryProcessor = queryProcessor;
       ...
   }
   ...
   public IEnumerable<AccountDTO> GetListCorrespondentAccount(long userId)
        {
            
            //  вместо этой фигни
            //

            AmountTransactionQuery amountTransactionQuery = new AmountTransactionQuery();
            var qb = amountTransactionQuery.Get(amountTransactionRepository.GetList(),
                accountRepository.GetList(),
                userRepository.GetList()).Where(t => t.UserId == userId);

            var q = from t in qb
                    group t by new { t.СorrespondentAccountId, t.CorrespondentAccountUserName, t.UserId } into grp
                    orderby grp.Max(t => t.DateTransaction) descending
                    let maxDateTransaction = grp.Max(t => t.DateTransaction)
                    select new AccountDTO()
                    {
                        Id = grp.Key.СorrespondentAccountId,
                        UserId = grp.Key.UserId,
                        UserName = grp.Key.CorrespondentAccountUserName,
                        MaxDateTransaction = maxDateTransaction
                    };

            return q.ToList();

            // вот так правильно и красиво

            // получаем уже материализованные данные, а не IQueryable
            var result = _queryProcessor(new CorrespondentAccountQuery(userId));
            // делаем чо надо, отдаём результат. всё красиво и понятно, вся логика запроса инкапсулирована
            // внутри соответствующего QueryHandler, он же получает нужные зависимости и там только запрос
            // никакой логики 
            return result;
}