Return lambda expression based on parameters
Personally, I find your code easy enough to follow. The flow control is lengthy but is quite simple. A few notes before searching alternatives for the flow control.



Expression&lt;Func&lt;ScheduleItemDto, bool&gt;&gt; notAdminExpression = x =&gt; x.Active == true;


Could be

Expression&lt;Func&lt;ScheduleItemDto, bool&gt;&gt; notAdminExpression = x =&gt; x.Active;




Your function could be broken in two pieces, one for the switch statement and another for the permission part. It may be a matter of personal preference, but allows early return statements, removing the assignment operation and thus entirely removing any state from the function, pure functions are easier to follow.

// ...
case null:
    if (eventGuid == null)
    {
        return baseExpression;                      
    }
    else
    {
        return Expression.Lambda&lt;Func&lt;ScheduleItemDto, bool&gt;&gt;(Expression.AndAlso(baseExpression.Body, eventExpression.Body), baseExpression.Parameters[0]);
    }
// ...

private Expression&lt;Func&lt;ScheduleItemDto, bool&gt;&gt; RestrictPermission(Expression&lt;Func&lt;ScheduleItemDto, bool&gt;&gt; baseExpression)
{
    Expression&lt;Func&lt;ScheduleItemDto, bool&gt;&gt; notAdminExpression = x =&gt; x.Active
    return Expression.Lambda&lt;Func&lt;ScheduleItemDto, bool&gt;&gt;(Expression.AndAlso(baseExpression.Body, notAdminExpression.Body), baseExpression.Parameters[0]);
}
// ...
RestrictPermission(Where(...));




Now the ways I can think of rewriting the switch statement

If chain

if(closed == null &amp;&amp; eventGuid == null)
    return ...;
else if (closed == null &amp;&amp; eventGuid != null)
    return ...;
else if (closed &amp;&amp; eventGuid == null)
    return ...;
...


Very easy to parse which case each return belongs, but quite verbose.

Dictionary

 var options = new Dictionary&lt;Tuple&lt;bool?, bool&gt;, Expression&lt;Func&lt;ScheduleItemDto, bool&gt;&gt;&gt; {
    { Tuple.Create(null, true), baseExpression },
    { Tuple.Create(null, false), Expression.Lambda&lt;Func&lt;ScheduleItemDto, bool&gt;&gt;(Expression.AndAlso(baseExpression.Body, eventExpression.Body), baseExpression.Parameters[0]) },
    { Tuple.Create(true, true), Expression.Lambda&lt;Func&lt;ScheduleItemDto, bool&gt;&gt;(Expression.AndAlso(baseExpression.Body, closedExpression.Body), baseExpression.Parameters[0]) },
    // ...
}
return options[closed, eventGuid == null];


Adds complexity and reduces readability, but is probably the most compact version.

If plus ternary

if (closed == null)
    return eventGuid == null
        ? baseExpression 
        : Expression.Lambda&lt;Func&lt;ScheduleItemDto, bool&gt;&gt;(Expression.AndAlso(baseExpression.Body, closedExpression.Body), baseExpression.Parameters[0]);
else if (closed)
    ...
else
    ...


Half-way between readability and verbosity.



Honestly, I would stick to your switch or a chained-if. You can't get much elegance without making the code unnecessary complex. Or at least not with the options I know, I hope someone has a better solution.