< Summary

Information
Class: MyNet.Temporal.CalendarAmount
Assembly: MyNet.Temporal
File(s): https://raw.githubusercontent.com/sandre58/MyNet/5aaaab311aa14541478b9e402357d98b657a23e4/src/MyNet.Temporal/CalendarAmount.cs
Tag: 342_31701152804
Line coverage
41%
Covered lines: 42
Uncovered lines: 59
Coverable lines: 101
Total lines: 404
Line coverage: 41.5%
Branch coverage
63%
Covered branches: 19
Total branches: 30
Branch coverage: 63.3%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
get_Ticks()100%210%
get_Days()100%11100%
get_Hours()100%210%
get_Milliseconds()100%210%
get_Minutes()100%210%
get_Seconds()100%210%
get_TotalDays()100%210%
get_TotalHours()100%210%
get_TotalMilliseconds()100%210%
get_TotalMinutes()100%210%
get_TotalSeconds()100%210%
op_Implicit(...)100%11100%
op_Addition(...)100%210%
op_Addition(...)100%210%
op_Addition(...)100%210%
op_Subtraction(...)100%210%
op_Subtraction(...)100%210%
op_Subtraction(...)100%210%
op_Equality(...)100%44100%
op_Equality(...)0%2040%
op_Equality(...)50%44100%
op_Inequality(...)100%210%
op_Inequality(...)100%210%
op_Inequality(...)100%210%
op_UnaryNegation(...)100%210%
op_LessThan(...)100%210%
op_LessThan(...)100%210%
op_LessThan(...)100%210%
op_LessThanOrEqual(...)100%11100%
op_LessThanOrEqual(...)100%210%
op_LessThanOrEqual(...)100%210%
op_GreaterThan(...)100%210%
op_GreaterThan(...)100%210%
op_GreaterThan(...)100%210%
op_GreaterThanOrEqual(...)100%210%
op_GreaterThanOrEqual(...)100%210%
op_GreaterThanOrEqual(...)100%210%
FromTimeSpan(...)100%11100%
ToApproximateTimeSpan()100%11100%
Add(...)100%210%
Add(...)100%11100%
Subtract(...)100%210%
Subtract(...)100%210%
CompareTo(...)50%44100%
CompareTo(...)50%5466.66%
CompareTo(...)100%44100%
Negate()100%210%
Clone()100%11100%
ToString()100%210%
Equals(...)100%11100%
Equals(...)83.33%7675%
GetHashCode()100%210%
SubtractInternal(...)100%11100%
AddInternal(...)100%11100%
AddInternal(...)100%210%
SubtractInternal(...)100%210%
SubtractInternal(...)100%210%

File(s)

https://raw.githubusercontent.com/sandre58/MyNet/5aaaab311aa14541478b9e402357d98b657a23e4/src/MyNet.Temporal/CalendarAmount.cs

#LineLine coverage
 1// -----------------------------------------------------------------------
 2// <copyright file="CalendarAmount.cs" company="Stéphane ANDRE">
 3// Copyright (c) Stéphane ANDRE. All rights reserved.
 4// </copyright>
 5// -----------------------------------------------------------------------
 6
 7using System;
 8using System.Runtime.InteropServices;
 9
 10namespace MyNet.Temporal;
 11
 12/// <summary>
 13/// Represents a calendar amount composed of years and/or months plus a fixed <see cref="TimeSpan"/>.
 14/// This is not a universal duration: calendar components must be applied via <c>AddYears</c>/<c>AddMonths</c>
 15/// (for example through <c>AddCalendarAmount</c>). Use <see cref="ToApproximateTimeSpan"/> only when an
 16/// approximate fixed duration is acceptable (365 days/year, 30 days/month).
 17/// </summary>
 18[StructLayout(LayoutKind.Sequential)]
 19public readonly struct CalendarAmount :
 20    IEquatable<CalendarAmount>,
 21    IComparable<TimeSpan>,
 22    IComparable<CalendarAmount>
 23{
 24    private const int DaysPerYear = 365;
 25    private const int DaysPerMonth = 30;
 26
 27    /// <summary>
 28    /// Gets the number of months component of the calendar amount.
 29    /// </summary>
 30    public int Months { get; init; }
 31
 32    /// <summary>
 33    /// Gets the number of years component of the calendar amount.
 34    /// </summary>
 35    public int Years { get; init; }
 36
 37    /// <summary>
 38    /// Gets the fixed <see cref="TimeSpan"/> component of the calendar amount (days, hours, minutes, etc.).
 39    /// </summary>
 40    public TimeSpan TimeSpan { get; init; }
 41
 42    /// <summary>
 43    /// Gets the approximate number of ticks, using <see cref="ToApproximateTimeSpan"/>.
 44    /// </summary>
 045    public long Ticks => ToApproximateTimeSpan().Ticks;
 46
 47    /// <summary>
 48    /// Gets the days portion of the approximate <see cref="TimeSpan"/>.
 49    /// </summary>
 650    public int Days => ToApproximateTimeSpan().Days;
 51
 52    /// <summary>
 53    /// Gets the hours portion of the approximate <see cref="TimeSpan"/>.
 54    /// </summary>
 055    public int Hours => ToApproximateTimeSpan().Hours;
 56
 57    /// <summary>
 58    /// Gets the milliseconds portion of the approximate <see cref="TimeSpan"/>.
 59    /// </summary>
 060    public int Milliseconds => ToApproximateTimeSpan().Milliseconds;
 61
 62    /// <summary>
 63    /// Gets the minutes portion of the approximate <see cref="TimeSpan"/>.
 64    /// </summary>
 065    public int Minutes => ToApproximateTimeSpan().Minutes;
 66
 67    /// <summary>
 68    /// Gets the seconds portion of the approximate <see cref="TimeSpan"/>.
 69    /// </summary>
 070    public int Seconds => ToApproximateTimeSpan().Seconds;
 71
 72    /// <summary>
 73    /// Gets the approximate total days, using <see cref="ToApproximateTimeSpan"/>.
 74    /// </summary>
 075    public double TotalDays => ToApproximateTimeSpan().TotalDays;
 76
 77    /// <summary>
 78    /// Gets the approximate total hours, using <see cref="ToApproximateTimeSpan"/>.
 79    /// </summary>
 080    public double TotalHours => ToApproximateTimeSpan().TotalHours;
 81
 82    /// <summary>
 83    /// Gets the approximate total milliseconds, using <see cref="ToApproximateTimeSpan"/>.
 84    /// </summary>
 085    public double TotalMilliseconds => ToApproximateTimeSpan().TotalMilliseconds;
 86
 87    /// <summary>
 88    /// Gets the approximate total minutes, using <see cref="ToApproximateTimeSpan"/>.
 89    /// </summary>
 090    public double TotalMinutes => ToApproximateTimeSpan().TotalMinutes;
 91
 92    /// <summary>
 93    /// Gets the approximate total seconds, using <see cref="ToApproximateTimeSpan"/>.
 94    /// </summary>
 095    public double TotalSeconds => ToApproximateTimeSpan().TotalSeconds;
 96
 97    /// <summary>
 98    /// Converts a <see cref="TimeSpan"/> to a <see cref="CalendarAmount"/> with only the <see cref="TimeSpan"/> compone
 99    /// </summary>
 100    /// <param name="timeSpan">The TimeSpan to convert.</param>
 168101    public static implicit operator CalendarAmount(TimeSpan timeSpan) => FromTimeSpan(timeSpan);
 102
 103    /// <summary>
 104    /// Adds two <see cref="CalendarAmount"/> instances.
 105    /// </summary>
 0106    public static CalendarAmount operator +(CalendarAmount left, CalendarAmount right) => AddInternal(left, right);
 107
 108    /// <summary>
 109    /// Adds a <see cref="TimeSpan"/> to a <see cref="CalendarAmount"/>.
 110    /// </summary>
 0111    public static CalendarAmount operator +(CalendarAmount left, TimeSpan right) => AddInternal(left, right);
 112
 113    /// <summary>
 114    /// Adds a <see cref="TimeSpan"/> and a <see cref="CalendarAmount"/>.
 115    /// </summary>
 0116    public static CalendarAmount operator +(TimeSpan left, CalendarAmount right) => AddInternal(left, right);
 117
 118    /// <summary>
 119    /// Subtracts two <see cref="CalendarAmount"/> instances.
 120    /// </summary>
 0121    public static CalendarAmount operator -(CalendarAmount left, CalendarAmount right) => SubtractInternal(left, right);
 122
 123    /// <summary>
 124    /// Subtracts a <see cref="CalendarAmount"/> from a <see cref="TimeSpan"/>.
 125    /// </summary>
 0126    public static CalendarAmount operator -(TimeSpan left, CalendarAmount right) => SubtractInternal(left, right);
 127
 128    /// <summary>
 129    /// Subtracts a <see cref="TimeSpan"/> from a <see cref="CalendarAmount"/>.
 130    /// </summary>
 0131    public static CalendarAmount operator -(CalendarAmount left, TimeSpan right) => SubtractInternal(left, right);
 132
 133    /// <summary>
 134    /// Determines whether two <see cref="CalendarAmount"/> instances are equal by comparing years, months, and <see cre
 135    /// </summary>
 66136    public static bool operator ==(CalendarAmount left, CalendarAmount right) => left.Years == right.Years &&
 66137        left.Months == right.Months &&
 66138        left.TimeSpan == right.TimeSpan;
 139
 140    /// <summary>
 141    /// Determines whether a <see cref="TimeSpan"/> and a <see cref="CalendarAmount"/> are equal.
 142    /// Equal only when the calendar amount has zero years and months and its <see cref="TimeSpan"/> equals <paramref na
 143    /// </summary>
 0144    public static bool operator ==(TimeSpan left, CalendarAmount right) => right is { Years: 0, Months: 0 } && right.Tim
 145
 146    /// <summary>
 147    /// Determines whether a <see cref="CalendarAmount"/> and a <see cref="TimeSpan"/> are equal.
 148    /// Equal only when the calendar amount has zero years and months and its <see cref="TimeSpan"/> equals <paramref na
 149    /// </summary>
 3150    public static bool operator ==(CalendarAmount left, TimeSpan right) => left is { Years: 0, Months: 0 } && left.TimeS
 151
 152    /// <summary>
 153    /// Determines whether two <see cref="CalendarAmount"/> instances are not equal.
 154    /// </summary>
 0155    public static bool operator !=(CalendarAmount left, CalendarAmount right) => !(left == right);
 156
 157    /// <summary>
 158    /// Determines whether a <see cref="TimeSpan"/> and a <see cref="CalendarAmount"/> are not equal.
 159    /// </summary>
 0160    public static bool operator !=(TimeSpan left, CalendarAmount right) => !(left == right);
 161
 162    /// <summary>
 163    /// Determines whether a <see cref="CalendarAmount"/> and a <see cref="TimeSpan"/> are not equal.
 164    /// </summary>
 0165    public static bool operator !=(CalendarAmount left, TimeSpan right) => !(left == right);
 166
 167    /// <summary>
 168    /// Returns the negation of the specified calendar amount.
 169    /// </summary>
 0170    public static CalendarAmount operator -(CalendarAmount value) => value.Negate();
 171
 172    /// <summary>
 173    /// Less-than comparison using structural ordering (years, then months, then <see cref="TimeSpan"/>).
 174    /// </summary>
 0175    public static bool operator <(CalendarAmount left, CalendarAmount right) => left.CompareTo(right) < 0;
 176
 177    /// <summary>
 178    /// Less-than comparison. When years/months are zero, compares the fixed component; otherwise compares approximate d
 179    /// </summary>
 0180    public static bool operator <(CalendarAmount left, TimeSpan right) => left.CompareTo(right) < 0;
 181
 182    /// <summary>
 183    /// Less-than comparison. When years/months are zero, compares the fixed component; otherwise compares approximate d
 184    /// </summary>
 0185    public static bool operator <(TimeSpan left, CalendarAmount right) => right.CompareTo(left) > 0;
 186
 187    /// <summary>
 188    /// Less-than-or-equal comparison using structural ordering (years, then months, then <see cref="TimeSpan"/>).
 189    /// </summary>
 3190    public static bool operator <=(CalendarAmount left, CalendarAmount right) => left.CompareTo(right) <= 0;
 191
 192    /// <summary>
 193    /// Less-than-or-equal comparison against a <see cref="TimeSpan"/>.
 194    /// </summary>
 0195    public static bool operator <=(CalendarAmount left, TimeSpan right) => left.CompareTo(right) <= 0;
 196
 197    /// <summary>
 198    /// Less-than-or-equal comparison against a <see cref="TimeSpan"/>.
 199    /// </summary>
 0200    public static bool operator <=(TimeSpan left, CalendarAmount right) => right.CompareTo(left) >= 0;
 201
 202    /// <summary>
 203    /// Greater-than comparison using structural ordering (years, then months, then <see cref="TimeSpan"/>).
 204    /// </summary>
 0205    public static bool operator >(CalendarAmount left, CalendarAmount right) => left.CompareTo(right) > 0;
 206
 207    /// <summary>
 208    /// Greater-than comparison against a <see cref="TimeSpan"/>.
 209    /// </summary>
 0210    public static bool operator >(CalendarAmount left, TimeSpan right) => left.CompareTo(right) > 0;
 211
 212    /// <summary>
 213    /// Greater-than comparison against a <see cref="TimeSpan"/>.
 214    /// </summary>
 0215    public static bool operator >(TimeSpan left, CalendarAmount right) => right.CompareTo(left) < 0;
 216
 217    /// <summary>
 218    /// Greater-than-or-equal comparison using structural ordering (years, then months, then <see cref="TimeSpan"/>).
 219    /// </summary>
 0220    public static bool operator >=(CalendarAmount left, CalendarAmount right) => left.CompareTo(right) >= 0;
 221
 222    /// <summary>
 223    /// Greater-than-or-equal comparison against a <see cref="TimeSpan"/>.
 224    /// </summary>
 0225    public static bool operator >=(CalendarAmount left, TimeSpan right) => left.CompareTo(right) >= 0;
 226
 227    /// <summary>
 228    /// Greater-than-or-equal comparison against a <see cref="TimeSpan"/>.
 229    /// </summary>
 0230    public static bool operator >=(TimeSpan left, CalendarAmount right) => right.CompareTo(left) <= 0;
 231
 232    /// <summary>
 233    /// Creates a <see cref="CalendarAmount"/> from a <see cref="TimeSpan"/> (no years/months component).
 234    /// </summary>
 235    /// <param name="timeSpan">The <see cref="TimeSpan"/> to convert.</param>
 236    /// <returns>A calendar amount representing the same fixed duration.</returns>
 168237    public static CalendarAmount FromTimeSpan(TimeSpan timeSpan) => new() { TimeSpan = timeSpan };
 238
 239    /// <summary>
 240    /// Converts this calendar amount into an approximate <see cref="TimeSpan"/>
 241    /// (months = 30 days, years = 365 days). Prefer calendar-aware application via AddYears/AddMonths when possible.
 242    /// </summary>
 243    /// <returns>The approximate <see cref="TimeSpan"/>.</returns>
 244    public TimeSpan ToApproximateTimeSpan()
 245    {
 9246        var daysFromYears = DaysPerYear * Years;
 9247        var daysFromMonths = DaysPerMonth * Months;
 9248        var days = daysFromMonths + daysFromYears;
 9249        return new TimeSpan(days, 0, 0, 0) + TimeSpan;
 250    }
 251
 252    /// <summary>
 253    /// Adds another calendar amount to this instance.
 254    /// </summary>
 255    /// <param name="number">The calendar amount to add.</param>
 0256    public CalendarAmount Add(CalendarAmount number) => AddInternal(this, number);
 257
 258    /// <summary>
 259    /// Adds a <see cref="TimeSpan"/> to this calendar amount.
 260    /// </summary>
 261    /// <param name="timeSpan">The TimeSpan to add.</param>
 6262    public CalendarAmount Add(TimeSpan timeSpan) => AddInternal(this, timeSpan);
 263
 264    /// <summary>
 265    /// Subtracts the specified calendar amount from this instance.
 266    /// </summary>
 267    /// <param name="calendarAmount">The calendar amount to subtract.</param>
 0268    public CalendarAmount Subtract(CalendarAmount calendarAmount) => SubtractInternal(this, calendarAmount);
 269
 270    /// <summary>
 271    /// Subtracts the specified <see cref="TimeSpan"/> from this calendar amount.
 272    /// </summary>
 273    /// <param name="timeSpan">The TimeSpan to subtract.</param>
 0274    public CalendarAmount Subtract(TimeSpan timeSpan) => SubtractInternal(this, timeSpan);
 275
 276    /// <summary>
 277    /// Compares this calendar amount to a <see cref="TimeSpan"/>.
 278    /// When years and months are zero, compares the fixed component exactly; otherwise uses <see cref="ToApproximateTim
 279    /// </summary>
 280    public int CompareTo(TimeSpan other) =>
 9281        Years == 0 && Months == 0
 9282            ? TimeSpan.CompareTo(other)
 9283            : ToApproximateTimeSpan().CompareTo(other);
 284
 285    /// <summary>
 286    /// Compares this calendar amount to an object that must be a <see cref="TimeSpan"/> or <see cref="CalendarAmount"/>
 287    /// </summary>
 6288    public int CompareTo(object value) => value switch
 6289    {
 0290        TimeSpan timeSpan => CompareTo(timeSpan),
 6291        CalendarAmount amount => CompareTo(amount),
 0292        _ => throw new ArgumentException("Value must be a TimeSpan or CalendarAmount", nameof(value))
 6293    };
 294
 295    /// <summary>
 296    /// Compares this calendar amount to another using structural ordering: years, then months, then <see cref="TimeSpan
 297    /// </summary>
 298    public int CompareTo(CalendarAmount other)
 299    {
 12300        var years = Years.CompareTo(other.Years);
 12301        if (years != 0)
 3302            return years;
 303
 9304        var months = Months.CompareTo(other.Months);
 9305        return months != 0 ? months : TimeSpan.CompareTo(other.TimeSpan);
 306    }
 307
 308    /// <summary>
 309    /// Returns a new calendar amount that represents the negation of this instance.
 310    /// </summary>
 0311    public CalendarAmount Negate() => new()
 0312    {
 0313        TimeSpan = -TimeSpan,
 0314        Months = -Months,
 0315        Years = -Years
 0316    };
 317
 318    /// <summary>
 319    /// Creates a new object that is a copy of the current instance.
 320    /// </summary>
 321    /// <returns>A copy of this instance.</returns>
 3322    public object Clone() => new CalendarAmount
 3323    {
 3324        TimeSpan = TimeSpan,
 3325        Months = Months,
 3326        Years = Years
 3327    };
 328
 329    /// <inheritdoc />
 0330    public override string ToString() => ToApproximateTimeSpan().ToString();
 331
 332    /// <summary>
 333    /// Determines whether the specified calendar amount is equal to the current instance.
 334    /// </summary>
 60335    public bool Equals(CalendarAmount other) => this == other;
 336
 337    /// <inheritdoc />
 338    public override bool Equals(object? obj)
 339    {
 9340        if (obj == null)
 0341            return false;
 9342        var type = obj.GetType();
 9343        return type == typeof(CalendarAmount) ? this == (CalendarAmount)obj : type == typeof(TimeSpan) && this == (TimeS
 344    }
 345
 346    /// <inheritdoc />
 0347    public override int GetHashCode() => Months.GetHashCode() ^ Years.GetHashCode() ^ TimeSpan.GetHashCode();
 348
 349    /// <summary>
 350    /// Subtracts a <see cref="CalendarAmount"/> from a <see cref="TimeSpan"/> by negating the months and years componen
 351    /// </summary>
 352    /// <param name="left">The TimeSpan from which to subtract.</param>
 353    /// <param name="right">The CalendarAmount to subtract.</param>
 354    /// <returns>A new CalendarAmount representing the result of the subtraction.</returns>
 3355    internal static CalendarAmount SubtractInternal(TimeSpan left, CalendarAmount right) => new()
 3356    {
 3357        Months = -right.Months,
 3358        Years = -right.Years,
 3359        TimeSpan = left - right.TimeSpan
 3360    };
 361
 362    /// <summary>
 363    /// Adds a <see cref="TimeSpan"/> to a <see cref="CalendarAmount"/> by adding the TimeSpan components and keeping th
 364    /// </summary>
 365    /// <param name="left">The CalendarAmount to which to add.</param>
 366    /// <param name="right">The TimeSpan to add.</param>
 367    /// <returns>A new CalendarAmount representing the result of the addition.</returns>
 6368    private static CalendarAmount AddInternal(CalendarAmount left, TimeSpan right) => left with { TimeSpan = left.TimeSp
 369
 370    /// <summary>
 371    /// Adds two <see cref="CalendarAmount"/> instances by adding their months, years, and TimeSpan components together.
 372    /// </summary>
 373    /// <param name="left">The first CalendarAmount to add.</param>
 374    /// <param name="right">The second CalendarAmount to add.</param>
 375    /// <returns>A new CalendarAmount representing the result of the addition.</returns>
 0376    private static CalendarAmount AddInternal(CalendarAmount left, CalendarAmount right) => new()
 0377    {
 0378        Years = left.Years + right.Years,
 0379        Months = left.Months + right.Months,
 0380        TimeSpan = left.TimeSpan + right.TimeSpan
 0381    };
 382
 383    /// <summary>
 384    /// Subtracts a <see cref="TimeSpan"/> from a <see cref="CalendarAmount"/> by subtracting the TimeSpan components an
 385    /// </summary>
 386    /// <param name="left">The CalendarAmount from which to subtract.</param>
 387    /// <param name="right">The TimeSpan to subtract.</param>
 388    /// <returns>A new CalendarAmount representing the result of the subtraction.</returns>
 0389    private static CalendarAmount SubtractInternal(CalendarAmount left, TimeSpan right) => left with { TimeSpan = left.T
 390
 391    /// <summary>
 392    /// Subtracts two <see cref="CalendarAmount"/> instances by subtracting their months, years, and TimeSpan components
 393    /// </summary>
 394    /// <param name="left">The first CalendarAmount to subtract.</param>
 395    /// <param name="right">The second CalendarAmount to subtract.</param>
 396    /// <returns>A new CalendarAmount representing the result of the subtraction.</returns>
 0397    private static CalendarAmount SubtractInternal(CalendarAmount left, CalendarAmount right) => new()
 0398    {
 0399        Years = left.Years - right.Years,
 0400        Months = left.Months - right.Months,
 0401        TimeSpan = left.TimeSpan - right.TimeSpan
 0402    };
 403}
 404

Methods/Properties

get_Ticks()
get_Days()
get_Hours()
get_Milliseconds()
get_Minutes()
get_Seconds()
get_TotalDays()
get_TotalHours()
get_TotalMilliseconds()
get_TotalMinutes()
get_TotalSeconds()
op_Implicit(System.TimeSpan)
op_Addition(MyNet.Temporal.CalendarAmount,MyNet.Temporal.CalendarAmount)
op_Addition(MyNet.Temporal.CalendarAmount,System.TimeSpan)
op_Addition(System.TimeSpan,MyNet.Temporal.CalendarAmount)
op_Subtraction(MyNet.Temporal.CalendarAmount,MyNet.Temporal.CalendarAmount)
op_Subtraction(System.TimeSpan,MyNet.Temporal.CalendarAmount)
op_Subtraction(MyNet.Temporal.CalendarAmount,System.TimeSpan)
op_Equality(MyNet.Temporal.CalendarAmount,MyNet.Temporal.CalendarAmount)
op_Equality(System.TimeSpan,MyNet.Temporal.CalendarAmount)
op_Equality(MyNet.Temporal.CalendarAmount,System.TimeSpan)
op_Inequality(MyNet.Temporal.CalendarAmount,MyNet.Temporal.CalendarAmount)
op_Inequality(System.TimeSpan,MyNet.Temporal.CalendarAmount)
op_Inequality(MyNet.Temporal.CalendarAmount,System.TimeSpan)
op_UnaryNegation(MyNet.Temporal.CalendarAmount)
op_LessThan(MyNet.Temporal.CalendarAmount,MyNet.Temporal.CalendarAmount)
op_LessThan(MyNet.Temporal.CalendarAmount,System.TimeSpan)
op_LessThan(System.TimeSpan,MyNet.Temporal.CalendarAmount)
op_LessThanOrEqual(MyNet.Temporal.CalendarAmount,MyNet.Temporal.CalendarAmount)
op_LessThanOrEqual(MyNet.Temporal.CalendarAmount,System.TimeSpan)
op_LessThanOrEqual(System.TimeSpan,MyNet.Temporal.CalendarAmount)
op_GreaterThan(MyNet.Temporal.CalendarAmount,MyNet.Temporal.CalendarAmount)
op_GreaterThan(MyNet.Temporal.CalendarAmount,System.TimeSpan)
op_GreaterThan(System.TimeSpan,MyNet.Temporal.CalendarAmount)
op_GreaterThanOrEqual(MyNet.Temporal.CalendarAmount,MyNet.Temporal.CalendarAmount)
op_GreaterThanOrEqual(MyNet.Temporal.CalendarAmount,System.TimeSpan)
op_GreaterThanOrEqual(System.TimeSpan,MyNet.Temporal.CalendarAmount)
FromTimeSpan(System.TimeSpan)
ToApproximateTimeSpan()
Add(MyNet.Temporal.CalendarAmount)
Add(System.TimeSpan)
Subtract(MyNet.Temporal.CalendarAmount)
Subtract(System.TimeSpan)
CompareTo(System.TimeSpan)
CompareTo(System.Object)
CompareTo(MyNet.Temporal.CalendarAmount)
Negate()
Clone()
ToString()
Equals(MyNet.Temporal.CalendarAmount)
Equals(System.Object)
GetHashCode()
SubtractInternal(System.TimeSpan,MyNet.Temporal.CalendarAmount)
AddInternal(MyNet.Temporal.CalendarAmount,System.TimeSpan)
AddInternal(MyNet.Temporal.CalendarAmount,MyNet.Temporal.CalendarAmount)
SubtractInternal(MyNet.Temporal.CalendarAmount,System.TimeSpan)
SubtractInternal(MyNet.Temporal.CalendarAmount,MyNet.Temporal.CalendarAmount)