in C#, can I create Exression tree object from a method instead of lambda?

I want to create an expression tree object that represents some condition to be used in EF Core Linq query Where clause.
Since this condition will be used in different queries I want to define it once and use it anywhere.
However, I also want to have this condition in a form of a method so that I can use it without Linq.

So my question is can I have method from which I can build expression tree object? I know expression tree can be built from the lambda when immediately assigned to it, but can I create expression tree from separately defined methods? Here is what I mean:

using System.Linq.Expressions;

internal class Program
{
    private static void Main(string[] args)
    {
        Console.WriteLine("Hello, World!");

        Expression<Func<int, bool>> expressionTree1 = (int x) => x % 2 == 0; // compiles

        var lambda1 = (int x) => x % 2 == 0;

        // following two don't compile with an error:
        //      Expression<Func<int, bool>> does not contain a constructor that takes 1 argument
        var expressionTree2 = new Expression<Func<int, bool>>(lambda1);
        var expressionTree3 = new Expression<Func<int, bool>>(IsEven);
    }

    private static bool IsEven(int x)
    {
        return x % 2 == 0;
    }
}

So I would like to somehow build Expression<Func<int, bool>> from method defined elsewhere such as IsEven above.

I don't think you can, since expression trees can only contain a subset of what a method can contain.

How about declaring the method in terms of the expression tree, rather than the other way around? This should also achieve your goal of only writing the condition once.

static Expression<Func<int, bool>> expressionTree1 = (int x) => x % 2 == 0;

// only need to compile this once
static Func<int, bool> compiledExpressionTree1 = expressionTree1.Compile();

private static void Main(string[] args)
{
    Console.WriteLine(IsEven(1)); // false
}

private static bool IsEven(int x)
{
    return compiledExpressionTree1(x);
}

When you create an expression from a lambda inline (like expressionTree1) the C# compiler coverts the C# code into Expression objects; the lambda method itself doesn't exist, it's just syntactic sugar. This results in code like:

ParameterExpression paramX = Expression.Parameter(typeof(int), "x");
Expression isEven = Expression.Lambda(
    Expression.Equal(
        Expression.Modulo(
            paramX,
            Expression.Constant(2)
        ),
        Expression.Constant(0)
    ),
    paramX
);

You can't create an expression from a method because the compiler can't get the body of the method to convert it. In your example the the code is in the same file, but you might want to use a method in a different file or assembly (which you might not have the source code to).

You can create an expression that calls your method but this won't work with EF Core because EF converts the expression tree into an SQL query.

ParameterExpression paramX = Expression.Parameter(typeof(int), "x");
Expression isEven = Expression.Lambda(
    Expression.Call(
        typeof(Program).GetMethod(nameof(IsEven), BindingFlags.Static | BindingFlags.NonPublic)!,
        paramX
    ),
    paramX
);

Sweeper's answer is is the solution, this answer is just to explain the why.