Merge branch 'develop'

kekyo · kekyo · commit 02b60fa23e09 · 2024-06-26T10:58:57.000+09:00
diff --git a/.github/workflows/build.yaml b/.github/workflows/build.yaml
@@ -11,7 +11,7 @@ jobs:
     #-----------------------------------------------------------------------
     # Checkout
 
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
       with:
         fetch-depth: 0
     #   lfs: true
@@ -29,26 +29,16 @@ jobs:
     #-----------------------------------------------------------------------
     # Setup environments
 
-    - name: Setup .NET Core 2.2
-      uses: actions/setup-dotnet@v1
+    - name: Setup .NET SDKs
+      uses: actions/setup-dotnet@v4
       with:
-        dotnet-version: 2.2.*
-    - name: Setup .NET Core 3.1
-      uses: actions/setup-dotnet@v1
-      with:
-        dotnet-version: 3.1.*
-    - name: Setup .NET 5
-      uses: actions/setup-dotnet@v1
-      with:
-        dotnet-version: 5.0.*
-    - name: Setup .NET 6
-      uses: actions/setup-dotnet@v1
-      with:
-        dotnet-version: 6.0.*
-    - name: Setup .NET 7
-      uses: actions/setup-dotnet@v1
-      with:
-        dotnet-version: 7.0.*
+        dotnet-version: |
+          2.2.x
+          3.1.x
+          5.0.x
+          6.0.x
+          7.0.x
+          8.0.x
         
     #- name: Setup NuGet package reference
     #  run: |
diff --git a/Directory.Build.props b/Directory.Build.props
@@ -8,6 +8,7 @@
     <DebugSymbols>true</DebugSymbols>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
     <CheckEolTargetFramework>false</CheckEolTargetFramework>
+    <SuppressNETCoreSdkPreviewMessage>true</SuppressNETCoreSdkPreviewMessage>
     <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
     <PublishRepositoryUrl>true</PublishRepositoryUrl>
     <RepositoryType>git</RepositoryType>
@@ -31,7 +32,7 @@
     <PackageTags>synchronization;context;threading;apartment;affinity</PackageTags>
     <AllowedOutputExtensionsInPackageBuildOutputFolder>.pdb</AllowedOutputExtensionsInPackageBuildOutputFolder>
     <IsPackable>false</IsPackable>
-    <NoWarn>$(NoWarn);NU1605;NU1701;NU1803</NoWarn>
+    <NoWarn>$(NoWarn);NU1605;NU1701;NU1803;NU1902;NU1903</NoWarn>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(Configuration)' != 'Release'">
@@ -46,10 +47,12 @@
     <Deterministic>true</Deterministic>
     <EmbedUntrackedSources>true</EmbedUntrackedSources>
     <ContinuousIntegrationBuild>true</ContinuousIntegrationBuild>
+    <RepoRoot>$([System.IO.Path]::GetFullPath('$(MSBuildThisFileDirectory)..\'))</RepoRoot>
+    <PathMap>$(RepoRoot)=.</PathMap>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="RelaxVersioner" Version="2.14.0" PrivateAssets="All" />
+    <PackageReference Include="RelaxVersioner" Version="3.4.0" PrivateAssets="All" />
   </ItemGroup>
 
   <ItemGroup Condition="'$(Configuration)' == 'Release'">
diff --git a/Lepracaun.Tests/InvokingTest.cs b/Lepracaun.Tests/InvokingTest.cs
@@ -96,7 +96,10 @@ public void RunExceptionTest1()
 
         Exception? ex = null;
         app.UnhandledException += (s, e) =>
+        {
             ex = e.Exception;
+            e.Handled = true;
+        };
 
         app.Run(() =>
         {
@@ -117,7 +120,10 @@ public void RunExceptionTest2()
 
         Exception? ex = null;
         app.UnhandledException += (s, e) =>
+        {
             ex = e.Exception;
+            e.Handled = true;
+        };
 
         app.Run(async () =>
         {
@@ -137,7 +143,10 @@ public void RunExceptionTest3()
 
         Exception? ex = null;
         app.UnhandledException += (s, e) =>
+        {
             ex = e.Exception;
+            e.Handled = true;
+        };
 
         app.Run(async () =>
         {
@@ -153,4 +162,76 @@ static async Task Child()
 
         IsTrue(ex is ApplicationException aex && aex.Message == "ABC");
     }
+
+    [Test]
+    public void RunExceptionTest4()
+    {
+        IsNull(SynchronizationContext.Current);
+
+        using var app = new Application();
+
+        Exception? ex = null;
+        try
+        {
+            app.Run(() =>
+            {
+                throw new ApplicationException("ABC");
+            });
+        }
+        catch (Exception ex2)
+        {
+            ex = ex2;
+        }
+
+        IsTrue(ex is ApplicationException aex && aex.Message == "ABC");
+    }
+
+    [Test]
+    public void RunExceptionTest5()
+    {
+        IsNull(SynchronizationContext.Current);
+
+        using var app = new Application();
+
+        Exception? ex = null;
+        try
+        {
+            app.Run(() =>
+            {
+                var tcs = new TaskCompletionSource<int>();
+                tcs.SetException(new ApplicationException("ABC"));
+                return tcs.Task;
+            });
+        }
+        catch (Exception ex2)
+        {
+            ex = ex2;
+        }
+
+        IsTrue(ex is ApplicationException aex && aex.Message == "ABC");
+    }
+
+    [Test]
+    public void RunExceptionTest6()
+    {
+        IsNull(SynchronizationContext.Current);
+
+        using var app = new Application();
+
+        Exception? ex = null;
+        try
+        {
+            app.Run(async() =>
+            {
+                await Task.Delay(1);
+                throw new ApplicationException("ABC");
+            });
+        }
+        catch (Exception ex2)
+        {
+            ex = ex2;
+        }
+
+        IsTrue(ex is ApplicationException aex && aex.Message == "ABC");
+    }
 }
diff --git a/Lepracaun/Lepracaun.csproj b/Lepracaun/Lepracaun.csproj
@@ -1,7 +1,7 @@
 ﻿<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>net35;net40;net45;net461;net48;netstandard1.3;netstandard1.6;netstandard2.0;netstandard2.1;netcoreapp2.0;netcoreapp2.2;netcoreapp3.0;netcoreapp3.1;net5.0;net6.0;net7.0</TargetFrameworks>
+    <TargetFrameworks>net35;net40;net45;net461;net48;net481;netstandard1.3;netstandard1.6;netstandard2.0;netstandard2.1;netcoreapp2.0;netcoreapp2.2;netcoreapp3.0;netcoreapp3.1;net5.0;net6.0;net7.0;net8.0</TargetFrameworks>
     <IsPackable>true</IsPackable>
   </PropertyGroup>
 
diff --git a/Lepracaun/ManagedThreadSynchronizationContext.cs b/Lepracaun/ManagedThreadSynchronizationContext.cs
@@ -7,10 +7,16 @@
 //
 /////////////////////////////////////////////////////////////////////////////////////
 
+using System;
 using Lepracaun.Internal;
 using System.Collections.Generic;
+using System.Reflection;
 using System.Threading;
 
+#if !NET35 && !NET40
+using System.Runtime.ExceptionServices;
+#endif
+
 namespace Lepracaun;
 
 /// <summary>
@@ -34,6 +40,11 @@ public abstract class ManagedThreadSynchronizationContext :
     /// </summary>
     private bool completeAdding;
 
+    /// <summary>
+    /// Finalized with an exception.
+    /// </summary>
+    private Exception? completeWithException;
+
     /// <summary>
     /// Constructor.
     /// </summary>
@@ -91,11 +102,22 @@ protected override sealed void OnRun(
                 entry.Continuation,
                 entry.State);
         }
+
+        if (this.completeWithException is { } ex)
+        {
+#if NET35 || NET40
+            throw new TargetInvocationException(ex);
+#else
+            var edi = ExceptionDispatchInfo.Capture(ex);
+            edi.Throw();
+#endif
+        }
     }
 
     protected override sealed void OnShutdown(
-        int targetThreadId)
+        int targetThreadId, Exception? ex)
     {
+        this.completeWithException = ex;
         this.completeAdding = true;
         this.available.Set();
     }
diff --git a/Lepracaun/ThreadBoundSynchronizationContext.cs b/Lepracaun/ThreadBoundSynchronizationContext.cs
@@ -17,6 +17,8 @@
 using System.Runtime.ExceptionServices;
 #endif
 
+#pragma warning disable CS0618
+
 namespace Lepracaun;
 
 /// <summary>
@@ -94,27 +96,31 @@ protected abstract void OnRun(
     /// Shutdown requested.
     /// </summary>
     /// <param name="targetThreadId">Target thread identity.</param>
+    [Obsolete("Use OnShutdown with exception overload instead.")]
+    protected virtual void OnShutdown(
+        int targetThreadId) =>
+        this.OnShutdown(targetThreadId, null);
+
+    /// <summary>
+    /// Shutdown requested.
+    /// </summary>
+    /// <param name="targetThreadId">Target thread identity.</param>
+    /// <param name="ex">Exception when shutdown reason</param>
     protected abstract void OnShutdown(
-        int targetThreadId);
+        int targetThreadId, Exception? ex);
 
-    private bool InvokeUnhandledException(Exception ex)
-    {
-        UnhandledExceptionEventArgs e;
-        if (ex is AggregateException aex &&
-            aex.InnerExceptions.Count == 1)
-        {
-            e = new(aex.InnerExceptions[0]);
-        }
-        else if (ex is TargetInvocationException tex &&
-            tex.InnerException != null)
+    private Exception UnwrapIfRequired(Exception ex) =>
+        ex switch
         {
-            e = new(tex.InnerException);
-        }
-        else
-        {
-            e = new(ex);
-        }
+            AggregateException aex when aex.InnerExceptions.Count == 1 => aex.InnerExceptions[0],
+            TargetInvocationException tex when tex.InnerException != null => tex.InnerException,
+            _ => ex,
+        };
 
+    private bool InvokeUnhandledException(Exception ex)
+    {
+        var e = new UnhandledExceptionEventArgs(ex);
+        
         try
         {
             this.UnhandledException?.Invoke(this, e);
@@ -135,7 +141,7 @@ protected void OnInvoke(SendOrPostCallback continuation, object? state)
         }
         catch (Exception ex)
         {
-            if (!this.InvokeUnhandledException(ex))
+            if (!this.InvokeUnhandledException(UnwrapIfRequired(ex)))
             {
                 throw;
             }
@@ -236,6 +242,34 @@ public override void Post(SendOrPostCallback continuation, object? state)
 
         this.OnPost(this.boundThreadId, continuation, state);
     }
+    
+    /// <summary>
+    /// Schedule task final completion.
+    /// </summary>
+    /// <param name="task">Task</param>
+    protected void HookTaskFinalizer(Task? task) =>
+        task?.ContinueWith(t =>
+        {
+            if (t.IsCanceled)
+            {
+                var ex = UnwrapIfRequired(t.Exception!);
+                if (!this.InvokeUnhandledException(ex))
+                {
+                    this.OnShutdown(this.boundThreadId, ex);
+                    return;
+                }
+            }
+            else if (t.IsFaulted)
+            {
+                var ex = UnwrapIfRequired(t.Exception!);
+                if (!this.InvokeUnhandledException(ex))
+                {
+                    this.OnShutdown(this.boundThreadId, ex);
+                    return;
+                }
+            }
+            this.OnShutdown(this.boundThreadId, null);
+        });
 
     /// <summary>
     /// Execute message queue.
@@ -251,21 +285,7 @@ public virtual void Run(Task task)
                 $"Thread mismatch between created and running: Created={this.boundThreadId}, Running={currentThreadId}");
         }
 
-        // Schedule task completion.
-        task?.ContinueWith(t =>
-        {
-            if (t.IsCanceled)
-            {
-                this.InvokeUnhandledException(t.Exception!);
-            }
-            else if (t.IsFaulted)
-            {
-                this.InvokeUnhandledException(t.Exception!);
-            }
-
-            this.OnShutdown(this.boundThreadId);
-        });
-
+        this.HookTaskFinalizer(task);
         this.OnRun(this.boundThreadId);
     }
 
diff --git a/Lepracaun/Win32MessagingSynchronizationContext.cs b/Lepracaun/Win32MessagingSynchronizationContext.cs
diff --git a/Lepracaun/WorkerThreadSynchronizationContext.cs b/Lepracaun/WorkerThreadSynchronizationContext.cs
diff --git a/README.md b/README.md
