diff --git a/Ical.Net.Benchmarks/ApplicationWorkflows.cs b/Ical.Net.Benchmarks/ApplicationWorkflows.cs
index 92aa8b29e..c2e8aa599 100644
--- a/Ical.Net.Benchmarks/ApplicationWorkflows.cs
+++ b/Ical.Net.Benchmarks/ApplicationWorkflows.cs
@@ -9,6 +9,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using Ical.Net.Evaluation;
 
 namespace Ical.Net.Benchmarks;
 
@@ -38,7 +39,7 @@ public List<Occurrence> SingleThreaded()
         return _manyCalendars
             .SelectMany(Calendar.Load<Calendar>)
             .SelectMany(c => c.Events)
-            .SelectMany(e => e.GetOccurrences(_searchStart).TakeWhile(p => p.Period.StartTime < _searchEnd))
+            .SelectMany(e => e.GetOccurrences(_searchStart).TakeWhile(p => p.Period.StartTime.LessThan(_searchEnd)))
             .ToList();
     }
 
@@ -49,7 +50,7 @@ public List<Occurrence> ParallelUponDeserialize()
             .AsParallel()
             .SelectMany(Calendar.Load<Calendar>)
             .SelectMany(c => c.Events)
-            .SelectMany(e => e.GetOccurrences(_searchStart).TakeWhile(p => p.Period.StartTime < _searchEnd))
+            .SelectMany(e => e.GetOccurrences(_searchStart).TakeWhile(p => p.Period.StartTime.LessThan(_searchEnd)))
             .ToList();
     }
 
@@ -60,7 +61,7 @@ public List<Occurrence> ParallelUponGetOccurrences()
             .SelectMany(Calendar.Load<Calendar>)
             .SelectMany(c => c.Events)
             .AsParallel()
-            .SelectMany(e => e.GetOccurrences(_searchStart).TakeWhile(p => p.Period.StartTime < _searchEnd))
+            .SelectMany(e => e.GetOccurrences(_searchStart).TakeWhile(p => p.Period.StartTime.LessThan(_searchEnd)))
             .ToList();
     }
 
@@ -72,7 +73,7 @@ public List<Occurrence> ParallelDeserializeSequentialGatherEventsParallelGetOccu
             .SelectMany(Calendar.Load<Calendar>)
             .AsSequential()
             .SelectMany(c => c.Events)
-            .SelectMany(e => e.GetOccurrences(_searchStart).TakeWhile(p => p.Period.StartTime < _searchEnd))
+            .SelectMany(e => e.GetOccurrences(_searchStart).TakeWhile(p => p.Period.StartTime.LessThan(_searchEnd)))
             .ToList();
     }
 }
diff --git a/Ical.Net.Benchmarks/CalDateTimePerfTests.cs b/Ical.Net.Benchmarks/CalDateTimePerfTests.cs
index 9fcd21725..52b5f248f 100644
--- a/Ical.Net.Benchmarks/CalDateTimePerfTests.cs
+++ b/Ical.Net.Benchmarks/CalDateTimePerfTests.cs
@@ -6,6 +6,7 @@
 using BenchmarkDotNet.Attributes;
 using Ical.Net.DataTypes;
 using System;
+using Ical.Net.Evaluation;
 
 namespace Ical.Net.Benchmarks;
 
diff --git a/Ical.Net.Benchmarks/OccurencePerfTests.cs b/Ical.Net.Benchmarks/OccurencePerfTests.cs
index a17ab58ce..63ee91624 100644
--- a/Ical.Net.Benchmarks/OccurencePerfTests.cs
+++ b/Ical.Net.Benchmarks/OccurencePerfTests.cs
@@ -9,6 +9,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using Ical.Net.Evaluation;
 
 namespace Ical.Net.Benchmarks;
 
@@ -35,7 +36,7 @@ public void MultipleEventsWithUntilOccurrencesSearchingByWholeCalendar()
     {
         var searchStart = _calendarFourEvents.Events.First().DtStart!.AddYears(-1);
         var searchEnd = _calendarFourEvents.Events.Last().DtStart!.AddYears(1);
-        _ = _calendarFourEvents.GetOccurrences(searchStart).TakeWhile(p => p.Period.StartTime < searchEnd);
+        _ = _calendarFourEvents.GetOccurrences(searchStart).TakeWhile(p => p.Period.StartTime.LessThan(searchEnd));
     }
 
     [Benchmark]
@@ -44,7 +45,7 @@ public void MultipleEventsWithUntilOccurrences()
         var searchStart = _calendarFourEvents.Events.First().DtStart!.AddYears(-1);
         var searchEnd = _calendarFourEvents.Events.Last().DtStart!.AddYears(1);
         _ = _calendarFourEvents.Events
-            .SelectMany(e => e.GetOccurrences(searchStart).TakeWhile(p => p.Period.StartTime < searchEnd))
+            .SelectMany(e => e.GetOccurrences(searchStart).TakeWhile(p => p.Period.StartTime.LessThan(searchEnd)))
             .ToList();
     }
 
@@ -55,7 +56,7 @@ public void MultipleEventsWithUntilOccurrencesEventsAsParallel()
         var searchEnd = _calendarFourEvents.Events.Last().DtStart!.AddYears(1).AddDays(10);
         _ = _calendarFourEvents.Events
             .AsParallel()
-            .SelectMany(e => e.GetOccurrences(searchStart).TakeWhile(p => p.Period.StartTime < searchEnd))
+            .SelectMany(e => e.GetOccurrences(searchStart).TakeWhile(p => p.Period.StartTime.LessThan(searchEnd)))
             .ToList();
     }
 
@@ -113,7 +114,7 @@ public void MultipleEventsWithCountOccurrencesSearchingByWholeCalendar()
         var calendar = GetFourCalendarEventsWithCountRule();
         var searchStart = calendar.Events.First().DtStart!.AddYears(-1);
         var searchEnd = calendar.Events.Last().DtStart!.AddYears(1);
-        _ = calendar.GetOccurrences(searchStart).TakeWhile(p => p.Period.StartTime < searchEnd);
+        _ = calendar.GetOccurrences(searchStart).TakeWhile(p => p.Period.StartTime.LessThan(searchEnd));
     }
 
     [Benchmark]
@@ -123,7 +124,7 @@ public void MultipleEventsWithCountOccurrences()
         var searchStart = calendar.Events.First().DtStart!.AddYears(-1);
         var searchEnd = calendar.Events.Last().DtStart!.AddYears(1);
         _ = calendar.Events
-            .SelectMany(e => e.GetOccurrences(searchStart).TakeWhile(p => p.Period.StartTime < searchEnd))
+            .SelectMany(e => e.GetOccurrences(searchStart).TakeWhile(p => p.Period.StartTime.LessThan(searchEnd)))
             .ToList();
     }
 
@@ -135,7 +136,7 @@ public void MultipleEventsWithCountOccurrencesEventsAsParallel()
         var searchEnd = calendar.Events.Last().DtStart!.AddYears(1).AddDays(10);
         _ = calendar.Events
             .AsParallel()
-            .SelectMany(e => e.GetOccurrences(searchStart).TakeWhile(p => p.Period.StartTime < searchEnd))
+            .SelectMany(e => e.GetOccurrences(searchStart).TakeWhile(p => p.Period.StartTime.LessThan(searchEnd)))
             .ToList();
     }
 
diff --git a/Ical.Net.Benchmarks/ThroughputTests.cs b/Ical.Net.Benchmarks/ThroughputTests.cs
index 323676e4e..ff45c8619 100644
--- a/Ical.Net.Benchmarks/ThroughputTests.cs
+++ b/Ical.Net.Benchmarks/ThroughputTests.cs
@@ -6,6 +6,7 @@
 using BenchmarkDotNet.Attributes;
 using System.Linq;
 using Ical.Net.DataTypes;
+using Ical.Net.Evaluation;
 
 namespace Ical.Net.Benchmarks;
 
@@ -70,7 +71,7 @@ rsion 08.00.0681.000"">\n<TITLE></TITLE>\n</HEAD>\n<BODY>\n<!-- Converted f
         var calendarEvent = calendar.Events.First();
         var searchStart = new CalDateTime(2009, 06, 20);
         var searchEnd = new CalDateTime(2011, 06, 23);
-        var occurrences = calendarEvent.GetOccurrences(searchStart).TakeWhile(p => p.Period.StartTime < searchEnd);
+        _ = calendarEvent.GetOccurrences(searchStart).TakeWhile(p => p.Period.StartTime.LessThan(searchEnd));
     }
 
     [Benchmark]
@@ -132,6 +133,6 @@ rsion 08.00.0681.000"">\n<TITLE></TITLE>\n</HEAD>\n<BODY>\n<!-- Converted f
         var calendarEvent = calendar.Events.First();
         var searchStart = new CalDateTime(2009, 06, 20);
         var searchEnd = new CalDateTime(2011, 06, 23);
-        var occurrences = calendarEvent.GetOccurrences(searchStart).TakeWhile(p => p.Period.StartTime < searchEnd);
+        _ = calendarEvent.GetOccurrences(searchStart).TakeWhile(p => p.Period.StartTime.LessThan(searchEnd));
     }
 }
diff --git a/Ical.Net.Tests/CalDateTimeTests.cs b/Ical.Net.Tests/CalDateTimeTests.cs
index 6463a1581..4c7e3ef8c 100644
--- a/Ical.Net.Tests/CalDateTimeTests.cs
+++ b/Ical.Net.Tests/CalDateTimeTests.cs
@@ -12,6 +12,7 @@
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
+using Ical.Net.Evaluation;
 
 namespace Ical.Net.Tests;
 
@@ -55,10 +56,10 @@ public void ToTimeZoneFloating()
     [Test, TestCaseSource(nameof(ToTimeZoneTestCases))]
     public void ToTimeZoneTests(CalendarEvent calendarEvent, string targetTimeZone)
     {
-        var startAsUtc = calendarEvent.Start.AsUtc;
+        var startAsUtc = calendarEvent.Start!.AsUtc();
 
         var convertedStart = calendarEvent.Start.ToTimeZone(targetTimeZone);
-        var convertedAsUtc = convertedStart.AsUtc;
+        var convertedAsUtc = convertedStart.AsUtc();
 
         Assert.That(convertedAsUtc, Is.EqualTo(startAsUtc));
     }
@@ -96,11 +97,11 @@ public void SameDateTimeWithDifferentTzIdShouldReturnSameUtc()
         var someTime = DateTimeOffset.Parse("2018-05-21T11:35:00-04:00", CultureInfo.InvariantCulture);
 
         var someDt = new CalDateTime(someTime.DateTime, "America/New_York");
-        var firstUtc = someDt.AsUtc;
+        var firstUtc = someDt.AsUtc();
         Assert.That(firstUtc, Is.EqualTo(someTime.UtcDateTime));
 
         someDt = new CalDateTime(someTime.DateTime, "Europe/Berlin");
-        var berlinUtc = someDt.AsUtc;
+        var berlinUtc = someDt.AsUtc();
         Assert.That(berlinUtc, Is.Not.EqualTo(firstUtc));
     }
 
@@ -142,14 +143,26 @@ public static IEnumerable DateTimeKindOverrideTestCases()
             .SetName("DateTime with Kind = Local and null tzid returns DateTimeKind.Unspecified");
     }
 
-    [Test, TestCaseSource(nameof(ToStringTestCases))]
-    public string ToStringTests(CalDateTime calDateTime, string format, IFormatProvider formatProvider)
+    [Test]
+    public void ToStringTest()
+    {
+        var calDateTime = new CalDateTime(2024, 8, 30, 10, 30, 0, tzId: "Pacific/Auckland");
+        Assert.That(calDateTime.ToString(),
+            Is.EqualTo("08/30/2024 10:30:00 Pacific/Auckland"));
+#pragma warning disable CA1305
+        Assert.That(calDateTime.ToString("yyyy-MM-dd HH:mm:ss"),
+            Is.EqualTo("2024-08-30 10:30:00 Pacific/Auckland"));
+#pragma warning restore CA1305
+    }
+
+    [Test, TestCaseSource(nameof(ToStringWithFormatTestCases))]
+    public string ToStringWitFormatTests(CalDateTime calDateTime, string format, IFormatProvider formatProvider)
         => calDateTime.ToString(format, formatProvider);
 
-    public static IEnumerable ToStringTestCases()
+    public static IEnumerable ToStringWithFormatTestCases()
     {
         yield return new TestCaseData(new CalDateTime(2024, 8, 30, 10, 30, 0, tzId: "Pacific/Auckland"), "O", null)
-            .Returns("2024-08-30T10:30:00.0000000+12:00 Pacific/Auckland")
+            .Returns("2024-08-30T10:30:00.0000000 Pacific/Auckland")
             .SetName("Date and time with 'O' format arg, default culture");
 
         yield return new TestCaseData(new CalDateTime(2024, 8, 30), "O", null)
@@ -158,7 +171,7 @@ public static IEnumerable ToStringTestCases()
 
         yield return new TestCaseData(new CalDateTime(2024, 8, 30, 10, 30, 0, tzId: "Pacific/Auckland"), "O",
                 CultureInfo.GetCultureInfo("fr-FR"))
-            .Returns("2024-08-30T10:30:00.0000000+12:00 Pacific/Auckland")
+            .Returns("2024-08-30T10:30:00.0000000 Pacific/Auckland")
             .SetName("Date and time with 'O' format arg, French culture");
 
         yield return new TestCaseData(new CalDateTime(2024, 8, 30, 10, 30, 0, tzId: "Pacific/Auckland"),
@@ -190,15 +203,15 @@ public static IEnumerable DateTimeArithmeticTestCases()
 
         yield return new TestCaseData(new Func<CalDateTime, CalDateTime>(dt => dt.AddHours(1)))
             .Returns(dateTime.AddHours(1))
-            .SetName($"{nameof(CalDateTime.AddHours)} 1 hour");
+            .SetName($"{nameof(CalDateTimeExtensions.AddHours)} 1 hour");
 
         yield return new TestCaseData(new Func<CalDateTime, CalDateTime>(dt => dt.Add(Duration.FromSeconds(30))))
             .Returns(dateTime.Add(TimeSpan.FromSeconds(30)))
-            .SetName($"{nameof(CalDateTime.Add)} 30 seconds");
+            .SetName($"{nameof(CalDateTimeExtensions.Add)} 30 seconds");
 
         yield return new TestCaseData(new Func<CalDateTime, CalDateTime>(dt => dt.AddMinutes(70)))
             .Returns(dateTime.AddMinutes(70))
-            .SetName($"{nameof(CalDateTime.AddMinutes)} 70 minutes");
+            .SetName($"{nameof(CalDateTimeExtensions.AddMinutes)} 70 minutes");
     }
 
     [Test, TestCaseSource(nameof(EqualityTestCases))]
@@ -259,27 +272,27 @@ public static IEnumerable DateOnlyValidArithmeticTestCases()
 
         yield return new TestCaseData(new Func<CalDateTime, CalDateTime>(dt => dt.Add(-Duration.FromDays(1))))
             .Returns((dateTime.AddDays(-1), false))
-            .SetName($"{nameof(CalDateTime.Add)} -1 day TimeSpan");
+            .SetName($"{nameof(CalDateTimeExtensions.Add)} -1 day TimeSpan");
 
         yield return new TestCaseData(new Func<CalDateTime, CalDateTime>(dt => dt.AddYears(1)))
             .Returns((dateTime.AddYears(1), false))
-            .SetName($"{nameof(CalDateTime.AddYears)} 1 year");
+            .SetName($"{nameof(CalDateTimeExtensions.AddYears)} 1 year");
 
         yield return new TestCaseData(new Func<CalDateTime, CalDateTime>(dt => dt.AddMonths(2)))
             .Returns((dateTime.AddMonths(2), false))
-            .SetName($"{nameof(CalDateTime.AddMonths)} 2 months");
+            .SetName($"{nameof(CalDateTimeExtensions.AddMonths)} 2 months");
 
         yield return new TestCaseData(new Func<CalDateTime, CalDateTime>(dt => dt.AddDays(7)))
             .Returns((dateTime.AddDays(7), false))
-            .SetName($"{nameof(CalDateTime.AddDays)} 7 days");
+            .SetName($"{nameof(CalDateTimeExtensions.AddDays)} 7 days");
 
         yield return new TestCaseData(new Func<CalDateTime, CalDateTime>(dt => dt.Add(Duration.FromDays(1))))
             .Returns((dateTime.Add(TimeSpan.FromDays(1)), false))
-            .SetName($"{nameof(CalDateTime.Add)} 1 day TimeSpan");
+            .SetName($"{nameof(CalDateTimeExtensions.Add)} 1 day TimeSpan");
 
         yield return new TestCaseData(new Func<CalDateTime, CalDateTime>(dt => dt.Add(Duration.Zero)))
             .Returns((dateTime.Add(TimeSpan.Zero), false))
-            .SetName($"{nameof(CalDateTime.Add)} TimeSpan.Zero");
+            .SetName($"{nameof(CalDateTimeExtensions.Add)} TimeSpan.Zero");
     }
 
     [Test]
diff --git a/Ical.Net.Tests/CalDateTimeZonedTests.cs b/Ical.Net.Tests/CalDateTimeZonedTests.cs
new file mode 100644
index 000000000..1437d51d9
--- /dev/null
+++ b/Ical.Net.Tests/CalDateTimeZonedTests.cs
@@ -0,0 +1,457 @@
+//
+// Copyright ical.net project maintainers and contributors.
+// Licensed under the MIT license.
+//
+
+#nullable enable
+using System;
+using System.Globalization;
+using Ical.Net.DataTypes;
+using Ical.Net.Evaluation;
+using NUnit.Framework;
+
+namespace Ical.Net.Tests;
+
+[TestFixture]
+internal class CalDateTimeZonedTests
+{
+#pragma warning disable NUnit2043 // Use ComparisonConstraint for better assertion messages in case of failure
+
+    [Test]
+    public void Offset_ReturnsZero_WhenNoZone()
+    {
+        var zoned = new CalDateTime(2024, 1, 1, 12, 0, 0).AsZoned();
+
+        Assert.That(zoned.Offset, Is.EqualTo(TimeSpan.Zero));
+    }
+
+    [Test]
+    public void Offset_ReturnsCorrectOffset_WhenZonePresent()
+    {
+        var zoned = new CalDateTime(2024, 1, 1, 12, 0, 0, "Europe/Vienna").AsZoned();
+
+        Assert.That(zoned.Offset, Is.EqualTo(TimeSpan.FromHours(1)));
+    }
+
+    [Test]
+    public void HasZone_IsFalse_WhenZonedDateTimeIsNull()
+    {
+        var zoned = new CalDateTime(2024, 1, 1).AsZoned();
+
+        Assert.That(zoned.HasZone, Is.False);
+    }
+
+    [Test]
+    public void HasZone_IsTrue_WhenZonedDateTimeIsNotNull()
+    {
+        var zonedDt = new CalDateTime(2024, 1, 1, 12, 0, 0, CalDateTime.UtcTzId).AsZoned();
+
+        Assert.That(zonedDt.HasZone, Is.True);
+    }
+
+    [Test]
+    public void Equals_Object_ReturnsTrueForSameValues()
+    {
+        var zonedDt = new CalDateTime(2024, 1, 1, 12, 0, 0, CalDateTime.UtcTzId).AsZoned();
+        var a = zonedDt;
+        var b = zonedDt;
+
+        // Using the Equals method directly
+        Assert.That(a.Equals(b), Is.True);
+    }
+
+    [Test]
+    public void Equals_Object_ReturnsFalseForDifferentValues()
+    {
+        var zonedDt1 = new CalDateTime(2024, 1, 1, 12, 0, 0, CalDateTime.UtcTzId).AsZoned();
+        var zonedDt2 = new CalDateTime(2024, 2, 2, 12, 0, 0, CalDateTime.UtcTzId).AsZoned();
+
+        // Using the Equals method directly
+        // Typed Equals:
+        Assert.That(zonedDt1.Equals(zonedDt2), Is.False);
+        Assert.That(zonedDt1.Equals(zonedDt1), Is.True);
+        // Equals object;
+        Assert.That(zonedDt1.Equals((object) zonedDt2), Is.False); 
+        Assert.That(zonedDt1.Equals((object) zonedDt1), Is.True);
+        Assert.That(zonedDt2.Equals(null), Is.False);
+        Assert.That(zonedDt2.Equals(new object()), Is.False);
+    }
+
+    [Test]
+    public void GetHashCode_SameForEqualInstances()
+    {
+        var zonedDt = new CalDateTime(2024, 1, 1, 12, 0, 0, CalDateTime.UtcTzId).AsZoned();
+
+        var a = zonedDt;
+        var b = zonedDt;
+
+        Assert.That(a.GetHashCode(), Is.EqualTo(b.GetHashCode()));
+    }
+
+    [Test]
+    public void Equals_CalDateTimeZoned_ReturnsTrueForSameValues()
+    {
+        var zonedDt = new CalDateTime(2024, 1, 1, 12, 0, 0, CalDateTime.UtcTzId).AsZoned();
+        var a = zonedDt;
+        var b = zonedDt;
+
+        // Using the Equals method directly
+        Assert.That(a.Equals(b), Is.True);
+    }
+
+    [Test]
+    public void Equals_CalDateTimeZoned_ReturnsFalseForDifferentValues()
+    {
+        var zonedDt1 = new CalDateTime(2024, 1, 1, 12, 0, 0, CalDateTime.UtcTzId).AsZoned();
+        var zonedDt2 = new CalDateTime(2024, 2, 2, 12, 0, 0, CalDateTime.UtcTzId).AsZoned();
+
+        // Using the Equals method directly
+        Assert.That(zonedDt1.Equals(zonedDt2), Is.False);
+    }
+
+    [Test]
+    public void Operator_Equality_ReturnsTrueForEqual()
+    {
+        var zonedDt = new CalDateTime(2024, 1, 1, 12, 0, 0, CalDateTime.UtcTzId).AsZoned();
+        var a = zonedDt;
+        var b = zonedDt;
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(a == b, Is.True);
+            Assert.That(null == a, Is.False);
+            Assert.That(a == null, Is.False);
+        });
+        
+    }
+
+    [Test]
+    public void Operator_Inequality_ReturnsTrueForDifferent()
+    {
+        var zonedDt1 = new CalDateTime(2024, 1, 1, 12, 0, 0, CalDateTime.UtcTzId).AsZoned();
+        var zonedDt2 = new CalDateTime(2024, 1, 2, 12, 0, 0, CalDateTime.UtcTzId).AsZoned();
+
+        Assert.That(zonedDt1 != zonedDt2, Is.True);
+    }
+
+    [Test]
+    public void Operator_LessThan_Works()
+    {
+        var zonedDt1 = new CalDateTime(2024, 1, 1, 12, 0, 0, CalDateTime.UtcTzId).AsZoned();
+        var zonedDt2 = new CalDateTime(2024, 1, 2, 12, 0, 0, CalDateTime.UtcTzId).AsZoned();
+        Assert.Multiple(() =>
+        {
+            Assert.That(zonedDt1 < zonedDt2, Is.True);
+            Assert.That(null < zonedDt2, Is.False);
+            Assert.That(zonedDt1 < null, Is.False);
+        });
+        
+    }
+
+    [Test]
+    public void Operator_LessThanOrEqual_Works()
+    {
+        var zonedDt1 = new CalDateTime(2024, 1, 1, 12, 0, 0, CalDateTime.UtcTzId).AsZoned();
+        var zonedDt2 = new CalDateTime(2024, 1, 2, 12, 0, 0, CalDateTime.UtcTzId).AsZoned();
+
+#pragma warning disable CS1718 // Comparison made to same variable
+        Assert.Multiple(() =>
+        {
+            // ReSharper disable once EqualExpressionComparison
+            Assert.That(zonedDt1 <= zonedDt2, Is.True);
+            Assert.That(null <= zonedDt2, Is.False);
+            Assert.That(zonedDt1 <= null, Is.False);
+        });
+#pragma warning restore CS1718 // Comparison made to same variable
+    }
+
+    [Test]
+    public void Operator_GreaterThan_Works()
+    {
+        var zonedDt1 = new CalDateTime(2024, 1, 2, 12, 0, 0, CalDateTime.UtcTzId).AsZoned();
+        var zonedDt2 = new CalDateTime(2024, 1, 1, 12, 0, 0, CalDateTime.UtcTzId).AsZoned();
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(zonedDt1 > zonedDt2, Is.True);
+            Assert.That(null > zonedDt2, Is.False);
+            Assert.That(zonedDt1 > null, Is.False);
+        });
+    }
+
+    [Test]
+    public void Operator_GreaterThanOrEqual_Works()
+    {
+        var zonedDt1 = new CalDateTime(2024, 1, 2, 12, 0, 0, CalDateTime.UtcTzId).AsZoned();
+        var zonedDt2 = new CalDateTime(2024, 1, 1, 12, 0, 0, CalDateTime.UtcTzId).AsZoned();
+
+#pragma warning disable CS1718 // Comparison made to same variable
+        Assert.Multiple(() =>
+        {
+            // ReSharper disable once EqualExpressionComparison
+            Assert.That(zonedDt1 >= zonedDt2, Is.True);
+            Assert.That(null >= zonedDt2, Is.False);
+            Assert.That(zonedDt1 >= null, Is.False);
+        });
+#pragma warning restore CS1718 // Comparison made to same variable
+    }
+
+    [Test]
+    public void CompareTo_ReturnsZeroForEqual()
+    {
+        var zonedDt = new CalDateTime(2024, 1, 1, 12, 0, 0, CalDateTime.UtcTzId).AsZoned();
+        var a = zonedDt;
+        var b = zonedDt;
+
+        Assert.That(a.CompareTo(b), Is.EqualTo(0));
+    }
+
+    [Test]
+    public void CompareTo_ReturnsNegativeForLess()
+    {
+        var zonedDt1 = new CalDateTime(2024, 1, 1, 12, 0, 0, CalDateTime.UtcTzId).AsZoned();
+        var zonedDt2 = new CalDateTime(2024, 2, 2, 12, 0, 0, CalDateTime.UtcTzId).AsZoned();
+
+        Assert.That(zonedDt1.CompareTo(zonedDt2), Is.LessThan(0));
+    }
+
+    [Test]
+    public void CompareTo_ReturnsPositiveForGreater()
+    {
+        var zonedDt1 = new CalDateTime(2024, 2, 2, 12, 0, 0, CalDateTime.UtcTzId).AsZoned();
+        var zonedDt2 = new CalDateTime(2024, 1, 1, 12, 0, 0, CalDateTime.UtcTzId).AsZoned();
+
+        Assert.That(zonedDt1.CompareTo(zonedDt2), Is.GreaterThan(0));
+    }
+
+    [Test]
+    public void CompareTo_Throws_WhenNoTimeZoneExists()
+    {
+        var zonedDt1 = new CalDateTime(2024, 1, 1).AsZoned();
+        var zonedDt2 = new CalDateTime(2024, 1, 2).AsZoned();
+
+        Assert.Throws<InvalidOperationException>(() => _ = zonedDt1.CompareTo(zonedDt2)); // Both have no zone
+    }
+
+    [Test]
+    public void CompareTo_Throws_WhenOnlyOneHasTimeZone()
+    {
+        var withZone = new CalDateTime(2024, 1, 2, 10, 11, 12, "UTC").AsZoned();
+        var noZone = new CalDateTime(2024, 1, 2, 10, 11, 12).AsZoned();
+
+        Assert.Throws<InvalidOperationException>(() => _ = withZone.CompareTo(noZone));
+        Assert.Throws<InvalidOperationException>(() => _ = noZone.CompareTo(withZone));
+    }
+
+    [Test]
+    public void SubtractWithMissingTimePart_ShouldThrow()
+    {
+        var zonedNoTime = new CalDateTime(2025, 8, 1).AsZoned();
+        var zonedWithTime = new CalDateTime(2025, 6, 1, 12, 0, 0).AsZoned();
+
+        Assert.Multiple(() =>
+        {
+            Assert.Throws<InvalidOperationException>(() => _ = zonedWithTime.Subtract(zonedNoTime), "Cannot subtract a date with no time from one with time.");
+            Assert.Throws<InvalidOperationException>(() => _ = zonedWithTime.Subtract(zonedNoTime), "Cannot subtract a date with time from one with no time.");
+        });
+    }
+#pragma warning restore NUnit2043 // Use ComparisonConstraint for better assertion messages in case of failure
+
+    [Test]
+    public void ToString_ReturnsRequestedFormat()
+    {
+        var dt = new CalDateTime(2025, 5, 1, 12, 0, 0, "America/New_York");
+        var zonedDt1 = dt.AsZoned();
+        var zonedDt2 = zonedDt1.ToTimeZone("Asia/Istanbul");
+        var result1 = zonedDt1.ToString("yyyy-MM-dd HH:mm:ss zzz", null);
+        var result2 = zonedDt2.ToString(null, CultureInfo.GetCultureInfo("en-US"));
+        var result3 = zonedDt2.ToString();
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(result1, Is.EqualTo("2025-05-01 12:00:00 -04:00 America/New_York"));
+            Assert.That(result2, Is.EqualTo("5/1/2025 7:00:00 PM +03:00 Asia/Istanbul"));
+            Assert.That(result3, Is.EqualTo("05/01/2025 19:00:00 +03:00 Asia/Istanbul"));
+        });
+    }
+
+    [Test, TestCaseSource(nameof(LessThanTestCases))]
+    public void LessThanComparisonTestCases(CalDateTimeZoned? self, CalDateTimeZoned? other, bool expected)
+    {
+        Assert.Multiple(() =>
+        {
+            Assert.That(self?.LessThan(other) == true, Is.EqualTo(expected));
+            Assert.That(self?.LessThanOrEqual(other) == true, Is.EqualTo(expected));
+        });
+    }
+
+    public static System.Collections.IEnumerable LessThanTestCases
+    {
+        get
+        {
+            // Floating: both
+            yield return new TestCaseData(
+                new CalDateTime(2025, 1, 1).AsZoned(),
+                new CalDateTime(2025, 1, 2).AsZoned(),
+                true
+            ).SetName("LessThan_BothHaveIsFloating");
+
+            // Floating self.IsFloating = true, other.IsFloating = false
+            yield return new TestCaseData(
+                new CalDateTime(2025, 1, 1).AsZoned(),
+                new CalDateTime(2025, 1, 2, 12, 0, 0, "UTC").AsZoned(),
+                true
+            ).SetName("LessThan_LeftIsFloating_OtherNotFloating");
+
+            // Floating self.IsFloating = false, other.IsFloating = true
+            yield return new TestCaseData(
+                new CalDateTime(2025, 1, 1, 12, 0, 0, "UTC").AsZoned(),
+                new CalDateTime(2025, 1, 2).AsZoned(),
+                true
+            ).SetName("LessThan_LeftIsNotFloating_OtherIsFloating");
+
+            // Timezone: same
+            yield return new TestCaseData(
+                new CalDateTime(2025, 1, 1, 12, 0, 0, "UTC").AsZoned(),
+                new CalDateTime(2025, 1, 2, 12, 0, 0, "UTC").AsZoned(),
+                true
+            ).SetName("LessThan_SameTimeZone");
+
+            // Timezone: same
+            yield return new TestCaseData(
+                new CalDateTime(2025, 1, 2, 12, 0, 0, "UTC").AsZoned(),
+                new CalDateTime(2025, 1, 1, 12, 0, 0, "UTC").AsZoned(),
+                false
+            ).SetName("NotLessThan_SameTimeZone");
+
+            // Timezone: different
+            yield return new TestCaseData(
+                new CalDateTime(2025, 1, 1, 12, 0, 0, "UTC").AsZoned(),
+                new CalDateTime(2025, 1, 2, 12, 0, 0, "Europe/Vienna").AsZoned(),
+                true
+            ).SetName("LessThan_DifferentTimeZone");
+
+            // Timezone: different
+            yield return new TestCaseData(
+                new CalDateTime(2025, 1, 2, 12, 0, 0, "Europe/Vienna").AsZoned(),
+                new CalDateTime(2025, 1, 1, 12, 0, 0, "UTC").AsZoned(),
+                false
+            ).SetName("NotLessThan_DifferentTimeZone");
+
+            // self is null, other is not
+            yield return new TestCaseData(
+                null,
+                new CalDateTime(2025, 1, 2, 12, 0, 0, "Europe/Vienna").AsZoned(),
+                false
+            ).SetName("LessThan_LeftIsNull");
+
+            // self is null, other is not
+            yield return new TestCaseData(
+                new CalDateTime(2025, 1, 1, 12, 0, 0, "UTC").AsZoned(),
+                null,
+                false
+            ).SetName("LessThan_OtherIsNull");
+        }
+    }
+
+    [Test]
+    public void LessThanForEquality()
+    {
+        var zoned = new CalDateTime(2025, 1, 1, 12, 0, 0, "UTC").AsZoned();
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(zoned.LessThanOrEqual(zoned), Is.True);
+            Assert.That(zoned.LessThan(zoned), Is.False);
+        });
+    }
+
+    [Test, TestCaseSource(nameof(GreaterThanTestCases))]
+    public void GreaterThanComparisonTestCases(CalDateTimeZoned? self, CalDateTimeZoned? other, bool expected)
+    {
+        Assert.Multiple(() =>
+        {
+            Assert.That(self?.GreaterThan(other) == true, Is.EqualTo(expected));
+            Assert.That(self?.GreaterThanOrEqual(other) == true, Is.EqualTo(expected));
+        });
+    }
+
+    public static System.Collections.IEnumerable GreaterThanTestCases
+    {
+        get
+        {
+            // Floating: both
+            yield return new TestCaseData(
+                new CalDateTime(2025, 1, 2).AsZoned(),
+                new CalDateTime(2025, 1, 1).AsZoned(),
+                true
+            ).SetName("GreaterThan_BothHaveIsFloating");
+
+            // Floating self.IsFloating = true, other.IsFloating = false
+            yield return new TestCaseData(
+                new CalDateTime(2025, 1, 2, 12, 0, 0, "UTC").AsZoned(),
+                new CalDateTime(2025, 1, 1).AsZoned(),
+                true
+            ).SetName("GreaterThan_LeftIsFloating_OtherNotFloating");
+
+            // Floating self.IsFloating = false, other.IsFloating = true
+            yield return new TestCaseData(
+                new CalDateTime(2025, 1, 2).AsZoned(),
+                new CalDateTime(2025, 1, 1, 12, 0, 0, "UTC").AsZoned(),
+                true
+            ).SetName("GreaterThan_LeftIsNotFloating_OtherIsFloating");
+
+            // Timezone: same
+            yield return new TestCaseData(
+                new CalDateTime(2025, 1, 2, 12, 0, 0, "UTC").AsZoned(),
+                new CalDateTime(2025, 1, 1, 12, 0, 0, "UTC").AsZoned(),
+                true
+            ).SetName("GreaterThan_SameTimeZone");
+
+            // Timezone: same
+            yield return new TestCaseData(
+                new CalDateTime(2025, 1, 1, 12, 0, 0, "UTC").AsZoned(),
+                new CalDateTime(2025, 1, 2, 12, 0, 0, "UTC").AsZoned(),
+                false
+            ).SetName("NotGreaterThan_SameTimeZone");
+
+            // Timezone: different
+            yield return new TestCaseData(
+                new CalDateTime(2025, 1, 2, 12, 0, 0, "Europe/Vienna").AsZoned(),
+                new CalDateTime(2025, 1, 1, 12, 0, 0, "UTC").AsZoned(),
+                true
+            ).SetName("GreaterThan_DifferentTimeZone");
+
+            // Timezone: different
+            yield return new TestCaseData(
+                new CalDateTime(2025, 1, 1, 12, 0, 0, "UTC").AsZoned(),
+                new CalDateTime(2025, 1, 2, 12, 0, 0, "Europe/Vienna").AsZoned(),
+                false
+            ).SetName("NotGreaterThan_DifferentTimeZone");
+
+            yield return new TestCaseData(
+                null,
+                new CalDateTime(2025, 1, 2, 12, 0, 0, "Europe/Vienna").AsZoned(),
+                false
+            ).SetName("GreaterThan_LeftIsNull");
+
+            // self is null, other is not
+            yield return new TestCaseData(
+                new CalDateTime(2025, 1, 1, 12, 0, 0, "UTC").AsZoned(),
+                null,
+                false
+            ).SetName("GreaterThan_OtherIsNull");
+        }
+    }
+
+    [Test]
+    public void GreaterThanForEquality()
+    {
+        var zoned = new CalDateTime(2025, 1, 1, 12, 0, 0, "UTC").AsZoned();
+        Assert.Multiple(() =>
+        {
+            Assert.That(zoned.GreaterThanOrEqual(zoned), Is.True);
+            Assert.That(zoned.GreaterThan(zoned), Is.False);
+        });
+    }
+}
diff --git a/Ical.Net.Tests/EqualityAndHashingTests.cs b/Ical.Net.Tests/EqualityAndHashingTests.cs
index 99f5971c3..bdbabaa82 100644
--- a/Ical.Net.Tests/EqualityAndHashingTests.cs
+++ b/Ical.Net.Tests/EqualityAndHashingTests.cs
@@ -11,6 +11,7 @@
 using System.Text;
 using Ical.Net.CalendarComponents;
 using Ical.Net.DataTypes;
+using Ical.Net.Evaluation;
 using Ical.Net.Serialization;
 using Ical.Net.Utility;
 using NUnit.Framework;
@@ -203,9 +204,9 @@ public void CalDateTimeComparisonOperatorTests()
     {
         TestComparison((dt1, dt2) => dt1 == dt2, (i1, i2) => i1 == i2);
         TestComparison((dt1, dt2) => dt1 != dt2, (i1, i2) => i1 != i2);
-        TestComparison((dt1, dt2) => dt1 > dt2, (i1, i2) => i1 > i2);
-        TestComparison((dt1, dt2) => dt1 >= dt2, (i1, i2) => i1 >= i2);
-        TestComparison((dt1, dt2) => dt1 < dt2, (i1, i2) => i1 < i2);
-        TestComparison((dt1, dt2) => dt1 <= dt2, (i1, i2) => i1 <= i2);
+        TestComparison((dt1, dt2) => dt1?.GreaterThan(dt2) == true, (i1, i2) => i1 > i2);
+        TestComparison((dt1, dt2) => dt1?.GreaterThanOrEqual(dt2) == true, (i1, i2) => i1 >= i2);
+        TestComparison((dt1, dt2) => dt1?.LessThan(dt2) == true, (i1, i2) => i1 < i2);
+        TestComparison((dt1, dt2) => dt1?.LessThanOrEqual(dt2) == true, (i1, i2) => i1 <= i2);
     }
 }
diff --git a/Ical.Net.Tests/PeriodListWrapperTests.cs b/Ical.Net.Tests/PeriodListWrapperTests.cs
index 995d392f1..2e7d585b1 100644
--- a/Ical.Net.Tests/PeriodListWrapperTests.cs
+++ b/Ical.Net.Tests/PeriodListWrapperTests.cs
@@ -7,6 +7,7 @@
 using System.Linq;
 using Ical.Net.CalendarComponents;
 using Ical.Net.DataTypes;
+using Ical.Net.Evaluation;
 using Ical.Net.Serialization;
 using NUnit.Framework;
 
diff --git a/Ical.Net.Tests/PeriodTests.cs b/Ical.Net.Tests/PeriodTests.cs
index db3c5a766..210078cee 100644
--- a/Ical.Net.Tests/PeriodTests.cs
+++ b/Ical.Net.Tests/PeriodTests.cs
@@ -6,6 +6,7 @@
 #nullable enable
 using System;
 using Ical.Net.DataTypes;
+using Ical.Net.Evaluation;
 using NUnit.Framework;
 
 namespace Ical.Net.Tests;
@@ -17,21 +18,29 @@ public class PeriodTests
     public void CreatePeriodWithArguments()
     {
         var period = new Period(new CalDateTime(2025, 1, 1, 0, 0, 0, "America/New_York"));
-        var periodWithEndTime = new Period(new CalDateTime(2025, 1, 1, 0, 0, 0, "America/New_York"), new CalDateTime(2025, 1, 1, 1, 0, 0, "America/New_York"));
-        var periodWithDuration = new Period(new CalDateTime(2025, 1, 1, 0, 0, 0, "America/New_York"), Duration.FromHours(1));
+        var periodWithEndTime = new Period(new CalDateTime(2025, 1, 1, 0, 0, 0, "America/New_York"),
+            new CalDateTime(2025, 1, 1, 1, 0, 0, "America/New_York"));
+        var periodWithDuration =
+            new Period(new CalDateTime(2025, 1, 1, 0, 0, 0, "America/New_York"), Duration.FromHours(1));
 
         Assert.Multiple(() =>
         {
             Assert.That(period.StartTime, Is.EqualTo(new CalDateTime(2025, 1, 1, 0, 0, 0, "America/New_York")));
             Assert.That(period.EndTime, Is.Null);
             Assert.That(period.Duration, Is.Null);
-            
-            Assert.That(periodWithEndTime.StartTime, Is.EqualTo(new CalDateTime(2025, 1, 1, 0, 0, 0, "America/New_York")));
-            Assert.That(periodWithEndTime.EffectiveEndTime, Is.EqualTo(new CalDateTime(2025, 1, 1, 1, 0, 0, "America/New_York")));
+            Assert.That(period.EffectiveEndTime, Is.Null);
+            Assert.That(period.EffectiveDuration, Is.Null);
+
+            Assert.That(periodWithEndTime.StartTime,
+                Is.EqualTo(new CalDateTime(2025, 1, 1, 0, 0, 0, "America/New_York")));
+            Assert.That(periodWithEndTime.EffectiveEndTime,
+                Is.EqualTo(new CalDateTime(2025, 1, 1, 1, 0, 0, "America/New_York")));
             Assert.That(periodWithEndTime.EffectiveDuration, Is.EqualTo(Duration.FromHours(1)));
 
-            Assert.That(periodWithDuration.StartTime, Is.EqualTo(new CalDateTime(2025, 1, 1, 0, 0, 0, "America/New_York")));
-            Assert.That(periodWithDuration.EffectiveEndTime, Is.EqualTo(new CalDateTime(2025, 1, 1, 1, 0, 0, "America/New_York")));
+            Assert.That(periodWithDuration.StartTime,
+                Is.EqualTo(new CalDateTime(2025, 1, 1, 0, 0, 0, "America/New_York")));
+            Assert.That(periodWithDuration.EffectiveEndTime,
+                Is.EqualTo(new CalDateTime(2025, 1, 1, 1, 0, 0, "America/New_York")));
             Assert.That(periodWithDuration.EffectiveDuration, Is.EqualTo(Duration.FromHours(1)));
 
             Assert.That(Period.Create(period.StartTime).Duration, Is.Null);
@@ -42,6 +51,7 @@ public void CreatePeriodWithArguments()
     [Test]
     public void CreatePeriodWithInvalidArgumentsShouldThrow()
     {
+        // Test with CalDateTime
         Assert.Multiple(() =>
         {
             // EndTime is before StartTime
@@ -62,6 +72,28 @@ public void CreatePeriodWithInvalidArgumentsShouldThrow()
             Assert.Throws<ArgumentException>(() => _ = new Period(new CalDateTime(2025, 1, 2, 0, 0, 0),
                 new CalDateTime(2025, 1, 1)));
         });
+
+        // Test with CalDateTimeZoned
+        Assert.Multiple(() =>
+        {
+            // EndTime is before StartTime
+            Assert.Throws<ArgumentException>(() => _ = new Period(
+                new CalDateTime(2025, 1, 2, 0, 0, 0, "America/New_York").AsZoned(),
+                new CalDateTime(2025, 1, 1, 0, 0, 0, "America/New_York").AsZoned()));
+
+            // Duration is negative
+            Assert.Throws<ArgumentException>(() =>
+                _ = new Period(new CalDateTime(2025, 1, 1, 0, 0, 0, "America/New_York").AsZoned(), Duration.FromHours(-1)));
+
+            // Timezones are different
+            Assert.Throws<ArgumentException>(() => _ = new Period(
+                new CalDateTime(2025, 1, 2, 0, 0, 0, "America/New_York").AsZoned(),
+                new CalDateTime(2025, 1, 1, 0, 0, 0, "Europe/Vienna").AsZoned()));
+
+            // StartTime is date-only while EndTime has time
+            Assert.Throws<ArgumentException>(() => _ = new Period(new CalDateTime(2025, 1, 2, 0, 0, 0).AsZoned(),
+                new CalDateTime(2025, 1, 1).AsZoned()));
+        });
     }
 
     [Test]
@@ -82,6 +114,7 @@ public void Timezones_StartTime_EndTime_MustBeEqual()
             foreach (var p in periods)
             {
                 Assert.Throws<ArgumentException>(() => _ = new Period(p.Item1, p.Item2));
+                Assert.Throws<ArgumentException>(() => _ = new Period(p.Item1.AsZoned(), p.Item2.AsZoned()));
             }
         });
     }
@@ -100,4 +133,95 @@ public void CollidesWithPeriod()
             Assert.That(period2.CollidesWith(period3), Is.True);
         });
     }
+
+    [Test]
+    public void CreatePeriodWith_StartTime_and_Duration()
+    {
+        var dt = new CalDateTime(2025, 7, 1, 10, 0, 0, "Europe/London");
+        var periodCal = new Period(dt, Duration.FromHours(1));
+        var periodZoned = new Period(dt.AsZoned(), Duration.FromHours(1));
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(periodCal.StartTime, Is.EqualTo(dt));
+            Assert.That(periodCal.EffectiveEndTime, Is.EqualTo(new CalDateTime(2025, 7, 1, 11, 0, 0, "Europe/London")));
+            Assert.That(periodZoned.StartTime, Is.EqualTo(dt));
+            Assert.That(periodZoned.EffectiveEndTime,
+                Is.EqualTo(new CalDateTime(2025, 7, 1, 11, 0, 0, "Europe/London")));
+        });
+    }
+
+    [Test]
+    public void CreatePeriodWith_StartTime_and_EndTime()
+    {
+        var dt1 = new CalDateTime(2025, 7, 1, 10, 0, 0, "Europe/London");
+        var dt2 = new CalDateTime(2025, 7, 1, 11, 0, 0, "Europe/London");
+        var periodCal = new Period(dt1, dt2);
+        var periodZoned = new Period(dt1.AsZoned(), dt2.AsZoned());
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(periodCal.StartTime, Is.EqualTo(dt1));
+            Assert.That(periodCal.EndTime, Is.EqualTo(dt2));
+            Assert.That(periodCal.EffectiveEndTime,
+                Is.EqualTo(new CalDateTime(2025, 7, 1, 11, 0, 0, "Europe/London")));
+
+            Assert.That(periodZoned.StartTime, Is.EqualTo(dt1));
+            Assert.That(periodZoned.EndTime, Is.EqualTo(dt2));
+            Assert.That(periodZoned.EffectiveEndTime,
+                Is.EqualTo(new CalDateTime(2025, 7, 1, 11, 0, 0, "Europe/London")));
+        });
+    }
+
+    [Test]
+    public void CreatePeriodWith_StartTime_Only()
+    {
+        var dt = new CalDateTime(2025, 7, 1, 10, 0, 0, "Europe/London");
+        var periodCal = new Period(dt);
+        var periodZoned = new Period(dt.AsZoned());
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(periodCal.StartTime, Is.EqualTo(dt));
+            Assert.That(periodCal.EndTime, Is.Null);
+            Assert.That(periodCal.Duration, Is.Null);
+            Assert.That(periodCal.EffectiveEndTime, Is.Null);
+
+            Assert.That(periodZoned.StartTime, Is.EqualTo(dt));
+            Assert.That(periodZoned.EndTime, Is.Null);
+            Assert.That(periodZoned.Duration, Is.Null);
+            Assert.That(periodZoned.EffectiveEndTime, Is.Null);
+        });
+    }
+
+    [Test]
+    public void PeriodCompareToNull_ShouldReturnOne()
+    {
+        var dt = new CalDateTime(2025, 7, 1, 10, 0, 0, "Europe/London");
+        var period = new Period(dt, Duration.FromHours(1));
+
+        Assert.That(period.CompareTo(null), Is.EqualTo(1));
+    }
+
+    [Test]
+    public void PeriodCopyFrom_ShouldBeEquivalentToOriginal()
+    {
+        var original = new Period(new CalDateTime(2025, 1, 1, 0, 0, 0, "America/New_York"), Duration.FromHours(10));
+        var copy = new Period();
+        copy.CopyFrom(original);
+
+        var copyEmpty = new Period(); // internal CTOR
+        // another ICopyable instance which is not a Period
+        copyEmpty.CopyFrom(new PeriodList());
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(copy.StartTime, Is.EqualTo(original.StartTime));
+            Assert.That(copy.Duration, Is.EqualTo(original.Duration));
+
+            Assert.That(copyEmpty.StartTime, Is.Null);
+            Assert.That(copyEmpty.EndTime, Is.Null);
+            Assert.That(copyEmpty.Duration, Is.Null);
+        });
+    }
 }
diff --git a/Ical.Net.Tests/RecurrenceTests.cs b/Ical.Net.Tests/RecurrenceTests.cs
index bf53a0c7a..3e44ca58f 100644
--- a/Ical.Net.Tests/RecurrenceTests.cs
+++ b/Ical.Net.Tests/RecurrenceTests.cs
@@ -3906,7 +3906,7 @@ public void TestDtStartTimezone(string? tzId)
         var cal = Calendar.Load(icalText)!;
         var evt = cal.Events.First();
         var ev = new EventEvaluator(evt);
-        var occurrences = ev.Evaluate(evt.DtStart!, evt.DtStart!.ToTimeZone(tzId), null).TakeWhileBefore(evt.DtStart.AddMinutes(61).ToTimeZone(tzId));
+        var occurrences = ev.Evaluate(evt.DtStart!, evt.DtStart!.ToTimeZone(tzId), null).TakeWhileBefore(evt.DtStart!.AddMinutes(61).ToTimeZone(tzId));
         var occurrencesStartTimes = occurrences.Select(x => x.StartTime).Take(2).ToList();
 
         var expectedStartTimes = new[]
@@ -4031,4 +4031,37 @@ public void Disallowed_Recurrence_RangeChecks_Should_Throw()
             Assert.That(() => serializer.CheckRange("a", (int?) 0, 1, 2, false), Throws.TypeOf<ArgumentOutOfRangeException>());
         });
     }
+
+    [Test]
+    public void AmbiguousLocalTime_WithShortDurationOfRecurrence()
+    {
+        // Short recurrence falls into an ambiguous local time
+        // for the end time of the second occurrence because
+        // of DST transition on 2025-10-25 03:00
+        // See also: https://github.com/ical-org/ical.net/issues/737
+        var ics = """
+                  BEGIN:VCALENDAR
+                  BEGIN:VEVENT
+                  DTSTART;TZID=Europe/Vienna:20201024T023000
+                  DURATION:PT45M
+                  RRULE:FREQ=DAILY;UNTIL=20201025T013000Z
+                  END:VEVENT
+                  END:VCALENDAR
+                  """;
+        var cal = Calendar.Load(ics)!;
+        var occ = cal.GetOccurrences().ToList();
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(occ.Count, Is.EqualTo(2));
+
+            Assert.That(occ[0].Period.StartTime, Is.EqualTo(new CalDateTime(2020, 10, 24, 2, 30, 0, "Europe/Vienna")));
+            Assert.That(occ[0].Period.EndTime, Is.EqualTo(new CalDateTime(2020, 10, 24, 3, 15, 0, "Europe/Vienna")));
+            Assert.That(occ[0].Period.EffectiveDuration, Is.EqualTo(new Duration(0, 0, 0, 45, 0)));
+
+            Assert.That(occ[1].Period.StartTime, Is.EqualTo(new CalDateTime(2020, 10, 25, 2, 30, 0, "Europe/Vienna")));
+            Assert.That(occ[1].Period.EndTime, Is.EqualTo(new CalDateTime(2020, 10, 25, 2, 15, 0, "Europe/Vienna")));
+            Assert.That(occ[1].Period.EffectiveDuration, Is.EqualTo(new Duration(0, 0, 0, 45, 0)));
+        });
+    }
 }
diff --git a/Ical.Net.Tests/RecurrenceWithRDateTests.cs b/Ical.Net.Tests/RecurrenceWithRDateTests.cs
index fe072e982..022c4526b 100644
--- a/Ical.Net.Tests/RecurrenceWithRDateTests.cs
+++ b/Ical.Net.Tests/RecurrenceWithRDateTests.cs
@@ -9,6 +9,7 @@
 using Ical.Net.CalendarComponents;
 using Ical.Net.Collections;
 using Ical.Net.DataTypes;
+using Ical.Net.Evaluation;
 using Ical.Net.Serialization;
 using Ical.Net.Utility;
 using NUnit.Framework;
diff --git a/Ical.Net.Tests/SerializationTests.cs b/Ical.Net.Tests/SerializationTests.cs
index 5919b5a54..e376ef61f 100644
--- a/Ical.Net.Tests/SerializationTests.cs
+++ b/Ical.Net.Tests/SerializationTests.cs
@@ -12,6 +12,7 @@
 using System.Text.RegularExpressions;
 using Ical.Net.CalendarComponents;
 using Ical.Net.DataTypes;
+using Ical.Net.Evaluation;
 using Ical.Net.Serialization;
 using Ical.Net.Serialization.DataTypes;
 using Ical.Net.Utility;
diff --git a/Ical.Net/CalendarComponents/FreeBusy.cs b/Ical.Net/CalendarComponents/FreeBusy.cs
index d3d86fc84..a839bb95f 100644
--- a/Ical.Net/CalendarComponents/FreeBusy.cs
+++ b/Ical.Net/CalendarComponents/FreeBusy.cs
@@ -22,7 +22,7 @@ public class FreeBusy : UniqueComponent, IMergeable
         }
 
         var occurrences = occ.GetOccurrences<CalendarEvent>(freeBusyRequest.Start, options)
-            .TakeWhile(p => (freeBusyRequest.End == null) || (p.Period.StartTime < freeBusyRequest.End));
+            .TakeWhile(p => (freeBusyRequest.End == null) || (p.Period.Start.LessThan(freeBusyRequest.End.AsZoned())));
 
         var contacts = new List<string>();
         var isFilteredByAttendees = false;
diff --git a/Ical.Net/CalendarComponents/RecurringComponent.cs b/Ical.Net/CalendarComponents/RecurringComponent.cs
index 7c37f0cda..c89bb2072 100644
--- a/Ical.Net/CalendarComponents/RecurringComponent.cs
+++ b/Ical.Net/CalendarComponents/RecurringComponent.cs
@@ -195,5 +195,5 @@ public virtual IEnumerable<Occurrence> GetOccurrences(CalDateTime? startTime = n
     public virtual IList<AlarmOccurrence> PollAlarms() => PollAlarms(null, null);
 
     public virtual IList<AlarmOccurrence> PollAlarms(CalDateTime? startTime, CalDateTime? endTime)
-        => Alarms.SelectMany(a => a.Poll(startTime).TakeWhile(p => (endTime == null) || (p.Period?.StartTime < endTime))).ToList();
+        => Alarms.SelectMany(a => a.Poll(startTime).TakeWhile(p => (endTime == null) || (p.Period?.StartTime.AsZoned().LessThan(endTime.AsZoned()) == true))).ToList();
 }
diff --git a/Ical.Net/CalendarComponents/VTimeZone.cs b/Ical.Net/CalendarComponents/VTimeZone.cs
index b92aca88c..8532a0b07 100644
--- a/Ical.Net/CalendarComponents/VTimeZone.cs
+++ b/Ical.Net/CalendarComponents/VTimeZone.cs
@@ -11,6 +11,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using Ical.Net.Evaluation;
 
 namespace Ical.Net.CalendarComponents;
 
diff --git a/Ical.Net/CalendarExtensions.cs b/Ical.Net/CalendarExtensions.cs
index 1da2c3ae1..d97396509 100644
--- a/Ical.Net/CalendarExtensions.cs
+++ b/Ical.Net/CalendarExtensions.cs
@@ -6,6 +6,7 @@
 using System;
 using System.Globalization;
 using Ical.Net.DataTypes;
+using Ical.Net.Evaluation;
 
 namespace Ical.Net;
 
diff --git a/Ical.Net/CollectionExtensions.cs b/Ical.Net/CollectionExtensions.cs
index e2851c489..ae1d79ab8 100644
--- a/Ical.Net/CollectionExtensions.cs
+++ b/Ical.Net/CollectionExtensions.cs
@@ -31,7 +31,7 @@ public static class CollectionExtensions
     /// The elements of the sequence of occurrences to only include those that start before the specified period end.
     /// </returns>
     public static IEnumerable<Occurrence> TakeWhileBefore(this IEnumerable<Occurrence> sequence, CalDateTime periodEnd)
-        => sequence.TakeWhile(p => p.Period.StartTime < periodEnd);
+        => sequence.TakeWhile(p => p.Period.StartTime.LessThan(periodEnd));
 
     /// <summary>
     /// Returns the elements of the sequence of periods to only include those that start before the specified period end.
@@ -54,5 +54,5 @@ public static IEnumerable<Occurrence> TakeWhileBefore(this IEnumerable<Occurrenc
     /// The elements of the sequence of periods to only include those that start before the specified period end.
     /// </returns>
     public static IEnumerable<Period> TakeWhileBefore(this IEnumerable<Period> sequence, CalDateTime periodEnd)
-        => sequence.TakeWhile(p => p.StartTime < periodEnd);
+        => sequence.TakeWhile(p => p.StartTime.LessThan(periodEnd));
 }
diff --git a/Ical.Net/DataTypes/CalDateTime.cs b/Ical.Net/DataTypes/CalDateTime.cs
index f653bcd48..b3af33860 100644
--- a/Ical.Net/DataTypes/CalDateTime.cs
+++ b/Ical.Net/DataTypes/CalDateTime.cs
@@ -4,11 +4,11 @@
 //
 
 using Ical.Net.Serialization.DataTypes;
-using Ical.Net.Utility;
-using NodaTime;
 using System;
+using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using System.IO;
+using Ical.Net.Evaluation;
 
 namespace Ical.Net.DataTypes;
 
@@ -24,6 +24,8 @@ namespace Ical.Net.DataTypes;
 /// </summary>
 public sealed class CalDateTime : IComparable<CalDateTime>, IFormattable
 {
+    private const string ComparisonObsoleteMessage = "Comparison operators are depreciated. Use the timezone-aware extensions 'LessThan', 'LessThanOrEqual', `GreaterThan', 'GreaterThanOrEqual'";
+
     // The date part that is used to return the Value property.
     private DateOnly _dateOnly;
     // The time part that is used to return the Value property.
@@ -218,12 +220,11 @@ private void Initialize(DateOnly dateOnly, TimeOnly? timeOnly, string? tzId)
         };
     }
 
-    /// <inheritdoc/>
     private void CopyFrom(CalDateTime calDt)
     {
         // Maintain the private date/time backing fields
         _dateOnly = calDt._dateOnly;
-        _timeOnly = TruncateTimeToSeconds(calDt._timeOnly);
+        _timeOnly = calDt._timeOnly;
         _tzId = calDt._tzId;
     }
 
@@ -234,43 +235,42 @@ public override bool Equals(object? obj)
         => obj is CalDateTime other && this == other;
 
     /// <inheritdoc/>
-    public override int GetHashCode()
-    {
-        unchecked
-        {
-            var hashCode = Value.GetHashCode();
-            hashCode = (hashCode * 397) ^ HasTime.GetHashCode();
-            hashCode = (hashCode * 397) ^ (TzId != null ? TzId.GetHashCode() : 0);
-            return hashCode;
-        }
-    }
+    public override int GetHashCode() => HashCode.Combine(Value, HasTime, TzId);
 
+    [Obsolete(ComparisonObsoleteMessage, true)]
+    [ExcludeFromCodeCoverage]
     public static bool operator <(CalDateTime? left, CalDateTime? right)
     {
         return left != null
                && right != null
-               && ((left.IsFloating || right.IsFloating || left.TzId == right.TzId) ? left.Value < right.Value : left.AsUtc < right.AsUtc);
+               && left.LessThan(right);
     }
 
+    [Obsolete(ComparisonObsoleteMessage, true)]
+    [ExcludeFromCodeCoverage]
     public static bool operator >(CalDateTime? left, CalDateTime? right)
     {
         return left != null
                && right != null
-               && ((left.IsFloating || right.IsFloating || left.TzId == right.TzId) ? left.Value > right.Value : left.AsUtc > right.AsUtc);
+               && left.GreaterThan(right);
     }
 
+    [Obsolete(ComparisonObsoleteMessage, true)]
+    [ExcludeFromCodeCoverage]
     public static bool operator <=(CalDateTime? left, CalDateTime? right)
     {
         return left != null
                && right != null
-               && ((left.IsFloating || right.IsFloating || left.TzId == right.TzId) ? left.Value <= right.Value : left.AsUtc <= right.AsUtc);
+               && left.LessThanOrEqual(right);
     }
 
+    [Obsolete(ComparisonObsoleteMessage, true)]
+    [ExcludeFromCodeCoverage]
     public static bool operator >=(CalDateTime? left, CalDateTime? right)
     {
         return left != null
                && right != null
-               && ((left.IsFloating || right.IsFloating || left.TzId == right.TzId) ? left.Value >= right.Value : left.AsUtc >= right.AsUtc);
+               && left.GreaterThanOrEqual(right);
     }
 
     public static bool operator ==(CalDateTime? left, CalDateTime? right)
@@ -306,7 +306,9 @@ public override int GetHashCode()
     /// it means that the <see cref="Value"/> is considered as local time for every timezone:
     /// The returned <see cref="Value"/> is unchanged, but with <see cref="DateTimeKind.Utc"/>.
     /// </summary>
-    public DateTime AsUtc => DateTime.SpecifyKind(ToTimeZone(UtcTzId).Value, DateTimeKind.Utc);
+    [Obsolete("Use the timezone-ware conversion AsUtc().", true)]
+    [ExcludeFromCodeCoverage]
+    public DateTime AsUtc => this.AsUtc();
 
     /// <summary>
     /// Gets the date and time value in the ISO calendar as a <see cref="DateTime"/> type with <see cref="DateTimeKind.Unspecified"/>.
@@ -436,183 +438,8 @@ public DateTime Value
         return new TimeOnly(time.Value.Hour, time.Value.Minute, time.Value.Second);
     }
 
-    /// <summary>
-    /// Any <see cref="Time"/> values are truncated to seconds, because
-    /// RFC 5545, Section 3.3.5 does not allow for fractional seconds.
-    /// </summary>
-    private static TimeOnly? TruncateTimeToSeconds(DateTime dateTime) => new TimeOnly(dateTime.Hour, dateTime.Minute, dateTime.Second);
-
-    /// <summary>
-    /// Converts the <see cref="Value"/> to a date/time
-    /// within the specified <see paramref="otherTzId"/> timezone.
-    /// <para/>
-    /// If <see cref="IsFloating"/>==<see langword="true"/>
-    /// it means that the <see cref="Value"/> is considered as local time for every timezone:
-    /// The returned <see cref="Value"/> is unchanged and the <see paramref="otherTzId"/> is set as <see cref="TzId"/>.
-    /// </summary>
-    public CalDateTime ToTimeZone(string? otherTzId)
-    {
-        if (otherTzId is null)
-            return new CalDateTime(Value, null, HasTime);
-
-        ZonedDateTime converted;
-        if (IsFloating)
-        {
-            // Make sure, we properly fix the time if it doesn't exist in the target tz.
-            converted = DateUtil.ToZonedDateTimeLeniently(Value, otherTzId);
-        }
-        else
-        {
-            var zonedOriginal = DateUtil.ToZonedDateTimeLeniently(Value, TzId!);
-            converted = zonedOriginal.WithZone(DateUtil.GetZone(otherTzId));
-        }
-
-        return converted.Zone == DateTimeZone.Utc
-            ? new CalDateTime(converted.ToDateTimeUtc(), UtcTzId)
-            : new CalDateTime(converted.ToDateTimeUnspecified(), otherTzId);
-    }
-
-    /// <summary>
-    /// Add the specified <see cref="Duration"/> to this instance/>.
-    /// </summary>
-    /// <remarks>
-    /// In correspondence to RFC5545, the weeks and day fields of a duration are considered nominal durations while the time fields are considered exact values.
-    /// </remarks>
-    /// <exception cref="InvalidOperationException">
-    /// Thrown when attempting to add a time span to a date-only instance, 
-    /// and the time span is not a multiple of full days.
-    /// </exception>
-    public CalDateTime Add(Duration d)
-    {
-        if (!HasTime && d.HasTime)
-        {
-            throw new InvalidOperationException($"This instance represents a 'date-only' value '{ToString()}'. Only multiples of full days can be added to a 'date-only' instance, not '{d}'");
-        }
-
-        // RFC 5545 3.3.6:
-        // If the property permits, multiple "duration" values are specified by a COMMA-separated
-        // list of values.The format is based on the[ISO.8601.2004] complete representation basic
-        // format with designators for the duration of time.The format can represent nominal
-        // durations(weeks and days) and accurate durations(hours, minutes, and seconds).
-        // Note that unlike[ISO.8601.2004], this value type doesn't support the "Y" and "M"
-        // designators to specify durations in terms of years and months.
-        //
-        // The duration of a week or a day depends on its position in the calendar. In the case
-        // of discontinuities in the time scale, such as the change from standard time to daylight
-        // time and back, the computation of the exact duration requires the subtraction or
-        // addition of the change of duration of the discontinuity.Leap seconds MUST NOT be
-        // considered when computing an exact duration.When computing an exact duration, the
-        // greatest order time components MUST be added first, that is, the number of days MUST be
-        // added first, followed by the number of hours, number of minutes, and number of seconds.
-
-        (TimeSpan? nominalPart, TimeSpan? exactPart) dt;
-        if (TzId is null)
-            dt = (d.ToTimeSpanUnspecified(), null);
-        else
-            dt = (d.HasDate ? d.DateAsTimeSpan : null, d.HasTime ? d.TimeAsTimeSpan : null);
-
-        var newDateTime = this;
-        if (dt.nominalPart is not null)
-            newDateTime = new CalDateTime(newDateTime.Value.Add(dt.nominalPart.Value), TzId, HasTime);
-
-        if (dt.exactPart is not null)
-            newDateTime = new CalDateTime(newDateTime.AsUtc.Add(dt.exactPart.Value), UtcTzId, HasTime);
-        
-        if (TzId is not null)
-            // Convert to the original timezone even if already set to ensure we're not in a non-existing time.
-            newDateTime = newDateTime.ToTimeZone(TzId);
-
-        return newDateTime;
-    }
-
-    /// <summary>Returns a new <see cref="TimeSpan" /> from subtracting the specified <see cref="CalDateTime"/> from to the value of this instance.</summary>
-    /// <param name="dt"></param>
-    public TimeSpan SubtractExact(CalDateTime dt) => AsUtc - dt.AsUtc;
-
-    /// <summary>
-    /// Returns a new <see cref="Duration"/> from subtracting the specified <see cref="CalDateTime"/> from to the value of this instance.
-    /// </summary>
-    /// <param name="dt"></param>
-    /// <returns></returns>
-    /// <exception cref="InvalidOperationException"></exception>
-    public Duration Subtract(CalDateTime dt)
-    {
-        if (this.TzId is not null)
-            return SubtractExact(dt).ToDurationExact();
-
-        if (dt.HasTime != HasTime)
-            throw new InvalidOperationException($"Trying to calculate the difference between dates of different types. An instance of type DATE cannot be subtracted from a DATE-TIME and vice versa: {ToString()} - {dt.ToString()}");
-
-        return (Value - dt.Value).ToDuration();
-    }
-
     internal CalDateTime Copy()
-        => new CalDateTime(_dateOnly, _timeOnly, _tzId);
-
-    /// <inheritdoc cref="DateTime.AddYears"/>
-    public CalDateTime AddYears(int years)
-    {
-        var dt = Copy();
-        dt._dateOnly = dt._dateOnly.AddYears(years);
-        return dt;
-    }
-
-    /// <inheritdoc cref="DateTime.AddMonths"/>
-    public CalDateTime AddMonths(int months)
-    {
-        var dt = Copy();
-        dt._dateOnly = dt._dateOnly.AddMonths(months);
-        return dt;
-    }
-
-    /// <inheritdoc cref="DateTime.AddDays"/>
-    public CalDateTime AddDays(int days)
-    {
-        var dt = Copy();
-        dt._dateOnly = dt._dateOnly.AddDays(days);
-        return dt;
-    }
-
-    /// <inheritdoc cref="DateTime.AddHours"/>
-    /// <exception cref="InvalidOperationException">
-    /// Thrown when attempting to add a time span to a date-only instance, 
-    /// and the time span is not a multiple of full days.
-    /// </exception>
-    public CalDateTime AddHours(int hours) => Add(Duration.FromHours(hours));
-
-    /// <inheritdoc cref="DateTime.AddMinutes"/>
-    /// <exception cref="InvalidOperationException">
-    /// Thrown when attempting to add a time span to a date-only instance, 
-    /// and the time span is not a multiple of full days.
-    /// </exception>
-    public CalDateTime AddMinutes(int minutes) => Add(Duration.FromMinutes(minutes));
-
-    /// <inheritdoc cref="DateTime.AddSeconds"/>
-    /// <exception cref="InvalidOperationException">
-    /// Thrown when attempting to add a time span to a date-only instance, 
-    /// and the time span is not a multiple of full days.
-    /// </exception>
-    public CalDateTime AddSeconds(int seconds) => Add(Duration.FromSeconds(seconds));
-
-    /// <summary>
-    /// Returns <see langword="true"/> if the current <see cref="CalDateTime"/> instance is less than <paramref name="dt"/>.
-    /// </summary>
-    public bool LessThan(CalDateTime? dt) => this < dt;
-
-    /// <summary>
-    /// Returns <see langword="true"/> if the current <see cref="CalDateTime"/> instance is greater than <paramref name="dt"/>.
-    /// </summary>
-    public bool GreaterThan(CalDateTime? dt) => this > dt;
-
-    /// <summary>
-    /// Returns <see langword="true"/> if the current <see cref="CalDateTime"/> instance is less than or equal to <paramref name="dt"/>.
-    /// </summary>
-    public bool LessThanOrEqual(CalDateTime? dt) => this <= dt;
-
-    /// <summary>
-    /// Returns <see langword="true"/> if the current <see cref="CalDateTime"/> instance is greater than or equal to <paramref name="dt"/>.
-    /// </summary>
-    public bool GreaterThanOrEqual(CalDateTime? dt) => this >= dt;
+        => new(_dateOnly, _timeOnly, _tzId);
 
     /// <summary>
     /// Compares the current instance with another <see cref="CalDateTime"/> object and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other CalDateTime.
@@ -623,26 +450,7 @@ public CalDateTime AddDays(int days)
     /// Zero: This instance is equal to <paramref name="dt"/>.
     /// Greater than zero: This instance is greater than <paramref name="dt"/>.
     /// </returns>
-    public int CompareTo(CalDateTime? dt)
-    {
-        if (dt == null)
-        {
-            return 1;
-        }
-
-        if (Equals(dt))
-        {
-            return 0;
-        }
-
-        if (this < dt)
-        {
-            return -1;
-        }
-
-        // Meaning "this > dt"
-        return 1;
-    }
+    public int CompareTo(CalDateTime? dt) => Value.CompareTo(dt?.Value);
 
     /// <inheritdoc />
     public override string ToString() => ToString(null, null);
@@ -651,20 +459,18 @@ public int CompareTo(CalDateTime? dt)
     public string ToString(string? format) => ToString(format, null);
 
     /// <inheritdoc cref="ToString()"/>
+    /// <remarks>To format including offset<br/>
+    /// * convert with <see cref="CalDateTimeEvaluator.AsZoned"/><br/>
+    /// * and then call <see cref="CalDateTimeZoned.ToString(string?, IFormatProvider?)"/>.
+    /// </remarks>
     public string ToString(string? format, IFormatProvider? formatProvider)
     {
         formatProvider ??= CultureInfo.InvariantCulture;
-        var dateTimeOffset = DateUtil.ToZonedDateTimeLeniently(Value, _tzId ?? string.Empty).ToDateTimeOffset();
-
-        // Use the .NET format options to format the DateTimeOffset
-        var tzIdString = _tzId is not null ? $" {_tzId}" : string.Empty;
 
-        if (HasTime)
-        {
-            return $"{dateTimeOffset.ToString(format, formatProvider)}{tzIdString}";
-        }
+        var tzIdString = TzId is not null ? $" {TzId}" : string.Empty;
 
-        // No time part
-        return $"{DateOnly.FromDateTime(dateTimeOffset.Date).ToString(format ?? "d", formatProvider)}{tzIdString}";
+        return HasTime
+            ? $"{Value.ToString(format, formatProvider)}{tzIdString}"
+            : $"{Date.ToString(format ?? "d", formatProvider)}{tzIdString}";
     }
 }
diff --git a/Ical.Net/DataTypes/Duration.cs b/Ical.Net/DataTypes/Duration.cs
index 6fd3dc070..ea2d1d9da 100644
--- a/Ical.Net/DataTypes/Duration.cs
+++ b/Ical.Net/DataTypes/Duration.cs
@@ -5,6 +5,7 @@
 
 using System;
 using System.IO;
+using Ical.Net.Evaluation;
 using Ical.Net.Serialization.DataTypes;
 
 namespace Ical.Net.DataTypes;
@@ -180,7 +181,7 @@ public TimeSpan ToTimeSpanUnspecified()
     /// use <see cref="ToTimeSpan"/>.
     /// </remarks>
     public TimeSpan ToTimeSpan(CalDateTime start)
-        => start.Add(this).SubtractExact(start);
+        => start.AsZoned().Add(this).SubtractExact(start.AsZoned());
 
     /// <summary>
     /// Gets a value indicating whether the duration is zero, that is, all fields are null or 0.
diff --git a/Ical.Net/DataTypes/Period.cs b/Ical.Net/DataTypes/Period.cs
index 842880a18..933333ce3 100644
--- a/Ical.Net/DataTypes/Period.cs
+++ b/Ical.Net/DataTypes/Period.cs
@@ -4,6 +4,7 @@
 //
 
 using System;
+using Ical.Net.Evaluation;
 using Ical.Net.Serialization.DataTypes;
 
 namespace Ical.Net.DataTypes;
@@ -18,8 +19,8 @@ namespace Ical.Net.DataTypes;
 /// </summary>
 public class Period : EncodableDataType, IComparable<Period>
 {
-    private CalDateTime _startTime = null!;
-    private CalDateTime? _endTime;
+    private CalDateTimeZoned _start;
+    private CalDateTimeZoned? _end;
     private Duration? _duration;
 
     /// <summary>
@@ -53,8 +54,41 @@ internal static Period Create(CalDateTime start, CalDateTime? end = null, Durati
         return new Period(start) { AssociatedObject = associatedObject };
     }
 
-    // Needed for the serialization factory
-    internal Period() { }
+    internal Period()
+    {
+        // Needed for the serialization factory
+    }
+
+    internal Period(CalDateTimeZoned start, CalDateTimeZoned? end = null)
+    {
+        // Ensure consistent arguments
+        if (end != null && start.TzId != end.Value.TzId)
+            throw new ArgumentException($"Start time ({start}) and end time ({end}) must have the same timezone.");
+
+        if (end != null && start.HasTime != end.Value.HasTime)
+            throw new ArgumentException(
+                $"Start time ({start}) and end time ({end}) must both have a time or both be date-only.");
+
+        if (end != null && end.Value.ToTimeZone(CalDateTime.UtcTzId)
+                .LessThan(start.ToTimeZone(CalDateTime.UtcTzId)))
+            throw new ArgumentException($"End time ({end}) must be greater than start time ({start}).", nameof(end));
+
+        _start = start;
+        _end = end;
+    }
+
+    internal Period(CalDateTimeZoned start, Duration duration)
+    {
+        if (duration.Sign < 0)
+            throw new ArgumentException($"Duration ({duration}) must be greater than or equal to zero.", nameof(duration));
+
+        _start = start;
+        _duration = duration;
+    }
+
+    internal CalDateTimeZoned Start => _start;
+
+    internal CalDateTimeZoned? End => _end;
 
     /// <summary>
     /// Creates a new <see cref="Period"/> instance starting at the given time
@@ -69,6 +103,9 @@ internal Period() { }
     /// <exception cref="ArgumentNullException"></exception>
     public Period(CalDateTime start, CalDateTime? end = null)
     {
+        _start = start.AsZoned();
+        _end = end?.AsZoned();
+
         // Ensure consistent arguments
         if (end != null && start.TzId != end.TzId)
             throw new ArgumentException($"Start time ({start}) and end time ({end}) must have the same timezone.");
@@ -77,11 +114,9 @@ public Period(CalDateTime start, CalDateTime? end = null)
             throw new ArgumentException(
                 $"Start time ({start}) and end time ({end}) must both have a time or both be date-only.");
 
-        if (end != null && end.LessThan(start))
-            throw new ArgumentException($"End time ({end}) must be greater than start time ({start}).", nameof(end));
-
-        _startTime = start;
-        _endTime = end;
+        if (end != null && end.AsZoned().ToTimeZone(CalDateTime.UtcTzId)
+                .LessThan(start.AsZoned().ToTimeZone(CalDateTime.UtcTzId)))
+            throw new ArgumentException($"End time ({end}) as UTC must be greater than start time as UTC ({start}).", nameof(end));
     }
 
     /// <summary>
@@ -99,7 +134,7 @@ public Period(CalDateTime start, Duration duration)
         if (duration.Sign < 0)
             throw new ArgumentException($"Duration ({duration}) must be greater than or equal to zero.", nameof(duration));
 
-        _startTime = start;
+        _start = start.AsZoned();
         _duration = duration;
     }
 
@@ -110,12 +145,12 @@ public override void CopyFrom(ICopyable obj)
 
         if (obj is not Period p) return;
 
-        _startTime = p._startTime.Copy();
-        _endTime = p._endTime?.Copy();
+        _start = p._start;
+        _end = p._end;
         _duration = p._duration;
     }
 
-    protected bool Equals(Period other) => Equals(StartTime, other.StartTime) && Equals(EndTime, other.EndTime) && Equals(Duration, other.Duration);
+    protected bool Equals(Period other) => Equals(Start, other.Start) && Equals(End, other.End) && Equals(Duration, other.Duration);
 
     /// <inheritdoc/>
     public override bool Equals(object? obj)
@@ -147,12 +182,12 @@ public override int GetHashCode()
     /// <summary>
     /// Gets the start time of the period.
     /// </summary>
-    public virtual CalDateTime StartTime => _startTime;
+    public virtual CalDateTime StartTime => _start.CalDateTime;
 
     /// <summary>
     /// Gets the original end time that was set,
     /// </summary>
-    public virtual CalDateTime? EndTime => _endTime;
+    public virtual CalDateTime? EndTime => _end?.CalDateTime;
 
     /// <summary>
     /// Gets the end time of the period that was set, or - if this is <see langword="null"/> -
@@ -160,17 +195,20 @@ public override int GetHashCode()
     /// If <see cref="Duration"/> and <see cref="EndTime"/> are both <see langword="null"/>, the method returns <see langword="null"/>.
     /// </summary>
     public virtual CalDateTime? EffectiveEndTime
+        => EffectiveEnd?.CalDateTime;
+
+    internal CalDateTimeZoned? EffectiveEnd
     {
         get
         {
             var effectiveDuration = EffectiveDuration;
-            return _endTime switch
+
+            return _end switch
             {
                 null when _duration is null => null,
                 { } endTime => endTime,
-                _ => effectiveDuration is not null
-                    ? _startTime.Add(effectiveDuration.Value)
-                    : null
+                // When _duration is not null, effectiveDuration is guaranteed to be not null 
+                _ => _start.Add(effectiveDuration!.Value)
             };
         }
     }
@@ -188,20 +226,17 @@ public virtual CalDateTime? EffectiveEndTime
     /// </summary>
     public virtual Duration? EffectiveDuration
     {
-        get
-        {
-            return _duration switch
+        get =>
+            _duration switch
             {
-                null when _endTime is null => null,
+                null when _end is null => null,
                 { } d => d,
-                _ => _endTime is { } endTime
-                    ? endTime.Subtract(_startTime)
-                    : null
+                // _end and _start are not null
+                _ => _end.Value.Subtract(_start)
             };
-        }
     }
 
-    internal string? TzId => _startTime.TzId; // same timezone for start and end
+    internal string? TzId => _start.TzId; // same timezone for start and end
 
     internal PeriodKind PeriodKind
     {
@@ -224,18 +259,21 @@ internal PeriodKind PeriodKind
     /// </remarks>
     /// <param name="dt"></param>
     public virtual bool Contains(CalDateTime? dt)
+        => Contains(dt?.AsZoned());
+
+    internal bool Contains(CalDateTimeZoned? dt)
     {
         // Start time is inclusive
-        if (dt == null || !_startTime.LessThanOrEqual(dt))
+        if (dt == null || !_start.LessThanOrEqual(dt))
         {
             return false;
         }
 
-        var endTime = EffectiveEndTime;
+        var end = EffectiveEnd;
         // End time is exclusive
-        return endTime?.GreaterThan(dt) != false;
+        return end?.GreaterThan(dt) != false;
     }
-
+    
     /// <summary>
     /// Checks if the start time of the given period is contained within the current period
     /// or if the end time of the given period is contained within the current period.
@@ -247,10 +285,10 @@ public virtual bool Contains(CalDateTime? dt)
     /// <param name="period"></param>
     /// <returns></returns>
     public virtual bool CollidesWith(Period period)
-            => Contains(period.StartTime)
-            || period.Contains(StartTime)
-            || Contains(period.EffectiveEndTime)
-            || period.Contains(EffectiveEndTime);
+            => Contains(period.Start)
+            || period.Contains(Start)
+            || Contains(period.EffectiveEnd)
+            || period.Contains(EffectiveEnd);
 
     /// <inheritdoc/>
     public int CompareTo(Period? other)
@@ -260,16 +298,16 @@ public int CompareTo(Period? other)
             return 1;
         }
 
-        if (StartTime.AsUtc.Equals(other.StartTime.AsUtc))
+        if (Start.ToTimeZone(CalDateTime.UtcTzId).Equals(other.Start.ToTimeZone(CalDateTime.UtcTzId)))
         {
             return 0;
         }
-        if (StartTime.LessThanOrEqual(other.StartTime))
+        if (Start.LessThanOrEqual(other.Start))
         {
             return -1;
         }
 
-        // StartTime is greater than other.StartTime
+        // Start is greater than other.Start
         return 1;
     }
 }
diff --git a/Ical.Net/Evaluation/CalDateTimeEvaluator.cs b/Ical.Net/Evaluation/CalDateTimeEvaluator.cs
new file mode 100644
index 000000000..9a47abf10
--- /dev/null
+++ b/Ical.Net/Evaluation/CalDateTimeEvaluator.cs
@@ -0,0 +1,238 @@
+//
+// Copyright ical.net project maintainers and contributors.
+// Licensed under the MIT license.
+//
+
+using System;
+using System.Globalization;
+using Ical.Net.DataTypes;
+using Ical.Net.Utility;
+using NodaTime;
+
+namespace Ical.Net.Evaluation;
+
+/// <summary>
+/// Provides evaluation and utility methods for working with <see cref="CalDateTime"/>
+/// and <see cref="CalDateTimeZoned"/> objects,  including conversions between timezones,
+/// adding durations, and formatting.
+/// </summary>
+internal static class CalDateTimeEvaluator
+{
+    private static ZonedDateTime? ResolveZonedDateTime(CalDateTime calDateTime)
+    {
+        if (calDateTime.IsUtc)
+        {
+            return LocalDateTime.FromDateTime(calDateTime.Value).InZoneStrictly(DateTimeZone.Utc);
+        }
+        if (calDateTime.IsFloating)
+        {
+            return null;
+        }
+        var zone = DateUtil.GetZone(calDateTime.TzId!);
+        return DateUtil.ToZonedDateTimeLeniently(calDateTime.Value, zone.Id);
+    }
+
+    public static CalDateTimeZoned AsZoned(this CalDateTime calDateTime)
+    {
+        var zonedDateTime = ResolveZonedDateTime(calDateTime);
+        return new CalDateTimeZoned(calDateTime, zonedDateTime);
+    }
+
+    /// <summary>
+    /// Converts the <see cref="CalDateTime.Value"/> to a date/time
+    /// within the specified <see paramref="otherTzId"/> timezone.
+    /// <para/>
+    /// If <see cref="CalDateTime.IsFloating"/>==<see langword="true"/>
+    /// it means that the <see cref="CalDateTime.Value"/> is considered as local time for every timezone:
+    /// The returned <see cref="CalDateTime.Value"/> is unchanged and the <see paramref="otherTzId"/> is set as <see cref="TzId"/>.
+    /// </summary>
+    /// <param name="zoned">The CalDateTimeZoned instance.</param>
+    /// <param name="otherTzId">The target time zone ID, or null for floating.</param>
+    /// <returns>A new CalDateTime in the specified time zone.</returns>
+    public static CalDateTimeZoned ToTimeZone(this CalDateTimeZoned zoned, string? otherTzId)
+    {
+        if (otherTzId is null)
+            return new CalDateTimeZoned(new CalDateTime(zoned.CalDateTime.Value, null, zoned.CalDateTime.HasTime), null);
+
+        ZonedDateTime converted;
+        if (zoned.IsFloating)
+        {
+            // Make sure, we properly fix the time if it doesn't exist in the target tz.
+            converted = DateUtil.ToZonedDateTimeLeniently(zoned.Value, otherTzId);
+        }
+        else
+        {
+            converted = otherTzId != zoned.TzId
+                ? zoned.ZonedDateTime!.Value.WithZone(DateUtil.GetZone(otherTzId))
+                : zoned.ZonedDateTime!.Value;
+        }
+        var convCalDt = new CalDateTime(converted.ToDateTimeUnspecified(), otherTzId, zoned.CalDateTime.HasTime);
+        
+        return new CalDateTimeZoned(convCalDt, converted);
+    }
+
+    /// <summary>
+    /// Converts the specified <see cref="CalDateTimeZoned"/> instance to UTC timezone.
+    /// </summary>
+    /// <param name="zoned">The <see cref="CalDateTimeZoned"/> instance to convert.</param>
+    /// <returns>A new <see cref="CalDateTimeZoned"/> instance representing the same date and time in UTC.</returns>
+    public static CalDateTimeZoned ToUtc(this CalDateTimeZoned zoned)
+        => ToTimeZone(zoned, CalDateTime.UtcTzId);
+
+    /// <summary>
+    /// Add the specified <see cref="DataTypes.Duration"/> to this instance/>.
+    /// </summary>
+    /// <remarks>
+    /// In correspondence to RFC5545, the weeks and day fields of a duration are considered nominal durations while the time fields are considered exact values.
+    /// </remarks>
+    /// <exception cref="InvalidOperationException">
+    /// Thrown when attempting to add a time span to a date-only instance, 
+    /// and the time span is not a multiple of full days.
+    /// </exception>
+    public static CalDateTimeZoned Add(this CalDateTimeZoned zoned, DataTypes.Duration d)
+    {
+        if (!zoned.HasTime && d.HasTime)
+        {
+            throw new InvalidOperationException($"This instance represents a 'date-only' value '{zoned.ToString()}'. Only multiples of full days can be added to a 'date-only' instance, not '{d}'");
+        }
+
+        // RFC 5545 3.3.6:
+        // If the property permits, multiple "duration" values are specified by a COMMA-separated
+        // list of values.The format is based on the[ISO.8601.2004] complete representation basic
+        // format with designators for the duration of time.The format can represent nominal
+        // durations(weeks and days) and accurate durations(hours, minutes, and seconds).
+        // Note that unlike[ISO.8601.2004], this value type doesn't support the "Y" and "M"
+        // designators to specify durations in terms of years and months.
+        //
+        // The duration of a week or a day depends on its position in the calendar. In the case
+        // of discontinuities in the timescale, such as the change from standard time to daylight
+        // time and back, the computation of the exact duration requires the subtraction or
+        // addition of the change of duration of the discontinuity.Leap seconds MUST NOT be
+        // considered when computing an exact duration.When computing an exact duration, the
+        // greatest order time components MUST be added first, that is, the number of days MUST be
+        // added first, followed by the number of hours, number of minutes, and number of seconds.
+
+        (TimeSpan? nominalPart, TimeSpan? exactPart) dt;
+        if (zoned.TzId is null)
+            dt = (d.ToTimeSpanUnspecified(), null);
+        else
+            dt = (d.HasDate ? d.DateAsTimeSpan : null, d.HasTime ? d.TimeAsTimeSpan : null);
+
+        var newDateTime = zoned.CalDateTime;
+        var newZoned = zoned;
+        if (dt.nominalPart is not null)
+            newDateTime = new CalDateTime(newDateTime.Value.Add(dt.nominalPart.Value), zoned.TzId, zoned.HasTime);
+        
+        if (dt.exactPart is not null)
+        {
+            var utcZoned = new CalDateTimeZoned(newDateTime, ResolveZonedDateTime(newDateTime)).ToUtc();
+            newDateTime = new CalDateTime(utcZoned.CalDateTime.Value.Add(dt.exactPart.Value), CalDateTime.UtcTzId, utcZoned.HasTime);
+            utcZoned = new CalDateTimeZoned(newDateTime, ResolveZonedDateTime(newDateTime));
+            if (zoned.TzId is not null)
+                return utcZoned.ToTimeZone(zoned.TzId);
+        }
+
+        if (zoned.TzId is not null)
+        {
+            // Convert to the original timezone even if already set to ensure we're not in a non-existing time.
+            newZoned = new CalDateTimeZoned(newDateTime, ResolveZonedDateTime(newDateTime)).ToTimeZone(zoned.TzId);
+            newDateTime = newZoned.CalDateTime;
+        }
+
+        return new CalDateTimeZoned(newDateTime, newZoned.ZonedDateTime);
+    }
+
+    /// <summary>
+    /// Returns a new <see cref="TimeSpan" /> from subtracting the specified <see cref="CalDateTime"/> from
+    /// the value of this instance.</summary>
+    public static TimeSpan SubtractExact(this CalDateTimeZoned zoned, CalDateTimeZoned other)
+        => zoned.ToTimeZone(CalDateTime.UtcTzId).Utc!.Value - other.ToTimeZone(CalDateTime.UtcTzId).Utc!.Value;
+
+    /// <summary>
+    /// Returns a new <see cref="DataTypes.Duration"/> from
+    /// subtracting the specified <see cref="CalDateTime"/>
+    /// from the value of this instance.
+    /// </summary>
+    /// <exception cref="InvalidOperationException"></exception>
+    public static DataTypes.Duration Subtract(this CalDateTimeZoned zoned, CalDateTimeZoned other)
+    {
+        if (zoned.HasZone)
+            return SubtractExact(zoned, other).ToDurationExact();
+
+        if (zoned.HasTime != other.HasTime)
+            throw new InvalidOperationException($"Trying to calculate the difference between dates of different types. An instance of type DATE cannot be subtracted from a DATE-TIME and vice versa: {zoned.ToString()} - {other.ToString()}");
+
+        return DateUtil.ToDuration((zoned.Value - other.Value));
+    }
+
+    /// <summary>
+    /// Returns a new instance that adds the specified number
+    /// of years to the value of this instance.
+    /// </summary>
+    public static CalDateTimeZoned AddYears(this CalDateTimeZoned zoned, int years)
+        => new CalDateTime(zoned.CalDateTime.Value.AddYears(years), zoned.TzId, zoned.HasTime).AsZoned();
+
+    /// <summary>
+    /// Returns a new instance that adds the specified number
+    /// of months to the value of this instance.
+    /// </summary>
+    public static CalDateTimeZoned AddMonths(this CalDateTimeZoned zoned, int months)
+        => new CalDateTime(zoned.CalDateTime.Value.AddMonths(months), zoned.TzId, zoned.HasTime).AsZoned();
+
+    /// <summary>
+    /// Returns a new instance that adds the specified number
+    /// of days to the value of this instance.
+    /// </summary>
+    public static CalDateTimeZoned AddDays(this CalDateTimeZoned zoned, int days)
+        => new CalDateTime(zoned.CalDateTime.Value.AddDays(days), zoned.TzId, zoned.HasTime).AsZoned();
+
+    /// <summary>
+    /// Returns a new instance that adds the specified number
+    /// of hours to the value of this instance.
+    /// </summary>
+    /// <exception cref="InvalidOperationException">
+    /// Throws when attempting to add a time span to a date-only instance.
+    /// </exception>
+    public static CalDateTimeZoned AddHours(this CalDateTimeZoned zoned, int hours)
+        => zoned.Add(DataTypes.Duration.FromHours(hours));
+
+    /// <summary>
+    /// Returns a new instance that adds the specified number
+    /// of minutes to the value of this instance.
+    /// </summary>
+    /// <exception cref="InvalidOperationException">
+    /// Throws when attempting to add a time span to a date-only instance, 
+    /// and the time span is not a multiple of full days.
+    /// </exception>
+    public static CalDateTimeZoned AddMinutes(this CalDateTimeZoned zoned, int minutes)
+        => zoned.Add(DataTypes.Duration.FromMinutes(minutes));
+
+    /// <summary>
+    /// Returns a new instance that adds the specified number
+    /// of seconds to the value of this instance.
+    /// </summary>
+    /// <exception cref="InvalidOperationException">
+    /// Throws when attempting to add a time span to a date-only instance, 
+    /// and the time span is not a multiple of full days.
+    /// </exception>
+    public static CalDateTimeZoned AddSeconds(this CalDateTimeZoned zoned, int seconds)
+        => zoned.Add(DataTypes.Duration.FromSeconds(seconds));
+
+    /// <summary>
+    /// Returns a string that includes the date and time with the timezone identifier,
+    /// formatted according to the specified format and culture information.
+    /// </summary>
+    public static string ToString(this CalDateTimeZoned zoned, string? format, IFormatProvider? formatProvider)
+    {
+        formatProvider ??= CultureInfo.InvariantCulture;
+        var dateTimeOffset = zoned.ZonedDateTime?.ToDateTimeOffset()
+            ?? new DateTimeOffset(zoned.CalDateTime.Value);
+
+        // Use the .NET format options to format the DateTimeOffset
+        var tzIdString = zoned.TzId is not null ? $" {zoned.TzId}" : string.Empty;
+
+        return zoned.HasTime
+            ? $"{dateTimeOffset.ToString(format, formatProvider)}{tzIdString}"
+            : $"{DateOnly.FromDateTime(dateTimeOffset.Date).ToString(format ?? "d", formatProvider)}{tzIdString}";
+    }
+}
diff --git a/Ical.Net/Evaluation/CalDateTimeExtensions.cs b/Ical.Net/Evaluation/CalDateTimeExtensions.cs
new file mode 100644
index 000000000..51aeae063
--- /dev/null
+++ b/Ical.Net/Evaluation/CalDateTimeExtensions.cs
@@ -0,0 +1,143 @@
+//
+// Copyright ical.net project maintainers and contributors.
+// Licensed under the MIT license.
+//
+
+using System;
+using Ical.Net.DataTypes;
+
+namespace Ical.Net.Evaluation;
+
+/// <summary>
+/// This class belongs to the evaluation layer of the library.
+/// It provides extension methods for the <see cref="CalDateTime"/> class
+/// </summary>
+public static class CalDateTimeExtensions
+{
+    /// <summary>
+    /// Converts the <see cref="CalDateTime"/> to the UTC timezone.
+    /// If <see cref="CalDateTime.IsFloating"/>==<see langword="true"/>
+    /// it means that the <see cref="CalDateTime.Value"/> is considered as local time for every timezone:
+    /// The returned <see cref="CalDateTime.Value"/> is unchanged, but with <see cref="DateTimeKind.Utc"/>.
+    /// </summary>
+    public static DateTime AsUtc(this CalDateTime calDateTime)
+        => calDateTime.AsZoned().ToTimeZone(CalDateTime.UtcTzId).Utc!.Value;
+
+    /// <summary>
+    /// Converts the <see cref="CalDateTime.Value"/> to a date/time
+    /// within the specified <see paramref="otherTzId"/> timezone.
+    /// <para/>
+    /// If <see cref="CalDateTime.IsFloating"/>==<see langword="true"/>
+    /// it means that the <see cref="CalDateTime.Value"/> is considered as local time for every timezone:
+    /// The returned <see cref="CalDateTime.Value"/> is unchanged and the <see paramref="otherTzId"/> is set as <see cref="TzId"/>.
+    /// </summary>
+    /// <param name="calDateTime">The CalDateTime instance.</param>
+    /// <param name="otherTzId">The target time zone ID, or null for floating.</param>
+    /// <returns>A new CalDateTime in the specified time zone.</returns>
+    public static CalDateTime ToTimeZone(this CalDateTime calDateTime, string? otherTzId)
+        => calDateTime.AsZoned().ToTimeZone(otherTzId).CalDateTime;
+
+    /// <summary>
+    /// Add the specified <see cref="DataTypes.Duration"/> to this instance (timezone-aware)./>.
+    /// </summary>
+    /// <remarks>
+    /// In correspondence to RFC5545, the weeks and day fields of a duration are considered nominal durations while the time fields are considered exact values.
+    /// </remarks>
+    /// <exception cref="InvalidOperationException">
+    /// Thrown when attempting to add a time span to a date-only instance, 
+    /// and the time span is not a multiple of full days.
+    /// </exception>
+    public static CalDateTime Add(this CalDateTime calDateTime, Duration d)
+        => calDateTime.AsZoned().Add(d).CalDateTime;
+
+    /// <summary>
+    /// Returns a new <see cref="TimeSpan" /> from subtracting the specified <see cref="CalDateTime"/>
+    /// from the value of this instance (timezone-aware).</summary>
+    public static TimeSpan SubtractExact(this CalDateTime dt, CalDateTime other)
+        => dt.AsZoned().ToTimeZone(CalDateTime.UtcTzId).Utc!.Value - other.AsZoned().ToTimeZone(CalDateTime.UtcTzId).Utc!.Value;
+
+    /// <summary>
+    /// Returns a new <see cref="DataTypes.Duration"/> from subtracting the specified <see cref="CalDateTime"/>
+    /// from the value of this instance (timezone-aware).
+    /// </summary>
+    /// <exception cref="InvalidOperationException"></exception>
+    public static Duration Subtract(this CalDateTime dt, CalDateTime other)
+        => dt.AsZoned().Subtract(other.AsZoned());
+
+    /// <summary>
+    /// Returns a new instance that adds the specified number
+    /// of years to the value of this instance.
+    /// </summary>
+    public static CalDateTime AddYears(this CalDateTime dt, int years)
+        => dt.AsZoned().AddYears(years).CalDateTime;
+
+    /// <summary>
+    /// Returns a new instance that adds the specified number
+    /// of months to the value of this instance.
+    /// </summary>
+    public static CalDateTime AddMonths(this CalDateTime dt, int months)
+        => dt.AsZoned().AddMonths(months).CalDateTime;
+
+    /// <summary>
+    /// Returns a new instance that adds the specified number
+    /// of days to the value of this instance.
+    /// </summary>
+    public static CalDateTime AddDays(this CalDateTime dt, int days)
+        => dt.AsZoned().AddDays(days).CalDateTime;
+
+    /// <summary>
+    /// Returns a new instance that adds the specified number
+    /// of hours to the value of this instance (timezone-aware).
+    /// </summary>
+    /// <exception cref="InvalidOperationException">
+    /// Throws when attempting to add a time span to a date-only instance.
+    /// </exception>
+    public static CalDateTime AddHours(this CalDateTime dt, int hours)
+        => dt.AsZoned().AddHours(hours).CalDateTime;
+
+    /// <summary>
+    /// Returns a new instance that adds the specified number
+    /// of minutes to the value of this instance (timezone-aware).
+    /// </summary>
+    /// <exception cref="InvalidOperationException">
+    /// Throws when attempting to add a time span to a date-only instance, 
+    /// and the time span is not a multiple of full days.
+    /// </exception>
+    public static CalDateTime AddMinutes(this CalDateTime dt, int minutes)
+        => dt.AsZoned().AddMinutes(minutes).CalDateTime;
+
+    /// <summary>
+    /// Returns a new instance that adds the specified number
+    /// of seconds to the value of this instance (timezone-aware).
+    /// </summary>
+    /// <exception cref="InvalidOperationException">
+    /// Throws when attempting to add a time span to a date-only instance, 
+    /// and the time span is not a multiple of full days.
+    /// </exception>
+    public static CalDateTime AddSeconds(this CalDateTime dt, int seconds)
+        => dt.AsZoned().AddSeconds(seconds).CalDateTime;
+
+    /// <summary>
+    /// Returns <see langword="true"/> if the current <see cref="CalDateTime"/>
+    /// instance is less than <paramref name="dt"/> (timezone-aware).
+    /// </summary>
+    public static bool LessThan(this CalDateTime dt, CalDateTime? other) => dt.AsZoned().LessThan(other?.AsZoned());
+
+    /// <summary>
+    /// Returns <see langword="true"/> if the current <see cref="CalDateTime"/>
+    /// instance is greater than <paramref name="dt"/> (timezone-aware).
+    /// </summary>
+    public static bool GreaterThan(this CalDateTime dt, CalDateTime? other) => dt.AsZoned().GreaterThan(other?.AsZoned());
+
+    /// <summary>
+    /// Returns <see langword="true"/> if the current <see cref="CalDateTime"/>
+    /// instance is less than or equal to <paramref name="dt"/> (timezone-aware).
+    /// </summary>
+    public static bool LessThanOrEqual(this CalDateTime dt, CalDateTime? other) => dt.AsZoned().LessThanOrEqual(other?.AsZoned());
+
+    /// <summary>
+    /// Returns <see langword="true"/> if the current <see cref="CalDateTime"/>
+    /// instance is greater than or equal to <paramref name="dt"/> (timezone-aware).
+    /// </summary>
+    public static bool GreaterThanOrEqual(this CalDateTime dt, CalDateTime? other) => dt.AsZoned().GreaterThanOrEqual(other?.AsZoned());
+}
diff --git a/Ical.Net/Evaluation/CalDateTimeZoned.cs b/Ical.Net/Evaluation/CalDateTimeZoned.cs
new file mode 100644
index 000000000..aef905908
--- /dev/null
+++ b/Ical.Net/Evaluation/CalDateTimeZoned.cs
@@ -0,0 +1,229 @@
+//
+// Copyright ical.net project maintainers and contributors.
+// Licensed under the MIT license.
+//
+
+using System;
+using Ical.Net.DataTypes;
+using NodaTime;
+
+namespace Ical.Net.Evaluation;
+
+/// <summary>
+/// A <see cref="CalDateTime"/> and its evaluated timezone representation.
+/// The timezone-specific members can be used only if <see cref="DataTypes.CalDateTime"/>
+/// can be evaluated to timezone information.
+/// Test for <see cref="HasZone"/> to determine if the timezone information is available.
+/// </summary>
+internal readonly struct CalDateTimeZoned : IEquatable<CalDateTimeZoned?>, IComparable<CalDateTimeZoned>, IFormattable
+{
+    public CalDateTimeZoned(CalDateTime calDateTime, ZonedDateTime? zonedDateTime)
+    {
+        CalDateTime = calDateTime;
+        ZonedDateTime = zonedDateTime;
+    }
+
+    /// <summary>
+    /// Gets the iCalendar date and time associated with the current instance.
+    /// </summary>
+    public CalDateTime CalDateTime { get; }
+
+    /// <summary>
+    /// Gets the date and time information, including the time zone, for the current context.
+    /// It is <see langword="null"/> if the <see cref="CalDateTime.TzId"/> is <see langword="null"/>.
+    /// </summary>
+    internal ZonedDateTime? ZonedDateTime { get; }
+
+    /// <summary>
+    /// Gets the current <see cref="CalDateTime.Value"/>.
+    /// </summary>
+    public DateTime Value => CalDateTime.Value;
+
+    /// <summary>
+    /// Gets the UTC representation of the current date and time.
+    /// </summary>
+    /// <remarks>This property retrieves the UTC equivalent of the date and time stored in the
+    /// timezone information. If <see cref="HasZone"/> is <see langword="false"/>, this property will
+    /// return <see langword="null"/>.
+    /// </remarks>
+    public DateTime? Utc => ZonedDateTime?.ToDateTimeUtc();
+
+    /// <summary>
+    /// Gets the time offset from UTC for the current timezone.
+    /// </summary>
+    /// <remarks>This property retrieves the <c>Offset</c> of the date and time stored in the
+    /// in timezone information. If <see cref="HasZone"/> is <see langword="false"/>,
+    /// this property will return <see cref="TimeSpan.Zero"/>.
+    /// </remarks>
+    public TimeSpan Offset => ZonedDateTime?.Offset.ToTimeSpan() ?? TimeSpan.Zero;
+
+    /// <summary>
+    /// Gets the identifier of the time zone associated with the calendar date and time.
+    /// </summary>
+    public string? TzId => CalDateTime.TzId;
+
+    /// <summary>
+    /// Gets a value indicating whether the associated date-time includes a time component.
+    /// </summary>
+    public bool HasTime => CalDateTime.HasTime;
+
+    /// <summary>
+    /// Gets a value indicating whether the current instance has an associated time zone.
+    /// </summary>
+    public bool HasZone => ZonedDateTime is not null;
+
+    /// <summary>
+    /// Gets a value indicating whether the associated calendar date and time is floating.
+    /// </summary>
+    public bool IsFloating => CalDateTime.IsFloating;
+
+    /// <inheritdoc/>
+    public override string ToString() => ToString(null, null);
+
+    /// <summary>
+    /// Returns a string that includes the date and time with the timezone identifier,
+    /// formatted according to the specified format and culture information.
+    /// </summary>
+    public string ToString(string? format, IFormatProvider? formatProvider)
+        => CalDateTimeEvaluator.ToString(this, format, formatProvider);
+
+    #region *** Equality ***
+
+    /// <inheritdoc/>
+    public bool Equals(CalDateTimeZoned? other)
+    {
+        return CalDateTime.Equals(other?.CalDateTime) &&
+               ZonedDateTime.Equals(other?.ZonedDateTime);
+    }
+
+    /// <inheritdoc/>
+    public override bool Equals(object? obj)
+        => obj is CalDateTimeZoned other && Equals(other);
+
+    /// <inheritdoc/>
+    public override int GetHashCode()
+        => HashCode.Combine(CalDateTime, ZonedDateTime);
+
+    #endregion
+
+    #region *** Comparison ***
+
+    /// <inheritdoc/>
+    public int CompareTo(CalDateTimeZoned other)
+    {
+        if (Utc.HasValue && other.Utc.HasValue)
+        {
+            return Utc.Value.CompareTo(other.Utc.Value);
+        }
+
+        throw new InvalidOperationException("Cannot compare instances without timezone as UTC.");
+    }
+
+    /// <summary>
+    /// Determines whether the current instance represents a point
+    /// in time earlier than the specified <see cref="CalDateTimeZoned"/>.
+    /// </summary>
+    public bool LessThan(CalDateTimeZoned? zoned)
+    {
+        if (!zoned.HasValue) return false;
+
+        var self = CalDateTime;
+        var other = zoned.Value.CalDateTime;
+
+        // CalDateTime.Floating has no timezone information, so we compare the values
+        return
+            (self.IsFloating || other.IsFloating || self.TzId == other.TzId)
+                ? self.Value < other.Value
+                : Utc!.Value < zoned.Value.Utc!.Value; // Both have timezones, so UTC is not null
+    }
+
+    /// <summary>
+    /// Determines whether the current instance represents a point
+    /// in time earlier than or equal to the specified <see cref="CalDateTimeZoned"/>.
+    /// </summary>
+    public bool LessThanOrEqual(CalDateTimeZoned? zoned)
+    {
+        if (!zoned.HasValue) return false;
+
+        var self = CalDateTime;
+        var other = zoned.Value.CalDateTime;
+
+        // CalDateTime.Floating has no timezone information, so we compare the values
+        return
+            (self.IsFloating || other.IsFloating || self.TzId == other.TzId)
+                ? self.Value <= other.Value
+                : Utc!.Value <= zoned.Value.Utc!.Value; // Both have timezones, so UTC is not null
+    }
+
+    /// <summary>
+    /// Determines whether the current instance represents a point
+    /// in time later than the specified <see cref="CalDateTimeZoned"/>.
+    /// </summary>
+    public bool GreaterThan(CalDateTimeZoned? zoned)
+    {
+        if (!zoned.HasValue) return false;
+
+        var self = CalDateTime;
+        var other = zoned.Value.CalDateTime;
+
+        // CalDateTime.Floating has no timezone information, so we compare the values
+        return
+            (self.IsFloating || other.IsFloating || self.TzId == other.TzId)
+                ? self.Value > other.Value
+                : Utc!.Value > zoned.Value.Utc!.Value; // Both have timezones, so UTC is not null
+    }
+
+    /// <summary>
+    /// Determines whether the current instance represents a point
+    /// in time later than or equal to the specified <see cref="CalDateTimeZoned"/>.
+    /// </summary>
+    public bool GreaterThanOrEqual(CalDateTimeZoned? zoned)
+    {
+        if (!zoned.HasValue) return false;
+
+        var self = CalDateTime;
+        var other = zoned.Value.CalDateTime;
+
+        // CalDateTime.Floating has no timezone information, so we compare the values
+        return
+            (self.IsFloating || other.IsFloating || self.TzId == other.TzId)
+                ? self.Value >= other.Value
+                : Utc!.Value >= zoned.Value.Utc!.Value; // Both have timezones, so UTC is not null
+    }
+
+    #endregion
+
+    #region *** Operators ***
+
+    public static bool operator ==(CalDateTimeZoned? left, CalDateTimeZoned? right)
+    {
+        return left?.Equals(right) == true;
+    }
+
+    public static bool operator !=(CalDateTimeZoned? left, CalDateTimeZoned? right)
+    {
+        return !left.Equals(right);
+    }
+
+    public static bool operator <(CalDateTimeZoned? left, CalDateTimeZoned? right)
+    {
+        return left?.LessThan(right) == true;
+    }
+
+    public static bool operator <=(CalDateTimeZoned? left, CalDateTimeZoned? right)
+    {
+        return left?.LessThanOrEqual(right) == true;
+    }
+
+    public static bool operator >(CalDateTimeZoned? left, CalDateTimeZoned? right)
+    {
+        return left?.GreaterThan(right) == true;
+    }
+
+    public static bool operator >=(CalDateTimeZoned? left, CalDateTimeZoned? right)
+    {
+        return left?.GreaterThanOrEqual(right) == true;
+    }
+
+    #endregion
+}
diff --git a/Ical.Net/Evaluation/EventEvaluator.cs b/Ical.Net/Evaluation/EventEvaluator.cs
index 193c9771e..28cfa1b26 100644
--- a/Ical.Net/Evaluation/EventEvaluator.cs
+++ b/Ical.Net/Evaluation/EventEvaluator.cs
@@ -68,16 +68,17 @@ and it may differ from the time span added to the period start time.
              */
             var tsToAdd = CalendarEvent.EffectiveDuration;
 
-            CalDateTime endTime;
+            CalDateTimeZoned endTime;
             if (tsToAdd.IsZero)
             {
                 // For a zero-duration event, the end time is the same as the start time.
-                endTime = period.StartTime;
+                endTime = period.Start;
             }
             else
             {
-                // Calculate the end time of the event as a DateTime
-                var endDt = period.StartTime.Add(tsToAdd);
+                // Calculate the end time of the event
+                // Note: endDt could be in a different DST than period.StartTime
+                var endDt = period.Start.Add(tsToAdd);
                 if ((CalendarEvent.End is { } end) && (end.TzId != period.StartTime.TzId) && (end.TzId is { } tzid))
                 {
                     // Ensure the end time has the same timezone as the event end time.
@@ -94,10 +95,10 @@ and it may differ from the time span added to the period start time.
             // and has priority over the calculated end time.
 
             return new Period(
-                start: period.StartTime,
-                end: period.Duration == null
+                start: period.Start,
+                end: period.Duration is null
                     ? endTime
-                    : period.EffectiveEndTime);
+                    : period.EffectiveEndTime!.AsZoned());
         }
         catch (ArgumentOutOfRangeException)
         {
diff --git a/Ical.Net/Evaluation/RecurrencePatternEvaluator.cs b/Ical.Net/Evaluation/RecurrencePatternEvaluator.cs
index a0e286a04..b0e265994 100644
--- a/Ical.Net/Evaluation/RecurrencePatternEvaluator.cs
+++ b/Ical.Net/Evaluation/RecurrencePatternEvaluator.cs
@@ -135,7 +135,7 @@ private IEnumerable<CalDateTime> GetDates(CalDateTime seed, CalDateTime? periodS
         if (pattern.Count is null)
         {
             var incremented = seedCopy;
-            while (incremented < periodStartDt)
+            while (incremented.LessThan(periodStartDt))
             {
                 seedCopy = incremented;
                 IncrementDate(ref incremented, pattern, pattern.Interval);
@@ -163,12 +163,12 @@ private IEnumerable<CalDateTime> EnumerateDates(CalDateTime originalDate, CalDat
         var dateCount = 0;
         while (true)
         {
-            if (searchEndDate < GetIntervalLowerLimit(intervalRefTime, pattern))
+            if (searchEndDate?.LessThan(GetIntervalLowerLimit(intervalRefTime, pattern)) == true)
                 break;
 
             var candidates = GetCandidates(intervalRefTime, pattern, expandBehavior);
 
-            foreach (var t in candidates.Where(t => t >= originalDate))
+            foreach (var t in candidates.Where(t => t.GreaterThanOrEqual(originalDate)))
             {
                 noCandidateIncrementCount = 0;
                 var candidate = t;
@@ -773,7 +773,7 @@ public override IEnumerable<Period> Evaluate(CalDateTime referenceDate, CalDateT
             .Select(dt => CreatePeriod(dt, referenceDate));
 
         if (pattern.Until is not null)
-            periodQuery = periodQuery.TakeWhile(p => p.StartTime <= pattern.Until);
+            periodQuery = periodQuery.TakeWhile(p => p.StartTime.LessThanOrEqual(pattern.Until));
 
         return periodQuery;
     }
diff --git a/Ical.Net/Evaluation/TodoEvaluator.cs b/Ical.Net/Evaluation/TodoEvaluator.cs
index 022bc29cb..b8d055212 100644
--- a/Ical.Net/Evaluation/TodoEvaluator.cs
+++ b/Ical.Net/Evaluation/TodoEvaluator.cs
@@ -46,7 +46,7 @@ internal IEnumerable<Period> EvaluateToPreviousOccurrence(CalDateTime completedD
         }
 
         return Evaluate(Todo.Start, beginningDate, options)
-            .Where(p => p.StartTime <= currDt);
+            .Where(p => p.StartTime.AsZoned().LessThanOrEqual(currDt.AsZoned()));
     }
 
     private static void DetermineStartingRecurrence(IEnumerable<Period> rdate, ref CalDateTime referenceDateTime)
diff --git a/Ical.Net/Ical.Net.csproj b/Ical.Net/Ical.Net.csproj
index 08627e3e7..02942d210 100644
--- a/Ical.Net/Ical.Net.csproj
+++ b/Ical.Net/Ical.Net.csproj
@@ -12,6 +12,7 @@
     </ItemGroup>
     <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0' OR '$(TargetFramework)' == 'netstandard2.1'">
         <PackageReference Include="Portable.System.DateTimeOnly" Version="8.0.1" />
+        <PackageReference Include="Microsoft.Bcl.HashCode" Version="6.0.0" />
     </ItemGroup>
     <ItemGroup>
         <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleToAttribute">
diff --git a/Ical.Net/Utility/DateUtil.cs b/Ical.Net/Utility/DateUtil.cs
index e961aa4f0..d49722fb5 100644
--- a/Ical.Net/Utility/DateUtil.cs
+++ b/Ical.Net/Utility/DateUtil.cs
@@ -5,6 +5,7 @@
 
 using System;
 using Ical.Net.DataTypes;
+using Ical.Net.Evaluation;
 using NodaTime;
 
 namespace Ical.Net.Utility;
@@ -80,7 +81,7 @@ public static ZonedDateTime ToZonedDateTimeLeniently(DateTime dateTime, string t
         // Thus, TZID=America/New_York:20070311T023000 indicates March 11,
         // 2007 at 3:30 A.M. EDT (UTC-04:00), one hour after 1:30 A.M. EST
         // (UTC-05:00).
-        var lenientZonedDateTime = localDt.InZoneLeniently(zone).WithZone(zone);
+        var lenientZonedDateTime = localDt.InZoneLeniently(zone);
 
         return lenientZonedDateTime;
     }