c＃对象实例化

Question

What's the difference between:

Object o = new Object();
o.foo();

and

new Object().foo();

(assuming I do not need the reference afterwards) ?

Are there any reasons for using one instead of the other one (eg memory usage) ?

Answer 1

There's no difference in terms of execution.

There can be a difference in terms of debugging:

• It can be handy to break after the object has been created but before foo() is called
• It can be handy to be able to inspect the value of the variable afterwards
• If an exception is thrown, separating calls into multiple lines can make the source clearer. (I don't think it would be a problem in this particular case, but for NullReferenceException s in particular, it can be tricky if there are multiple dereferencing operations in the same statement).

I'm definitely not saying that you should always split everything out - just that it can be useful for debugging purposes.

Answer 2

如果之后不需要实例，则没有区别。

Answer 3

If you don't need o afterwords then there is no difference.
The (JIT) compiler will probably treat them as being the same.

So it's a matter of taste. In this case I have a slight preference for the first one, but sometimes the fluent notation of the second sample is more readable.

Answer 4

No difference.

To probe it, you can compile both codes (release mode), inspect them with ildasm and you will see the resulting bytecode witll be the same.

EDIT: actually, I sometimes find it easier to debug when the variable is declared. Easier to inspect, so, easier to debug.

Answer 5

EDIT: Removed incorrect code

The difference is that in the first case you can see the object being created in the debugger.