c# interview question

[=?Utf-8?B?U3RldmUgQnVnZGVu?=]

Hi,

I recently had an interview where I was asked a number of questions on C#.
Unfortunately I didn't get the answers from the test and find that one of
them is still niggling me.

It was something like this:

Consider the following code:

int i = 0;
Console.WriteLi ne("The value is: " + i);
Console.WriteLi ne("The value is: " + i.ToString());

Which would you use to write an integer to the console and why would it give
better performance?

I said I would use: Console.WriteLi ne("The value is: " +
i.ToString());

But I can't think why this should give a performance advantage. I can only
guess that the compiler should be able to realise that a string is required
from the integer for the line not using the ToString() method and generate
the same MSIL.

Can anyone please enlighten me?

Best Regards,

Steve

[Peter Bradley]

My guess - and it is just a guess - is that the implicit cast probably uses
the ToString() method anyway. I would have thought any difference between
the two would have been optimized away by the compiler, but what do I know?

One thing's for sure, if you (or rather your prospective employers) need to
worry about performance at this level, then they're using the wrong
language. To me, it's on a par with worrying about whether:

i++;

is more efficient than:

++i;

Who cares. If you're writing code where these differences are significant,
use C or C++, or even Assembly language.

Just my 2c. YMMV.
Peter

"Steve Bugden" <St*********@di scussions.micro soft.comwrote in message
news:60******** *************** ***********@mic rosoft.com...

Hi,

I recently had an interview where I was asked a number of questions on C#.
Unfortunately I didn't get the answers from the test and find that one of
them is still niggling me.

It was something like this:

Consider the following code:

int i = 0;
Console.WriteLi ne("The value is: " + i);
Console.WriteLi ne("The value is: " + i.ToString());

Which would you use to write an integer to the console and why would it
give
better performance?

I said I would use: Console.WriteLi ne("The value is: " +
i.ToString());

But I can't think why this should give a performance advantage. I can only
guess that the compiler should be able to realise that a string is
required
from the integer for the line not using the ToString() method and generate
the same MSIL.

Can anyone please enlighten me?

Best Regards,

Steve

[glenn]

Steve

The code with the ToString() call would be quicker 'cus I don't think the
first would even compile.

Personally, I think it should have been

Console.WriteLi ne( "This value is: {0}", i );

In this case ToString would be called anyway, so an explicit call to
ToString() is superfluous.

Glenn

"Steve Bugden" <St*********@di scussions.micro soft.comwrote in message
news:60******** *************** ***********@mic rosoft.com...

Hi,

I recently had an interview where I was asked a number of questions on C#.
Unfortunately I didn't get the answers from the test and find that one of
them is still niggling me.

It was something like this:

Consider the following code:

int i = 0;
Console.WriteLi ne("The value is: " + i);
Console.WriteLi ne("The value is: " + i.ToString());

Which would you use to write an integer to the console and why would it
give
better performance?

I said I would use: Console.WriteLi ne("The value is: " +
i.ToString());

But I can't think why this should give a performance advantage. I can only
guess that the compiler should be able to realise that a string is
required
from the integer for the line not using the ToString() method and generate
the same MSIL.

Can anyone please enlighten me?

Best Regards,

Steve

[DeveloperX]

On 12 Mar, 09:39, Steve Bugden <SteveBug...@di scussions.micro soft.com>
wrote:

Hi,

I recently had an interview where I was asked a number of questions on C#.
Unfortunately I didn't get the answers from the test and find that one of
them is still niggling me.

It was something like this:

Consider the following code:

int i = 0;
Console.WriteLi ne("The value is: " + i);
Console.WriteLi ne("The value is: " + i.ToString());

Which would you use to write an integer to the console and why would it give
better performance?

I said I would use: Console.WriteLi ne("The value is: " +
i.ToString());

But I can't think why this should give a performance advantage. I can only
guess that the compiler should be able to realise that a string is required
from the integer for the line not using the ToString() method and generate
the same MSIL.

Can anyone please enlighten me?

Best Regards,

Steve

Well if we look at the IL of the two statements you can see the IL
takes a slightly different route on each go:

Here's the first one ( Console.WriteLi ne("The value is: " + i) ):

L_0007: call void [mscorlib]System.Console: :WriteLine(stri ng)
L_000c: ldstr "The value is: "
L_0011: ldloc.0
L_0012: box int32
L_0017: call string [mscorlib]System.String:: Concat(object,
object)
L_001c: call void [mscorlib]System.Console: :WriteLine(stri ng)

And here's the second:

L_0026: call void [mscorlib]System.Console: :WriteLine(stri ng)
L_002b: ldstr "The value is: "
L_0030: ldloca.s i
L_0032: call instance string [mscorlib]System.Int32::T oString()
L_0037: call string [mscorlib]System.String:: Concat(string,
string)
L_003c: call void [mscorlib]System.Console: :WriteLine(stri ng)

Now the two things that leap out immediately, in the first
String.Concat is called taking two objects and the int is boxed.
Boxing always carries an overhead. It has to be boxed to pass it as an
object (value type and reference type issue).

In the second it calls Concat taking two strings.
Here's the interesting bit. If we look at Concat(object, object) we
see

public static string Concat(object arg0, object arg1)
{
if (arg0 == null)
{
arg0 = Empty;
}
if (arg1 == null)
{
arg1 = Empty;
}
return (arg0.ToString( ) + arg1.ToString() );
}
So it takes the two objects and attempts to call ToString on both of
them. Internally then it looks like the first lot of IL that uses the
two object signature will end up calling an internal version of the
second lot of IL, ie calling string.Concat(s tring, string).

Therefore I'd say the second version is quicker as it only runs Concat
once.

[Mark Rae]

"Peter Bradley" <pb******@uwic. ac.ukwrote in message
news:%2******** ********@TK2MSF TNGP05.phx.gbl. ..

One thing's for sure, if you (or rather your prospective employers) need
to worry about performance at this level, then they're using the wrong
language.

I couldn't agree more!!! What an utterly pointless and irrelevant
question...

Having been on both sides of the interview process many times over the
years, if you want to find out whether the prospective candidate is a good
developer or not, the most useful question is "Tell me about your last
development project"... You'll know in probably less than a minute if you
want to hire the person or not...

[Laura T.]

The first version, Console.WriteLi ne("The value is: " + i);, would force the
compiler to box the value of i into a reference type, and because of boxing,
it would also use string.Concat(o bject,object) which is slower than
string.Concat(s tring,string).

The second version, Console.WriteLi ne("The value is: " + i.ToString());,
needs no boxing and it would use string.Concate( string,string).

"Steve Bugden" <St*********@di scussions.micro soft.comha scritto nel
messaggio news:60******** *************** ***********@mic rosoft.com...

Hi,

I recently had an interview where I was asked a number of questions on C#.
Unfortunately I didn't get the answers from the test and find that one of
them is still niggling me.

It was something like this:

Consider the following code:

int i = 0;
Console.WriteLi ne("The value is: " + i);
Console.WriteLi ne("The value is: " + i.ToString());

Which would you use to write an integer to the console and why would it
give
better performance?

I said I would use: Console.WriteLi ne("The value is: " +
i.ToString());

But I can't think why this should give a performance advantage. I can only
guess that the compiler should be able to realise that a string is
required
from the integer for the line not using the ToString() method and generate
the same MSIL.

Can anyone please enlighten me?

Best Regards,

Steve

[glenn]

Peter

You could argue they're testing the depth of knowledge by asking the
question, but I do agree, I wouldn't like to work for a company that
constantly questioned my choice of string concatenation technique.

Glenn

"Peter Bradley" <pb******@uwic. ac.ukwrote in message
news:%2******** ********@TK2MSF TNGP05.phx.gbl. ..

My guess - and it is just a guess - is that the implicit cast probably
uses the ToString() method anyway. I would have thought any difference
between the two would have been optimized away by the compiler, but what
do I know?

One thing's for sure, if you (or rather your prospective employers) need
to worry about performance at this level, then they're using the wrong
language. To me, it's on a par with worrying about whether:

i++;

is more efficient than:

++i;

Who cares. If you're writing code where these differences are
significant, use C or C++, or even Assembly language.

Just my 2c. YMMV.
Peter

"Steve Bugden" <St*********@di scussions.micro soft.comwrote in message
news:60******** *************** ***********@mic rosoft.com...

>Hi,

I recently had an interview where I was asked a number of questions on
C#.
Unfortunatel y I didn't get the answers from the test and find that one of
them is still niggling me.

It was something like this:

Consider the following code:

int i = 0;
Console.WriteLi ne("The value is: " + i);
Console.WriteLi ne("The value is: " + i.ToString());

Which would you use to write an integer to the console and why would it
give
better performance?

I said I would use: Console.WriteLi ne("The value is: " +
i.ToString() );

But I can't think why this should give a performance advantage. I can
only
guess that the compiler should be able to realise that a string is
required
from the integer for the line not using the ToString() method and
generate
the same MSIL.

Can anyone please enlighten me?

Best Regards,

Steve

[glenn]

I'm wrong, of course it would compile.

Must read documentation before posting, must read documentation before
posting...

"glenn" <gl**********@y ahoo.co.ukwrote in message
news:uZ******** *****@TK2MSFTNG P02.phx.gbl...

Steve

The code with the ToString() call would be quicker 'cus I don't think the
first would even compile.

Personally, I think it should have been

Console.WriteLi ne( "This value is: {0}", i );

In this case ToString would be called anyway, so an explicit call to
ToString() is superfluous.

Glenn

"Steve Bugden" <St*********@di scussions.micro soft.comwrote in message
news:60******** *************** ***********@mic rosoft.com...

>Hi,

I recently had an interview where I was asked a number of questions on
C#.
Unfortunatel y I didn't get the answers from the test and find that one of
them is still niggling me.

It was something like this:

Consider the following code:

int i = 0;
Console.WriteLi ne("The value is: " + i);
Console.WriteLi ne("The value is: " + i.ToString());

Which would you use to write an integer to the console and why would it
give
better performance?

I said I would use: Console.WriteLi ne("The value is: " +
i.ToString() );

But I can't think why this should give a performance advantage. I can
only
guess that the compiler should be able to realise that a string is
required
from the integer for the line not using the ToString() method and
generate
the same MSIL.

Can anyone please enlighten me?

Best Regards,

Steve

[=?Utf-8?B?U3RldmUgQnVnZGVu?=]

Hi Peter and Gelnn.

Thankyou for your comments.

It does compile by the way.

It could have been:
Console.WriteLi ne( "This value is: {0}", i );
I can't remember exactly.

I didn't get the job by the way. I narrowly missed out by a few percent on
the passmark and this question is one that cost me.

It does seem reasonable to me that the compiler should be able to deal with
it, as you mention.

Oh well I will know what to say next time.

Thanks once again.

Steve.

"glenn" wrote:

Steve

The code with the ToString() call would be quicker 'cus I don't think the
first would even compile.

Personally, I think it should have been

Console.WriteLi ne( "This value is: {0}", i );

In this case ToString would be called anyway, so an explicit call to
ToString() is superfluous.

Glenn

"Steve Bugden" <St*********@di scussions.micro soft.comwrote in message
news:60******** *************** ***********@mic rosoft.com...

Hi,

I recently had an interview where I was asked a number of questions on C#.
Unfortunately I didn't get the answers from the test and find that one of
them is still niggling me.

It was something like this:

Consider the following code:

int i = 0;
Console.WriteLi ne("The value is: " + i);
Console.WriteLi ne("The value is: " + i.ToString());

Which would you use to write an integer to the console and why would it
give
better performance?

I said I would use: Console.WriteLi ne("The value is: " +
i.ToString());

But I can't think why this should give a performance advantage. I can only
guess that the compiler should be able to realise that a string is
required
from the integer for the line not using the ToString() method and generate
the same MSIL.

Can anyone please enlighten me?

Best Regards,

Steve

[Mike Schilling]

"Steve Bugden" <St*********@di scussions.micro soft.comwrote in message
news:60******** *************** ***********@mic rosoft.com...

Hi,

I recently had an interview where I was asked a number of questions on C#.
Unfortunately I didn't get the answers from the test and find that one of
them is still niggling me.

It was something like this:

Consider the following code:

int i = 0;
Console.WriteLi ne("The value is: " + i);
Console.WriteLi ne("The value is: " + i.ToString());

Which would you use to write an integer to the console and why would it
give
better performance?

By definition, they mean exactly the same thing, so it doesn't matter which
one you use. (If it were possible for "i" to be null, the first one would
be better, since it could never cause a null reference exception, but a
value type can't be null.) The analyses in other posts in the thread aren't
about the difference between these two statements, they're about what IL a
particular version of the compiler happens to generate. If these people
expect you to know that off the top of your head, they're idiots. Likewise,
if these people think that the difference between the two sets of generated
IL cause any measurable difference in performance, they're idiots.

>
I said I would use: Console.WriteLi ne("The value is: " +
i.ToString());

But I can't think why this should give a performance advantage. I can only
guess that the compiler should be able to realise that a string is
required
from the integer for the line not using the ToString() method and generate
the same MSIL.

Can anyone please enlighten me?

Best Regards,

Steve