My Repository class has a few methods for operations with the database. I recently developed the FindAsync() method, which allows you to grab only a few rows from the database based on an expression.

using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Orbit.Infrastructure.Repositories.Interfaces;
using System.Linq.Expressions;

namespace Orbit.Infrastructure.Repositories
{
    public class Repository<TEntity> : IRepository<TEntity> where TEntity : class
    {
        protected readonly DbContext Context;

        public Repository(DbContext context, IConfiguration configuration)
        {
            IConfigurationSection sectNamespaces = configuration.GetSection("AllowedEntityNamespaces");
            List<string> namespacesInConfig = [];

            foreach (IConfigurationSection child in sectNamespaces.GetChildren())
            {
                namespacesInConfig.Add(child.Path);
            }

            if (namespacesInConfig.Contains(typeof(TEntity).Namespace!))
            {
                throw new ArgumentException($"O namespace ${typeof(TEntity).Namespace} não está habilitado!");
            }
            Context = context;
            }

        public async Task AddAsync(TEntity entity)
        {
            ArgumentNullException.ThrowIfNull(nameof(entity));
            _ = await Context.Set<TEntity>().AddAsync(entity);
        }

        public async Task AddRangeAsync(IEnumerable<TEntity> entities)
        {
            ArgumentNullException.ThrowIfNull(nameof(entities));
            await Context.Set<TEntity>().AddRangeAsync(entities);
        }

        public async Task<IEnumerable<TEntity>> FindAsync(Expression<Func<TEntity, bool>> predicate)
        {
            ArgumentNullException.ThrowIfNull(predicate);
            return await Context.Set<TEntity>().Where(predicate).ToListAsync();
        }

        public async Task<IEnumerable<TEntity>> GetAllAsync()
        {
            return await Context.Set<TEntity>().ToListAsync();
        }

        public async Task<IEnumerable<TEntity>> GetAllAsync(params string[] navProperties)
        {
            IQueryable<TEntity> entities = Context.Set<TEntity>().AsQueryable();
            foreach (string prop in navProperties)
            {
                entities = entities.Include(prop);
            }

            return await entities.ToListAsync();
        }

        public async Task<TEntity?> GetAsync(int id)
        {
            ArgumentNullException.ThrowIfNull(id);
            return await Context.Set<TEntity>().FindAsync(id);
        }

        public async Task RemoveAsync(TEntity entity)
        {
            ArgumentNullException.ThrowIfNull(entity);
            await Task.Run(() =>
            {
                _ = Context.Set<TEntity>().Remove(entity);
            });
        }

        public async Task RemoveRangeAsync(IEnumerable<TEntity> entities)
        {
            ArgumentNullException.ThrowIfNull(entities);
            await Task.Run(() =>
            {
                Context.Set<TEntity>().RemoveRange(entities);
            });
        }

    }
}

Up until now, in most operations where I needed to grab one or more users based on a specific criterion, I pulled in all the users (using GetAllAsync()) and only then did I filter the users using LINQ. I realized that this was not the best solution. Ideally, you would want to throw this load of pulling a few specific users into the efcore and balance the load on the application.

In my class of services I also developed a method that allows you to find a user based on a predicate and that’s where the problem lies.

UserAddRequest (DTO)

using Orbit.Domain.Entities;
using System.ComponentModel.DataAnnotations;

namespace Orbit.Application.Dtos.Requests
{
    public class UserAddRequest
    {
        [Required(ErrorMessage = "Insira o nome do usuário!")]
        [StringLength(100, MinimumLength = 5, ErrorMessage = "O nome do usuário deve ter no máximo 100 caracteres.")]
        [RegularExpression(@"^[a-zA-Z0-9_]*$", ErrorMessage = "O nome do usuário só pode conter letras, números e underline.")]
        [Display(Name = "Name")]
        public string UserName { get; set; } = null!;

        [Required(ErrorMessage = "Insira o email do usuário!")]
        [StringLength(200, ErrorMessage = "O email do usuário deve ter no máximo 200 caracteres.")]
        [EmailAddress(ErrorMessage = "O email do usuário não é válido.")]
        [Display(Name = "Email")]
        public string UserEmail { get; set; } = null!;

        [Required(ErrorMessage = "Insira a data de nascimento do usuário!")]
        [DataType(DataType.Date, ErrorMessage = "Formato de data inválido.")]
        [Display(Name = "Data de Nascimento")]
        public DateOnly UserDateOfBirth { get; set; }

        [Required(ErrorMessage = "Insira a senha do usuário!")]
        [StringLength(200, ErrorMessage = "A senha do usuário deve ter no máximo 200 caracteres.")]
        [RegularExpression(@"^(?=.*?[A-Z])(?=.*?[a-z])(?=.*?[0-9])(?=.*?[#?!@$ %^&*-]).{8,}$", ErrorMessage = "A senha deve conter pelo menos uma letra minúscula, uma letra maiúscula, um caractere especial (@$!%*?&)")]
        [Display(Name = "Senha")]
        public string UserPassword { get; set; } = null!;

        [Required(ErrorMessage = "O campo {0} é obrigatório.")]
        [Range(1, 31, ErrorMessage = "O campo {0} deve estar entre 1 e 31.")]
        [Display(Name = "Dia")]
        public int Day { get; set; }

        [Required(ErrorMessage = "O campo {0} é obrigatório.")]
        [Range(1, 12, ErrorMessage = "O campo {0} deve estar entre 1 e 12.")]
        [Display(Name = "Mês")]
        public int Month { get; set; }

        [Required(ErrorMessage = "O campo {0} é obrigatório.")]
        [Range(1, 9999, ErrorMessage = "O campo {0} deve estar entre 1 e 9999.")]
        [Display(Name = "Ano")]
        public int Year { get; set; }

        public User ToUser()
        {
            return new User
            {
                UserName = UserName,
                UserDateOfBirth = new DateOnly(Year, Month, Day),
                UserEmail = UserEmail,
                UserPassword = UserPassword
            };
        }
    }
}

UserResponse (DTO)

using Orbit.Domain.Entities;

namespace Orbit.Application.Dtos.Responses
{
    public class UserResponse
    {
        public uint UserId { get; set; }
        public string UserName { get; set; } = null!;
        public string UserEmail { get; set; } = null!;
        public DateOnly UserDateOfBirth { get; set; }
        public string UserPassword { get; set; } = null!;
        public string? UserDescription { get; set; }
        public byte[]? UserImageByteType { get; set; }
        public string? UserProfileName { get; set; }
        public ICollection<UserResponse>? Followers { get; set; }
        public ICollection<UserResponse>? Users { get; set; }
    }

    public static class UserExtensions
    {
        public static UserResponse ToUserResponse(this User user)
        {
            return user.ToUserResponseInternal([]);
        }

        private static UserResponse ToUserResponseInternal(this User user, List<uint> processedUserIds)
        {
            if (processedUserIds.Contains(user.UserId))
            {
                return new UserResponse
                {
                    UserId = user.UserId,
                    UserName = user.UserName,
                    UserEmail = user.UserEmail,
                    UserDateOfBirth = user.UserDateOfBirth,
                    UserPassword = user.UserPassword,
                    UserDescription = user.UserDescription,
                    UserProfileName = user.UserProfileName,
                    UserImageByteType = user.UserImageByteType,
                    Followers = [],
                    Users = []
                };
            }

            processedUserIds.Add(user.UserId);

            UserResponse response = new()
            {
                UserId = user.UserId,
                UserName = user.UserName,
                UserEmail = user.UserEmail,
                UserDateOfBirth = user.UserDateOfBirth,
                UserPassword = user.UserPassword,
                UserDescription = user.UserDescription,
                UserProfileName = user.UserProfileName,
                UserImageByteType = user.UserImageByteType,
                Followers = user.Followers.Select(u => u.ToUserResponseInternal(new List<uint>(processedUserIds))).ToList(),
                Users = user.Users.Select(u => u.ToUserResponseInternal(new List<uint>(processedUserIds))).ToList()
            };

            return response;
        }
    }

}
User Model (EFcore and repository model)

namespace Orbit.Domain.Entities;

public partial class User
{
    public uint UserId { get; set; }

    public string UserName { get; set; } = null!;

    public string UserEmail { get; set; } = null!;

    public DateOnly UserDateOfBirth { get; set; }

    public string UserPassword { get; set; } = null!;

    public string? UserDescription { get; set; }

    public byte[]? UserImageByteType { get; set; }

    public string? UserProfileName { get; set; }

    public virtual ICollection<User> Followers { get; set; } = [];

    public virtual ICollection<User> Users { get; set; } = [];
}

My FindUserAsync method of the UserService class has an Expression<Func<UserResponse, bool>> as a parameter, and the FindAsync method of the Repository takes an Expression<Func<TEntity, bool>> as an argument. In the service class, the generic TEntity is actually the User Model

public async Task<IEnumerable<UserResponse>> FindUsersAsync(Func<UserResponse, bool> predicate)
{
    return await _unitOfWork.User.FindAsync(predicate); // This isn't allowed. Causes compilation error
}

How can I convert one expression to another? Is there a way to convert the expressions or use string to map? I don’t have the slightest idea how to proceed from here.

I’ve tried to find some solutions on the internet, but I haven’t found anything that I understand in the slightest bit about what’s going on.

Thanks!