How do you name your filter methods? Do you use "By" or "With"?

Question

I am working on a library that will contain many filter methods.

I have seen many project that use this syntax for filters

public Foo GetFooByBar(bar);

In other project people use this syntax

public Foo GetFooWithBar(bar);

Since this library will be reused by many other developers I wanted to know which one developers feel more comfortable with.

Please let me know which you prefer and if possible why.

Thanks

EDIT: The first few answers suggest just overloading a GetFoo method to accept various arguments. This works well for a standard interface in a language that supports overloading. But in my case some I will also have some more fluent apis so I will want to link various filters like this

Foo GetFoo().ByBar(bar).ByBaz(Baz); or Foo GetFoo().WithBar(bar).WithBaz(baz);

Answer 1

This may not be popular, but I like

public Foo GetFoo();
public Foo GetFoo(Bar bar);
public Foo GetFoo(Baz baz);

No need for an extra "ByWhatever", overloading is enough.

I'm not really sure why I like this, it's probably because I dislike redundancy, and the argument is already saying enough.

If the current language supports no overloading and you need more than one type of filter for the same object, then I prefer

public Foo GetFooByBar(Bar bar)

By suggests to me better the real meaning of the method.

EDIT: In fluent interfaces I prefer much more strongly the By option. With looks like it's adding something, instead of filtering, like "Get me a hot dog with ketchup".

Answer 2

IMO, GetFooByBar suggests "filter Foo using Bar as some kind of condition"... but GetFooWithBar suggests that Bar is some extra (optional) information that can come back with a Foo - i.e. GetOrderWithLines...

At a push, I'd use By - but in general? nothing at all; the fact that the parameter is a Bar should suggest enough.

The only time this gets tricky is when you have an API that doesn't support method overloads - basic SOAP, for example. Then you might need different ByX, ByY methods.

Answer 3

Some of the other answers are wrong, overloaded methods should result in the same answer. If different parametersresult in different filter conditions then you have basically done the wrong thing. Overloading should basically only exist as a means of doing studff like offering sensible defaults, type conversions and so on. Most of the time there will be one method with the bulk of the code , with the others doing a little massaging, setting up defaults or whatever and then invoking the main method.

That said, I would probably call my methods, "withId", "withSurname" only because I think with implies that the found entity has that Id or name. By seems not quite as accurate in describing the predicate. In the end the most important thing is to be consistent.