Biblioteca estándar de Anexo C
C.1 General
Una implementación de C# conforme proporcionará un conjunto mínimo de tipos que tengan semántica específica. Estos tipos y sus miembros se enumeran aquí, en orden alfabético por espacio de nombres y tipo. Para obtener una definición formal de estos tipos y sus miembros, consulte ISO/IEC 23271:2012 Common Language Infrastructure (CLI), Partition IV; Biblioteca de clases base (BCL), Biblioteca numérica extendida y Biblioteca de matrices extendidas, que se incluyen por referencia en esta especificación.
Este texto es informativo.
La biblioteca estándar está pensada para ser el conjunto mínimo de tipos y miembros requeridos por una implementación de C# conforme. Por lo tanto, solo contiene los miembros que requieren explícitamente la especificación del lenguaje C#.
Se espera que una implementación de C# conforme proporcione una biblioteca significativamente más extensa que permita escribir programas útiles. Por ejemplo, una implementación conforme podría ampliar esta biblioteca mediante
- Agregar espacios de nombres.
- Agregar tipos.
- Agregar miembros a tipos que no son de interfaz.
- Agregar interfaces o clases base intermedias.
- Tener tipos de clase y estructura implementan interfaces adicionales.
- Agregar atributos (distintos de
ConditionalAttribute) a los tipos y miembros existentes.
Fin del texto informativo.
C.2 Tipos de biblioteca estándar definidos en ISO/IEC 23271
Nota: Algunos
structtipos siguientes tienen elreadonlymodificador . Este modificador no estaba disponible cuando se lanzó ISO/IEC 23271, pero es necesario para cumplir las implementaciones de esta especificación. nota final
namespace System
{
public delegate void Action();
public class ArgumentException : SystemException
{
public ArgumentException();
public ArgumentException(string message);
public ArgumentException(string message, Exception innerException);
}
public class ArithmeticException : Exception
{
public ArithmeticException();
public ArithmeticException(string message);
public ArithmeticException(string message, Exception innerException);
}
public abstract class Array : IList, ICollection, IEnumerable
{
public int Length { get; }
public int Rank { get; }
public int GetLength(int dimension);
}
public class ArrayTypeMismatchException : Exception
{
public ArrayTypeMismatchException();
public ArrayTypeMismatchException(string message);
public ArrayTypeMismatchException(string message,
Exception innerException);
}
[AttributeUsageAttribute(AttributeTargets.All, Inherited = true,
AllowMultiple = false)]
public abstract class Attribute
{
protected Attribute();
}
public enum AttributeTargets
{
Assembly = 0x1,
Module = 0x2,
Class = 0x4,
Struct = 0x8,
Enum = 0x10,
Constructor = 0x20,
Method = 0x40,
Property = 0x80,
Field = 0x100,
Event = 0x200,
Interface = 0x400,
Parameter = 0x800,
Delegate = 0x1000,
ReturnValue = 0x2000,
GenericParameter = 0x4000,
All = 0x7FFF
}
[AttributeUsageAttribute(AttributeTargets.Class, Inherited = true)]
public sealed class AttributeUsageAttribute : Attribute
{
public AttributeUsageAttribute(AttributeTargets validOn);
public bool AllowMultiple { get; set; }
public bool Inherited { get; set; }
public AttributeTargets ValidOn { get; }
}
public readonly struct Boolean { }
public readonly struct Byte { }
public readonly struct Char { }
public readonly struct Decimal { }
public abstract class Delegate { }
public class DivideByZeroException : ArithmeticException
{
public DivideByZeroException();
public DivideByZeroException(string message);
public DivideByZeroException(string message, Exception innerException);
}
public readonly struct Double { }
public abstract class Enum : ValueType
{
protected Enum();
}
public class Exception
{
public Exception();
public Exception(string message);
public Exception(string message, Exception innerException);
public sealed Exception InnerException { get; }
public virtual string Message { get; }
}
public class GC { }
public interface IDisposable
{
void Dispose();
}
public interface IFormattable { }
public sealed class IndexOutOfRangeException : Exception
{
public IndexOutOfRangeException();
public IndexOutOfRangeException(string message);
public IndexOutOfRangeException(string message,
Exception innerException);
}
public readonly struct Int16 { }
public readonly struct Int32 { }
public readonly struct Int64 { }
public readonly struct IntPtr { }
public class InvalidCastException : Exception
{
public InvalidCastException();
public InvalidCastException(string message);
public InvalidCastException(string message, Exception innerException);
}
public class InvalidOperationException : Exception
{
public InvalidOperationException();
public InvalidOperationException(string message);
public InvalidOperationException(string message,
Exception innerException);
}
public class NotSupportedException : Exception
{
public NotSupportedException();
public NotSupportedException(string message);
public NotSupportedException(string message,
Exception innerException);
}
public struct Nullable<T>
{
public bool HasValue { get; }
public T Value { get; }
}
public class NullReferenceException : Exception
{
public NullReferenceException();
public NullReferenceException(string message);
public NullReferenceException(string message, Exception innerException);
}
public class Object
{
public Object();
~Object();
public virtual bool Equals(object obj);
public virtual int GetHashCode();
public Type GetType();
public virtual string ToString();
}
[AttributeUsageAttribute(AttributeTargets.Class | AttributeTargets.Struct |
AttributeTargets.Enum | AttributeTargets.Interface |
AttributeTargets.Constructor | AttributeTargets.Method |
AttributeTargets.Property | AttributeTargets.Field |
AttributeTargets.Event | AttributeTargets.Delegate, Inherited = false)]
public sealed class ObsoleteAttribute : Attribute
{
public ObsoleteAttribute();
public ObsoleteAttribute(string message);
public ObsoleteAttribute(string message, bool error);
public bool IsError { get; }
public string Message { get; }
}
public class OutOfMemoryException : Exception
{
public OutOfMemoryException();
public OutOfMemoryException(string message);
public OutOfMemoryException(string message, Exception innerException);
}
public class OverflowException : ArithmeticException
{
public OverflowException();
public OverflowException(string message);
public OverflowException(string message, Exception innerException);
}
public readonly struct SByte { }
public readonly struct Single { }
public sealed class StackOverflowException : Exception
{
public StackOverflowException();
public StackOverflowException(string message);
public StackOverflowException(string message, Exception innerException);
}
public sealed class String : IEnumerable<Char>, IEnumerable
{
public int Length { get; }
public char this [int index] { get; }
public static string Format(string format, params object[] args);
}
public abstract class Type : MemberInfo { }
public sealed class TypeInitializationException : Exception
{
public TypeInitializationException(string fullTypeName,
Exception innerException);
}
public readonly struct UInt16 { }
public readonly struct UInt32 { }
public readonly struct UInt64 { }
public readonly struct UIntPtr { }
public abstract class ValueType
{
protected ValueType();
}
}
namespace System.Collections
{
public interface ICollection : IEnumerable
{
int Count { get; }
bool IsSynchronized { get; }
object SyncRoot { get; }
void CopyTo(Array array, int index);
}
public interface IEnumerable
{
IEnumerator GetEnumerator();
}
public interface IEnumerator
{
object Current { get; }
bool MoveNext();
void Reset();
}
public interface IList : ICollection, IEnumerable
{
bool IsFixedSize { get; }
bool IsReadOnly { get; }
object this [int index] { get; set; }
int Add(object value);
void Clear();
bool Contains(object value);
int IndexOf(object value);
void Insert(int index, object value);
void Remove(object value);
void RemoveAt(int index);
}
}
namespace System.Collections.Generic
{
public interface ICollection<T> : IEnumerable<T>
{
int Count { get; }
bool IsReadOnly { get; }
void Add(T item);
void Clear();
bool Contains(T item);
void CopyTo(T[] array, int arrayIndex);
bool Remove(T item);
}
public interface IEnumerable<T> : IEnumerable
{
IEnumerator<T> GetEnumerator();
}
public interface IEnumerator<T> : IDisposable, IEnumerator
{
T Current { get; }
}
public interface IList<T> : ICollection<T>
{
T this [int index] { get; set; }
int IndexOf(T item);
void Insert(int index, T item);
void RemoveAt(int index);
}
}
namespace System.Diagnostics
{
[AttributeUsageAttribute(AttributeTargets.Method | AttributeTargets.Class,
AllowMultiple = true)]
public sealed class ConditionalAttribute : Attribute
{
public ConditionalAttribute(string conditionString);
public string ConditionString { get; }
}
}
namespace System.Reflection
{
public abstract class MemberInfo
{
protected MemberInfo();
}
}
namespace System.Runtime.CompilerServices
{
public sealed class IndexerNameAttribute : Attribute
{
public IndexerNameAttribute(String indexerName);
}
public static class Unsafe
{
public static ref T NullRef<T>();
}
}
namespace System.Threading
{
public static class Monitor
{
public static void Enter(object obj);
public static void Exit(object obj);
}
}
C.3 Tipos de biblioteca estándar no definidos en ISO/IEC 23271
Los siguientes tipos, incluidos los miembros enumerados, se definirán en una biblioteca estándar conforme. (Estos tipos se pueden definir en una edición futura de ISO/IEC 23271). Se espera que muchos de estos tipos tengan más miembros disponibles de los enumerados.
Una implementación conforme puede proporcionar Task.GetAwaiter() y Task<TResult>.GetAwaiter() como métodos de extensión.
namespace System
{
public class FormattableString : IFormattable { }
public class OperationCanceledException : Exception
{
public OperationCanceledException();
public OperationCanceledException(string message);
public OperationCanceledException(string message, Exception innerException);
}
public readonly ref struct ReadOnlySpan<T>
{
public int Length { get; }
public ref readonly T this[int index] { get; }
}
public readonly ref struct Span<T>
{
public int Length { get; }
public ref T this[int index] { get; }
public static implicit operator ReadOnlySpan<T>(Span<T> span);
}
public struct ValueTuple<T1>
{
public T1 Item1;
public ValueTuple(T1 item1);
}
public struct ValueTuple<T1, T2>
{
public T1 Item1;
public T2 Item2;
public ValueTuple(T1 item1, T2 item2);
}
public struct ValueTuple<T1, T2, T3>
{
public T1 Item1;
public T2 Item2;
public T3 Item3;
public ValueTuple(T1 item1, T2 item2, T3 item3);
}
public struct ValueTuple<T1, T2, T3, T4>
{
public T1 Item1;
public T2 Item2;
public T3 Item3;
public T4 Item4;
public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4);
}
public struct ValueTuple<T1, T2, T3, T4, T5>
{
public T1 Item1;
public T2 Item2;
public T3 Item3;
public T4 Item4;
public T5 Item5;
public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5);
}
public struct ValueTuple<T1, T2, T3, T4, T5, T6>
{
public T1 Item1;
public T2 Item2;
public T3 Item3;
public T4 Item4;
public T5 Item5;
public T6 Item6;
public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5,
T6 item6);
}
public struct ValueTuple<T1, T2, T3, T4, T5, T6, T7>
{
public T1 Item1;
public T2 Item2;
public T3 Item3;
public T4 Item4;
public T5 Item5;
public T6 Item6;
public T7 Item7;
public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5,
T6 item6, T7 item7);
}
public struct ValueTuple<T1, T2, T3, T4, T5, T6, T7, TRest>
{
public T1 Item1;
public T2 Item2;
public T3 Item3;
public T4 Item4;
public T5 Item5;
public T6 Item6;
public T7 Item7;
public TRest Rest;
public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5,
T6 item6, T7 item7, TRest rest);
}
}
namespace System.Collections.Generic
{
public interface IReadOnlyCollection<out T> : IEnumerable<T>
{
int Count { get; }
}
public interface IReadOnlyList<out T> : IReadOnlyCollection<T>
{
T this [int index] { get; }
}
}
namespace System.Linq.Expressions
{
public sealed class Expression<TDelegate>
{
public TDelegate Compile();
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct |
AttributeTargets.Interface,
Inherited = false, AllowMultiple = false)]
public sealed class AsyncMethodBuilderAttribute : Attribute
{
public AsyncMethodBuilderAttribute(Type builderType) {}
public Type BuilderType { get; }
}
[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
public sealed class CallerFilePathAttribute : Attribute
{
public CallerFilePathAttribute() { }
}
[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
public sealed class CallerLineNumberAttribute : Attribute
{
public CallerLineNumberAttribute() { }
}
[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
public sealed class CallerMemberNameAttribute : Attribute
{
public CallerMemberNameAttribute() { }
}
public static class FormattableStringFactory
{
public static FormattableString Create(string format,
params object[] arguments);
}
public interface ICriticalNotifyCompletion : INotifyCompletion
{
void UnsafeOnCompleted(Action continuation);
}
public interface INotifyCompletion
{
void OnCompleted(Action continuation);
}
public readonly struct TaskAwaiter : ICriticalNotifyCompletion,
INotifyCompletion
{
public bool IsCompleted { get; }
public void GetResult();
}
public readonly struct TaskAwaiter<TResult> : ICriticalNotifyCompletion,
INotifyCompletion
{
public bool IsCompleted { get; }
public TResult GetResult();
}
public readonly struct ValueTaskAwaiter : ICriticalNotifyCompletion,
INotifyCompletion
{
public bool IsCompleted { get; }
public void GetResult();
}
public readonly struct ValueTaskAwaiter<TResult>
: ICriticalNotifyCompletion, INotifyCompletion
{
public bool IsCompleted { get; }
public TResult GetResult();
}
[System.AttributeUsage(System.AttributeTargets.Field |
System.AttributeTargets.Parameter | System.AttributeTargets.Property,
Inherited=false)]
public sealed class AllowNullAttribute : Attribute
{
public AllowNullAttribute() { }
}
[System.AttributeUsage(System.AttributeTargets.Field |
System.AttributeTargets.Parameter | System.AttributeTargets.Property,
Inherited=false)]
public sealed class DisallowNullAttribute : Attribute
{
public DisallowNullAttribute() {}
}
[System.AttributeUsage(System.AttributeTargets.Method, Inherited=false)]
public sealed class DoesNotReturnAttribute : Attribute
{
public DoesNotReturnAttribute() {}
}
[System.AttributeUsage(System.AttributeTargets.Parameter, Inherited=false)]
public sealed class DoesNotReturnIfAttribute : Attribute
{
public DoesNotReturnIfAttribute(bool parameterValue) {}
}
[System.AttributeUsage(System.AttributeTargets.Field |
System.AttributeTargets.Parameter | System.AttributeTargets.Property |
System.AttributeTargets.ReturnValue, Inherited=false)]
public sealed class MaybeNullAttribute : Attribute
{
public MaybeNullAttribute() {}
}
[System.AttributeUsage(System.AttributeTargets.Parameter, Inherited=false)]
public sealed class MaybeNullWhenAttribute : Attribute
{
public MaybeNullWhenAttribute(bool returnValue) {}
}
[System.AttributeUsage(System.AttributeTargets.Field |
System.AttributeTargets.Parameter | System.AttributeTargets.Property |
System.AttributeTargets.ReturnValue, Inherited=false)]
public sealed class NotNullAttribute : Attribute
{
public NotNullAttribute() {}
}
[System.AttributeUsage(System.AttributeTargets.Parameter |
System.AttributeTargets.Property | System.AttributeTargets.ReturnValue,
AllowMultiple=true, Inherited=false)]
public sealed class NotNullIfNotNullAttribute : Attribute
{
public NotNullIfNotNullAttribute(string parameterName) {}
}
[System.AttributeUsage(System.AttributeTargets.Parameter, Inherited=false)]
public sealed class NotNullWhenAttribute : Attribute
{
public NotNullWhenAttribute(bool returnValue) {}
}
}
namespace System.Threading.Tasks
{
public class Task
{
public System.Runtime.CompilerServices.TaskAwaiter GetAwaiter();
}
public class Task<TResult> : Task
{
public new System.Runtime.CompilerServices.TaskAwaiter<T> GetAwaiter();
}
public readonly struct ValueTask : System.IEquatable<ValueTask>
{
public System.Runtime.CompilerServices.ValueTaskAwaiter GetAwaiter();
}
public readonly struct ValueTask<TResult>
: System.IEquatable<ValueTask<TResult>>
{
public new System.Runtime.CompilerServices.ValueTaskAwaiter<TResult>
GetAwaiter();
}
}
Especificaciones de formato de C.4
El significado de los formatos, como se usa en expresiones de cadena interpoladas (§12.8.3), se definen en ISO/IEC 23271:2012. Para mayor comodidad, el texto siguiente se copia de la descripción de System.IFormattable.
Este texto es informativo.
Un formato es una cadena que describe la apariencia de un objeto cuando se convierte en una cadena. Se pueden usar formatos estándar o personalizados. Un formato estándar toma la forma Axx, donde A es un único carácter alfabético denominado especificador de formato, y xx es un entero entre cero y 99 inclusive, denominado especificador de precisión. El especificador de formato controla el tipo de formato aplicado al valor que se representa como una cadena. El especificador de precisión controla el número de dígitos significativos o posiciones decimales en la cadena, si procede.
Nota: Para obtener la lista de especificadores de formato estándar, consulte la tabla siguiente. Tenga en cuenta que un tipo de datos determinado, como
System.Int32, podría no admitir uno o varios de los especificadores de formato estándar. nota final
Nota: Cuando un formato incluye símbolos que varían según la referencia cultural, como el currencysymbol incluido en los formatos 'C' y 'c', un objeto de formato proporciona los caracteres reales usados en la representación de cadena. Un método puede incluir un parámetro para pasar un
System.IFormatProviderobjeto que proporciona un objeto de formato o el método podría usar el objeto de formato predeterminado, que contiene las definiciones de símbolos de la referencia cultural actual. La referencia cultural actual suele usar el mismo conjunto de símbolos usados en todo el sistema de forma predeterminada. En la biblioteca de clases base, el objeto de formato para los tipos numéricos proporcionados por el sistema es unaSystem.Globalization.NumberFormatInfoinstancia de . PorSystem.DateTimeejemplo, se usa unSystem.Globalization.DateTimeFormatInfo. nota final
En la tabla siguiente se describen los especificadores de formato estándar y los miembros de objeto de formato asociados que se usan con tipos de datos numéricos en la biblioteca de clases base.
| Especificador de formato | Descripción |
|---|---|
|
Formato de moneda: se usa para cadenas que contienen un valor monetario. Los
Si se omite el especificador de precisión, |
|
Formato decimal: (este formato solo es válido cuando se especifica con tipos de datos enteros). Se usa para cadenas que contienen valores enteros. Los números negativos tienen como prefijo el símbolo de número negativo especificado por la El especificador de precisión determina el número mínimo de dígitos que aparecen en la cadena. Si la precisión especificada requiere más dígitos que el valor contiene, la cadena se rellena a la izquierda con ceros. Si el especificador de precisión especifica menos dígitos de los que están en el valor, se omite el especificador de precisión. |
|
Formato científico (ingeniería): se usa para las cadenas de una de las formas siguientes: ]m.ddddddE+xxx ]m.ddddddE-xxx ]m.ddddd e+xxx ]m.dddddde-xxx El símbolo de número negativo ("-") solo aparece si el valor es negativo y lo proporciona la Exactamente un dígito decimal distinto de cero (m) precede al separador decimal ('.'), proporcionado por la El especificador de precisión determina el número de posiciones decimales (dddddd) en la cadena. Si se omite el especificador de precisión, se incluyen seis posiciones decimales en la cadena. El exponente (+/-xxx) consta de un símbolo de número positivo o negativo seguido de un mínimo de tres dígitos (xxx). El exponente se rellena a la izquierda con ceros, si es necesario. El caso del especificador de formato ('E' o 'e') determina el caso usado para el prefijo exponente (E o e) en la cadena. Los resultados se redondean al valor representable más cercano cuando sea necesario. La propiedad proporciona el |
|
Formato de punto fijo: se usa para las cadenas de la siguiente forma: ]m.dd... d Al menos un dígito decimal distinto de cero (m) precede al separador decimal ('.'), proporcionado por la Un signo de símbolo de número negativo ('-') precede solo si el valor es negativo. Esta propiedad proporciona El especificador de precisión determina el número de posiciones decimales (dd... d) en la cadena. Si se omite el especificador de precisión, |
|
Formato general: la cadena tiene el formato de punto fijo ('F' o 'f') o el formato científico ('E' o 'e'). Para tipos enteros: Los valores tienen el formato de punto fijo si especifican la precisión del exponente< , donde exponente es el exponente del valor en formato científico. Para todos los demás valores, se usa el formato científico. Si se omite el especificador de precisión, se usa una precisión predeterminada igual al ancho de campo necesario para mostrar el valor máximo del tipo de datos, lo que da como resultado el valor al que se le da formato en formato de punto fijo. Las precisiónes predeterminadas para los tipos enteros son las siguientes: Para tipos Single, Decimal y Double: Los valores tienen el formato de punto fijo si el exponente ≥ -4 y el especificador de precisión del exponente< , donde exponente es el exponente del valor en formato científico. Para todos los demás valores, se usa el formato científico. Los resultados se redondean al valor representable más cercano cuando sea necesario. Si se omite el especificador de precisión, se usan las siguientes precisiónes predeterminadas: Para todos los tipos:
|
|
Formato de número: se usa para las cadenas de la siguiente forma: ]d,ddd,ddd.dd... d La representación de valores negativos viene determinada por la Al menos un dígito decimal distinto de cero (d) precede al separador decimal ('.'), proporcionado por la El especificador de precisión determina el número de posiciones decimales (dd... d). Si se omite el especificador de precisión, |
|
Formato de porcentaje: se usa para cadenas que contienen un porcentaje. Los
Si no se especifica ninguna precisión, el número de posiciones decimales en el resultado viene determinado por El resultado se escala en 100 (.99 se convierte en el 99 %). |
|
Formato de ida y vuelta: (este formato solo es válido cuando se especifica con System.Double o System.Single. Se usa para asegurarse de que la precisión de la representación de cadena de un valor de punto flotante es tal que el análisis de la cadena no da lugar a una pérdida de precisión en comparación con el valor original. Si la precisión máxima del tipo de datos (7 para System.Singley 15 para System.Double) daría lugar a una pérdida de precisión, la precisión se incrementa en dos posiciones decimales. Si se proporciona un especificador de precisión con este especificador de formato, se omite. Este formato es idéntico al formato de punto fijo. |
|
Formato hexadecimal: (Este formato solo es válido cuando se especifica con tipos de datos enteros). Se usa para representaciones de cadena de números en Base 16. La precisión determina el número mínimo de dígitos de la cadena. Si la precisión especifica más dígitos que el número contiene, el número se rellena a la izquierda con ceros. El caso del especificador de formato ("X" o "x") determina si se usan letras mayúsculas o minúsculas en la representación hexadecimal. |
Si el valor numérico es o System.Single System.Double con un valor de NaN, PositiveInfinityo NegativeInfinity, se omite el especificador de formato y se devuelve uno de los siguientes valores: System.Globalization.NumberFormatInfo.NaNSymbol, System.Globalization.NumberFormatInfo.PositiveInfinitySymbolo System.Globalization.NumberFormatInfo.NegativeInfinitySymbol.
Un formato personalizado es cualquier cadena especificada como un formato que no está en forma de una cadena de formato estándar (Axx) descrita anteriormente. En la tabla siguiente se describen los caracteres que se usan en la construcción de formatos personalizados.
| Especificador de formato | Descripción |
|---|---|
0 (cero) |
Marcador de posición cero: si el valor al que se da formato tiene un dígito en la posición donde aparece un "0" en el formato personalizado, ese dígito se copia en la cadena de salida; de lo contrario, un cero se almacena en esa posición en la cadena de salida. La posición del separador "0" situado más a la izquierda antes del separador decimal y del 0 más a la derecha después del separador decimal determinan el intervalo de dígitos que siempre están presentes en la cadena de salida. El número de marcadores de posición Cero o Dígito después del separador decimal determina el número de dígitos que aparecen después del separador decimal. Los valores se redondean según sea necesario. |
# |
Marcador de posición de dígitos: si el valor al que se da formato tiene un dígito en la posición donde aparece un "#" en el formato personalizado, ese dígito se copia en la cadena de salida; de lo contrario, no se almacena nada en esa posición en la cadena de salida. Tenga en cuenta que este especificador nunca almacena el carácter "0" si no es un dígito significativo, aunque "0" sea el único dígito de la cadena. (Muestra el carácter "0" en la cadena de salida si es un dígito significativo). El número de marcadores de posición Cero o Dígito después del separador decimal determina el número de dígitos que aparecen después del separador decimal. Los valores se redondean según sea necesario. |
. (período) |
Separador decimal: la izquierda más '.'
carácter en la cadena de formato determina la ubicación del separador decimal en el valor con formato; cualquier '.' adicional. se omiten los caracteres. La System.Globalization.NumberFormatInfo.NumberDecimalSeparator propiedad determina el símbolo utilizado como separador decimal. |
, (coma) |
Separador de grupos y escalado de números: el carácter ',' tiene dos propósitos. En primer lugar, si el formato personalizado contiene este carácter entre dos marcadores de posición Cero o Dígito (0 o #) y a la izquierda del separador decimal si hay uno presente, la salida tendrá separadores de grupo insertados entre cada grupo de dígitos a la izquierda del separador decimal. Las Si la cadena de formato contiene uno o varios caracteres "", inmediatamente a la izquierda del separador decimal, se escalará el número. El factor de escala viene determinado por el número de caracteres separadores de grupo inmediatamente a la izquierda del separador decimal. Si hay x caracteres, el valor se divide entre 1000X antes de dar formato. Por ejemplo, la cadena de formato '0', dividirá un valor en un millón. Tenga en cuenta que la presencia del carácter "", para indicar que el escalado no inserta separadores de grupo en la cadena de salida. Por lo tanto, para escalar un número en 1 millón e insertar separadores de grupo, use un formato personalizado similar a '#,##0,'. |
% (porcentaje) |
Marcador de posición de porcentaje: la presencia de un carácter '%' en un formato personalizado hace que un número se multiplique por 100 antes de que tenga formato. El símbolo de porcentaje se inserta en la cadena de salida en la ubicación donde aparece '%' en la cadena de formato. La System.Globalization.NumberFormatInfo.PercentSymbol propiedad determina el símbolo de porcentaje. |
|
Formato de ingeniería: si cualquiera de las cadenas 'E', 'E+', 'E-', 'e', 'e+' o 'e-' están presentes en un formato personalizado y se sigue inmediatamente por al menos un carácter '0', el valor se da formato mediante notación científica. El número de caracteres '0' que sigue al prefijo exponente (E o e) determina el número mínimo de dígitos del exponente. Los formatos "E+" y "e+" indican que un símbolo de número positivo o negativo siempre precede al exponente. Los formatos 'E', 'E-', 'e' o 'e-' indican que un símbolo de número negativo precede a los exponentes negativos; ningún símbolo precede a los exponentes positivos. La propiedad proporciona el System.Globalization.NumberFormatInfo.PositiveSign símbolo de número positivo. La propiedad proporciona el System.Globalization.NumberFormatInfo.NegativeSign símbolo de número negativo. |
\ (barra diagonal inversa) |
Carácter de escape: en algunos lenguajes, como C#, el carácter de barra diagonal inversa hace que el siguiente carácter en el formato personalizado se interprete como una secuencia de escape. Se usa con secuencias de formato de lenguaje C, como '\n' (nueva línea). En algunos lenguajes, el propio carácter de escape debe ir precedido por un carácter de escape cuando se usa como literal. De lo contrario, el compilador interpreta el carácter como una secuencia de escape. No es necesario admitir este carácter de escape en todos los lenguajes de programación. |
|
Cadena literal: los caracteres entre comillas simples o dobles se copian en la cadena de salida literalmente y no afectan al formato. |
; (punto y coma) |
Separador de sección: el carácter ';' se usa para separar secciones para números positivos, negativos y cero en la cadena de formato. (Esta característica se describe en detalle a continuación). |
| Otros | Todos los demás caracteres: todos los demás caracteres se almacenan en la cadena de salida como literales en la posición en la que aparecen. |
Tenga en cuenta que para las cadenas de formato de punto fijo (cadenas que no contienen "E0", "E+0", "E-0", "e0", "e+0" o "e-0", los números se redondean a tantas posiciones decimales como hay marcadores de posición Cero o Dígito a la derecha del separador decimal. Si el formato personalizado no contiene un separador decimal, el número se redondea al entero más cercano. Si el número tiene más dígitos que cero o dígitos a la izquierda del separador decimal, los dígitos adicionales se copian en la cadena de salida inmediatamente antes del primer marcador de posición Cero o Dígito.
Un formato personalizado puede contener hasta tres secciones separadas por caracteres separadores de sección, para especificar un formato diferente para valores positivos, negativos y cero. Las secciones se interpretan de la siguiente manera:
Una sección: el formato personalizado se aplica a todos los valores (positivo, negativo y cero). Los valores negativos incluyen un signo negativo.
Dos secciones: la primera sección se aplica a valores positivos y ceros, y la segunda sección se aplica a valores negativos. Si el valor al que se va a dar formato es negativo, pero se convierte en cero después del redondeo según el formato de la segunda sección, se da formato al cero resultante según la primera sección. Los valores negativos no incluyen un signo negativo para permitir el control total sobre las representaciones de valores negativos. Por ejemplo, un negativo se puede representar entre paréntesis mediante un formato personalizado similar a '###.#; (####.####)’.
Tres secciones: la primera sección se aplica a valores positivos, la segunda sección se aplica a valores negativos y la tercera sección se aplica a ceros. La segunda sección puede estar vacía (nada aparece entre los punto y coma), en cuyo caso la primera sección se aplica a todos los valores distintos de cero y los valores negativos incluyen un signo negativo. Si el número al que se va a dar formato es distinto de cero, pero se convierte en cero después del redondeo según el formato de la primera o segunda sección, se da formato al cero resultante según la tercera sección.
Los System.Enum tipos y System.DateTime también admiten el uso de especificadores de formato para dar formato a representaciones de cadena de valores. El significado de un especificador de formato específico varía según el tipo de datos (numérico, fecha y hora, enumeración) con formato. Consulte System.Enum y System.Globalization.DateTimeFormatInfo para obtener una lista completa de los especificadores de formato admitidos por cada tipo.
Abreviaturas de tipo de biblioteca de C.5
En esta especificación se hace referencia a los siguientes tipos de biblioteca. A continuación se enumeran los nombres completos de esos tipos, incluido el calificador de espacio de nombres global. A lo largo de esta especificación, estos tipos aparecen como el nombre completo; con el calificador de espacio de nombres global omitido; o como un nombre de tipo no completo simple, con el espacio de nombres omitido también. Por ejemplo, el tipo ICollection<T>, cuando se usa en esta especificación, siempre significa el tipo global::System.Collections.Generic.ICollection<T>.
global::System.Actionglobal::System.ArgumentExceptionglobal::System.ArithmeticExceptionglobal::System.Arrayglobal::System.ArrayTypeMisMatchExceptionglobal::System.Attributeglobal::System.AttributeTargetsglobal::System.AttributeUsageAttributeglobal::System.Booleanglobal::System.Byteglobal::System.Charglobal::System.Collections.Generic.ICollection<T>global::System.Collections.Generic.IEnumerable<T>global::System.Collections.Generic.IEnumerator<T>global::System.Collections.Generic.IList<T>global::System.Collections.Generic.IReadonlyCollection<out T>global::System.Collections.Generic.IReadOnlyList<out T>global::System.Collections.ICollectionglobal::System.Collections.IEnumerableglobal::System.Collections.IListglobal::System.Collections.IEnumeratorglobal::System.Decimalglobal::System.Delegateglobal::System.Diagnostics.ConditionalAttributeglobal::System.DivideByZeroExceptionglobal::System.Doubleglobal::System.Enumglobal::System.Exceptionglobal::System.GCglobal::System.ICollectionglobal::System.IDisposableglobal::System.IEnumerableglobal::System.IEnumerable<out T>global::System.IListglobal::System.IndexOutOfRangeExceptionglobal::System.Int16global::System.Int32global::System.Int64global::System.IntPtrglobal::System.InvalidCastExceptionglobal::System.InvalidOperationExceptionglobal::System.Linq.Expressions.Expression<TDelegate>global::System.MemberInfoglobal::System.NotSupportedExceptionglobal::System.Nullable<T>global::System.NullReferenceExceptionglobal::System.Objectglobal::System.ObsoleteAttributeglobal::System.OutOfMemoryExceptionglobal::System.OverflowExceptionglobal::System.Runtime.CompilerServices.CallerFileAttributeglobal::System.Runtime.CompilerServices.CallerLineNumberAttributeglobal::System.Runtime.CompilerServices.CallerMemberNameAttributeglobal::System.Runtime.CompilerServices.ICriticalNotifyCompletionglobal::System.Runtime.CompilerServices.IndexerNameAttributeglobal::System.Runtime.CompilerServices.INotifyCompletionglobal::System.Runtime.CompilerServices.TaskAwaiterglobal::System.Runtime.CompilerServices.TaskAwaiter<T>global::System.SByteglobal::System.Singleglobal::System.StackOverflowExceptionglobal::System.Stringglobal::System.SystemExceptionglobal::System.Threading.Monitorglobal::System.Threading.Tasks.Taskglobal::System.Threading.Tasks.Task<TResult>global::System.Typeglobal::System.TypeInitializationExceptionglobal::System.UInt16global::System.UInt32global::System.UInt64global::System.UIntPtrglobal::System.ValueType
Fin del texto informativo.
ECMA C# draft specification