The method ToDictionaryExpressions<TModel>(List<string> propertyNames) is a generic method that builds a lambda expression, which will accept an instance of type TModel and returns a dictionary containing specified object properties.

public static Expression<Func<TModel, IDictionary>> ToDictionaryExpressions<TModel>(List<string> propertyNames)
{
    var parameter = Expression.Parameter(typeof(TModel), "x");
    var addMethod = typeof(IDictionary).GetMethod("Add");
    var dictionary = Expression.New(typeof(Dictionary<string, object>));

    var propertiesToLower = propertyNames.ConvertAll(d => d.ToLowerInvariant());

    var validProperties = propertiesToLower
        .Where(name => typeof(TModel).GetProperties().Any(property => property.Name.ToLowerInvariant() == name)) // Filter out invalid properties
        .ToList();

    var elements = validProperties.Select(name =>
    {
        var property = Expression.Property(parameter, name);
        var addExp = Expression.ElementInit(addMethod!, Expression.Constant(name), Expression.Convert(property, typeof(object)));
        return addExp;
    });
    var body = Expression.ListInit(dictionary, elements);

    return Expression.Lambda<Func<TModel, IDictionary>>(body, parameter);
}

Break down:

Parameter Definition: The first line is defining a parameter expression, which will be used later in the lambda expression. The parameter type is TModel and named as "x"

    var parameter = Expression.Parameter(typeof(TModel), "x");

Get Add Method Info: Next, it retrieves the MethodInfo object representing the Add method of the IDictionary type. This will be used later to invoke the Add method of created dictionary object

    var addMethod = typeof(IDictionary).GetMethod("Add");

Create A New Dictionary: Then, it creates a NewExpression, which expresses construction of a new Dictionary of type <string, object>

    var dictionary = Expression.New(typeof(Dictionary<string, object>));

Filter Out Invalid Properties: It then converts the provided property names to lower case and returns a list of those that exist on the model

    var propertiesToLower = propertyNames.ConvertAll(d => d.ToLowerInvariant());
    var validProperties = propertiesToLower
        .Where(name => typeof(TModel).GetProperties().Any(property => property.Name.ToLowerInvariant() == name))
        .ToList();

Create ElementInit Expressions: For each of the valid property names, it creates an ElementInit expression, i.e., an Add method call on the dictionary to add a key-value pair where key is the property name and value is the property value of the model

    var elements = validProperties.Select(name =>
    {
        var property = Expression.Property(parameter, name);
        var addExp = Expression.ElementInit(addMethod!, Expression.Constant(name), Expression.Convert(property, typeof(object)));
        return addExp;
    });

Create ListInit Expression: It then creates a ListInit expression, i.e., a NewExpression (for new dictionary) followed by multiple ElementInit expressions (for adding key-value pairs to dictionary)

    var body = Expression.ListInit(dictionary, elements);

Create Lambda Expression: Finally, it packages everything into a Lambda expression which the user can then compile and execute

    return Expression.Lambda<Func<TModel, IDictionary>>(body, parameter);

This code snippet is useful when you want to create a method that takes an object of type TModel and returns a Dictionary containing specified properties of that object.

Usage:

var fieldsArray = resourceParameters.Fields.Split(',').Select(field => field.Trim()).ToList();
var selectExpression = ExpressionExtensions.ToDictionaryExpressions<BookDto>(fieldsArray);
var booksDbSelectedFields = booksDto.AsQueryable().Select(selectExpression);