Struct LocalDate

LocalDate is an immutable struct representing a date within the calendar, with no reference to a particular time zone or time of day.

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

However, the CompareTo(LocalDate) method (implementing IComparable<T>) is calendar-insensitive; it compares the two dates 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 an instance for the given era, year of era, month and day in the ISO calendar.

Type	Name	Description
Era	era	The era within which to create a date. Must be a valid era within the ISO calendar.
Int32	yearOfEra	The year of era.
Int32	month	The month of year.
Int32	day	The day of month.

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

However, the CompareTo(LocalDate) method (implementing IComparable<T>) is calendar-insensitive; it compares the two dates 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 an instance for the given era, year of era, month and day in the specified calendar.

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

Type	Name	Description
Era	era	The era within which to create a date. Must be a valid era within the specified calendar.
Int32	yearOfEra	The year of era.
Int32	month	The month of year.
Int32	day	The day of month.
CalendarSystem	calendar	Calendar system in which to create the date.

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

However, the CompareTo(LocalDate) method (implementing IComparable<T>) is calendar-insensitive; it compares the two dates 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 an instance for the given year, month and day in the ISO calendar.

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

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.

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

However, the CompareTo(LocalDate) method (implementing IComparable<T>) is calendar-insensitive; it compares the two dates 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 an instance for the given year, month and day in the specified calendar.

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

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.
CalendarSystem	calendar	Calendar system in which to create the date.

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

However, the CompareTo(LocalDate) method (implementing IComparable<T>) is calendar-insensitive; it compares the two dates 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.

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

Type	Description
CalendarSystem

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

However, the CompareTo(LocalDate) method (implementing IComparable<T>) is calendar-insensitive; it compares the two dates 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 within the month.

Type	Description
Int32

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

However, the CompareTo(LocalDate) method (implementing IComparable<T>) is calendar-insensitive; it compares the two dates 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 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 within the year.

Type	Description
Int32

Type	Description
Int32

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

However, the CompareTo(LocalDate) method (implementing IComparable<T>) is calendar-insensitive; it compares the two dates 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.

Type	Description
Era

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

However, the CompareTo(LocalDate) method (implementing IComparable<T>) is calendar-insensitive; it compares the two dates 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 expressed as an IsoDayOfWeek value, for calendars which use ISO days of the week.

Type	Description
IsoDayOfWeek

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

However, the CompareTo(LocalDate) method (implementing IComparable<T>) is calendar-insensitive; it compares the two dates 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 within the year.

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

Type	Description
Int32

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

However, the CompareTo(LocalDate) method (implementing IComparable<T>) is calendar-insensitive; it compares the two dates 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

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

However, the CompareTo(LocalDate) method (implementing IComparable<T>) is calendar-insensitive; it compares the two dates 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.

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.

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 within the century.

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

Gets the year of this local date within the era.

Type	Description
Int32

Type	Description
Int32

Type	Description
Int32

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

However, the CompareTo(LocalDate) method (implementing IComparable<T>) is calendar-insensitive; it compares the two dates 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 the specified period to the date. Friendly alternative to operator+().

Type	Name	Description
LocalDate	date	The date to add the period to
Period	period	The period to add. Must not contain any (non-zero) time units.

Type	Description
LocalDate	The sum of the given date and period

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

However, the CompareTo(LocalDate) method (implementing IComparable<T>) is calendar-insensitive; it compares the two dates 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 a LocalDateTime at midnight on the date represented by this local date.

Type	Description
LocalDateTime	The LocalDateTime representing midnight on tthis local date, in the same calendar system.

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

However, the CompareTo(LocalDate) method (implementing IComparable<T>) is calendar-insensitive; it compares the two dates 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 is earlier, later or the same as another one.

Type	Name	Description
LocalDate	other	The other date to compare this one with

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

The comparison is performed in terms of a calendar-independent notion of date; the calendar systems of both LocalDate 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.

Compares two LocalDate values for equality. This requires that the dates be the same, within the same calendar.

Type	Name	Description
LocalDate	other	The value to compare this date with.

Type	Description
Boolean	True if the given value is another local date equal to this one; false otherwise.

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

However, the CompareTo(LocalDate) method (implementing IComparable<T>) is calendar-insensitive; it compares the two dates 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 LocalDate values for equality. This requires that the dates be the same, within the same calendar.

Type	Name	Description
Object	obj	The object to compare this date with.

Type	Description
Boolean	True if the given value is another local date equal to this one; false otherwise.

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

However, the CompareTo(LocalDate) method (implementing IComparable<T>) is calendar-insensitive; it compares the two dates 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 local date corresponding to the given "week year", "week of week year", and "day of week" in the ISO calendar system.

Type	Name	Description
Int32	weekYear	ISO-8601 week year of value to return
Int32	weekOfWeekYear	ISO-8601 week of week year of value to return
IsoDayOfWeek	dayOfWeek	ISO-8601 day of week to return

Type	Description
LocalDate	The date corresponding to the given week year / week of week year / day of week.

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

However, the CompareTo(LocalDate) method (implementing IComparable<T>) is calendar-insensitive; it compares the two dates 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 local date.

Type	Description
Int32	A hash code for this local date.

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

However, the CompareTo(LocalDate) method (implementing IComparable<T>) is calendar-insensitive; it compares the two dates 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 this date. Fluent alternative to operator-().

Type	Name	Description
Period	period	The period to subtract. Must not contain any (non-zero) time units.

Type	Description
LocalDate	The result of subtracting the given period from this date.

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

However, the CompareTo(LocalDate) method (implementing IComparable<T>) is calendar-insensitive; it compares the two dates 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 LocalDate falling on the specified IsoDayOfWeek. This is a strict "next" - if this date on already falls on the target day of the week, the returned value will be a week later.

Type	Name	Description
IsoDayOfWeek	targetDayOfWeek	The ISO day of the week to return the next date of.

Type	Description
LocalDate	The next LocalDate falling on the specified day of the week.

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

However, the CompareTo(LocalDate) method (implementing IComparable<T>) is calendar-insensitive; it compares the two dates 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
InvalidOperationException	The underlying calendar doesn't use ISO days of the week.
ArgumentOutOfRangeException	`targetDayOfWeek` is not a valid day of the week (Monday to Sunday).

Adds the specified period to this date. Fluent alternative to operator+().

Type	Name	Description
Period	period	The period to add. Must not contain any (non-zero) time units.

Type	Description
LocalDate	The sum of this date and the given period

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

However, the CompareTo(LocalDate) method (implementing IComparable<T>) is calendar-insensitive; it compares the two dates 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 LocalDate representing the current value with the given number of days added.

Type	Name	Description
Int32	days	The number of days to add

Type	Description
LocalDate	The current value plus the given number of days.

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

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

Type	Name	Description
Int32	months	The number of months to add

Type	Description
LocalDate	The current date plus the given number of months

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 LocalDate representing the current value with the given number of weeks added.

Type	Name	Description
Int32	weeks	The number of weeks to add

Type	Description
LocalDate	The current value plus the given number of weeks.

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

However, the CompareTo(LocalDate) method (implementing IComparable<T>) is calendar-insensitive; it compares the two dates 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 LocalDate 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.

Type	Name	Description
Int32	years	The number of years to add

Type	Description
LocalDate	The current value plus the given number of years.

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

Type	Name	Description
IsoDayOfWeek	targetDayOfWeek	The ISO day of the week to return the previous date of.

Type	Description
LocalDate	The previous LocalDate falling on the specified day of the week.

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

However, the CompareTo(LocalDate) method (implementing IComparable<T>) is calendar-insensitive; it compares the two dates 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. Friendly alternative to operator-().

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

However, the CompareTo(LocalDate) method (implementing IComparable<T>) is calendar-insensitive; it compares the two dates 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 String that represents this instance.

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

However, the CompareTo(LocalDate) method (implementing IComparable<T>) is calendar-insensitive; it compares the two dates 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.

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

However, the CompareTo(LocalDate) method (implementing IComparable<T>) is calendar-insensitive; it compares the two dates 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 LocalDate representing the same physical date, but in a different calendar. The returned LocalDate is likely to have different field values to this one. For example, January 1st 1970 in the Gregorian calendar was December 19th 1969 in the Julian calendar.

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

However, the CompareTo(LocalDate) method (implementing IComparable<T>) is calendar-insensitive; it compares the two dates 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.

Combines the given LocalDate and LocalTime components into a single LocalDateTime.

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

However, the CompareTo(LocalDate) method (implementing IComparable<T>) is calendar-insensitive; it compares the two dates 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 the specified period to the date.

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

However, the CompareTo(LocalDate) method (implementing IComparable<T>) is calendar-insensitive; it compares the two dates 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 LocalDate values for equality. This requires that the dates be the same, within the same calendar.

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

However, the CompareTo(LocalDate) method (implementing IComparable<T>) is calendar-insensitive; it compares the two dates 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 LocalDate 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 LocalDate 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.

Compares two LocalDate values for inequality.

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

However, the CompareTo(LocalDate) method (implementing IComparable<T>) is calendar-insensitive; it compares the two dates 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 LocalDate 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 LocalDate 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 the specified period from the date.

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

However, the CompareTo(LocalDate) method (implementing IComparable<T>) is calendar-insensitive; it compares the two dates 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 LocalDates.

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

Type	Name	Description
String	patternText	The String specifying the pattern to use, or null to use the default format pattern.
IFormatProvider	formatProvider	The IFormatProvider to use when formatting the value, or null to use the current thread's culture to obtain a format provider.

Type	Name	Description
LocalDate	date	The date to subtract the period from
Period	period	The period to subtract. Must not contain any (non-zero) time units.

Type	Name	Description
LocalDate	date	The date to add the time to
LocalTime	time	The time to add

Type	Name	Description
LocalDate	lhs	The first value to compare
LocalDate	rhs	The second value to compare

Type	Name	Description
LocalDate	lhs	First operand of the comparison
LocalDate	rhs	Second operand of the comparison

Implements

Inherited Members

Namespace: NodaTime

Assembly: NodaTime.dll

Syntax

Remarks

Constructors

LocalDate(Era, Int32, Int32, Int32)

Declaration

Parameters

Remarks

Exceptions

LocalDate(Era, Int32, Int32, Int32, CalendarSystem)

Declaration

Parameters

Remarks

Exceptions

LocalDate(Int32, Int32, Int32)

Declaration

Parameters

Remarks

Exceptions

LocalDate(Int32, Int32, Int32, CalendarSystem)

Declaration

Parameters

Remarks

Exceptions

Properties

Calendar

Declaration

Property Value

Remarks

Day

Declaration

Property Value

Remarks

DayOfWeek

Declaration

Property Value

Remarks

See Also

DayOfYear

Declaration

Property Value

Remarks

Era

Declaration

Property Value

Remarks

IsoDayOfWeek

Declaration

Property Value

Remarks

Exceptions

See Also

Month

Declaration

Property Value

Remarks

WeekOfWeekYear

Declaration

Property Value

Remarks

WeekYear

Declaration

Property Value

Remarks

Year

Declaration

Property Value

Remarks

YearOfCentury

Declaration

Property Value

Remarks

YearOfEra

Declaration

Property Value

Remarks