[API Implementation]: Use TimeSpan everywhere we use an int for seconds, milliseconds, and timeouts (Group 1/3)

src/coreclr/System.Private.CoreLib/src/System/GC.cs

@@ -16,6 +16,7 @@
 using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using System.Threading;
 
 namespace System
 {
@@ -423,6 +424,8 @@ public static GCNotificationStatus WaitForFullGCApproach(int millisecondsTimeout
             return (GCNotificationStatus)_WaitForFullGCApproach(millisecondsTimeout);
         }
 
+        public static GCNotificationStatus WaitForFullGCApproach(TimeSpan timeout) => WaitForFullGCApproach(WaitHandle.ToTimeoutMilliseconds(timeout));
+
         public static GCNotificationStatus WaitForFullGCComplete()
         {
             return (GCNotificationStatus)_WaitForFullGCComplete(-1);
@@ -435,6 +438,8 @@ public static GCNotificationStatus WaitForFullGCComplete(int millisecondsTimeout
             return (GCNotificationStatus)_WaitForFullGCComplete(millisecondsTimeout);
         }
 
+        public static GCNotificationStatus WaitForFullGCComplete(TimeSpan timeout) => WaitForFullGCComplete(WaitHandle.ToTimeoutMilliseconds(timeout));
+
         private enum StartNoGCRegionStatus
         {
             Succeeded = 0,

src/coreclr/nativeaot/System.Private.CoreLib/src/System/GC.cs

@@ -215,6 +215,14 @@ public static GCNotificationStatus WaitForFullGCApproach(int millisecondsTimeout
             return (GCNotificationStatus)RuntimeImports.RhWaitForFullGCApproach(millisecondsTimeout);
         }
 
+        /// <summary>
+        /// Returns, in a specified time-out period, the status of a registered notification for determining whether a full,
+        /// blocking garbage collection by the common language runtime is imminent.
+        /// </summary>
+        /// <param name="timeout">The timeout on waiting for a full collection</param>
+        /// <returns>The status of a registered full GC notification</returns>
+        public static GCNotificationStatus WaitForFullGCApproach(TimeSpan timeout) => WaitForFullGCApproach(WaitHandle.ToTimeoutMilliseconds(timeout));
+
         /// <summary>
         /// Returns the status of a registered notification about whether a blocking garbage collection
         /// has completed. May wait indefinitely for a full collection.
@@ -243,6 +251,14 @@ public static GCNotificationStatus WaitForFullGCComplete(int millisecondsTimeout
             return (GCNotificationStatus)RuntimeImports.RhWaitForFullGCComplete(millisecondsTimeout);
         }
 
+        /// <summary>
+        /// Returns, in a specified time-out period, the status of a registered notification for determining whether a full,
+        /// blocking garbage collection by common language the runtime has completed.
+        /// </summary>
+        /// <param name="timeout">The timeout on waiting for a full collection</param>
+        /// <returns>The status of the registered garbage collection notification.</returns>
+        public static GCNotificationStatus WaitForFullGCComplete(TimeSpan timeout) => WaitForFullGCComplete(WaitHandle.ToTimeoutMilliseconds(timeout));
+
         /// <summary>
         /// Cancels an outstanding full GC notification.
         /// </summary>

src/libraries/System.ComponentModel.Annotations/ref/System.ComponentModel.Annotations.cs

@@ -237,6 +237,7 @@ public partial class RegularExpressionAttribute : System.ComponentModel.DataAnno
     {
         public RegularExpressionAttribute([System.Diagnostics.CodeAnalysis.StringSyntaxAttribute(System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.Regex)] string pattern) { }
         public int MatchTimeoutInMilliseconds { get { throw null; } set { } }
+        public System.TimeSpan MatchTimeout { get { throw null; } set { } }
         public string Pattern { get { throw null; } }
         public override string FormatErrorMessage(string name) { throw null; }
         public override bool IsValid(object? value) { throw null; }

src/libraries/System.ComponentModel.Annotations/src/Resources/Strings.resx

@@ -216,4 +216,10 @@
   <data name="Validator_Property_Value_Wrong_Type" xml:space="preserve">
     <value>The value for property '{0}' must be of type '{1}'.</value>
   </data>
+  <data name="ArgumentOutOfRange_NeedNonNegOrNegative1" xml:space="preserve">
+    <value>Number must be either non-negative and less than or equal to Int32.MaxValue or -1.</value>
+  </data>
+  <data name="ArgumentOutOfRange_LessEqualToIntegerMaxVal" xml:space="preserve">
+    <value>Argument must be less than or equal to 2^31 - 1 milliseconds.</value>
+  </data>
 </root>

src/libraries/System.ComponentModel.Annotations/src/System/ComponentModel/DataAnnotations/RegularExpressionAttribute.cs

@@ -31,6 +31,29 @@ public RegularExpressionAttribute([StringSyntax(StringSyntaxAttribute.Regex)] st
         /// </summary>
         public int MatchTimeoutInMilliseconds { get; set; }
 
+        /// <summary>
+        /// Gets or sets the timeout to use when matching the regular expression pattern
+        /// </summary>
+        public TimeSpan MatchTimeout
+        {
+            get => TimeSpan.FromMilliseconds(MatchTimeoutInMilliseconds);
+            set
+            {
+                long timeoutMilliseconds = (long)value.TotalMilliseconds;
+                if (timeoutMilliseconds < -1)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(value), SR.ArgumentOutOfRange_NeedNonNegOrNegative1);
+                }
+
+                if (timeoutMilliseconds > int.MaxValue)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(value), SR.ArgumentOutOfRange_LessEqualToIntegerMaxVal);
+                }
+
+                MatchTimeoutInMilliseconds = (int)timeoutMilliseconds;
+            }
+        }
+
         /// <summary>
         ///     Gets the regular expression pattern to use
         /// </summary>

src/libraries/System.ComponentModel.Annotations/tests/System.ComponentModel.Annotations.Tests.csproj

@@ -28,6 +28,7 @@
     <Compile Include="System\ComponentModel\DataAnnotations\PhoneAttributeTests.cs" />
     <Compile Include="System\ComponentModel\DataAnnotations\RangeAttributeTests.cs" Condition="'$(TargetFramework)' == '$(NetCoreAppCurrent)'" />
     <Compile Include="System\ComponentModel\DataAnnotations\RegularExpressionAttributeTests.cs" />
+    <Compile Include="System\ComponentModel\DataAnnotations\RegularExpressionAttributeTests.Core.cs" Condition="'$(TargetFramework)' == '$(NetCoreAppCurrent)'" />
     <Compile Include="System\ComponentModel\DataAnnotations\RequiredAttributeTests.cs" />
     <Compile Include="System\ComponentModel\DataAnnotations\ScaffoldColumnAttributeTests.cs" />
     <Compile Include="System\ComponentModel\DataAnnotations\Schema\ColumnAttributeTests.cs" />

src/libraries/System.ComponentModel.Annotations/tests/System/ComponentModel/DataAnnotations/RegularExpressionAttributeTests.Core.cs

@@ -0,0 +1,20 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.ComponentModel.DataAnnotations;
+using Xunit;
+
+namespace System.ComponentModel.Annotations.Tests.System.ComponentModel.DataAnnotations
+{
+    public sealed partial class RegularExpressionAttributeTests
+    {
+        [Theory]
+        [InlineData(12345)]
+        [InlineData(-1)]
+        public static void MatchTimeout_Get_ReturnsExpected(int newValue)
+        {
+            var attribute = new RegularExpressionAttribute("SomePattern") { MatchTimeoutInMilliseconds = newValue };
+            Assert.Equal(TimeSpan.FromMilliseconds(newValue), attribute.MatchTimeout);
+        }
+    }
+}

src/libraries/System.ComponentModel.Annotations/tests/System/ComponentModel/DataAnnotations/RegularExpressionAttributeTests.cs

@@ -7,7 +7,7 @@
 
 namespace System.ComponentModel.DataAnnotations.Tests
 {
-    public class RegularExpressionAttributeTests : ValidationAttributeTestBase
+    public sealed partial class RegularExpressionAttributeTests : ValidationAttributeTestBase
     {
         protected override IEnumerable<TestCase> ValidValues()
         {

src/libraries/System.ComponentModel.TypeConverter/ref/System.ComponentModel.TypeConverter.cs

@@ -2306,6 +2306,7 @@ public partial class Timer : System.ComponentModel.Component, System.ComponentMo
     {
         public Timer() { }
         public Timer(double interval) { }
+        public Timer(System.TimeSpan interval) { }
         [System.ComponentModel.DefaultValueAttribute(true)]
         public bool AutoReset { get { throw null; } set { } }
         [System.ComponentModel.DefaultValueAttribute(false)]

src/libraries/System.ComponentModel.TypeConverter/src/System/Timers/Timer.cs

@@ -59,6 +59,13 @@ public Timer(double interval) : this()
             _interval = (int)roundedInterval;
         }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref='Timer'/> class, setting the <see cref='Interval'/> property to the specified period.
+        /// </summary>
+        public Timer(TimeSpan interval) : this(interval.TotalMilliseconds)
+        {
+        }
+
         /// <summary>
         /// Gets or sets a value indicating whether the Timer raises the Tick event each time the specified
         /// Interval has elapsed, when Enabled is set to true.

src/libraries/System.Diagnostics.EventLog/src/Resources/Strings.resx

@@ -239,4 +239,10 @@
   <data name="LogAlreadyExistsAsSource" xml:space="preserve">
     <value>Log {0} has already been registered as a source on the local computer.</value>
   </data>
+  <data name="ArgumentOutOfRange_NeedNonNegOrNegative1" xml:space="preserve">
+    <value>Number must be either non-negative and less than or equal to Int32.MaxValue or -1.</value>
+  </data>
+  <data name="ArgumentOutOfRange_LessEqualToIntegerMaxVal" xml:space="preserve">
+    <value>Argument must be less than or equal to 2^31 - 1 milliseconds.</value>
+  </data>
 </root>

src/libraries/System.Diagnostics.Process/ref/System.Diagnostics.Process.cs

@@ -168,9 +168,11 @@ public void Refresh() { }
         public override string ToString() { throw null; }
         public void WaitForExit() { }
         public bool WaitForExit(int milliseconds) { throw null; }
+        public bool WaitForExit(System.TimeSpan timeout) { throw null; }
         public System.Threading.Tasks.Task WaitForExitAsync(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
         public bool WaitForInputIdle() { throw null; }
         public bool WaitForInputIdle(int milliseconds) { throw null; }
+        public bool WaitForInputIdle(System.TimeSpan timeout) { throw null; }
     }
     [System.ComponentModel.DesignerAttribute("System.Diagnostics.Design.ProcessModuleDesigner, System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a")]
     public partial class ProcessModule : System.ComponentModel.Component

src/libraries/System.Diagnostics.Process/src/Resources/Strings.resx

@@ -296,6 +296,12 @@
   <data name="ArgumentOutOfRange_NeedNonNegNum" xml:space="preserve">
     <value>Non-negative number required.</value>
   </data>
+  <data name="ArgumentOutOfRange_NeedNonNegOrNegative1" xml:space="preserve">
+    <value>Number must be either non-negative and less than or equal to Int32.MaxValue or -1.</value>
+  </data>
+  <data name="ArgumentOutOfRange_LessEqualToIntegerMaxVal" xml:space="preserve">
+    <value>Argument must be less than or equal to 2^31 - 1 milliseconds.</value>
+  </data>
   <data name="CantStartAsUser" xml:space="preserve">
     <value>The Process object must have the UseShellExecute property set to false in order to start a process as a user.</value>
   </data>

src/libraries/System.Diagnostics.Process/src/System/Diagnostics/Process.cs

@@ -826,6 +826,8 @@ public bool WaitForInputIdle(int milliseconds)
             return WaitForInputIdleCore(milliseconds);
         }
 
+        public bool WaitForInputIdle(TimeSpan timeout) => WaitForInputIdle(ToTimeoutMilliseconds(timeout));
+
         public ISynchronizeInvoke? SynchronizingObject { get; set; }
 
         /// <devdoc>
@@ -1414,6 +1416,27 @@ public bool WaitForExit(int milliseconds)
             return exited;
         }
 
+        /// <summary>
+        /// Instructs the Process component to wait the specified number of milliseconds for
+        /// the associated process to exit.
+        /// </summary>
+        public bool WaitForExit(TimeSpan timeout) => WaitForExit(ToTimeoutMilliseconds(timeout));
+
+        private static int ToTimeoutMilliseconds(TimeSpan timeout)
+        {
+            long timeoutMilliseconds = (long)timeout.TotalMilliseconds;
+            if (timeoutMilliseconds < -1)
+            {
+                throw new ArgumentOutOfRangeException(nameof(timeout), SR.ArgumentOutOfRange_NeedNonNegOrNegative1);
+            }
+
+            if (timeoutMilliseconds > int.MaxValue)
+            {
+                throw new ArgumentOutOfRangeException(nameof(timeout), SR.ArgumentOutOfRange_LessEqualToIntegerMaxVal);
+            }
+            return (int)timeoutMilliseconds;
+        }
+
         /// <summary>
         /// Instructs the Process component to wait for the associated process to exit, or
         /// for the <paramref name="cancellationToken"/> to be canceled.

src/libraries/System.IO.FileSystem.Watcher/ref/System.IO.FileSystem.Watcher.cs

@@ -50,6 +50,7 @@ protected void OnError(System.IO.ErrorEventArgs e) { }
         protected void OnRenamed(System.IO.RenamedEventArgs e) { }
         public System.IO.WaitForChangedResult WaitForChanged(System.IO.WatcherChangeTypes changeType) { throw null; }
         public System.IO.WaitForChangedResult WaitForChanged(System.IO.WatcherChangeTypes changeType, int timeout) { throw null; }
+        public System.IO.WaitForChangedResult WaitForChanged(System.IO.WatcherChangeTypes changeType, System.TimeSpan timeout) { throw null; }
     }
     public partial class InternalBufferOverflowException : System.SystemException
     {

src/libraries/System.IO.FileSystem.Watcher/src/Resources/Strings.resx

@@ -140,6 +140,12 @@
   <data name="ArgumentOutOfRange_FileLengthTooBig" xml:space="preserve">
     <value>Specified file length was too large for the file system.</value>
   </data>
+  <data name="ArgumentOutOfRange_NeedNonNegOrNegative1" xml:space="preserve">
+    <value>Number must be either non-negative and less than or equal to Int32.MaxValue or -1.</value>
+  </data>
+  <data name="ArgumentOutOfRange_LessEqualToIntegerMaxVal" xml:space="preserve">
+    <value>Argument must be less than or equal to 2^31 - 1 milliseconds.</value>
+  </data>
   <data name="IO_PathTooLong" xml:space="preserve">
     <value>The specified file name or path is too long, or a component of the specified path is too long.</value>
   </data>

src/libraries/System.IO.FileSystem.Watcher/src/System/IO/FileSystemWatcher.cs

@@ -618,6 +618,24 @@ public WaitForChangedResult WaitForChanged(WatcherChangeTypes changeType, int ti
                 WaitForChangedResult.TimedOutResult;
         }
 
+        public WaitForChangedResult WaitForChanged(WatcherChangeTypes changeType, TimeSpan timeout) =>
+            WaitForChanged(changeType, ToTimeoutMilliseconds(timeout));
+
+        private static int ToTimeoutMilliseconds(TimeSpan timeout)
+        {
+            long timeoutMilliseconds = (long)timeout.TotalMilliseconds;
+            if (timeoutMilliseconds < -1)
+            {
+                throw new ArgumentOutOfRangeException(nameof(timeout), SR.ArgumentOutOfRange_NeedNonNegOrNegative1);
+            }
+
+            if (timeoutMilliseconds > int.MaxValue)
+            {
+                throw new ArgumentOutOfRangeException(nameof(timeout), SR.ArgumentOutOfRange_LessEqualToIntegerMaxVal);
+            }
+            return (int)timeoutMilliseconds;
+        }
+
         /// <devdoc>
         ///     Stops and starts this object.
         /// </devdoc>

src/libraries/System.IO.FileSystem.Watcher/tests/FileSystemWatcher.WaitForChanged.cs

@@ -124,6 +124,57 @@ public void NonZeroTimeout_NoActivity_TimesOut(WatcherChangeTypes changeType, bo
             }
         }
 
+        [Theory]
+        [InlineData(false)]
+        [InlineData(true)]
+        public void ZeroTimeout_TimesOut_TimeSpan(bool enabledBeforeWait)
+        {
+            TimeSpan timeout = TimeSpan.FromMilliseconds(0);
+
+            using var testDirectory = new TempDirectory(GetTestFilePath());
+            using var dir = new TempDirectory(Path.Combine(testDirectory.Path, GetTestFileName()));
+            using var fsw = new FileSystemWatcher(testDirectory.Path);
+
+            if (enabledBeforeWait) fsw.EnableRaisingEvents = true;
+            AssertTimedOut(fsw.WaitForChanged(WatcherChangeTypes.All, timeout));
+            Assert.Equal(enabledBeforeWait, fsw.EnableRaisingEvents);
+        }
+
+        [Theory]
+        [InlineData(false)]
+        [InlineData(true)]
+        public void NonZeroTimeout_NoEvents_TimesOut_TimeSpan(bool enabledBeforeWait)
+        {
+            TimeSpan timeout = TimeSpan.FromMilliseconds(1);
+
+            using var testDirectory = new TempDirectory(GetTestFilePath());
+            using var dir = new TempDirectory(Path.Combine(testDirectory.Path, GetTestFileName()));
+            using var fsw = new FileSystemWatcher(testDirectory.Path);
+
+            if (enabledBeforeWait) fsw.EnableRaisingEvents = true;
+            AssertTimedOut(fsw.WaitForChanged(0, timeout));
+            Assert.Equal(enabledBeforeWait, fsw.EnableRaisingEvents);
+        }
+
+        [Theory]
+        [InlineData(WatcherChangeTypes.Deleted, false)]
+        [InlineData(WatcherChangeTypes.Created, true)]
+        [InlineData(WatcherChangeTypes.Changed, false)]
+        [InlineData(WatcherChangeTypes.Renamed, true)]
+        [InlineData(WatcherChangeTypes.All, true)]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/58418", typeof(PlatformDetection), nameof(PlatformDetection.IsMacCatalyst), nameof(PlatformDetection.IsArm64Process))]
+        public void NonZeroTimeout_NoActivity_TimesOut_TimeSpan(WatcherChangeTypes changeType, bool enabledBeforeWait)
+        {
+            TimeSpan timeout = TimeSpan.FromMilliseconds(1);
+            using var testDirectory = new TempDirectory(GetTestFilePath());
+            using var dir = new TempDirectory(Path.Combine(testDirectory.Path, GetTestFileName()));
+            using var fsw = new FileSystemWatcher(testDirectory.Path);
+
+            if (enabledBeforeWait) fsw.EnableRaisingEvents = true;
+            AssertTimedOut(fsw.WaitForChanged(changeType, timeout));
+            Assert.Equal(enabledBeforeWait, fsw.EnableRaisingEvents);
+        }
+
         [Theory]
         [OuterLoop("This test has a longer than average timeout and may fail intermittently")]
         [InlineData(WatcherChangeTypes.Created)]

src/libraries/System.IO.Pipes/ref/System.IO.Pipes.cs

@@ -54,9 +54,11 @@ public sealed partial class NamedPipeClientStream : System.IO.Pipes.PipeStream
         protected internal override void CheckPipePropertyOperations() { }
         public void Connect() { }
         public void Connect(int timeout) { }
+        public void Connect(System.TimeSpan timeout) { }
         public System.Threading.Tasks.Task ConnectAsync() { throw null; }
         public System.Threading.Tasks.Task ConnectAsync(int timeout) { throw null; }
         public System.Threading.Tasks.Task ConnectAsync(int timeout, System.Threading.CancellationToken cancellationToken) { throw null; }
+        public System.Threading.Tasks.Task ConnectAsync(System.TimeSpan timeout, System.Threading.CancellationToken cancellationToken) { throw null; }
         public System.Threading.Tasks.Task ConnectAsync(System.Threading.CancellationToken cancellationToken) { throw null; }
         ~NamedPipeClientStream() { }
     }

src/libraries/System.IO.Pipes/src/Resources/Strings.resx

@@ -123,6 +123,12 @@
   <data name="ArgumentOutOfRange_NeedValidPipeAccessRights" xml:space="preserve">
     <value>Invalid PipeAccessRights value.</value>
   </data>
+  <data name="ArgumentOutOfRange_NeedNonNegOrNegative1" xml:space="preserve">
+    <value>Number must be either non-negative and less than or equal to Int32.MaxValue or -1.</value>
+  </data>
+  <data name="ArgumentOutOfRange_LessEqualToIntegerMaxVal" xml:space="preserve">
+    <value>Argument must be less than or equal to 2^31 - 1 milliseconds.</value>
+  </data>
   <data name="Argument_NonContainerInvalidAnyFlag" xml:space="preserve">
     <value>This flag may not be set on a pipe.</value>
   </data>