Misunderstanding of .NET on overloaded methods with different parameters (Call Ambiguous)

Lambda expressions (x=> x.Id==1) do not have type by themselves - they automatically "cast" to Expression or Func/delegate of matching type when type is known. I.e. Why must a lambda expression be cast when supplied as a plain Delegate parameter deals with similar issue just between different delegate types.

In your case methods that are potential candidate suggest both variants and compiler can't make a choice.

If you really have to keep same name then callers will have to specify type themselves:

 myRepo.GetData((Expression<Func<TEntity, Boolean>>)(x => x.Id == 1));
 myRepo.GetData((Func<TEntity, Boolean>)(x => x.Id == 2));

I don't think you can use extension method for one of alternatives as search will stop at the class level. So really having methods with different names is the only real option (if you need both). Consider if just Expression version is enough. Alternatively you can split them between different classes (similar how extensions of IQueryable take Expression when similar methods on IEnumerable take Func (see QueryableExtenasions).

I believe the simplest way you can get rid of overloading confusion is to cast your input prior to sending it to the function. This can be done implicitly(inline) or in the form of defining a typed input(recommended way) rather than an anonymous one. Here is how i tested this and it works without giving off that warning.

MyRepo<MyEntity> myRepo = new MyRepo<MyEntity>();
Func<MyEntity, bool> predicate = x => x.Id == 1;
Expression<Func<MyEntity, bool>> expression = x => x.Id == 1;
// both below lines are fine now
myRepo.GetData(predicate);
myRepo.GetData(expression);

Apparently C# compiler is not precise enough to differentiate between the two because it demands some heuristic behavior, and anonymous inputs are inherently same. Anyhow, this workaround can solve the issue.

The problem is that when you compile the expression you will create a method with that same signature that the second.

I recommend you change the name of the first method

Also If you are going to use Expression return an IQueryable to take advantage of the deferred execution.