Is it possible to create in a lambda-function a dynamical field?

Question

I have a function like this:

public CountryDto FindCountryByName(string name)
{
    Country country = _countryRepository.GetAll().Where(g => g.Name.ToLower().Trim() == name.ToLower().Trim()).FirstOrDefault();

    var dto = _mapper.Map<Country, CountryDto>(country);

    return dto;
}

and it's referred to GetAll-function in the GenericRepository

public IEnumerable<T> GetAll()
{
    return table.ToList();
}

Is it possible creating a function like this (in the GenericRepository)?

public IEnumerable<T> FindByName(string objname, string name)
{
    return table.Where(t => t.GetType(objname) == name);
}

By example

Country country = _countryRepository.FindByName("CountryName", name);

and

AlbumTrack track = _albumtrackRepository.FindByName("SongTitle", songTitle);

Answer 1

I don't remember where I found this function, I'm using it to generate LINQ queries based on given property name, please note that you can change the search function "Equals" to "Contains" or "StartsWith" :

    ///<summary>
    /// Create query that search in given property of class T for matching results with value 
    /// </summary>
    public static IQueryable<T> CreateSearchQuery<T>(IQueryable<T> queryable, string PropertyName, string value) where T : class
    {
        IQueryable<T> query = queryable;

        List<Expression> expressions = new List<Expression>();

        ParameterExpression parameter = Expression.Parameter(typeof(T), "p");
        MethodInfo Equals_Method = typeof(string).GetMethod("Equals", new[] { typeof(string) });
        MethodInfo ToString_Method = typeof(object).GetMethod("ToString");

        //Iterate through all properties Except inherited ones
        foreach (PropertyInfo prop in typeof(T).GetProperties(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public)
            .Where(x => x.PropertyType == typeof(string) //properties of type string
            || x.Name == PropertyName))
        {

            ConstantExpression value_expression = Expression.Constant(value, typeof(string));
            MemberExpression member_expression = Expression.PropertyOrField(parameter, prop.Name);

            //Combine ToString() and Equals() methods
            MethodCallExpression callChain = Expression.Call(Expression.Call(member_expression, ToString_Method), Equals_Method, value_expression);

            expressions.Add(callChain);
        }

        if (expressions.Count == 0)
            return query;


        Expression or_expression = expressions[0];

        for (int i = 1; i < expressions.Count; i++)
        {
            or_expression = Expression.OrElse(or_expression, expressions[i]);
        }

        Expression<Func<T, bool>> expression = Expression.Lambda<Func<T, bool>>(or_expression, parameter);

        return query.Where(expression);
    }