From e64795aad8f17c1896f6cb77faef81fe7703f480 Mon Sep 17 00:00:00 2001 From: Christoph Wille Date: Sun, 26 May 2024 11:56:09 +0200 Subject: [PATCH 1/9] Prepare new AppEnv namespace that will house all application environment code (configuration and runtime) --- ILSpy/App.xaml.cs | 1 + ILSpy/{ => AppEnv}/CommandLineArguments.cs | 2 +- ILSpy/{ => AppEnv}/CommandLineTools.cs | 2 +- ILSpy/Commands/ScopeSearchToAssembly.cs | 1 + ILSpy/Commands/ScopeSearchToNamespace.cs | 1 + ILSpy/MainWindow.xaml.cs | 1 + ILSpy/Options/MiscSettingsViewModel.cs | 1 + ILSpy/Search/SearchPane.cs | 1 + 8 files changed, 8 insertions(+), 2 deletions(-) rename ILSpy/{ => AppEnv}/CommandLineArguments.cs (99%) rename ILSpy/{ => AppEnv}/CommandLineTools.cs (99%) diff --git a/ILSpy/App.xaml.cs b/ILSpy/App.xaml.cs index 5779727c4..26bad4cfe 100644 --- a/ILSpy/App.xaml.cs +++ b/ILSpy/App.xaml.cs @@ -30,6 +30,7 @@ using System.Windows.Documents; using System.Windows.Navigation; using System.Windows.Threading; +using ICSharpCode.ILSpy.AppEnv; using ICSharpCode.ILSpy.Options; using ICSharpCode.ILSpyX.Analyzers; using ICSharpCode.ILSpyX.Settings; diff --git a/ILSpy/CommandLineArguments.cs b/ILSpy/AppEnv/CommandLineArguments.cs similarity index 99% rename from ILSpy/CommandLineArguments.cs rename to ILSpy/AppEnv/CommandLineArguments.cs index df1114e38..116d8b188 100644 --- a/ILSpy/CommandLineArguments.cs +++ b/ILSpy/AppEnv/CommandLineArguments.cs @@ -21,7 +21,7 @@ using McMaster.Extensions.CommandLineUtils; using System.Collections.Generic; using System.Linq; -namespace ICSharpCode.ILSpy +namespace ICSharpCode.ILSpy.AppEnv { public sealed class CommandLineArguments { diff --git a/ILSpy/CommandLineTools.cs b/ILSpy/AppEnv/CommandLineTools.cs similarity index 99% rename from ILSpy/CommandLineTools.cs rename to ILSpy/AppEnv/CommandLineTools.cs index 898981996..4ff581ba6 100644 --- a/ILSpy/CommandLineTools.cs +++ b/ILSpy/AppEnv/CommandLineTools.cs @@ -20,7 +20,7 @@ using System; using System.Collections.Generic; using System.Text; -namespace ICSharpCode.ILSpy +namespace ICSharpCode.ILSpy.AppEnv { public class CommandLineTools { diff --git a/ILSpy/Commands/ScopeSearchToAssembly.cs b/ILSpy/Commands/ScopeSearchToAssembly.cs index 861e7c8f5..1ec6ef73b 100644 --- a/ILSpy/Commands/ScopeSearchToAssembly.cs +++ b/ILSpy/Commands/ScopeSearchToAssembly.cs @@ -20,6 +20,7 @@ using System; using ICSharpCode.Decompiler.TypeSystem; +using ICSharpCode.ILSpy.AppEnv; using ICSharpCode.ILSpy.Properties; using ICSharpCode.ILSpy.TreeNodes; diff --git a/ILSpy/Commands/ScopeSearchToNamespace.cs b/ILSpy/Commands/ScopeSearchToNamespace.cs index 2c5fead92..11a411ed6 100644 --- a/ILSpy/Commands/ScopeSearchToNamespace.cs +++ b/ILSpy/Commands/ScopeSearchToNamespace.cs @@ -18,6 +18,7 @@ using System; using ICSharpCode.Decompiler.TypeSystem; +using ICSharpCode.ILSpy.AppEnv; using ICSharpCode.ILSpy.Properties; using ICSharpCode.ILSpy.TreeNodes; diff --git a/ILSpy/MainWindow.xaml.cs b/ILSpy/MainWindow.xaml.cs index 999abdca3..474a86dd2 100644 --- a/ILSpy/MainWindow.xaml.cs +++ b/ILSpy/MainWindow.xaml.cs @@ -44,6 +44,7 @@ using ICSharpCode.Decompiler.Metadata; using ICSharpCode.Decompiler.TypeSystem; using ICSharpCode.Decompiler.TypeSystem.Implementation; using ICSharpCode.ILSpy.Analyzers; +using ICSharpCode.ILSpy.AppEnv; using ICSharpCode.ILSpy.Commands; using ICSharpCode.ILSpy.Docking; using ICSharpCode.ILSpy.Options; diff --git a/ILSpy/Options/MiscSettingsViewModel.cs b/ILSpy/Options/MiscSettingsViewModel.cs index 6e9562e1b..bb29b91e3 100644 --- a/ILSpy/Options/MiscSettingsViewModel.cs +++ b/ILSpy/Options/MiscSettingsViewModel.cs @@ -24,6 +24,7 @@ using System.Runtime.CompilerServices; using System.Windows; using System.Windows.Input; +using ICSharpCode.ILSpy.AppEnv; using ICSharpCode.ILSpy.Commands; using ICSharpCode.ILSpyX.Settings; diff --git a/ILSpy/Search/SearchPane.cs b/ILSpy/Search/SearchPane.cs index 87a65c6fa..55a29370c 100644 --- a/ILSpy/Search/SearchPane.cs +++ b/ILSpy/Search/SearchPane.cs @@ -32,6 +32,7 @@ using System.Windows.Input; using System.Windows.Media; using System.Windows.Threading; +using ICSharpCode.ILSpy.AppEnv; using ICSharpCode.ILSpy.Docking; using ICSharpCode.ILSpy.ViewModels; using ICSharpCode.ILSpyX; From 82fece3d167d0209776da6cd8b697dd6d476c283 Mon Sep 17 00:00:00 2001 From: Christoph Wille Date: Sun, 26 May 2024 12:23:06 +0200 Subject: [PATCH 2/9] Add unmodified Medo SingleInstance https://github.com/medo64/Medo/blob/main/src/Medo/Application/SingleInstance.cs --- ILSpy.Tests/CommandLineArgumentsTests.cs | 2 + ILSpy/App.xaml.cs | 16 +- ILSpy/AppEnv/CommandLineTools.cs | 21 ++ ILSpy/AppEnv/SingleInstance.cs | 290 +++++++++++++++++++++++ ILSpy/MainWindow.xaml.cs | 40 +--- ILSpy/SingleInstanceHandling.cs | 158 ------------ 6 files changed, 331 insertions(+), 196 deletions(-) create mode 100644 ILSpy/AppEnv/SingleInstance.cs delete mode 100644 ILSpy/SingleInstanceHandling.cs diff --git a/ILSpy.Tests/CommandLineArgumentsTests.cs b/ILSpy.Tests/CommandLineArgumentsTests.cs index 026c86b81..addf682d4 100644 --- a/ILSpy.Tests/CommandLineArgumentsTests.cs +++ b/ILSpy.Tests/CommandLineArgumentsTests.cs @@ -2,6 +2,8 @@ using FluentAssertions; +using ICSharpCode.ILSpy.AppEnv; + using NUnit.Framework; namespace ICSharpCode.ILSpy.Tests diff --git a/ILSpy/App.xaml.cs b/ILSpy/App.xaml.cs index 26bad4cfe..86dbc410c 100644 --- a/ILSpy/App.xaml.cs +++ b/ILSpy/App.xaml.cs @@ -35,6 +35,8 @@ using ICSharpCode.ILSpy.Options; using ICSharpCode.ILSpyX.Analyzers; using ICSharpCode.ILSpyX.Settings; +using Medo.Application; + using Microsoft.VisualStudio.Composition; using TomsToolbox.Wpf.Styles; @@ -69,7 +71,8 @@ namespace ICSharpCode.ILSpy && !MiscSettingsPanel.CurrentMiscSettings.AllowMultipleInstances; if (forceSingleInstance) { - SingleInstanceHandling.ForceSingleInstance(cmdArgs); + SingleInstance.Attach(); // will auto-exit for second instance + SingleInstance.NewInstanceDetected += SingleInstance_NewInstanceDetected; } InitializeComponent(); @@ -101,6 +104,17 @@ namespace ICSharpCode.ILSpy } } + private static void SingleInstance_NewInstanceDetected(object? sender, NewInstanceEventArgs e) + { + var mainWindow = ICSharpCode.ILSpy.MainWindow.Instance; + + var args = new CommandLineArguments(e.Args); + if (mainWindow.HandleCommandLineArguments(args)) + { + mainWindow.HandleCommandLineArgumentsAfterShowList(args); + } + } + static Assembly ResolvePluginDependencies(AssemblyLoadContext context, AssemblyName assemblyName) { var rootPath = Path.GetDirectoryName(typeof(App).Assembly.Location); diff --git a/ILSpy/AppEnv/CommandLineTools.cs b/ILSpy/AppEnv/CommandLineTools.cs index 4ff581ba6..7379db12e 100644 --- a/ILSpy/AppEnv/CommandLineTools.cs +++ b/ILSpy/AppEnv/CommandLineTools.cs @@ -18,6 +18,7 @@ using System; using System.Collections.Generic; +using System.IO; using System.Text; namespace ICSharpCode.ILSpy.AppEnv @@ -110,6 +111,26 @@ namespace ICSharpCode.ILSpy.AppEnv b.Append('"'); } } + + public static string FullyQualifyPath(string argument) + { + // Fully qualify the paths before passing them to another process, + // because that process might use a different current directory. + if (string.IsNullOrEmpty(argument) || argument[0] == '-') + return argument; + try + { + if (argument.StartsWith("@")) + { + return "@" + FullyQualifyPath(argument.Substring(1)); + } + return Path.Combine(Environment.CurrentDirectory, argument); + } + catch (ArgumentException) + { + return argument; + } + } } // Source: https://github.com/dotnet/runtime/blob/bc9fc5a774d96f95abe0ea5c90fac48b38ed2e67/src/libraries/System.Diagnostics.Process/src/System/Diagnostics/Process.Unix.cs#L574-L606 diff --git a/ILSpy/AppEnv/SingleInstance.cs b/ILSpy/AppEnv/SingleInstance.cs new file mode 100644 index 000000000..0983eeab4 --- /dev/null +++ b/ILSpy/AppEnv/SingleInstance.cs @@ -0,0 +1,290 @@ +// Source: https://github.com/medo64/Medo/blob/main/src/Medo/Application/SingleInstance.cs + +/* Josip Medved * www.medo64.com * MIT License */ + +//2022-12-01: Compatible with .NET 6 and 7 +//2012-11-24: Suppressing bogus CA5122 warning (http://connect.microsoft.com/VisualStudio/feedback/details/729254/bogus-ca5122-warning-about-p-invoke-declarations-should-not-be-safe-critical) +//2010-10-07: Added IsOtherInstanceRunning method +//2008-11-14: Reworked code to use SafeHandle +//2008-04-11: Cleaned code to match FxCop 1.36 beta 2 (SpecifyMarshalingForPInvokeStringArguments, NestedTypesShouldNotBeVisible) +//2008-04-10: NewInstanceEventArgs is not nested class anymore +//2008-01-26: AutoExit parameter changed to NoAutoExit +//2008-01-08: Main method is now called Attach +//2008-01-06: System.Environment.Exit returns E_ABORT (0x80004004) +//2008-01-03: Added Resources +//2007-12-29: New version + +namespace Medo.Application; + +using System; +using System.Diagnostics; +using System.IO.Pipes; +using System.Reflection; +using System.Runtime.InteropServices; +using System.Security.Cryptography; +using System.Text; +using System.Text.Json; +using System.Text.Json.Serialization; +using System.Threading; + +/// +/// Handles detection and communication of programs multiple instances. +/// This class is thread safe. +/// +public static class SingleInstance +{ + + private static Mutex? _mtxFirstInstance; + private static Thread? _thread; + private static readonly object _syncRoot = new(); + + + /// + /// Returns true if this application is not already started. + /// Another instance is contacted via named pipe. + /// + /// API call failed. + public static bool Attach() + { + return Attach(false); + } + + /// + /// Returns true if this application is not already started. + /// Another instance is contacted via named pipe. + /// + /// If true, application will exit after informing another instance. + /// API call failed. + public static bool Attach(bool noAutoExit) + { + lock (_syncRoot) + { + var isFirstInstance = false; + try + { + _mtxFirstInstance = new Mutex(initiallyOwned: true, @"Global\" + MutexName, out isFirstInstance); + if (isFirstInstance == false) + { //we need to contact previous instance + var contentObject = new SingleInstanceArguments() { + CommandLine = Environment.CommandLine, + CommandLineArgs = Environment.GetCommandLineArgs(), + }; + var contentBytes = JsonSerializer.SerializeToUtf8Bytes(contentObject); + using var clientPipe = new NamedPipeClientStream(".", + MutexName, + PipeDirection.Out, + PipeOptions.CurrentUserOnly | PipeOptions.WriteThrough); + clientPipe.Connect(); + clientPipe.Write(contentBytes, 0, contentBytes.Length); + } + else + { //there is no application already running. + _thread = new Thread(Run) { + Name = typeof(SingleInstance).FullName, + IsBackground = true + }; + _thread.Start(); + } + } + catch (Exception ex) + { + Trace.TraceWarning(ex.Message + " {Medo.Application.SingleInstance}"); + } + + if ((isFirstInstance == false) && (noAutoExit == false)) + { + Trace.TraceInformation("Exit due to another instance running." + " [" + nameof(SingleInstance) + "]"); + if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) + { + Environment.Exit(unchecked((int)0x80004004)); // E_ABORT(0x80004004) + } + else + { + Environment.Exit(114); // EALREADY(114) + } + } + + return isFirstInstance; + } + } + + private static string? _mutexName; + private static string MutexName { + get { + lock (_syncRoot) + { + if (_mutexName == null) + { + var assembly = Assembly.GetEntryAssembly(); + + var sbMutextName = new StringBuilder(); + var assName = assembly?.GetName().Name; + if (assName != null) + { + sbMutextName.Append(assName, 0, Math.Min(assName.Length, 31)); + sbMutextName.Append('.'); + } + + var sbHash = new StringBuilder(); + sbHash.AppendLine(Environment.MachineName); + sbHash.AppendLine(Environment.UserName); + if (assembly != null) + { + sbHash.AppendLine(assembly.FullName); + sbHash.AppendLine(assembly.Location); + } + else + { + var args = Environment.GetCommandLineArgs(); + if (args.Length > 0) + { sbHash.AppendLine(args[0]); } + } + foreach (var b in SHA256.HashData(Encoding.UTF8.GetBytes(sbHash.ToString()))) + { + if (sbMutextName.Length == 63) + { sbMutextName.AppendFormat("{0:X1}", b >> 4); } // just take the first nubble + if (sbMutextName.Length == 64) + { break; } + sbMutextName.AppendFormat("{0:X2}", b); + } + _mutexName = sbMutextName.ToString(); + } + return _mutexName; + } + } + } + + /// + /// Gets whether there is another instance running. + /// It temporary creates mutex. + /// + public static bool IsOtherInstanceRunning { + get { + lock (_syncRoot) + { + if (_mtxFirstInstance != null) + { + return false; //no other instance is running + } + else + { + var tempInstance = new Mutex(true, MutexName, out var isFirstInstance); + tempInstance.Close(); + return (isFirstInstance == false); + } + } + } + } + + /// + /// Occurs in first instance when new instance is detected. + /// + public static event EventHandler? NewInstanceDetected; + + + /// + /// Thread function. + /// + private static void Run() + { + using var serverPipe = new NamedPipeServerStream(MutexName, + PipeDirection.In, + maxNumberOfServerInstances: 1, + PipeTransmissionMode.Byte, + PipeOptions.CurrentUserOnly | PipeOptions.WriteThrough); + while (_mtxFirstInstance != null) + { + try + { + if (!serverPipe.IsConnected) + { serverPipe.WaitForConnection(); } + var contentObject = JsonSerializer.Deserialize(serverPipe); + serverPipe.Disconnect(); + if (contentObject != null) + { + NewInstanceDetected?.Invoke(null, + new NewInstanceEventArgs( + contentObject.CommandLine, + contentObject.CommandLineArgs)); + } + } + catch (Exception ex) + { + Trace.TraceWarning(ex.Message + " [" + nameof(SingleInstance) + "]"); + Thread.Sleep(100); + } + } + } + + + [Serializable] + private sealed record SingleInstanceArguments + { // just a storage +#if NET7_0_OR_GREATER + [JsonInclude] + public required string CommandLine; + + [JsonInclude] + public required string[] CommandLineArgs; +#else + public SingleInstanceArguments() { + CommandLine = string.Empty; + CommandLineArgs = Array.Empty(); + } + + [JsonInclude] + public string CommandLine; + + [JsonInclude] + public string[] CommandLineArgs; +#endif + } + +} + + +/// +/// Arguments for newly detected application instance. +/// +public sealed class NewInstanceEventArgs : EventArgs +{ + /// + /// Creates new instance. + /// + /// Command line. + /// String array containing the command line arguments in the same format as Environment.GetCommandLineArgs. + internal NewInstanceEventArgs(string commandLine, string[] commandLineArgs) + { + CommandLine = commandLine; + _commandLineArgs = new string[commandLineArgs.Length]; + Array.Copy(commandLineArgs, _commandLineArgs, _commandLineArgs.Length); + } + + /// + /// Gets the command line. + /// + public string CommandLine { get; } + + private readonly string[] _commandLineArgs; + /// + /// Returns a string array containing the command line arguments. + /// + public string[] GetCommandLineArgs() + { + var argCopy = new string[_commandLineArgs.Length]; + Array.Copy(_commandLineArgs, argCopy, argCopy.Length); + return argCopy; + } + + /// + /// Gets a string array containing the command line arguments without the name of exectuable. + /// + public string[] Args { + get { + var argCopy = new string[_commandLineArgs.Length - 1]; + Array.Copy(_commandLineArgs, 1, argCopy, 0, argCopy.Length); + return argCopy; + } + } + +} diff --git a/ILSpy/MainWindow.xaml.cs b/ILSpy/MainWindow.xaml.cs index 474a86dd2..5b01ec67a 100644 --- a/ILSpy/MainWindow.xaml.cs +++ b/ILSpy/MainWindow.xaml.cs @@ -600,12 +600,7 @@ namespace ICSharpCode.ILSpy { base.OnSourceInitialized(e); PresentationSource source = PresentationSource.FromVisual(this); - HwndSource hwndSource = source as HwndSource; - if (hwndSource != null) - { - hwndSource.AddHook(WndProc); - } - SingleInstanceHandling.ReleaseSingleInstanceMutex(); + // Validate and Set Window Bounds Rect bounds = Rect.Transform(sessionSettings.WindowBounds, source.CompositionTarget.TransformToDevice); var boundsRect = new System.Drawing.Rectangle((int)bounds.Left, (int)bounds.Top, (int)bounds.Width, (int)bounds.Height); @@ -624,35 +619,6 @@ namespace ICSharpCode.ILSpy this.WindowState = sessionSettings.WindowState; } - unsafe IntPtr WndProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled) - { - if (msg == NativeMethods.WM_COPYDATA) - { - CopyDataStruct* copyData = (CopyDataStruct*)lParam; - string data = new string((char*)copyData->Buffer, 0, copyData->Size / sizeof(char)); - if (data.StartsWith("ILSpy:\r\n", StringComparison.Ordinal)) - { - data = data.Substring(8); - List lines = new List(); - using (StringReader r = new StringReader(data)) - { - string line; - while ((line = r.ReadLine()) != null) - lines.Add(line); - } - var args = new CommandLineArguments(lines); - if (HandleCommandLineArguments(args)) - { - if (!args.NoActivate && WindowState == WindowState.Minimized) - WindowState = WindowState.Normal; - HandleCommandLineArgumentsAfterShowList(args); - handled = true; - return (IntPtr)1; - } - } - } - return IntPtr.Zero; - } #endregion protected override void OnKeyDown(KeyEventArgs e) @@ -686,7 +652,7 @@ namespace ICSharpCode.ILSpy List commandLineLoadedAssemblies = new List(); - bool HandleCommandLineArguments(CommandLineArguments args) + internal bool HandleCommandLineArguments(CommandLineArguments args) { LoadAssemblies(args.AssembliesToLoad, commandLineLoadedAssemblies, focusNode: false); if (args.Language != null) @@ -698,7 +664,7 @@ namespace ICSharpCode.ILSpy /// Called on startup or when passed arguments via WndProc from a second instance. /// In the format case, spySettings is non-null; in the latter it is null. /// - void HandleCommandLineArgumentsAfterShowList(CommandLineArguments args, ILSpySettings spySettings = null) + internal void HandleCommandLineArgumentsAfterShowList(CommandLineArguments args, ILSpySettings spySettings = null) { var relevantAssemblies = commandLineLoadedAssemblies.ToList(); commandLineLoadedAssemblies.Clear(); // clear references once we don't need them anymore diff --git a/ILSpy/SingleInstanceHandling.cs b/ILSpy/SingleInstanceHandling.cs deleted file mode 100644 index 5736dffc7..000000000 --- a/ILSpy/SingleInstanceHandling.cs +++ /dev/null @@ -1,158 +0,0 @@ -// Copyright (c) 2022 AlphaSierraPapa for the SharpDevelop Team -// -// Permission is hereby granted, free of charge, to any person obtaining a copy of this -// software and associated documentation files (the "Software"), to deal in the Software -// without restriction, including without limitation the rights to use, copy, modify, merge, -// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons -// to whom the Software is furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in all copies or -// substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, -// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR -// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE -// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR -// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER -// DEALINGS IN THE SOFTWARE. - -using System; -using System.Collections.Generic; -using System.Diagnostics; -using System.IO; -using System.Linq; -using System.Threading; - -namespace ICSharpCode.ILSpy -{ - internal static class SingleInstanceHandling - { - internal static Mutex SingleInstanceMutex; - - internal static void ForceSingleInstance(IEnumerable cmdArgs) - { - bool isFirst; - try - { - SingleInstanceMutex = new Mutex(initiallyOwned: true, @"Local\ILSpyInstance", out isFirst); - } - catch (WaitHandleCannotBeOpenedException) - { - isFirst = true; - } - if (!isFirst) - { - try - { - SingleInstanceMutex.WaitOne(10000); - } - catch (AbandonedMutexException) - { - // continue, there is no concurrent start happening. - } - } - cmdArgs = cmdArgs.Select(FullyQualifyPath); - string message = string.Join(Environment.NewLine, cmdArgs); - if (SendToPreviousInstance("ILSpy:\r\n" + message, !App.CommandLineArguments.NoActivate)) - { - ReleaseSingleInstanceMutex(); - Environment.Exit(0); - } - } - - internal static string FullyQualifyPath(string argument) - { - // Fully qualify the paths before passing them to another process, - // because that process might use a different current directory. - if (string.IsNullOrEmpty(argument) || argument[0] == '-') - return argument; - try - { - if (argument.StartsWith("@")) - { - return "@" + FullyQualifyPath(argument.Substring(1)); - } - return Path.Combine(Environment.CurrentDirectory, argument); - } - catch (ArgumentException) - { - return argument; - } - } - - internal static void ReleaseSingleInstanceMutex() - { - var mutex = SingleInstanceMutex; - SingleInstanceMutex = null; - if (mutex == null) - { - return; - } - using (mutex) - { - mutex.ReleaseMutex(); - } - } - - #region Pass Command Line Arguments to previous instance - internal static bool SendToPreviousInstance(string message, bool activate) - { - string ownProcessName; - using (var ownProcess = Process.GetCurrentProcess()) - { - ownProcessName = ownProcess.ProcessName; - } - - bool success = false; - NativeMethods.EnumWindows( - (hWnd, lParam) => { - string windowTitle = NativeMethods.GetWindowText(hWnd, 100); - if (windowTitle.StartsWith("ILSpy", StringComparison.Ordinal)) - { - string processName = NativeMethods.GetProcessNameFromWindow(hWnd); - Debug.WriteLine("Found {0:x4}: '{1}' in '{2}'", hWnd, windowTitle, processName); - if (string.Equals(processName, ownProcessName, StringComparison.OrdinalIgnoreCase)) - { - IntPtr result = Send(hWnd, message); - Debug.WriteLine("WM_COPYDATA result: {0:x8}", result); - if (result == (IntPtr)1) - { - if (activate) - NativeMethods.SetForegroundWindow(hWnd); - success = true; - return false; // stop enumeration - } - } - } - return true; // continue enumeration - }, IntPtr.Zero); - return success; - } - - unsafe static IntPtr Send(IntPtr hWnd, string message) - { - const uint SMTO_NORMAL = 0; - - CopyDataStruct lParam; - lParam.Padding = IntPtr.Zero; - lParam.Size = message.Length * 2; - fixed (char* buffer = message) - { - lParam.Buffer = (IntPtr)buffer; - IntPtr result; - // SendMessage with 3s timeout (e.g. when the target process is stopped in the debugger) - if (NativeMethods.SendMessageTimeout( - hWnd, NativeMethods.WM_COPYDATA, IntPtr.Zero, ref lParam, - SMTO_NORMAL, 3000, out result) != IntPtr.Zero) - { - return result; - } - else - { - return IntPtr.Zero; - } - } - } - #endregion - } -} From 5fa25a606c0dbb6579c8de3c27fe56fe78d14e2d Mon Sep 17 00:00:00 2001 From: Christoph Wille Date: Sun, 26 May 2024 12:29:32 +0200 Subject: [PATCH 3/9] Add relative path logic to new SingleInstance code --- ILSpy/AppEnv/SingleInstance.cs | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/ILSpy/AppEnv/SingleInstance.cs b/ILSpy/AppEnv/SingleInstance.cs index 0983eeab4..55cb6a60b 100644 --- a/ILSpy/AppEnv/SingleInstance.cs +++ b/ILSpy/AppEnv/SingleInstance.cs @@ -19,6 +19,7 @@ namespace Medo.Application; using System; using System.Diagnostics; using System.IO.Pipes; +using System.Linq; using System.Reflection; using System.Runtime.InteropServices; using System.Security.Cryptography; @@ -27,6 +28,8 @@ using System.Text.Json; using System.Text.Json.Serialization; using System.Threading; +using ICSharpCode.ILSpy.AppEnv; + /// /// Handles detection and communication of programs multiple instances. /// This class is thread safe. @@ -49,6 +52,13 @@ public static class SingleInstance return Attach(false); } + private static string[] GetILSpyCommandLineArgs() + { + var cmdArgs = Environment.GetCommandLineArgs().Skip(1); + cmdArgs = cmdArgs.Select(CommandLineTools.FullyQualifyPath); + return cmdArgs.ToArray(); + } + /// /// Returns true if this application is not already started. /// Another instance is contacted via named pipe. @@ -67,7 +77,7 @@ public static class SingleInstance { //we need to contact previous instance var contentObject = new SingleInstanceArguments() { CommandLine = Environment.CommandLine, - CommandLineArgs = Environment.GetCommandLineArgs(), + CommandLineArgs = GetILSpyCommandLineArgs(), }; var contentBytes = JsonSerializer.SerializeToUtf8Bytes(contentObject); using var clientPipe = new NamedPipeClientStream(".", From 2f93d41abbcb4e6fdabe8deae6e3a48601eba84f Mon Sep 17 00:00:00 2001 From: Christoph Wille Date: Sun, 26 May 2024 12:29:48 +0200 Subject: [PATCH 4/9] Remove obsolete native imports --- ILSpy/NativeMethods.cs | 79 ------------------------------------------ 1 file changed, 79 deletions(-) diff --git a/ILSpy/NativeMethods.cs b/ILSpy/NativeMethods.cs index d24aeba6d..8ba9b02fa 100644 --- a/ILSpy/NativeMethods.cs +++ b/ILSpy/NativeMethods.cs @@ -17,73 +17,12 @@ // DEALINGS IN THE SOFTWARE. using System; -using System.ComponentModel; -using System.Diagnostics; using System.Runtime.InteropServices; -using System.Text; namespace ICSharpCode.ILSpy { static class NativeMethods { - public const uint WM_COPYDATA = 0x4a; - - [DllImport("user32.dll", CharSet = CharSet.Auto)] - [return: MarshalAs(UnmanagedType.Bool)] - internal static extern bool EnumWindows(EnumWindowsProc lpEnumFunc, IntPtr lParam); - - [DllImport("user32.dll", CharSet = CharSet.Auto)] - internal static extern unsafe int GetWindowThreadProcessId(IntPtr hWnd, int* lpdwProcessId); - - [DllImport("user32.dll", CharSet = CharSet.Unicode)] - static extern int GetWindowText(IntPtr hWnd, [Out] StringBuilder title, int size); - - public static string GetWindowText(IntPtr hWnd, int maxLength) - { - StringBuilder b = new StringBuilder(maxLength + 1); - if (GetWindowText(hWnd, b, b.Capacity) != 0) - return b.ToString(); - else - return string.Empty; - } - - [DllImport("user32.dll", CharSet = CharSet.Auto)] - internal static extern IntPtr SendMessageTimeout( - IntPtr hWnd, uint msg, IntPtr wParam, ref CopyDataStruct lParam, - uint flags, uint timeout, out IntPtr result); - - [DllImport("user32.dll", CharSet = CharSet.Auto)] - [return: MarshalAs(UnmanagedType.Bool)] - internal static extern bool SetForegroundWindow(IntPtr hWnd); - - public unsafe static string GetProcessNameFromWindow(IntPtr hWnd) - { - int processId; - GetWindowThreadProcessId(hWnd, &processId); - try - { - using (var p = Process.GetProcessById(processId)) - { - return p.ProcessName; - } - } - catch (ArgumentException ex) - { - Debug.WriteLine(ex.Message); - return null; - } - catch (InvalidOperationException ex) - { - Debug.WriteLine(ex.Message); - return null; - } - catch (Win32Exception ex) - { - Debug.WriteLine(ex.Message); - return null; - } - } - [DllImport("dwmapi.dll", PreserveSig = true)] public static extern int DwmSetWindowAttribute(IntPtr hwnd, DwmWindowAttribute attr, ref int attrValue, int attrSize); @@ -95,24 +34,6 @@ namespace ICSharpCode.ILSpy } } - [return: MarshalAs(UnmanagedType.Bool)] - delegate bool EnumWindowsProc(IntPtr hWnd, IntPtr lParam); - - [StructLayout(LayoutKind.Sequential)] - struct CopyDataStruct - { - public IntPtr Padding; - public int Size; - public IntPtr Buffer; - - public CopyDataStruct(IntPtr padding, int size, IntPtr buffer) - { - this.Padding = padding; - this.Size = size; - this.Buffer = buffer; - } - } - public enum DwmWindowAttribute : uint { NCRenderingEnabled = 1, From 7946f720242ae693f04bd0257e47eebc6300bba3 Mon Sep 17 00:00:00 2001 From: Christoph Wille Date: Sun, 26 May 2024 13:05:47 +0200 Subject: [PATCH 5/9] Centralize single instancing logic back in MainWindow, fix Skip(1) error due to .Args property implementation --- ILSpy/App.xaml.cs | 8 +------- ILSpy/AppEnv/SingleInstance.cs | 7 ++++--- ILSpy/MainWindow.xaml.cs | 16 ++++++++++++++-- 3 files changed, 19 insertions(+), 12 deletions(-) diff --git a/ILSpy/App.xaml.cs b/ILSpy/App.xaml.cs index 86dbc410c..2387c487a 100644 --- a/ILSpy/App.xaml.cs +++ b/ILSpy/App.xaml.cs @@ -106,13 +106,7 @@ namespace ICSharpCode.ILSpy private static void SingleInstance_NewInstanceDetected(object? sender, NewInstanceEventArgs e) { - var mainWindow = ICSharpCode.ILSpy.MainWindow.Instance; - - var args = new CommandLineArguments(e.Args); - if (mainWindow.HandleCommandLineArguments(args)) - { - mainWindow.HandleCommandLineArgumentsAfterShowList(args); - } + ICSharpCode.ILSpy.MainWindow.Instance.HandleSingleInstanceCommandLineArguments(e.Args); } static Assembly ResolvePluginDependencies(AssemblyLoadContext context, AssemblyName assemblyName) diff --git a/ILSpy/AppEnv/SingleInstance.cs b/ILSpy/AppEnv/SingleInstance.cs index 55cb6a60b..eb8e39966 100644 --- a/ILSpy/AppEnv/SingleInstance.cs +++ b/ILSpy/AppEnv/SingleInstance.cs @@ -54,9 +54,10 @@ public static class SingleInstance private static string[] GetILSpyCommandLineArgs() { - var cmdArgs = Environment.GetCommandLineArgs().Skip(1); - cmdArgs = cmdArgs.Select(CommandLineTools.FullyQualifyPath); - return cmdArgs.ToArray(); + // Note: NO Skip(1) here because .Args property on SingleInstanceArguments does this for us + return Environment.GetCommandLineArgs().AsEnumerable() + .Select(CommandLineTools.FullyQualifyPath) + .ToArray(); } /// diff --git a/ILSpy/MainWindow.xaml.cs b/ILSpy/MainWindow.xaml.cs index 5b01ec67a..757cdbe45 100644 --- a/ILSpy/MainWindow.xaml.cs +++ b/ILSpy/MainWindow.xaml.cs @@ -652,7 +652,19 @@ namespace ICSharpCode.ILSpy List commandLineLoadedAssemblies = new List(); - internal bool HandleCommandLineArguments(CommandLineArguments args) + internal async Task HandleSingleInstanceCommandLineArguments(string[] args) + { + var cmdArgs = new CommandLineArguments(args); + + await Dispatcher.InvokeAsync(() => { + if (HandleCommandLineArguments(cmdArgs)) + { + HandleCommandLineArgumentsAfterShowList(cmdArgs); + } + }); + } + + bool HandleCommandLineArguments(CommandLineArguments args) { LoadAssemblies(args.AssembliesToLoad, commandLineLoadedAssemblies, focusNode: false); if (args.Language != null) @@ -664,7 +676,7 @@ namespace ICSharpCode.ILSpy /// Called on startup or when passed arguments via WndProc from a second instance. /// In the format case, spySettings is non-null; in the latter it is null. /// - internal void HandleCommandLineArgumentsAfterShowList(CommandLineArguments args, ILSpySettings spySettings = null) + void HandleCommandLineArgumentsAfterShowList(CommandLineArguments args, ILSpySettings spySettings = null) { var relevantAssemblies = commandLineLoadedAssemblies.ToList(); commandLineLoadedAssemblies.Clear(); // clear references once we don't need them anymore From 8fa41a9cb019eb11a31c39120f80708864828dd5 Mon Sep 17 00:00:00 2001 From: Christoph Wille Date: Sun, 26 May 2024 13:18:32 +0200 Subject: [PATCH 6/9] Remove obsolete code --- ILSpy/AppEnv/SingleInstance.cs | 13 ------------- 1 file changed, 13 deletions(-) diff --git a/ILSpy/AppEnv/SingleInstance.cs b/ILSpy/AppEnv/SingleInstance.cs index eb8e39966..22d5ce6e0 100644 --- a/ILSpy/AppEnv/SingleInstance.cs +++ b/ILSpy/AppEnv/SingleInstance.cs @@ -231,24 +231,11 @@ public static class SingleInstance [Serializable] private sealed record SingleInstanceArguments { // just a storage -#if NET7_0_OR_GREATER [JsonInclude] public required string CommandLine; [JsonInclude] public required string[] CommandLineArgs; -#else - public SingleInstanceArguments() { - CommandLine = string.Empty; - CommandLineArgs = Array.Empty(); - } - - [JsonInclude] - public string CommandLine; - - [JsonInclude] - public string[] CommandLineArgs; -#endif } } From 94654e6d4952531155804c8722c30f63ebe48d0b Mon Sep 17 00:00:00 2001 From: Christoph Wille Date: Sun, 26 May 2024 13:37:10 +0200 Subject: [PATCH 7/9] Add back WindowState handling from command line arguments --- ILSpy/MainWindow.xaml.cs | 3 +++ 1 file changed, 3 insertions(+) diff --git a/ILSpy/MainWindow.xaml.cs b/ILSpy/MainWindow.xaml.cs index 757cdbe45..eed3732db 100644 --- a/ILSpy/MainWindow.xaml.cs +++ b/ILSpy/MainWindow.xaml.cs @@ -659,6 +659,9 @@ namespace ICSharpCode.ILSpy await Dispatcher.InvokeAsync(() => { if (HandleCommandLineArguments(cmdArgs)) { + if (!cmdArgs.NoActivate && WindowState == WindowState.Minimized) + WindowState = WindowState.Normal; + HandleCommandLineArgumentsAfterShowList(cmdArgs); } }); From bc8decc74847b05fd5e44e59a3fb7fc4b44f6613 Mon Sep 17 00:00:00 2001 From: Christoph Wille Date: Sat, 1 Jun 2024 15:42:56 +0200 Subject: [PATCH 8/9] Switch from DllImport to LibraryImport source generator --- ILSpy/NativeMethods.cs | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/ILSpy/NativeMethods.cs b/ILSpy/NativeMethods.cs index 8ba9b02fa..ba3e03b67 100644 --- a/ILSpy/NativeMethods.cs +++ b/ILSpy/NativeMethods.cs @@ -21,16 +21,19 @@ using System.Runtime.InteropServices; namespace ICSharpCode.ILSpy { - static class NativeMethods + // Uses https://learn.microsoft.com/en-us/dotnet/standard/native-interop/pinvoke-source-generation + internal static partial class NativeMethods { - [DllImport("dwmapi.dll", PreserveSig = true)] - public static extern int DwmSetWindowAttribute(IntPtr hwnd, DwmWindowAttribute attr, ref int attrValue, int attrSize); + const int S_OK = 0; + + [LibraryImport("dwmapi.dll", EntryPoint = "DwmSetWindowAttribute")] + internal static partial int DwmSetWindowAttribute(IntPtr hwnd, DwmWindowAttribute attr, ref int attrValue, int attrSize); public static bool UseImmersiveDarkMode(IntPtr hWnd, bool enable) { int darkMode = enable ? 1 : 0; - int hr = DwmSetWindowAttribute(hWnd, DwmWindowAttribute.UseImmersiveDarkMode, ref darkMode, sizeof(int)); - return hr >= 0; + int hResult = DwmSetWindowAttribute(hWnd, DwmWindowAttribute.UseImmersiveDarkMode, ref darkMode, sizeof(int)); + return hResult > S_OK; } } From baea9c940afad2bf22c9708bcacb01762c78fbfb Mon Sep 17 00:00:00 2001 From: Christoph Wille Date: Sat, 1 Jun 2024 15:53:09 +0200 Subject: [PATCH 9/9] CommandLineArguments ctor to static Create method --- ILSpy.Tests/CommandLineArgumentsTests.cs | 24 ++--- ILSpy/App.xaml.cs | 2 +- ILSpy/AppEnv/CommandLineArguments.cs | 115 +++++++++++++---------- ILSpy/MainWindow.xaml.cs | 2 +- 4 files changed, 79 insertions(+), 64 deletions(-) diff --git a/ILSpy.Tests/CommandLineArgumentsTests.cs b/ILSpy.Tests/CommandLineArgumentsTests.cs index addf682d4..20704250c 100644 --- a/ILSpy.Tests/CommandLineArgumentsTests.cs +++ b/ILSpy.Tests/CommandLineArgumentsTests.cs @@ -14,7 +14,7 @@ namespace ICSharpCode.ILSpy.Tests [Test] public void VerifyEmptyArgumentsArray() { - var cmdLineArgs = new CommandLineArguments(new string[] { }); + var cmdLineArgs = CommandLineArguments.Create(new string[] { }); cmdLineArgs.AssembliesToLoad.Should().BeEmpty(); cmdLineArgs.SingleInstance.Should().BeNull(); @@ -28,14 +28,14 @@ namespace ICSharpCode.ILSpy.Tests [Test] public void VerifyHelpOption() { - var cmdLineArgs = new CommandLineArguments(new string[] { "--help" }); + var cmdLineArgs = CommandLineArguments.Create(new string[] { "--help" }); cmdLineArgs.ArgumentsParser.IsShowingInformation.Should().BeTrue(); } [Test] public void VerifyForceNewInstanceOption() { - var cmdLineArgs = new CommandLineArguments(new string[] { "--newinstance" }); + var cmdLineArgs = CommandLineArguments.Create(new string[] { "--newinstance" }); cmdLineArgs.SingleInstance.Should().BeFalse(); } @@ -43,21 +43,21 @@ namespace ICSharpCode.ILSpy.Tests public void VerifyNavigateToOption() { const string navigateTo = "MyNamespace.MyClass"; - var cmdLineArgs = new CommandLineArguments(new string[] { "--navigateto", navigateTo }); + var cmdLineArgs = CommandLineArguments.Create(new string[] { "--navigateto", navigateTo }); cmdLineArgs.NavigateTo.Should().BeEquivalentTo(navigateTo); } [Test] public void VerifyNavigateToOption_NoneTest_Matching_VSAddin() { - var cmdLineArgs = new CommandLineArguments(new string[] { "--navigateto:none" }); + var cmdLineArgs = CommandLineArguments.Create(new string[] { "--navigateto:none" }); cmdLineArgs.NavigateTo.Should().BeEquivalentTo("none"); } [Test] public void VerifyCaseSensitivityOfOptionsDoesntThrow() { - var cmdLineArgs = new CommandLineArguments(new string[] { "--navigateTo:none" }); + var cmdLineArgs = CommandLineArguments.Create(new string[] { "--navigateTo:none" }); cmdLineArgs.ArgumentsParser.RemainingArguments.Should().HaveCount(1); } @@ -66,7 +66,7 @@ namespace ICSharpCode.ILSpy.Tests public void VerifySearchOption() { const string searchWord = "TestContainers"; - var cmdLineArgs = new CommandLineArguments(new string[] { "--search", searchWord }); + var cmdLineArgs = CommandLineArguments.Create(new string[] { "--search", searchWord }); cmdLineArgs.Search.Should().BeEquivalentTo(searchWord); } @@ -74,7 +74,7 @@ namespace ICSharpCode.ILSpy.Tests public void VerifyLanguageOption() { const string language = "csharp"; - var cmdLineArgs = new CommandLineArguments(new string[] { "--language", language }); + var cmdLineArgs = CommandLineArguments.Create(new string[] { "--language", language }); cmdLineArgs.Language.Should().BeEquivalentTo(language); } @@ -82,21 +82,21 @@ namespace ICSharpCode.ILSpy.Tests public void VerifyConfigOption() { const string configFile = "myilspyoptions.xml"; - var cmdLineArgs = new CommandLineArguments(new string[] { "--config", configFile }); + var cmdLineArgs = CommandLineArguments.Create(new string[] { "--config", configFile }); cmdLineArgs.ConfigFile.Should().BeEquivalentTo(configFile); } [Test] public void VerifyNoActivateOption() { - var cmdLineArgs = new CommandLineArguments(new string[] { "--noactivate" }); + var cmdLineArgs = CommandLineArguments.Create(new string[] { "--noactivate" }); cmdLineArgs.NoActivate.Should().BeTrue(); } [Test] public void MultipleAssembliesAsArguments() { - var cmdLineArgs = new CommandLineArguments(new string[] { "assembly1", "assembly2", "assembly3" }); + var cmdLineArgs = CommandLineArguments.Create(new string[] { "assembly1", "assembly2", "assembly3" }); cmdLineArgs.AssembliesToLoad.Should().HaveCount(3); } @@ -107,7 +107,7 @@ namespace ICSharpCode.ILSpy.Tests System.IO.File.WriteAllText(filepath, "assembly1\r\nassembly2\r\nassembly3\r\n--newinstance\r\n--noactivate"); - var cmdLineArgs = new CommandLineArguments(new string[] { $"@{filepath}" }); + var cmdLineArgs = CommandLineArguments.Create(new string[] { $"@{filepath}" }); try { diff --git a/ILSpy/App.xaml.cs b/ILSpy/App.xaml.cs index 2387c487a..0ac78e0f7 100644 --- a/ILSpy/App.xaml.cs +++ b/ILSpy/App.xaml.cs @@ -65,7 +65,7 @@ namespace ICSharpCode.ILSpy ILSpySettings.SettingsFilePathProvider = new ILSpySettingsFilePathProvider(); var cmdArgs = Environment.GetCommandLineArgs().Skip(1); - App.CommandLineArguments = new CommandLineArguments(cmdArgs); + App.CommandLineArguments = CommandLineArguments.Create(cmdArgs); bool forceSingleInstance = (App.CommandLineArguments.SingleInstance ?? true) && !MiscSettingsPanel.CurrentMiscSettings.AllowMultipleInstances; diff --git a/ILSpy/AppEnv/CommandLineArguments.cs b/ILSpy/AppEnv/CommandLineArguments.cs index 116d8b188..14e72f452 100644 --- a/ILSpy/AppEnv/CommandLineArguments.cs +++ b/ILSpy/AppEnv/CommandLineArguments.cs @@ -18,6 +18,7 @@ using McMaster.Extensions.CommandLineUtils; +using System; using System.Collections.Generic; using System.Linq; @@ -36,7 +37,12 @@ namespace ICSharpCode.ILSpy.AppEnv public CommandLineApplication ArgumentsParser { get; } - public CommandLineArguments(IEnumerable arguments) + private CommandLineArguments(CommandLineApplication app) + { + ArgumentsParser = app; + } + + public static CommandLineArguments Create(IEnumerable arguments) { var app = new CommandLineApplication() { // https://natemcmaster.github.io/CommandLineUtils/docs/response-file-parsing.html?tabs=using-attributes @@ -47,58 +53,67 @@ namespace ICSharpCode.ILSpy.AppEnv }; app.HelpOption(); - ArgumentsParser = app; - - var oForceNewInstance = app.Option("--newinstance", - "Start a new instance of ILSpy even if the user configuration is set to single-instance", - CommandOptionType.NoValue); - - var oNavigateTo = app.Option("-n|--navigateto ", - "Navigates to the member specified by the given ID string.\r\nThe member is searched for only in the assemblies specified on the command line.\r\nExample: 'ILSpy ILSpy.exe --navigateto:T:ICSharpCode.ILSpy.CommandLineArguments'", - CommandOptionType.SingleValue); - oNavigateTo.DefaultValue = null; - - var oSearch = app.Option("-s|--search ", - "Search for t:TypeName, m:Member or c:Constant; use exact match (=term), 'should not contain' (-term) or 'must contain' (+term); use /reg(ular)?Ex(pressions)?/ or both - t:/Type(Name)?/...", - CommandOptionType.SingleValue); - oSearch.DefaultValue = null; - - var oLanguage = app.Option("-l|--language ", - "Selects the specified language.\r\nExample: 'ILSpy --language:C#' or 'ILSpy --language:IL'", - CommandOptionType.SingleValue); - oLanguage.DefaultValue = null; - - var oConfig = app.Option("-c|--config ", - "Provide a specific configuration file.\r\nExample: 'ILSpy --config:myconfig.xml'", - CommandOptionType.SingleValue); - oConfig.DefaultValue = null; + var instance = new CommandLineArguments(app); - var oNoActivate = app.Option("--noactivate", - "Do not activate the existing ILSpy instance. This option has no effect if a new ILSpy instance is being started.", - CommandOptionType.NoValue); - - // https://natemcmaster.github.io/CommandLineUtils/docs/arguments.html#variable-numbers-of-arguments - // To enable this, MultipleValues must be set to true, and the argument must be the last one specified. - var files = app.Argument("Assemblies", "Assemblies to load", multipleValues: true); - - app.Parse(arguments.ToArray()); - - if (oForceNewInstance.HasValue()) - SingleInstance = false; - - NavigateTo = oNavigateTo.ParsedValue; - Search = oSearch.ParsedValue; - Language = oLanguage.ParsedValue; - ConfigFile = oConfig.ParsedValue; - - if (oNoActivate.HasValue()) - NoActivate = true; - - foreach (var assembly in files.Values) + try + { + var oForceNewInstance = app.Option("--newinstance", + "Start a new instance of ILSpy even if the user configuration is set to single-instance", + CommandOptionType.NoValue); + + var oNavigateTo = app.Option("-n|--navigateto ", + "Navigates to the member specified by the given ID string.\r\nThe member is searched for only in the assemblies specified on the command line.\r\nExample: 'ILSpy ILSpy.exe --navigateto T:ICSharpCode.ILSpy.CommandLineArguments'", + CommandOptionType.SingleValue); + oNavigateTo.DefaultValue = null; + + var oSearch = app.Option("-s|--search ", + "Search for t:TypeName, m:Member or c:Constant; use exact match (=term), 'should not contain' (-term) or 'must contain' (+term); use /reg(ular)?Ex(pressions)?/ or both - t:/Type(Name)?/...", + CommandOptionType.SingleValue); + oSearch.DefaultValue = null; + + var oLanguage = app.Option("-l|--language ", + "Selects the specified language.\r\nExample: 'ILSpy --language:C#' or 'ILSpy --language IL'", + CommandOptionType.SingleValue); + oLanguage.DefaultValue = null; + + var oConfig = app.Option("-c|--config ", + "Provide a specific configuration file.\r\nExample: 'ILSpy --config myconfig.xml'", + CommandOptionType.SingleValue); + oConfig.DefaultValue = null; + + var oNoActivate = app.Option("--noactivate", + "Do not activate the existing ILSpy instance. This option has no effect if a new ILSpy instance is being started.", + CommandOptionType.NoValue); + + // https://natemcmaster.github.io/CommandLineUtils/docs/arguments.html#variable-numbers-of-arguments + // To enable this, MultipleValues must be set to true, and the argument must be the last one specified. + var files = app.Argument("Assemblies", "Assemblies to load", multipleValues: true); + + app.Parse(arguments.ToArray()); + + if (oForceNewInstance.HasValue()) + instance.SingleInstance = false; + + instance.NavigateTo = oNavigateTo.ParsedValue; + instance.Search = oSearch.ParsedValue; + instance.Language = oLanguage.ParsedValue; + instance.ConfigFile = oConfig.ParsedValue; + + if (oNoActivate.HasValue()) + instance.NoActivate = true; + + foreach (var assembly in files.Values) + { + if (!string.IsNullOrWhiteSpace(assembly)) + instance.AssembliesToLoad.Add(assembly); + } + } + catch (Exception ex) { - if (!string.IsNullOrWhiteSpace(assembly)) - AssembliesToLoad.Add(assembly); + // Intentionally ignore exceptions if any, this is only added to always have an exception-free startup } + + return instance; } } } diff --git a/ILSpy/MainWindow.xaml.cs b/ILSpy/MainWindow.xaml.cs index eed3732db..10525cbb8 100644 --- a/ILSpy/MainWindow.xaml.cs +++ b/ILSpy/MainWindow.xaml.cs @@ -654,7 +654,7 @@ namespace ICSharpCode.ILSpy internal async Task HandleSingleInstanceCommandLineArguments(string[] args) { - var cmdArgs = new CommandLineArguments(args); + var cmdArgs = CommandLineArguments.Create(args); await Dispatcher.InvokeAsync(() => { if (HandleCommandLineArguments(cmdArgs))