Add .net10 support, remove dead code, rework how dlls are retrieved (#190)

Author: ScarletKuro

src/Directory.Build.props

@@ -1,7 +1,7 @@
 <Project>
 
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <LangVersion>latest</LangVersion>
     <ImplicitUsings>enable</ImplicitUsings>
     <UsingBrowserRuntimeWorkload>false</UsingBrowserRuntimeWorkload>

src/Try.Core/CompilationService.cs

@@ -8,6 +8,7 @@
     using System.Linq;
     using System.Net.Http;
     using System.Net.Http.Json;
+    using System.Reflection.Metadata;
     using System.Runtime;
     using System.Text;
     using System.Threading.Tasks;
@@ -48,14 +49,21 @@ public class CompilationService
         private static CSharpCompilation _baseCompilation;
         private static CSharpParseOptions _cSharpParseOptions;
 
+        private int _lastCodeHash;
+        private CompileToAssemblyResult _cachedResult;
+
         private readonly RazorProjectFileSystem fileSystem = new VirtualRazorProjectFileSystem();
         private readonly RazorConfiguration configuration = new(
             RazorLanguageVersion.Latest,
             ConfigurationName: "Blazor",
             Extensions: ImmutableArray<RazorExtension>.Empty);
 
-        public static async Task InitAsync(Func<IReadOnlyCollection<string>, ValueTask<IReadOnlyList<byte[]>>> getReferencedDllsBytesFunc)
+        private RazorProjectEngine _declarationProjectEngine;
+
+        public static unsafe Task InitAsync()
         {
+            if (_baseCompilation != null) return Task.CompletedTask;
+
             var basicReferenceAssemblyRoots = new[]
             {
                 typeof(Console).Assembly, // System.Console
@@ -71,22 +79,32 @@ public static async Task InitAsync(Func<IReadOnlyCollection<string>, ValueTask<I
                 typeof(WebAssemblyHostBuilder).Assembly, // Microsoft.AspNetCore.Components.WebAssembly
                 typeof(FluentValidation.AbstractValidator<>).Assembly,
             };
-            var assemblyNames = await getReferencedDllsBytesFunc(basicReferenceAssemblyRoots
-                .SelectMany(assembly => assembly.GetReferencedAssemblies().Concat(
-                [
-                    assembly.GetName()
-                ]))
-                .Select(assemblyName => assemblyName.Name)
-                .ToHashSet());
-
-            var basicReferenceAssemblies = assemblyNames
-                .Select(peImage => MetadataReference.CreateFromImage(peImage, MetadataReferenceProperties.Assembly))
-                .ToList();
+
+            var assemblyNames = basicReferenceAssemblyRoots
+                .SelectMany(assembly => assembly.GetReferencedAssemblies().Concat([assembly.GetName()]))
+                .Select(assemblyName => assemblyName.Name!)
+                .ToHashSet();
+
+            // netstandard facade is needed for libraries that target netstandard2.0
+            assemblyNames.Add("netstandard");
+
+            var loadedByName = AppDomain.CurrentDomain.GetAssemblies()
+                .Where(a => !a.IsDynamic && a.GetName().Name != null)
+                .ToDictionary(a => a.GetName().Name!, StringComparer.OrdinalIgnoreCase);
+
+            var references = new List<MetadataReference>();
+            foreach (var name in assemblyNames)
+            {
+                if (!loadedByName.TryGetValue(name, out var assembly)) continue;
+                if (!assembly.TryGetRawMetadata(out byte* blob, out int length)) continue;
+                var moduleMetadata = ModuleMetadata.CreateFromMetadata((IntPtr)blob, length);
+                references.Add(AssemblyMetadata.Create(moduleMetadata).GetReference());
+            }
 
             _baseCompilation = CSharpCompilation.Create(
                 DefaultRootNamespace,
                 Array.Empty<SyntaxTree>(),
-                basicReferenceAssemblies,
+                references,
                 new CSharpCompilationOptions(
                     OutputKind.DynamicallyLinkedLibrary,
                     optimizationLevel: OptimizationLevel.Release,
@@ -99,6 +117,7 @@ public static async Task InitAsync(Func<IReadOnlyCollection<string>, ValueTask<I
                     }));
 
             _cSharpParseOptions = new CSharpParseOptions(LanguageVersion.Preview);
+            return Task.CompletedTask;
         }
 
         public async Task<CompileToAssemblyResult> CompileToAssemblyAsync(
@@ -107,14 +126,60 @@ public async Task<CompileToAssemblyResult> CompileToAssemblyAsync(
         {
             ArgumentNullException.ThrowIfNull(codeFiles);
 
+            var codeHash = ComputeCodeHash(codeFiles);
+            if (_cachedResult != null && _lastCodeHash == codeHash)
+            {
+                return _cachedResult;
+            }
+
             var cSharpResults = await this.CompileToCSharpAsync(codeFiles, updateStatusFunc);
 
             await (updateStatusFunc?.Invoke("Compiling Assembly") ?? Task.CompletedTask);
             var result = CompileToAssembly(cSharpResults);
 
+            _lastCodeHash = codeHash;
+            _cachedResult = result;
+
             return result;
         }
 
+        private static int ComputeCodeHash(ICollection<CodeFile> codeFiles)
+        {
+            var hash = new HashCode();
+            foreach (var file in codeFiles)
+            {
+                hash.Add(file.Path);
+                hash.Add(file.Content);
+            }
+            return hash.ToHashCode();
+        }
+
+        // Compiles to a Roslyn compilation reference without emitting a PE image.
+        // Used for the declaration (phase 1) pass where we only need component type info.
+        private static (CompileToCSharpResult error, MetadataReference metadataRef) CompileToMetadataReference(
+            IReadOnlyList<CompileToCSharpResult> cSharpResults)
+        {
+            if (cSharpResults.Any(r => r.Diagnostics.Any(d => d.Severity == DiagnosticSeverity.Error)))
+            {
+                return (new CompileToCSharpResult { Diagnostics = cSharpResults.SelectMany(r => r.Diagnostics).ToList() }, null);
+            }
+
+            var syntaxTrees = new SyntaxTree[cSharpResults.Count];
+            for (var i = 0; i < cSharpResults.Count; i++)
+            {
+                syntaxTrees[i] = CSharpSyntaxTree.ParseText(cSharpResults[i].Code, _cSharpParseOptions, cSharpResults[i].FilePath);
+            }
+
+            var compilation = _baseCompilation.AddSyntaxTrees(syntaxTrees);
+            var diagnostics = compilation.GetDiagnostics().Where(d => d.Severity > DiagnosticSeverity.Info).ToList();
+            if (diagnostics.Any(d => d.Severity == DiagnosticSeverity.Error))
+            {
+                return (new CompileToCSharpResult { Diagnostics = diagnostics.Select(CompilationDiagnostic.FromCSharpDiagnostic).ToList() }, null);
+            }
+
+            return (null, compilation.ToMetadataReference());
+        }
+
         private static CompileToAssemblyResult CompileToAssembly(IReadOnlyList<CompileToCSharpResult> cSharpResults)
         {
             if (cSharpResults.Any(r => r.Diagnostics.Any(d => d.Severity == DiagnosticSeverity.Error)))
@@ -144,7 +209,7 @@ private static CompileToAssemblyResult CompileToAssembly(IReadOnlyList<CompileTo
 
             if (result.Diagnostics.All(x => x.Severity != DiagnosticSeverity.Error))
             {
-                using var peStream = new MemoryStream();
+                using var peStream = new MemoryStream(capacity: 512 * 1024);
                 finalCompilation.Emit(peStream);
 
                 result.AssemblyBytes = peStream.ToArray();
@@ -164,7 +229,10 @@ private static VirtualProjectItem CreateRazorProjectItem(string fileName, string
                 filePath = '/' + filePath;
             }
 
-            fileContent = fileContent.Replace("\r", string.Empty);
+            if (fileContent.Contains('\r'))
+            {
+                fileContent = fileContent.Replace("\r", string.Empty);
+            }
 
             return new VirtualProjectItem(
                 WorkingDirectory,
@@ -180,7 +248,8 @@ private async Task<IReadOnlyList<CompileToCSharpResult>> CompileToCSharpAsync(
             Func<string, Task> updateStatusFunc)
         {
             // The first phase won't include any metadata references for component discovery. This mirrors what the build does.
-            var projectEngine = this.CreateRazorProjectEngine(Array.Empty<MetadataReference>());
+            _declarationProjectEngine ??= this.CreateRazorProjectEngine(Array.Empty<MetadataReference>());
+            var projectEngine = _declarationProjectEngine;
 
             // Result of generating declarations
             var declarations = new CompileToCSharpResult[codeFiles.Count];
@@ -217,15 +286,15 @@ private async Task<IReadOnlyList<CompileToCSharpResult>> CompileToCSharpAsync(
                 index++;
             }
 
-            // Result of doing 'temp' compilation
-            var tempAssembly = CompileToAssembly(declarations);
-            if (tempAssembly.Diagnostics.Any(d => d.Severity == DiagnosticSeverity.Error))
+            // Result of doing 'temp' compilation (no emit needed — only used as a metadata reference)
+            var (tempErrors, tempRef) = CompileToMetadataReference(declarations);
+            if (tempErrors != null)
             {
-                return [new CompileToCSharpResult { Diagnostics = tempAssembly.Diagnostics }];
+                return [tempErrors];
             }
 
             // Add the 'temp' compilation as a metadata reference
-            var references = new List<MetadataReference>(_baseCompilation.References) { tempAssembly.Compilation.ToMetadataReference() };
+            var references = new List<MetadataReference>(_baseCompilation.References) { tempRef };
             projectEngine = CreateRazorProjectEngine(references);
 
             await (updateStatusFunc?.Invoke("Preparing Project") ?? Task.CompletedTask);

src/Try.Core/Try.Core.csproj

@@ -3,6 +3,7 @@
   <PropertyGroup>
     <AssemblyName>Microsoft.CodeAnalysis.Razor.Test</AssemblyName>
     <KeyOriginatorFile>$(PkgMicrosoft_DotNet_Arcade_Sdk)\tools\snk\AspNetCore.snk</KeyOriginatorFile>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
 
   <ItemGroup>

src/Try.Tests/SnippetsServiceTests.cs

@@ -42,7 +42,7 @@ public void Setup()
         [Ignore("Investigate failure")]
         public async Task TestGet()
         {
-            var snippetService = new SnippetsService(snippetsOptions, new System.Net.Http.HttpClient(), new MockNavigationManager());
+            var snippetService = new SnippetsService(snippetsOptions, new HttpClient(), new MockNavigationManager());
             var codeFiles = await snippetService.GetSnippetContentAsync("2021020540572059");
             Assert.That(codeFiles, Is.Not.Null);
         }
@@ -51,7 +51,7 @@ public async Task TestGet()
         [Ignore("Investigate failure")]
         public async Task TestPut()
         {
-            var snippetService = new SnippetsService(snippetsOptions, new System.Net.Http.HttpClient(), new MockNavigationManager());
+            var snippetService = new SnippetsService(snippetsOptions, new HttpClient(), new MockNavigationManager());
             var id = await snippetService.SaveSnippetAsync(codeFiles);
             Assert.That(id, Is.Not.Null);
             Console.WriteLine(id);

src/TryMudBlazor.Client/Components/SaveSnippetPopup.razor.cs

@@ -75,7 +75,7 @@ private async Task SaveAsync()
             }
         }
 
-        private async void OnClose()
+        private async Task OnClose()
         {
             Loading = false;
             SnippetLink = string.Empty;

src/TryMudBlazor.Client/Models/TryConstants.cs

@@ -19,7 +19,6 @@ public static class Editor
 
         public static class CodeExecution
         {
-            public const string GetCompilationDlls = "Try.CodeExecution.getCompilationDlls";
             public const string UpdateUserComponentsDll = "Try.CodeExecution.updateUserComponentsDll";
         }
     }

src/TryMudBlazor.Client/Pages/Repl.razor.cs

@@ -163,7 +163,7 @@ private async Task CompileAsync()
             this.Loading = true;
             this.LoaderText = "Processing";
 
-            await Task.Delay(10); // Ensure rendering has time to be called
+            await Task.Yield();
 
             CompileToAssemblyResult compilationResult = null;
             CodeFile mainComponent = null;
@@ -204,7 +204,7 @@ private async Task CompileAsync()
             if (compilationResult?.AssemblyBytes?.Length > 0)
             {
                 // Make sure the DLL is updated before reloading the user page
-                await this.JsRuntime.InvokeVoidAsync(Try.CodeExecution.UpdateUserComponentsDll, compilationResult.AssemblyBytes);
+                this.JsRuntime.InvokeVoid(Try.CodeExecution.UpdateUserComponentsDll, compilationResult.AssemblyBytes);
 
                 // TODO: Add error page in iframe
                 this.JsRuntime.InvokeVoid(Try.ReloadIframe, "user-page-window", MainUserPagePath);
@@ -271,29 +271,28 @@ private void UpdateActiveCodeFileContent()
             this.activeCodeFile.Content = this.CodeEditorComponent.GetCode();
         }
 
-        private Task UpdateLoaderTextAsync(string loaderText)
+        private async Task UpdateLoaderTextAsync(string loaderText)
         {
             this.LoaderText = loaderText;
 
             this.StateHasChanged();
 
-            return Task.Delay(10); // Ensure rendering has time to be called
+            await Task.Yield();
         }
 
-        private async void UpdateTheme()
+        private async Task UpdateTheme()
         {
             await LayoutService.ToggleDarkMode();
             string theme = LayoutService.IsDarkMode ? "vs-dark" : "default";
-            this.JsRuntime.InvokeVoid(Try.Editor.SetTheme, theme);
+            await JsRuntime.InvokeVoidAsync(Try.Editor.SetTheme, theme);
             // LayoutService calls StateHasChanged, we need the updated <style> tags for updateIframeTheme to work
             await Task.Yield();
             await JsRuntime.InvokeVoidAsync("updateIframeTheme");
         }
 
-        private async Task ClearCache()
+        private void ClearCache()
         {
-            await JsRuntime.InvokeVoidAsync("Try.clearCache");
-            NavigationManager.NavigateTo(NavigationManager.BaseUri, true);
+            NavigationManager.NavigateTo(NavigationManager.BaseUri, forceLoad: true);
         }
     }
 }

src/TryMudBlazor.Client/Shared/MainLayout.razor.cs

@@ -3,11 +3,9 @@
     using System;
     using System.Threading.Tasks;
     using Microsoft.AspNetCore.Components;
-    using Microsoft.JSInterop;
     using MudBlazor;
     using Services;
     using Try.Core;
-    using static TryMudBlazor.Client.Models.Try;
 
     public partial class MainLayout : LayoutComponentBase, IDisposable
     {
@@ -16,9 +14,6 @@ public partial class MainLayout : LayoutComponentBase, IDisposable
         [Inject]
         private LayoutService LayoutService { get; set; }
 
-        [Inject]
-        private IJSRuntime JsRuntime { get; set; }
-
         protected override void OnInitialized()
         {
             LayoutService.MajorUpdateOccured += LayoutServiceOnMajorUpdateOccured;
@@ -32,16 +27,11 @@ protected override async Task OnAfterRenderAsync(bool firstRender)
             if (firstRender)
             {
                 await ApplyUserPreferences();
-                await CompilationService.InitAsync(GetReferenceAssembliesStreamsAsync);
+                await CompilationService.InitAsync();
                 StateHasChanged();
             }
         }
 
-        private ValueTask<IReadOnlyList<byte[]>> GetReferenceAssembliesStreamsAsync(IReadOnlyCollection<string> referenceAssemblyNames)
-        {
-            return JsRuntime.InvokeAsync<IReadOnlyList<byte[]>>(CodeExecution.GetCompilationDlls, new List<string>(referenceAssemblyNames) { "netstandard" });
-        }
-
         private async Task ApplyUserPreferences()
         {
             var defaultDarkMode = await _mudThemeProvider.GetSystemDarkModeAsync();

src/TryMudBlazor.Client/TryMudBlazor.Client.csproj

@@ -2,14 +2,14 @@
 
   <PropertyGroup>
     <PublishTrimmed>false</PublishTrimmed>
-    <WasmEnableWebcil>false</WasmEnableWebcil>
+    <WasmEnableWebcil>true</WasmEnableWebcil>
   </PropertyGroup>
 
   <ItemGroup>
     <PackageReference Include="Blazored.LocalStorage" Version="4.5.0" />
-    <PackageReference Include="Microsoft.AspNetCore.Components.WebAssembly" Version="9.0.0" />
-    <PackageReference Include="Microsoft.AspNetCore.Components.WebAssembly.DevServer" Version="9.0.0" PrivateAssets="all" />
-    <PackageReference Include="Microsoft.AspNetCore.WebUtilities" Version="9.0.0" />
+    <PackageReference Include="Microsoft.AspNetCore.Components.WebAssembly" Version="10.0.0" />
+    <PackageReference Include="Microsoft.AspNetCore.Components.WebAssembly.DevServer" Version="10.0.0" PrivateAssets="all" />
+    <PackageReference Include="Microsoft.AspNetCore.WebUtilities" Version="10.0.0" />
   </ItemGroup>
 
   <ItemGroup>