WriteLine(int)よりもWriteLine(string, object)の方が速い

System.Console.WriteLine(1);
System.Console.WriteLine("{0}", 1);

public static void WriteLine(int value)
{
    Out.WriteLine(value);
}

public virtual void WriteLine(int value) {
    Write(value);
    WriteLine();
}

public virtual void Write(int value) {
    Write(value.ToString(FormatProvider));
}

public virtual void Write(String value) {
    if (value != null) Write(value.ToCharArray());
}

public virtual void Write(char[] buffer) {
    if (buffer != null) Write(buffer, 0, buffer.Length);
}

// Writes a range of a character array to the text stream. This method will
// write count characters of data into this TextWriter from the
// buffer character array starting at position index.
//
public virtual void Write(char[] buffer, int index, int count) {
    if (buffer==null)
        throw new ArgumentNullException("buffer", Environment.GetResourceString("ArgumentNull_Buffer"));
    if (index < 0)
        throw new ArgumentOutOfRangeException("index", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
    if (count < 0)
        throw new ArgumentOutOfRangeException("count", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
    if (buffer.Length - index < count)
        throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
    Contract.EndContractBlock();

    for (int i = 0; i < count; i++) Write(buffer[index + i]);
}

public static void WriteLine(String format, Object arg0)
{
    Out.WriteLine(format, arg0);
}

public virtual void WriteLine(String format, Object arg0)
{
    WriteLine(String.Format(FormatProvider, format, arg0));
}

// Writes a string followed by a line terminator to the text stream.
//
public virtual void WriteLine(String value) {

    if (value==null) {
        WriteLine();
    }
    else {
        // We'd ideally like WriteLine to be atomic, in that one call
        // to WriteLine equals one call to the OS (ie, so writing to 
        // console while simultaneously calling printf will guarantee we
        // write out a string and new line chars, without any interference).
        // Additionally, we need to call ToCharArray on Strings anyways,
        // so allocating a char[] here isn't any worse than what we were
        // doing anyways.  We do reduce the number of calls to the 
        // backing store this way, potentially.
        int vLen = value.Length;
        int nlLen = CoreNewLine.Length;
        char[] chars = new char[vLen+nlLen];
        value.CopyTo(0, chars, 0, vLen);
        // CoreNewLine will almost always be 2 chars, and possibly 1.
        if (nlLen == 2) {
            chars[vLen] = CoreNewLine[0];
            chars[vLen+1] = CoreNewLine[1];
        }
        else if (nlLen == 1)
            chars[vLen] = CoreNewLine[0];
        else
            Buffer.InternalBlockCopy(CoreNewLine, 0, chars, vLen * 2, nlLen * 2);
        Write(chars, 0, vLen + nlLen);
    }
    /*
       Write(value);  // We could call Write(String) on StreamWriter...
       WriteLine();
     */
}

for (int i = 0; i < N; i++) {
    Console.WriteLine(1);
}