Merge pull request #597 from Reloaded-Project/emergency-net905-patch

Added: Emergency Patch to rollback .NET 9.0.5 to 9.0.4

Author: Sewer56

source/Reloaded.Mod.Installer.DependencyInstaller/DependencyInstaller.cs

@@ -8,13 +8,13 @@ public static class DependencyInstaller
     /// Gets all URLs to missing runtime files.
     /// </summary>
     /// <param name="reloadedFolderPath">Folder path for an application, library will check every runtimeconfig.json inside this folder.</param>
-    public static async Task<HashSet<UrlCommandlinePair>> GetMissingRuntimeUrls(string reloadedFolderPath) 
+    public static async Task<HashSet<MissingDependency>> GetMissingDependencies(string reloadedFolderPath)
     {
         var allFiles = Directory.GetFiles(reloadedFolderPath, "*.*", SearchOption.AllDirectories);
         var filesWithRuntimeConfigs = allFiles.Where(x => x.EndsWith(".runtimeconfig.json")).ToArray();
 
         // Now that we have the runtime config files, get all missing deps from them.
-        var urlSet = new HashSet<UrlCommandlinePair>();
+        var urlSet = new HashSet<MissingDependency>();
         var dotNetCommandLineParams = new string[]
         {
             "/install",
@@ -30,38 +30,61 @@ public static async Task<HashSet<UrlCommandlinePair>> GetMissingRuntimeUrls(stri
             foreach (var runtimeConfig in filesWithRuntimeConfigs)
             {
                 var runtimeOptions = RuntimeOptions.FromFile(runtimeConfig);
-                var result = resolver.Resolve(runtimeOptions); ;
+                var result = resolver.Resolve(runtimeOptions);
                 foreach (var missingDep in result.MissingDependencies)
                 {
                     var frameworkDownloader = new FrameworkDownloader(runtimeOptions.GetAllFrameworks()[0].NuGetVersion, missingDep.FrameworkName);
-                    urlSet.Add(new UrlCommandlinePair()
+                    urlSet.Add(new MissingDependency()
                     {
-                        FriendlyName = $".NET Core {runtimeOptions.GetAllFrameworks()[0].Version} {architecture}",
-                        Url = await frameworkDownloader.GetDownloadUrlAsync(architecture),
-                        Parameters = dotNetCommandLineParams
+                        FriendlyName = $".NET Core {missingDep.Version} {missingDep.FrameworkName} ({architecture})",
+                        Url = await frameworkDownloader.GetDownloadUrlAsync(architecture, Platform.Windows, Format.Executable, false),
+                        Parameters = dotNetCommandLineParams,
+                        NetFrameworkName = missingDep.FrameworkName,
+                        Version = missingDep.Version,
+                        Architecture = architecture
                     });
                 }
             }
         }
 
+        // Filter out redundant .NET Runtime when .NET Desktop Runtime exists
+        var groupedDeps = urlSet
+            .Where(dep => dep.NetFrameworkName.HasValue)
+            .GroupBy(dep => new { dep.Version, dep.Architecture });
+
+        foreach (var group in groupedDeps)
+        {
+            var depsInGroup = group.ToList();
+            var hasDesktopRuntime = depsInGroup.Any(dep => dep.NetFrameworkName == FrameworkName.WindowsDesktop);
+            var appRuntimeDeps = depsInGroup.Where(dep => dep.NetFrameworkName == FrameworkName.App).ToList();
+
+            if (hasDesktopRuntime && appRuntimeDeps.Any())
+            {
+                foreach (var redundantDep in appRuntimeDeps)
+                    urlSet.Remove(redundantDep);
+            }
+        }
+
         // Also check for C++ Runtime.
         if (!RedistributablePackage.IsInstalled(RedistributablePackageVersion.VC2015to2019x64))
         {
-            urlSet.Add(new UrlCommandlinePair()
+            urlSet.Add(new MissingDependency()
             {
                 FriendlyName = "Visual C++ Redist x64",
                 Url = "https://aka.ms/vs/17/release/vc_redist.x64.exe",
-                Parameters = dotNetCommandLineParams
+                Parameters = dotNetCommandLineParams,
+                Architecture = Architecture.Amd64
             });
         }
 
         if (!RedistributablePackage.IsInstalled(RedistributablePackageVersion.VC2015to2019x86))
         {
-            urlSet.Add(new UrlCommandlinePair()
+            urlSet.Add(new MissingDependency()
             {
                 FriendlyName = "Visual C++ Redist x86",
                 Url = "https://aka.ms/vs/17/release/vc_redist.x86.exe",
-                Parameters = dotNetCommandLineParams
+                Parameters = dotNetCommandLineParams,
+                Architecture = Architecture.x86
             });
         }
 
@@ -81,7 +104,7 @@ public static async Task CheckAndInstallMissingRuntimesAsync(string folderPath,
     {
         // Get files with runtime configurations.
         setCurrentStepDescription?.Invoke("Searching for Missing Runtimes");
-        var urlSet = await GetMissingRuntimeUrls(folderPath);
+        var urlSet = await GetMissingDependencies(folderPath);
 
         await DownloadAndInstallRuntimesAsync(urlSet, downloadDirPath, progress, setCurrentStepDescription, token);
     }
@@ -91,21 +114,22 @@ public static async Task CheckAndInstallMissingRuntimesAsync(string folderPath,
     /// [Requires Admin Permission]
     /// Finds all missing runtimes and silently installs them.
     /// </summary>
-    /// <param name="urlSet">Set of all URLs and commandline arguments for the downloaded files. Obtained form running <see cref="GetMissingRuntimeUrls"/>.</param>
+    /// <param name="urlSet">Set of all URLs and commandline arguments for the downloaded files. Obtained form running <see cref="GetMissingDependencies"/>.</param>
     /// <param name="downloadDirPath">Path to where the temporary runtimes should be downloaded to.</param>
     /// <param name="progress">Progress for the installation operation.</param>
     /// <param name="setCurrentStepDescription">Shows a description of the current runtime installation step.</param>
     /// <param name="token">Token allowing you to cancel the install task.</param>
-    public static async Task DownloadAndInstallRuntimesAsync(HashSet<UrlCommandlinePair> urlSet, string downloadDirPath, IProgress<double> progress, Action<string> setCurrentStepDescription, CancellationToken token = default)
+    public static async Task DownloadAndInstallRuntimesAsync(IEnumerable<MissingDependency> urlSet, string downloadDirPath, IProgress<double> progress, Action<string> setCurrentStepDescription, CancellationToken token = default)
     {
         // Download Runtimes 
-        setCurrentStepDescription?.Invoke("Downloading & Installing Runtimes");
+        setCurrentStepDescription?.Invoke("Downloading Runtimes...");
         var progressSlicer = new ProgressSlicer(progress);
         var downloadSlice = progressSlicer.Slice(0.8f);
         var installSlice = progressSlicer.Slice(0.2f);
 
-        var downloadQueue = new ConcurrentQueue<UrlCommandlinePair>(urlSet);
-        var installQueue = new ConcurrentQueue<UrlCommandlinePair>();
+        var downloadQueue = new ConcurrentQueue<MissingDependency>(urlSet);
+        var numItems = downloadQueue.Count;
+        var installQueue = new ConcurrentQueue<MissingDependency>();
 
         // Start background download and install.
         var downloadTask = DownloadAllRuntimesAsync();
@@ -116,7 +140,7 @@ async Task DownloadAllRuntimesAsync()
             var downloadSlicer = new ProgressSlicer(downloadSlice);
             int x = 0;
 
-            while (downloadQueue.TryDequeue(out UrlCommandlinePair downloadLink))
+            while (downloadQueue.TryDequeue(out MissingDependency downloadLink))
             {
                 var client = new WebClient();
                 var downloadProgress = downloadSlicer.Slice(1.0 / queueElements);
@@ -130,8 +154,9 @@ async Task DownloadAllRuntimesAsync()
                 if (token.IsCancellationRequested)
                     throw new TaskCanceledException();
 
-                installQueue.Enqueue(new UrlCommandlinePair()
+                installQueue.Enqueue(new MissingDependency()
                 {
+                    FriendlyName = downloadLink.FriendlyName,
                     Parameters = downloadLink.Parameters,
                     Url = filePath
                 });
@@ -142,12 +167,13 @@ async Task DownloadAllRuntimesAsync()
         async Task InstallAllRuntimesAsync()
         {
             var installSlicer = new ProgressSlicer(installSlice);
-            var queueElements = urlSet.Count;
+            var queueElements = numItems;
 
             loopstart:
-            while (installQueue.TryDequeue(out UrlCommandlinePair runtimeInstallPath))
+            while (installQueue.TryDequeue(out MissingDependency runtimeInstallPath))
             {
                 var installProgress = installSlicer.Slice(1.0 / queueElements);
+                setCurrentStepDescription?.Invoke("Installing Runtime: " + runtimeInstallPath.FriendlyName);
                 ExecuteAsAdmin(runtimeInstallPath.Url, runtimeInstallPath.Parameters);
                 installProgress.Report(1);
             }
@@ -190,21 +216,66 @@ private static void SetArguments(this ProcessStartInfo processStartInfo, IEnumer
     }
 }
 
-public class UrlCommandlinePair
+public class MissingDependency : IEquatable<MissingDependency>
 {
     /// <summary>
     /// [Optional]
     /// Friendly name for the installation.
     /// </summary>
-    public string FriendlyName;
+    public string FriendlyName { get; set; }
 
     /// <summary>
     /// URL for the runtime to be downloaded, or for the extracted runtime.
     /// </summary>
-    public string Url;
+    public string Url { get; set; }
+
+    /// <summary>
+    /// Architecture of the runtime to be downloaded.
+    /// </summary>
+    public Architecture Architecture { get; set; }
 
     /// <summary>
     /// Commandline parameters to install the runtime components.
     /// </summary>
-    public IEnumerable<string> Parameters;
+    public IEnumerable<string> Parameters { get; set; }
+
+    /// <summary>
+    /// Name of the .NET Framework, e.g. "Microsoft.WindowsDesktop.App".
+    /// </summary>
+    public FrameworkName? NetFrameworkName { get; set; }
+    
+    /// <summary>
+    /// Optional version (if known).
+    /// </summary>
+    public string Version { get; set; }
+
+    // Autogenerated by R#
+    public bool Equals(MissingDependency other)
+    {
+        if (other is null) return false;
+        if (ReferenceEquals(this, other)) return true;
+        return FriendlyName == other.FriendlyName && Url == other.Url && Architecture == other.Architecture && Equals(Parameters, other.Parameters) && NetFrameworkName == other.NetFrameworkName && Version == other.Version;
+    }
+
+    public override bool Equals(object obj)
+    {
+        if (obj is null) return false;
+        if (ReferenceEquals(this, obj)) return true;
+        if (obj.GetType() != GetType()) return false;
+        return Equals((MissingDependency)obj);
+    }
+
+    public override int GetHashCode()
+    {
+        unchecked
+        {
+            var hashCode = (FriendlyName != null ? FriendlyName.GetHashCode() : 0);
+            hashCode = (hashCode * 397) ^ (Url != null ? Url.GetHashCode() : 0);
+            hashCode = (hashCode * 397) ^ (int)Architecture;
+            hashCode = (hashCode * 397) ^ (Parameters != null ? Parameters.GetHashCode() : 0);
+            hashCode = (hashCode * 397) ^ NetFrameworkName.GetHashCode();
+            hashCode = (hashCode * 397) ^ (Version != null ? Version.GetHashCode() : 0);
+            return hashCode;
+        }
+    }
 }

source/Reloaded.Mod.Launcher.Lib/Models/Model/Dialog/MissingDependency.cs

@@ -1,3 +1,6 @@
+using Reloaded.Mod.Installer.DependencyInstaller;
+using Reloaded.Mod.Installer.DependencyInstaller.IO;
+
 namespace Reloaded.Mod.Launcher.Lib.Models.ViewModel.Dialog;
 
 /// <summary>
@@ -8,12 +11,60 @@ public class MissingCoreDependencyDialogViewModel : ObservableObject
     /// <summary>
     /// List of missing dependencies to run Reloaded.
     /// </summary>
-    public ObservableCollection<MissingDependency> Dependencies { get; set; }
+    public required ObservableCollection<MissingDependency> Dependencies { get; init; }
+
+    /// <summary>
+    /// Progress of the current download operation.
+    /// Range 0 - 100.
+    /// </summary>
+    public double Progress { get; set; }
+
+    /// <summary>
+    /// True if user can press download button, else false.
+    /// </summary>
+    public bool CanDownload { get; set; } = true;
+
+    /// <summary>
+    /// The current step being performed during the download/installation process.
+    /// </summary>
+    public string CurrentStep { get; set; } = "";
 
-    /// <inheritdoc />
-    public MissingCoreDependencyDialogViewModel(DependencyChecker deps)
+    /// <summary>
+    /// Checks current dependencies, returning a new instance of this ViewModel if any dependencies are missing.
+    /// </summary>
+    /// <param name="launcherLocation"></param>
+    public static async Task<MissingCoreDependencyDialogViewModel> CreateAsync(string launcherLocation)
+    {
+        var deps = await DependencyInstaller.GetMissingDependencies(launcherLocation);
+        return new MissingCoreDependencyDialogViewModel()
+        {
+            Dependencies = new ObservableCollection<MissingDependency>(deps)
+        };
+    }
+
+    /// <summary>
+    /// True if any dependencies are missing.
+    /// </summary>
+    public bool MissingDependencies => Dependencies.Count > 0;
+
+    /// <summary>
+    /// Downloads and installs all missing dependencies with progress reporting.
+    /// </summary>
+    public async Task<bool> DownloadAndInstallMissingDependenciesAsync()
     {
-        var models = deps.Dependencies.Where(x => !x.Available).Select(x => new MissingDependency(x));
-        Dependencies = new ObservableCollection<MissingDependency>(models);
+        CanDownload = false;
+        try
+        {
+            using var tempDownloadDir = new TemporaryFolderAllocation();
+            await DependencyInstaller.DownloadAndInstallRuntimesAsync(Dependencies, tempDownloadDir.FolderPath, 
+                new Progress<double>(d => Progress = d * 100), 
+                step => CurrentStep = step);
+            return true;
+        }
+        finally
+        {
+            CanDownload = true;
+            CurrentStep = "";
+        }
     }
 }

source/Reloaded.Mod.Launcher.Lib/Models/ViewModel/Dialog/MissingCoreDependencyViewModel.cs

@@ -96,7 +96,7 @@ public async Task Update()
 
     private void OnApplySelfUpdate(string newUpdateDir)
     {
-        var updates = Task.Run(() => DependencyInstaller.GetMissingRuntimeUrls(newUpdateDir)).GetAwaiter().GetResult();
+        var updates = Task.Run(() => DependencyInstaller.GetMissingDependencies(newUpdateDir)).GetAwaiter().GetResult();
         if (updates.Count <= 0)
             return;
 

source/Reloaded.Mod.Launcher.Lib/Models/ViewModel/Dialog/ModLoaderUpdateDialogViewModel.cs

@@ -43,10 +43,6 @@
     </Content>
   </ItemGroup>
 
-  <ItemGroup>
-    <Folder Include="Models\Model\DownloadModDialog\" />
-  </ItemGroup>
-
   <Import Project="..\Reloaded.Mod.Shared\Reloaded.Mod.Shared.projitems" Label="Shared" />
 
 </Project>

source/Reloaded.Mod.Launcher.Lib/Reloaded.Mod.Launcher.Lib.csproj

@@ -35,7 +35,7 @@ public static async Task SetupApplicationAsync(Action<string> updateText, int mi
 
             updateText(Resources.SplashCreatingDefaultConfig.Get());
             backgroundTasks.Add(UpdateDefaultConfig()); // Fire and forget.
-            CheckForMissingDependencies();
+            await CheckForMissingDependenciesAsync(); // blocks async only if missing dependencies, so no perf penalty
 
             updateText(Resources.SplashPreparingResources.Get());
             backgroundTasks.Add(Task.Run(CheckForUpdatesAsync)); // Fire and forget, we don't want to delay startup time.
@@ -83,15 +83,17 @@ private static void HandleLogsAndCrashdumps()
     /// <summary>
     /// Checks for missing mod loader dependencies.
     /// </summary>
-    private static void CheckForMissingDependencies()
+    private static async Task CheckForMissingDependenciesAsync()
     {
-        var deps = new DependencyChecker(IoC.Get<LoaderConfig>(), IntPtr.Size == 8);
-        if (deps.AllAvailable) 
+        var loaderConfig = IoC.Get<LoaderConfig>();
+        var vm = await MissingCoreDependencyDialogViewModel.CreateAsync(Path.GetDirectoryName(loaderConfig.LauncherPath)!);
+        if (!vm.MissingDependencies)
             return;
-
+        
+        // ReSharper disable once MethodHasAsyncOverload
         ActionWrappers.ExecuteWithApplicationDispatcher(() =>
         {
-            Actions.ShowMissingCoreDependencyDialog(new MissingCoreDependencyDialogViewModel(deps));
+            Actions.ShowMissingCoreDependencyDialog(vm);
         });
     }