How to conditionally SetProperty with Entity Framework Core ExecuteUpdate?

When querying a database with EF Core, it's easy to conditionally add .Where clauses to a query before executing the query, e.g.:

[HttpGet]
public async Task<List<Entity>> GetEntitiesAsync(string? property1, string? property2)
{
    var query = _context.Entities.AsNoTracking();
    if (property1 != null)
    {
        query = query.Where(e => e.Property1.Contains(property1));
    }
    if (property2 != null)
    {
        query = query.Where(e => e.Property2.Contains(property2));
    }
    return await query.ToListAsync();
}

However, when using .ExecuteUpdate, I can't see how you would conditionally chain .SetProperty clauses:

[HttpPatch("{id}")]
public async Task<IActionResult> UpdateEntityAsync(int id, Entity entity)
{
    var entitiesUpdated = await _context.Entities
        .Where(e => e.Id == id)
        .ExecuteUpdateAsync(s => s
            // How to conditionally chain SetProperty based on
            // if entity.Property1 and entity.Property2 are null?
            .SetProperty(e => e.Property1, entity.Property1)
            .SetProperty(e => e.Property2, entity.Property2)
    );

    return entitiesUpdated == 1 ? NoContent() : NotFound();
}

You can't use if statements inside the lambda. It needs to be a single expression that evaluates to a SetPropertyCalls<T>. Maybe you could manually create an expression tree, but wouldn't you need to build it on top of the parameter passed into the lambda? Is there an easy way I'm not seeing?

SetProperty allows passing expression to calculate the value. To dynamically combine SetProperty calls based on condition you can use ternary conditional operator :

var entitiesUpdated = await _context.Entities
    .Where(e => e.Id == id)
    .ExecuteUpdateAsync(s => s
         .SetProperty(e => e.Property1, e => entity.Property1 != null
              ? entity.Property1
              : e.Property1)
         .SetProperty(e => e.Property2, , e => entity.Property2 != null
              ? entity.Property2
              : e.Property2));

Though this will generate SQL like "PropertyX" = "e"."PropertyX" for cases when the source is null.

A bit harder but more "correct" approach is to perform some expression trees manipulation:

Expression<Func<SetPropertyCalls<TEntity>, SetPropertyCalls<TEntity>>> AppendSetProperty<TEntity>(
	Expression<Func<SetPropertyCalls<TEntity>, SetPropertyCalls<TEntity>>> left,
	Expression<Func<SetPropertyCalls<TEntity>, SetPropertyCalls<TEntity>>> right)
{
	var replace = new ReplacingExpressionVisitor(right.Parameters, new []{left.Body});
	var combined = replace.Visit(right.Body);
	return Expression.Lambda<Func<SetPropertyCalls<TEntity>, SetPropertyCalls<TEntity>>>(combined, left.Parameters);
}

Expression<Func<SetPropertyCalls<Author>, SetPropertyCalls<Author>>> set = 
     calls => calls;

if (entity.Property1 is not null)
{
	set = AppendSetProperty(set,
          s => s.SetProperty(e => e.Property1, entity.Property1));
}

if (entity.Property2 is not null)
{
	set = AppendSetProperty(set,
          s => s.SetProperty(e => e.Property2, entity.Property2));
}

Here's a simple helper I wrote that composes the expression tree and enables these kinds of scenarios — while allowing you the same API shape, unlike Guru Stron's answer:

Usage:

int affectedCount = await dbContext.Books
    .Where(b => b.Id == someBookId)
    .ExecutePatchUpdateAsync(b =>
    {
        if (someCondition)
            b.SetProperty(b => b.Foo, "Foo");
        else
            b.SetProperty(b => b.Bar, "Bar");
    });

The implementation:

public static class QueryableExtension
{
	public static Task<int> ExecutePatchUpdateAsync<TSource>(
		this IQueryable<TSource> source,
		Action<SetPropertyBuilder<TSource>> setPropertyBuilder,
		CancellationToken ct = default
	)
	{
		var builder = new SetPropertyBuilder<TSource>();
		setPropertyBuilder.Invoke(builder);
		return source.ExecuteUpdateAsync(builder.SetPropertyCalls, ct);
	}

	public static int ExecutePatchUpdate<TSource>(
		this IQueryable<TSource> source,
		Action<SetPropertyBuilder<TSource>> setPropertyBuilder,
	)
	{
		var builder = new SetPropertyBuilder<TSource>();
		setPropertyBuilder.Invoke(builder);
		return source.ExecuteUpdate(builder.SetPropertyCalls);
	}
}

public class SetPropertyBuilder<TSource>
{
	public Expression<Func<SetPropertyCalls<TSource>, SetPropertyCalls<TSource>>> SetPropertyCalls { get; private set; } = b => b;

	public SetPropertyBuilder<TSource> SetProperty<TProperty>(
		Expression<Func<TSource, TProperty>> propertyExpression,
		TProperty value
	) => SetProperty(propertyExpression, _ => value);

	public SetPropertyBuilder<TSource> SetProperty<TProperty>(
		Expression<Func<TSource, TProperty>> propertyExpression,
		Expression<Func<TSource, TProperty>> valueExpression
	)
	{
		SetPropertyCalls = SetPropertyCalls.Update(
			body: Expression.Call(
				instance: SetPropertyCalls.Body,
				methodName: nameof(SetPropertyCalls<TSource>.SetProperty),
				typeArguments: new[] { typeof(TProperty) },
				arguments: new Expression[] {
					propertyExpression,
					valueExpression
				}
			),
			parameters: SetPropertyCalls.Parameters
		);

		return this;
	}
}