Struct LocalDateTime

A date and time in a particular calendar system. A LocalDateTime value does not represent an instant on the time line, because it has no associated time zone: "November 12th 2009 7pm, ISO calendar" occurred at different instants for different people around the world.

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Initializes a new instance of the LocalDateTime struct using the ISO calendar system.

Type	Name	Description
Int32	year	The year. This is the "absolute year", so a value of 0 means 1 BC, for example.
Int32	month	The month of year.
Int32	day	The day of month.
Int32	hour	The hour.
Int32	minute	The minute.

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Type	Condition
ArgumentOutOfRangeException	The parameters do not form a valid date/time.

Initializes a new instance of the LocalDateTime struct.

Type	Name	Description
Int32	year	The year. This is the "absolute year", so, for the ISO calendar, a value of 0 means 1 BC, for example.
Int32	month	The month of year.
Int32	day	The day of month.
Int32	hour	The hour.
Int32	minute	The minute.
CalendarSystem	calendar	The calendar.

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Type	Condition
ArgumentOutOfRangeException	The parameters do not form a valid date/time.
ArgumentNullException	calendar is null.

Initializes a new instance of the LocalDateTime struct using the ISO calendar system.

Type	Name	Description
Int32	year	The year. This is the "absolute year", so a value of 0 means 1 BC, for example.
Int32	month	The month of year.
Int32	day	The day of month.
Int32	hour	The hour.
Int32	minute	The minute.
Int32	second	The second.

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Type	Condition
ArgumentOutOfRangeException	The parameters do not form a valid date/time.

Initializes a new instance of the LocalDateTime struct.

Type	Name	Description
Int32	year	The year. This is the "absolute year", so, for the ISO calendar, a value of 0 means 1 BC, for example.
Int32	month	The month of year.
Int32	day	The day of month.
Int32	hour	The hour.
Int32	minute	The minute.
Int32	second	The second.
CalendarSystem	calendar	The calendar.

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Type	Condition
ArgumentOutOfRangeException	The parameters do not form a valid date/time.
ArgumentNullException	calendar is null.

Initializes a new instance of the LocalDateTime struct using the ISO calendar system.

Type	Name	Description
Int32	year	The year. This is the "absolute year", so a value of 0 means 1 BC, for example.
Int32	month	The month of year.
Int32	day	The day of month.
Int32	hour	The hour.
Int32	minute	The minute.
Int32	second	The second.
Int32	millisecond	The millisecond.

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Type	Condition
ArgumentOutOfRangeException	The parameters do not form a valid date/time.

Initializes a new instance of the LocalDateTime struct.

Type	Name	Description
Int32	year	The year. This is the "absolute year", so, for the ISO calendar, a value of 0 means 1 BC, for example.
Int32	month	The month of year.
Int32	day	The day of month.
Int32	hour	The hour.
Int32	minute	The minute.
Int32	second	The second.
Int32	millisecond	The millisecond.
CalendarSystem	calendar	The calendar.

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Type	Condition
ArgumentOutOfRangeException	The parameters do not form a valid date/time.
ArgumentNullException	calendar is null.

Initializes a new instance of the LocalDateTime struct.

Type	Name	Description
Int32	year	The year. This is the "absolute year", so a value of 0 means 1 BC, for example.
Int32	month	The month of year.
Int32	day	The day of month.
Int32	hour	The hour.
Int32	minute	The minute.
Int32	second	The second.
Int32	millisecond	The millisecond.
Int32	tickWithinMillisecond	The tick within millisecond.

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Type	Condition
ArgumentOutOfRangeException	The parameters do not form a valid date/time.

Initializes a new instance of the LocalDateTime struct.

Type	Name	Description
Int32	year	The year. This is the "absolute year", so, for the ISO calendar, a value of 0 means 1 BC, for example.
Int32	month	The month of year.
Int32	day	The day of month.
Int32	hour	The hour.
Int32	minute	The minute.
Int32	second	The second.
Int32	millisecond	The millisecond.
Int32	tickWithinMillisecond	The tick within millisecond.
CalendarSystem	calendar	The calendar.

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Gets the calendar system associated with this local date and time.

Type	Condition
ArgumentOutOfRangeException	The parameters do not form a valid date/time.
ArgumentNullException	calendar is null.

Type	Description
CalendarSystem

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Gets the century within the era of this local date and time.

Type	Description
Int32

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Gets the hour of the half-day of this local date and time, in the range 1 to 12 inclusive.

Type	Description
Int32

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Gets the date portion of this local date and time as a LocalDate in the same calendar system as this value.

Type	Description
LocalDate

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Gets the day of this local date and time within the month.

Type	Description
Int32

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Gets the week day of this local date and time as a number.

For calendars using ISO week days, this gives 1 for Monday to 7 for Sunday.

Gets the day of this local date and time within the year.

Type	Description
Int32

Type	Description
Int32

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Gets the era of this local date and time.

Type	Description
Era

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Gets the hour of day of this local date and time, in the range 0 to 23 inclusive.

Type	Description
Int32

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Gets the week day of this local date and time expressed as an IsoDayOfWeek value, for calendars which use ISO days of the week.

Type	Description
IsoDayOfWeek

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Gets the millisecond of this local date and time within the second, in the range 0 to 999 inclusive.

Type	Condition
InvalidOperationException	The underlying calendar doesn't use ISO days of the week.

Type	Description
Int32

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Gets the minute of this local date and time, in the range 0 to 59 inclusive.

Type	Description
Int32

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Gets the month of this local date and time within the year.

Type	Description
Int32

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Gets the second of this local date and time within the minute, in the range 0 to 59 inclusive.

Type	Description
Int32

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Gets the tick of this local date and time within the day, in the range 0 to 863,999,999,999 inclusive.

Type	Description
Int64

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Gets the tick of this local time within the second, in the range 0 to 9,999,999 inclusive.

Type	Description
Int32

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Gets the time portion of this local date and time as a LocalTime.

Type	Description
LocalTime

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Gets the week within the WeekYear. See WeekYear for more details.

Type	Description
Int32

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Gets the "week year" of this local date and time.

Type	Description
Int32

The WeekYear is the year that matches with the WeekOfWeekYear field. In the standard ISO8601 week algorithm, the first week of the year is that in which at least 4 days are in the year. As a result of this definition, day 1 of the first week may be in the previous year. The WeekYear allows you to query the effective year for that day.

For example, January 1st 2011 was a Saturday, so only two days of that week (Saturday and Sunday) were in 2011. Therefore January 1st is part of week 52 of WeekYear 2010. Conversely, December 31st 2012 is a Monday, so is part of week 1 of WeekYear 2013.

Gets the year of this local date and time.

This returns the "absolute year", so, for the ISO calendar, a value of 0 means 1 BC, for example.

Gets the year of this local date and time within its century.

This always returns a value in the range 0 to 99 inclusive.

Gets the year of this local date and time within its era.

Type	Description
Int32

Type	Description
Int32

Type	Description
Int32

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Add the specified period to the date and time. Friendly alternative to operator+().

Type	Name	Description
LocalDateTime	localDateTime	Initial local date and time
Period	period	Period to add

Type	Description
LocalDateTime	The resulting local date and time

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Indicates whether this date/time is earlier, later or the same as another one.

Type	Name	Description
LocalDateTime	other	The other local date/time to compare with this value.

Type	Description
Int32	A value less than zero if this date/time is earlier than `other`; zero if this date/time is the same as `other`; a value greater than zero if this date/time is later than `other`.

The comparison is performed in terms of a calendar-independent notion of dates and times; the calendar systems of both LocalDateTime values are ignored. When both values use the same calendar, this is absolutely natural. However, when comparing a value in one calendar with a value in another, this can lead to surprising results. For example, 1945 in the ISO calendar corresponds to around 1364 in the Islamic calendar, so an Islamic date in year 1400 is "after" a date in 1945 in the ISO calendar.

Indicates whether the current object is equal to another object of the same type.

Type	Name	Description
LocalDateTime	other	An object to compare with this object.

Type	Description
Boolean	true if the current object is equal to the `other` parameter; otherwise, false.

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Determines whether the specified Object is equal to this instance.

Type	Name	Description
Object	obj	The Object to compare with this instance.

Type	Description
Boolean	`true` if the specified Object is equal to this instance; otherwise, `false`.

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Converts a DateTime of any kind to a LocalDateTime in the ISO calendar. This does not perform any time zone conversions, so a DateTime with a Kind of Utc will still have the same day/hour/minute etc - it won't be converted into the local system time.

Type	Name	Description
DateTime	dateTime	Value to convert into a Noda Time local date and time

Type	Description
LocalDateTime	A new LocalDateTime with the same values as the specified `DateTime`.

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Returns a hash code for this instance.

Type	Description
Int32	A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table.

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Returns the mapping of this local date/time within Utc.

As UTC is a fixed time zone, there is no chance that this local date/time is ambiguous or skipped.

Resolves this local date and time into a ZonedDateTime in the given time zone, following the given ZoneLocalMappingResolver to handle ambiguity and skipped times.

See InZoneStrictly(DateTimeZone) and InZoneLeniently(DateTimeZone) for alternative ways to map a local time to a specific instant. This is a convenience method for calling ResolveLocal(LocalDateTime, ZoneLocalMappingResolver).

Returns the mapping of this local date/time within the given DateTimeZone, with "lenient" rules applied such that ambiguous values map to the later of the alternatives, and "skipped" values map to the start of the zone interval after the "gap".

See InZoneStrictly(DateTimeZone) and InZone(DateTimeZone, ZoneLocalMappingResolver) for alternative ways to map a local time to a specific instant. This is solely a convenience method for calling AtLeniently(LocalDateTime).

Returns the mapping of this local date/time within the given DateTimeZone, with "strict" rules applied such that an exception is thrown if either the mapping is ambiguous or the time is skipped.

See InZoneLeniently(DateTimeZone) and InZone(DateTimeZone, ZoneLocalMappingResolver) for alternative ways to map a local time to a specific instant. This is solely a convenience method for calling AtStrictly(LocalDateTime).

Subtracts a period from a local date/time. Fields are subtracted in the order provided by the period. This is a convenience operator over the Minus(Period) method.

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Returns the next LocalDateTime falling on the specified IsoDayOfWeek, at the same time of day as this value. This is a strict "next" - if this value on already falls on the target day of the week, the returned value will be a week later.

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Adds a period to this local date/time. Fields are added in the order provided by the period.

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Returns a new LocalDateTime representing the current value with the given number of days added.

This method does not try to maintain the month or year of the current value, so adding 3 days to a value on January 30th will result in a value on February 2nd.

Returns a new LocalDateTime representing the current value with the given number of hours added.

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Returns a new LocalDateTime representing the current value with the given number of milliseconds added.

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Returns a new LocalDateTime representing the current value with the given number of minutes added.

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Returns a new LocalDateTime representing the current value with the given number of months added.

This method does not try to maintain the year of the current value, so adding four months to a value in October will result in a value in the following February.

If the resulting date is invalid, the day of month is reduced to find a valid value. For example, adding one month to January 30th 2011 will return February 28th 2011; subtracting one month from March 30th 2011 will return February 28th 2011.

Returns a new LocalDateTime representing the current value with the given number of seconds added.

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Returns a new LocalDateTime representing the current value with the given number of ticks added.

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Returns a new LocalDateTime representing the current value with the given number of weeks added.

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Returns a new LocalDateTime representing the current value with the given number of years added.

If the resulting date is invalid, lower fields (typically the day of month) are reduced to find a valid value. For example, adding one year to February 29th 2012 will return February 28th 2013; subtracting one year from February 29th 2012 will return February 28th 2011.

Returns the previous LocalDateTime falling on the specified IsoDayOfWeek, at the same time of day as this value. This is a strict "previous" - if this value on already falls on the target day of the week, the returned value will be a week earlier.

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Subtracts the specified period from the date and time. Friendly alternative to operator-().

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Constructs a DateTime from this value which has a Kind of Unspecified.

Unspecified is slightly odd - it can be treated as UTC if you use ToLocalTime() or as system local time if you use ToUniversalTime(), but it's the only kind which allows you to construct a DateTimeOffset with an arbitrary offset, which makes it as close to the Noda Time non-system-specific "local" concept as exists in .NET.

Returns a String that represents this instance.

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Formats the value of the current instance using the specified pattern.

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Creates a new LocalDateTime representing the same physical date and time, but in a different calendar. The returned LocalDateTime is likely to have different date field values to this one. For example, January 1st 1970 in the Gregorian calendar was December 19th 1969 in the Julian calendar.

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Returns an OffsetDateTime for this local date/time with the given offset.

This method is purely a convenient alternative to calling the OffsetDateTime constructor directly.

Adds a period to a local date/time. Fields are added in the order provided by the period. This is a convenience operator over the Plus(Period) method.

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Implements the operator == (equality).

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Compares two LocalDateTime values to see if the left one is strictly later than the right one.

This operator always returns false if the two operands have different calendars. See the top-level type documentation for more information about comparisons.

Compares two LocalDateTime values to see if the left one is later than or equal to the right one.

This operator always returns false if the two operands have different calendars. See the top-level type documentation for more information about comparisons.

Implements the operator != (inequality).

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Compares two LocalDateTime values to see if the left one is strictly earlier than the right one.

This operator always returns false if the two operands have different calendars. See the top-level type documentation for more information about comparisons.

Compares two LocalDateTime values to see if the left one is earlier than or equal to the right one.

This operator always returns false if the two operands have different calendars. See the top-level type documentation for more information about comparisons.

Subtracts a period from a local date/time. Fields are subtracted in the order provided by the period. This is a convenience operator over the Minus(Period) method.

This type defaults to using the IsoCalendarSystem unless a different calendar system is specified.

Comparisons of values can be handled in a way which is either calendar-sensitive or calendar-insensitive. Noda Time implements all the operators (and the Equals(LocalDateTime) method) such that all operators other than Inequality(LocalDateTime, LocalDateTime) will return false if asked to compare two values in different calendar systems.

However, the CompareTo(LocalDateTime) method (implementing IComparable<T>) is calendar-insensitive; it compares the two values historically in terms of when they actually occurred, as if they're both converted to some "neutral" calendar system first.

It's unclear at the time of this writing whether this is the most appropriate approach, and it may change in future versions. In general, it would be a good idea for users to avoid comparing dates in different calendar systems, and indeed most users are unlikely to ever explicitly consider which calendar system they're working in anyway.

Implementation of CompareTo(Object) to compare two LocalDateTimes.

This uses explicit interface implementation to avoid it being called accidentally. The generic implementation should usually be preferred.

Implementation of GetObjectData(SerializationInfo, StreamingContext).