PROGRAMACIÓN I

Salida con formato

Hasta este punto, cuando un dato ha sido enviado al flujo de salida usando la sentencia Write() o
WriteLine(), ha sido mostrado usando el formato por defecto. Sin embargo, .NET Framework define
un mecanismo sofisticado que brinda control detallado sobre cómo los datos serán mostrados. El
usar estas opciones permite especificar la manera como se mostrarán los valores en una sentencia
Write() o WriteLine().
Cuando se muestra una lista de datos, se ha separado cada una de las partes de la lista con un signo
de adición, como se muestra a continuación:
Console.WriteLine("Usted ordenó " + 2 + " artículos a $" + 3 + " cada uno.");
A pesar de ser muy conveniente, mostrar información numérica de esta manera no proporciona
ningún control sobre cómo aparece la información. Por ejemplo, para valores de punto flotante,
no se puede controlar el número de lugares decimales mostrados. Por ejemplo, la sentencia:
Console.WriteLine("Esto es 10/3: " + 10.0/3.0);
Genera la salida:
Esto es 10/3: 3.33333333333333
A pesar de que esto está bien para algunos propósitos, mostrar tantos espacios decimales podría
ser inapropiado para otros. Por ejemplo, en cálculos financieros, usualmente se desea mostrar dos
lugares decimales.
Para controlar cómo se aplica formato a la información numérica, necesitará una segunda forma de
WriteLine() que permita incluir información de formato:
WriteLine(“cadena de formato”, arg0, arg1, ... , argN);
En esta versión, los argumentos para WriteLine() están separador por comas en lugar de signos +.
La cadena de formato contiene dos elementos: regular, que imprime el carácter como es; y
especificadores de formato. Los especificadores de formato toman esta forma general:
{numArg, ancho: fmt}

Donde:
numArg especifica el número de argumento (empezando desde cero) a mostrar. El ancho mínimo
del campo es especificado por ancho, y el formato es especificado por fmt. Los especificadores
ancho y fmt son opcionales.
Durante la ejecución, cuando un especificador de formato es encontrado en la cadena de formato,
el argumento correspondiente, como es especificado en numArg, es sustituido y mostrado. Así, la
posición de una especificación de formato dentro de la cadena de formato especifica el lugar donde
el dato correspondiente será mostrado. Ambos especificadores ancho y fmt son opcionales. Por

ING. VERÓNICA ROSA 1

PROGRAMACIÓN I

tanto, en su forma más simple, un especificador de formato indica cuál argumento mostrar. Por
ejemplo, {0} indica arg0, {1} especifica arg1, y así sucesivamente. Veamos el siguiente ejemplo
sencillo. La sentencia:
Console.WriteLine("Febrero tiene {0} o {1} días.", 28, 29);
Produce la salida siguiente:
Febrero tiene 28 o 29 días

Como se puede apreciar, el valor 28 es sustituido por {0} y 29 es sustituido por {1}. Así, los
especificadores de formato identifican la ubicación en la cual los argumentos subsecuentes, en este
caso 28 y 29, son mostrados dentro de la cadena. Es más, observe que los valores adicionales son
separados por comas, no por signos +.
Ahora se presenta una variación de la sentencia anterior que especifica anchos mínimos de campo:
Console.WriteLine("Febrero tiene {0,10} o {1,5} días.", 28, 29);

Produce la salida siguiente:

Febrero tiene 28 o 29 días

Como puede ver, los espacios han sido agregados para llenar las partes no usadas del campo.
Recuerde que un ancho mínimo de campo es justamente eso: el ancho mínimo. La salida puede
exceder ese ancho, de ser necesario.
Una de las formas más fáciles para especificar un formato es describir una plantilla para que sea
usada por WriteLine(). Para hacer esto se usan signos # para marcar posiciones de dígitos. También
se pueden especificar puntos decimales y comas. Por ejemplo:
Console.WriteLine("Esto es 10/3: {0:#.##}", 10.0/3.0);

La salida de esta sentencia es:

Esto es 10/3: 3.33
En este ejemplo, la plantilla es #.##, la cual le dice a WriteLine() que muestre dos espacios decimales.
Es importante entender, sin embargo, que WriteLine() mostrará más de un dígito a la izquierda del
punto decimal, si es necesario, para no malinterpretar el valor. Aquí está otro ejemplo:
Console.WriteLine("{0:###,###.##}", 123456.56);
Genera la salida siguiente:

ING. VERÓNICA ROSA 2

PROGRAMACIÓN I

123,456.56
Si desea mostrar valores monetarios, use el especificador de formato C. Por ejemplo:
decimal balance;
balance = 12323.09m;
Console.WriteLine("El balance actual es {0:C}", balance);
La salida para esta secuencia es mostrada (en formato de dólares estadounidenses):
El balance actual es $12,323.09

El formato especifica cómo va a ser la salida. Es una cadena de caracteres formada por caracteres
ordinarios, secuencias de escape y especificaciones de formato. El formato se lee de izquierda a
derecha.

Especificadores de formato argumentos

WriteLine(“Tiene {0,2:d} años y pesa {1,6:f2} kilos \n”, edad, peso);

Caracteres ordinarios secuencia de escape

Los argumentos representan el valor o valores a escribir. Cada argumento debe tener su
correspondiente especificación de formato y en el mismo orden. Si hay más argumentos que
especificaciones de formato, los argumentos en exceso se ignoran.
Cuando se ejecuta la sentencia anterior, los caracteres ordinarios se escribirán tal cual, las
especificaciones de formato serán sustituidas por los valores correspondientes en la lista de
argumentos y las secuencias de escape darán lugar al carácter o acción que representan. Así, para
edad igual a 20 y peso igual a 70.5, el resultado será:
Tiene 20 años y pesa 70.50 kilos
En general, una especificación de formato está compuesto por:
{posición [ , ancho ] [ : tipo [ posiciones decimales ] ] }
Una especificación de formato siempre está incluida entre llaves ({ }). El significado de cada uno de
los elementos se presenta a continuación:

ING. VERÓNICA ROSA 3

PROGRAMACIÓN I

posición Posición 1, 2, etc., del argumento en la lista de argumentos.

ancho Opcional. Número mínimo de posiciones para la salida. Si el ancho se omite o el

valor a escribir ocupa más posiciones de las especificadas, el ancho se incrementa
según sea necesario. Si este valor es negativo, el resultado se justifica a la izquierda
dentro del ancho especificado; si es positivo, la justificación se hace a la derecha.

tipo Opcional. Corresponde a uno de los caracteres de la tabla mostrada a continuación.

decimales Opcional. Es el número mínimo de dígitos a mostrar en el caso de enteros o de

decimales en el caso de fraccionarios. Cuando se especifica se escribe justo a
continuación de tipo, sin espacios en blanco.

A continuación, se presentan algunos ejemplos:

Carácter Descripción Ejemplos Salida

Coc Moneda Console.WriteLine (“{0,9:C2}”, 4.5); $4.50

Console.WriteLine (“{0:C2}”, -4.5); ($4.50)

Dod Enteros Console.WriteLine (“{0:D5}”, 45); 00045

Console.WriteLine (“{0,5:D}”, 45); 45

Eoe Científico Console.WriteLine (“{0:E}”, 450000); 4,500000E+005

Fof Coma fija Console.WriteLine (“{0:F2}”, 45); 45.00

Console.WriteLine (“{0:F0}”, 45); 45
Console.WriteLine (“{0,8:F2}”, 45); 45.00
Console.WriteLine (“{0,8:F2}”, 145.3); 145.30

Gog General Console.WriteLine (“{0:G}”, 4.5); 4.5

Non Numérico Console.WriteLine (“{0:N}”, 4500000); 4,500,000.00

Pop Porcentaje Console.WriteLine (“{0:P}”, 0.12345); 12.35%

Xox Hexadecimal Console.WriteLine (“{0:X}”, 1259); 4EB

ING. VERÓNICA ROSA 4