class Bar {...}
class Baz {...}
class Foo
{
    // Разные экземпляры Foo могут содержать barObj или bazObj ссылающиеся на один и тот же объект
    public Bar barObj = new Bar();
    public Baz bazObj = new Baz();
}

public List<Foo> list = ...

public Foo likeObj = ...

public Func<Foo, bool> FilterPredicate(propName)
{
    // Пробую воссоздать чтобы было так: x => ReferenceEquals(x.barObj, likeObj.barObj);
    var listItem = Expression.Parameter(typeof(Foo), "x");
    // Как в Expression записать ссылку на внешний объект likeObj? Я сделал через Expression.Constant, но не уверен, что это правильно, хотя работает.
    var likeItem = Expression.Constant(likeObj);
    
    var equals = Expression.Call(typeof(object), "ReferenceEquals", null, new Exception[] {
        Expression.Field(listItem, propName),
        Expression.Field(likeItem, propName)
    });
    var lambda = Exception.Lambda<Func<Foo, bool>>(equals, listItem);
    return lambda.Compile();
}

...

// Потом использовать так
list.Where(FilterPredicate("barObj"));
// или
list.Where(FilterPredicate("bazObj"));

public class Bar {}
public class Baz {}

public class Foo
{
    public Foo(string name, Bar barObj, Baz bazObj)
    {
        Name = name;
        BarObj = barObj;
        BazObj = bazObj;
    }

    public string Name { get; }
    public Bar BarObj { get; }
    public Baz BazObj { get; }

    public override string ToString()
    {
        return $"{nameof(Name)}: {Name}"; // просто для удобства тестирования
    }
}

public static class FilterBuilder
{
    // ссылка на метод ReferenceEquals резолвится один раз и кэшируется
    private static readonly MethodInfo ReferenceEqualsMethod =
        typeof(object).GetMethod(nameof(ReferenceEquals), BindingFlags.Static | BindingFlags.Public)
        ?? throw new InvalidOperationException();

    // создает делегат с двумя параметрами - объектами для сравнения
    public static Func<Foo, Foo, bool> CreateFilter(string name)
    {
        var leftPar = Expression.Parameter(typeof(Foo), "left");
        var rightPar = Expression.Parameter(typeof(Foo), "right");

        var body = Expression.Call(ReferenceEqualsMethod,
                                   Expression.PropertyOrField(leftPar, name),
                                   Expression.PropertyOrField(rightPar, name));

        var lambda = Expression.Lambda<Func<Foo, Foo, bool>>(body, leftPar, rightPar);
        var predicate = lambda.Compile();
        return predicate;
    }
}

var bar1 = new Bar();
var bar2 = new Bar();

var baz1 = new Baz();
var baz2 = new Baz();

List<Foo> fooList = new()
                        {
                            new Foo("obj1", bar1, baz1),
                            new Foo("obj2", bar1, baz2),
                            new Foo("obj3", bar2, baz1),
                            new Foo("obj4", bar2, baz2),
                        };

var likeObj = new Foo("like", bar1, baz1);

// фильтры лучше положить в переменные, иначе они будут компилироваться для каждого элемента коллекции, что просадит быстродействие
var filter1 = FilterBuilder.CreateFilter(nameof(Foo.BarObj));
var filter2 = FilterBuilder.CreateFilter(nameof(Foo.BazObj));

Console.WriteLine(String.Join(", ", fooList.Where(x => filter1(likeObj, x))));
Console.WriteLine(String.Join(", ", fooList.Where(x => filter2(likeObj, x))));

enum FilterProp { barObj, bazObj, ..., booObj}

...

public void DoSomething(FilterProp filterProp)
{
    var query = list.Where(FilterPredicate(filterProp.ToString()));
    ...
}

Func<Foo, bool> filter1 = x => ReferenceEquals(likeObj.barObj, x.barObj);

Func<Foo, bool> filter1 = x => ReferenceEquals(likeObj.barObj, x.barObj);

FLY>enum FilterProp { barObj, bazObj, ..., booObj}

FLY>...

FLY>public void DoSomething(FilterProp filterProp)
FLY>{
FLY>    var query = list.Where(FilterPredicate(filterProp.ToString()));
FLY>    ...
FLY>}
FLY>

FLY>Func<Foo, bool> filter1 = x => ReferenceEquals(likeObj.barObj, x.barObj);
FLY>

public static class FooMatchExtensions
{
    public static bool Matches(this Foo left, Foo right, string propertyName)
    {
        return propertyName switch
            {
                nameof(Foo.BarObj) => ReferenceEquals(left.BarObj, right.BarObj),
                nameof(Foo.BazObj) => ReferenceEquals(left.BazObj, right.BazObj),
                _ => false
            };
    }
}

Console.WriteLine(String.Join(", ", fooList.Where(x => likeObj.Matches(x, nameof(Foo.BarObj)))));
Console.WriteLine(String.Join(", ", fooList.Where(x => likeObj.Matches(x, nameof(Foo.BazObj)))));

var debugView = typeof(Expression).GetProperty("DebugView", BindingFlags.Instance | BindingFlags.NonPublic);

// Expression
var recordExpression = Expression.Parameter(typeof(Record), "record");
var expr2 = Expression.Lambda<Func<Record, bool>>(Expression.Call(typeof(object), "ReferenceEquals", null, new Expression[] {
    Expression.Field(recordExpression, "f2"),
    Expression.Field(Expression.Constant(recordList.currentRecord), "f2")
}), recordExpression);
// Вывод в консоль
.Lambda #Lambda1<System.Func`2[ConsoleApp.Record,System.Boolean]>(ConsoleApp.Record $record) {
    .Call System.Object.ReferenceEquals(
        $record.f2,
        .Constant<ConsoleApp.Record>(#4: 1, 2, 4).f2)
}

// Предикат
Expression<Func<Record, bool>> expr1 = record => ReferenceEquals(record.f2, recordList.currentRecord.f2);
Console.WriteLine(debugView.GetValue(expr1));
// Вывод в консоль
.Lambda #Lambda1<System.Func`2[ConsoleApp.Record,System.Boolean]>(ConsoleApp.Record $record) {
    .Call System.Object.ReferenceEquals(
        $record.f2,
        ((.Constant<ConsoleApp.Program+<>c__DisplayClass1_0>(ConsoleApp.Program+<>c__DisplayClass1_0).recordList).currentRecord).f2)
}