Given the below setup and code snippets, what reasons can you come up with for using one over the other? I have a couple arguments using either of them, but I am curious about what others think.
Setup
public class Foo
{
public void Bar()
{
}
}
Snippet One
var foo = new Foo();
foo.Bar();
Snippet Two
new Foo().Bar();
If you are not going to use the Foo instance for more than simply doing that call I would probably go for the second one, but I can't see that there should be any practical difference, unless the call happens extremely often (but that does not strike me as very likely with that construct).
I would favour the second as it makes it pretty clear that I don't need the object reference at all.
I'd question your motives for having this as a instance method. If I'd only new up the object to call one method on it and discard it afterwards, a static method with the classes dependencies as parameters should be the way to go (although I despise statics).
What leads to the more interesting problem: If you don't rely on internal state at all, then you are just a function and therefore I'd say you belong to some entity, not in your own class.
The first version means you can examine foo in a debugger more easily before calling Bar().
The first version also means you associate a name with the object (it's actually the name of variable of course, but there's clearly a mental association) which can be useful at times:
var customersWithBadDebt = (some big long expression)
customersWithBadDebt.HitWithBaseballBat();
is clearer than
(some big long expression).HitWithBaseballBat();
If neither of those reasons apply, feel free to go for the single line version of course. It's personal taste which is then applied to each specific context.
I'd go for snippet number one.
If you're going to have class Foo do Bar() then Bar2() it will be easier.
Plus its easier to debug because you can watch foo, something that you can't with snippet 2