There are two options for text handling in Noda Time. For some elements of
formatting, you can follow the "normal" approach from the .NET Base Class
Library (BCL) - in particular, most of the core Noda Time types implements
IFormattable. However, no parsing support is provided in this way. (It used
to be, but the whole approach is so convoluted that documenting it accurately
proved too great an overhead.)
The preferred approach is to use the "pattern" classes such as
and so forth. This leads to clearer, more robust code, and performs better. The formatting
support present in the BCL style is mostly present to work well with compound format strings,
where you may wish to mix several values of different types in a single formatting call.
All the types responsible for text in Noda Time are in the NodaTime.Text namespace.
A pattern is an object capable of parsing from text to a specific
type, and formatting a value to text. Parsing and formatting don't
take any other options: the pattern knows everything about how to
map between the value and text. In particular, internationalization
is handled by having the pattern hold a
Whereas using the BCL approach the format information has to be specified on every call, using the pattern approach the format information is fixed for any particular pattern. Convenience methods are provided to create new pattern instances based on existing ones but with different internationalization information or other options.
Each core Noda type has its own pattern type such as
these patterns implement the
which has simple
Parse methods taking just the value
and text respectively. The result of
Parse is a
encapsulates both success and failure results.
ToString(): Formats the value using the default pattern for the current thread's format provider.
ToString(string, IFormatProvider): Formats the value with the given pattern and format provider. The pattern text for this call is exactly the same as when creating a pattern object with the preferred API.
Each type has its own separate pattern text documentation. The available patterns are as consistent as possible within reason, but documenting each separately avoids confusion with some field specifiers being available for some types but not others.
Standard patterns are those denoted with a single character to represent a common pattern within the culture
being used. For example, the standard pattern
d for a
LocalDate is in month/day/year format in a US culture,
but day/month/year format in a UK culture. They're usually a shorthand for a possibly-culture-specific custom format,
but not always. (Some standard patterns in Noda Time can't be represented directly in custom patterns.)
Custom patterns give more direct control over how a value is formatted or parsed. It may
still be culture-sensitive like standard patterns, but in a lower level way - the
/ format specifier within a
LocalDate pattern is used to indicate
the culture-sensitive date separator, which is
/ in a US culture but
. in German culture, for example.
When a single character is specified for a pattern, it is always treated as a standard pattern. If no standard
pattern for that character exists, an exception is thrown. To create a custom pattern which would normally only
contain a single character, use
% to effectively "escape" the character. So a
LocalTime custom pattern which
formats the 24-hour hour-of-day without padding would be represented as
All custom patterns support the following characters:
||Escape to force a single-character custom pattern to be treated as such.||
||Open and close a text literal, which can include double quotes.||
||Open and close a text literal, which can include single quotes.||
||Escapes the following character.||
:always refers to the culture-specific time separator (a colon in the invariant culture)
/always refers to the culture-specific date separator (a forward slash in the invariant culture)
>are used for embedding one pattern within another. For consistency, these characters must always be quoted when they are intended to be used as text literals.
Any ASCII letters (a-z, A-Z) which are intended to be used as text literals (when parsing, they must be
matched exactly; when formatting they are reproduced exactly) must be quoted or escaped. Even if they do not have
a specific meaning for the given pattern type, their presence within the pattern would be a potential cause for
confusion and error. Additionally, by effectively reserving all ASCII letters, Noda Time has more room for future
expansion without compatibility concerns. The one exception to this rule is 'T', which is explicitly allowed within
date/time-based patterns (
LocalDateTime etc) as a common separator between the two parts. It is not permitted
(without quoting or escaping) in other patterns such as for
Any non-letter characters within a custom format which don't have a specific meaning are treated as text literals. You may wish to escape or quote such characters anyway, for the sake of consistency.
In general, a field may only occur once in a pattern in any form. For example, a pattern of "dd MM '('MMM')' yyyy" is invalid as it specifies the month twice, even though it specifies it in different forms. This restriction may be relaxed in the future, but it would always be invalid to have a value with inconsistencies.
In some cases, fields may be related without being the same. The most obvious example here is day-of-week and the other date fields. When parsing, the day-of-week field is only used for validation: in itself, it doesn't provide enough information to specify a date. (The week-year/week-of-week-year/day-of-week scheme is not currently supported in text handling.) If the day-of-week is present but does not concur with the other values, parsing will fail.
In other cases, there can be multiple fields specifying the same information - such as "year-of-era" and "absolute-year". In these cases either field is actually enough to determine the information, but when parsing the field values are validated for consistency.
Many patterns allow a template value to be specified - for date/time values this is typically midnight on January 1st 2000. This value is used to provide values for fields which aren't specified elsewhere. For example, if you create a
LocalDateTimePattern with a custom pattern of "dd HH:mm:ss" then that doesn't specify the year or month - those will be picked from the template value. Template values can be specified for both standard and custom patterns, although standard patterns will rarely use them.
The century in the template value is also used when a pattern specifies a two-digit year ("yy"), although such patterns are generally discouraged anyway.
Often you don't have much choice about how to parse or format text: if you're interoperating with another system which provides or expects the data in a particular format, you just have to go with their decision. However, often you do have a choice. A few points of guidance:
uuuu-MM-ddis naturally sortable in the text form (assuming you never need years outside the range 0-9999), whereas neither
There are some patterns that are unambiguous for humans, but which Noda Time won't parse in
all cases. For example, a
LocalTime pattern of
Hmm is always unambiguous for valid values,
as it will always be three characters (for a one-digit hour) or four characters (for a two-digit hour).
However, the Noda Time parsing strategy doesn't look ahead enough to handle this, so a value of
"120" is parsed as an "hour" value of 12, followed by not enough digits for the minutes. While
it would be possible to support this, it would add significant complexity for the sake of formats
which are quite hard to read as a human anyway.
To avoid this, either use a format with a fixed length for each field (e.g.
HHmm) or a format
with a separator between fields (e.g.
H:mm). Noda Time will then handle all values appropriately.