public class CityService : ICityService
    {
        private readonly IUnitOfWork _uow;
        private readonly IDbSet<City> _city;

        public CityService(IUnitOfWork uow)
        {
            _uow = uow;
            _city = _uow.Set<City>();
        }

        public int AddCity(City city)
        {
            ...
        }

        public int CitiesCount()
        {
            ...
        }

        public City SearchByCityName(string cityName)
        {
            ....
        }

        public void EditCity(City city)
        {
          ...
        }


        public int RemoveCity(City city)
        {
            ...
        }


        public City GetOneCity(int cityId)
        {
            return _city.Include(a => a.Province).Include(a => a.Province.Country).FirstOrDefault(a => a.CityId == cityId);
        }

        public IList<City> AllCities()
        {
            return _city.Include(a => a.Province).Include(a => a.Province.Country).ToList();
        }

        public IList<City> SearchByProvinceId(int provinceId)
        {
            return _city.Where(c => c.ProvinceId == provinceId).ToList();
        }

        public IList<City> GetCities(int startIndex, int pageSize, string sortexpression)
        {
            if (sortexpression == string.Empty)
            {
                sortexpression = "CityId ASC";
            }

            string sortColumnName = sortexpression.Split(' ')[0];
            string sortDirection = sortexpression.Split(' ')[1];
            var citiesQuery = _city.Include(a => a.Province).Include(a => a.Province.Country).AsQueryable();
            switch (sortColumnName)
            {
                case "CityId":
                    citiesQuery = ((sortDirection.ToLower() == "asc") ? citiesQuery.OrderBy(a => a.CityId) : citiesQuery.OrderByDescending(a => a.CityId));
                    break;
                case "CityName":
                    citiesQuery = ((sortDirection.ToLower() == "asc") ? citiesQuery.OrderBy(a => a.CityName) : citiesQuery.OrderByDescending(a => a.CityName));
                    break;
                case "TelCode":
                    citiesQuery = ((sortDirection.ToLower() == "asc") ? citiesQuery.OrderBy(a => a.TelCode) : citiesQuery.OrderByDescending(a => a.TelCode));
                    break;
...
            }
            return citiesQuery.Skip(startIndex).Take(pageSize).ToList();
        }

....و هر متد دیگری که نیاز دارید
    }

using System;
using System.ComponentModel.DataAnnotations;
namespace Test
{
    [AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
    public class CompareAttribute : ValidationAttribute
    {
        public CompareAttribute(string originalProperty, string confirmProperty)
        {
            OriginalProperty = originalProperty;
            ConfirmProperty = confirmProperty;
        }
        public string ConfirmProperty { get; private set; }
        public string OriginalProperty { get; private set; }
        protected override ValidationResult IsValid(object value, ValidationContext ctx)
        {
            if (value == null)
                return new ValidationResult("لطفا فیلدها را تکمیل نمائید");
            var confirmProperty = ctx.ObjectType.GetProperty(ConfirmProperty);
            if (confirmProperty == null)
                throw new InvalidOperationException(string.Format("لطفا فیلد {0} را تعریف نمائید", ConfirmProperty));
            var confirmValue = confirmProperty.GetValue(ctx.ObjectInstance, null) as string;
            if (string.IsNullOrWhiteSpace(confirmValue))
                return new ValidationResult(string.Format("لطفا فیلد {0} را تکمیل نمائید", ConfirmProperty));
            var originalProperty = ctx.ObjectType.GetProperty(OriginalProperty);
            if (originalProperty == null)
                throw new InvalidOperationException(string.Format("لطفا فیلد {0} را تعریف نمائید", OriginalProperty));
            var originalValue = originalProperty.GetValue(ctx.ObjectInstance, null) as string;
            if (string.IsNullOrWhiteSpace(originalValue))
                return new ValidationResult(string.Format("لطفا فیلد {0} را تکمیل نمائید", OriginalProperty));
            return originalValue == confirmValue ? ValidationResult.Success : new ValidationResult("مقادیر وارد شده یکسان نیستند");
        }
    }
}

using System;

namespace EFCoreDbFunctionsSample.Entities
{
    public class Person
    {
        public int Id { get; set; }

        public string Name { get; set; }

        public DateTime AddDate { get; set; }
    }
}

var usersInfo = context.People.Where(person => (DateTime.Now - person.AddDate).Days <= 10).ToList();

'The LINQ expression 'DbSet<Person>.Where(p => (DateTime.Now - p.AddDate).Days <= 10)'
could not be translated. Either rewrite the query in a form that can be translated,
or switch to client evaluation explicitly by inserting a call to either
AsEnumerable(), AsAsyncEnumerable(), ToList(), or ToListAsync().
See https://go.microsoft.com/fwlink/?linkid=2101038 for more information.'

SELECT [p].[Id], [p].[AddDate], [p].[Name]
FROM [People] AS [p]
WHERE DATEDIFF(Day, [p].[AddDate], GETDATE()) <= 10

namespace EFCoreDbFunctionsSample.DataLayer
{
    public enum SqlDateDiff
    {
        Year,
        Quarter,
        Month,
        DayOfYear,
        Day,
        Week,
        Hour,
        Minute,
        Second,
        MilliSecond,
        MicroSecond,
        NanoSecond
    }

    public static class SqlDbFunctionsExtensions
    {
        public static int SqlDateDiff(SqlDateDiff interval, DateTime initial, DateTime end)
            => throw new InvalidOperationException($"{nameof(SqlDateDiff)} method cannot be called from the client side.");
        public static readonly MethodInfo SqlDateDiffMethodInfo = typeof(SqlDbFunctionsExtensions)
            .GetRuntimeMethod(
                nameof(SqlDbFunctionsExtensions.SqlDateDiff),
                new[] { typeof(SqlDateDiff), typeof(DateTime), typeof(DateTime) }
            );
    }
}